feat: D-025 — sortie ESM, carte exports, sideEffects (véhicule 0.2.0)

Deux livraisons ESM par la chaîne Rollup existante, UMD prouvé identique à
l'octet :
- bundles dist/js/drake.esm.js, drake-core.esm.js, drake-util.esm.js
  (+ .esm.min.js) et les 13 composants .esm.js — externals via paths
  relatifs, aucune duplication d'instance, variante min cohérente ;
- arborescence dist/esm/ (preserveModules, 112 modules, imports relatifs
  avec extension, manifeste local type module émis par le build : import
  Node natif sans re-parse).

package.json : carte exports (., ./core, ./components/*, passe-plat
./dist/* obligatoire, ./package.json), main/style/types conservés,
sideEffects établi par lecture du code émis (3 modules à effets top-level
+ installateurs ; utilitaires et mixins élagables).

Gates étendus : fumée ESM au gate consommateur (import entrée + composant,
require inchangé, passe-plat résolu), 6 budgets de taille ajoutés
(21 artefacts sous budget), test de consommation des types PAR la carte
(traceResolution prouvé), manifeste 45 -> 189 fichiers, G9 couvre
dist/esm/. Matrice C0-C3 verte sans recapture. README : usage ESM
documenté.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Test-bot-cell

.gitignore

@@ -1,13 +1,20 @@
 /dist/*
 !/dist/fork-manifest.json
 !/dist/css/
+!/dist/esm/
 !/dist/js/
 /dist/js/*
 !/dist/js/components/
 !/dist/js/drake.js
 !/dist/js/drake.min.js
+!/dist/js/drake.esm.js
+!/dist/js/drake.esm.min.js
 !/dist/js/drake-core.js
 !/dist/js/drake-core.min.js
+!/dist/js/drake-core.esm.js
+!/dist/js/drake-core.esm.min.js
+!/dist/js/drake-util.esm.js
+!/dist/js/drake-util.esm.min.js
 !/dist/fonts/
 !/dist/types/
 /node_modules

CHANGELOG.md

@@ -17,6 +17,11 @@ dans [`docs/fork/CHANGELOG-uikit-amont.md`](docs/fork/CHANGELOG-uikit-amont.md).
   release outillé `pnpm release` (préflight, tag signé, release GitHub, vérification
   HTTP des chemins CDN), budgets de taille épinglés des artefacts principaux dans
   `pnpm verify` (relèvement = décision consignée, jamais silencieux).
+- Sortie ESM (décision D-025, amendant D-017) : bundles `drake.esm.js`,
+  `drake-core.esm.js` et composants `.esm.js`, arborescence de modules préservés
+  `dist/esm/` (tree-shaking réel), carte `exports` avec passe-plat `./dist/*`,
+  `sideEffects` déclaré, fumée ESM au gate consommateur, budgets et test de types
+  étendus — l'UMD reste livré à l'identique.
 
 ## 0.1.1 — 2026-07-21
 

README.md

@@ -67,6 +67,34 @@ dans `dist/js/` est l’artefact compilé indispensable aux navigateurs ; aucune
 JavaScript frontend n’est maintenue hors de `dist/`. Les composants individuels sont
 livrés sous `dist/js/components/`.
 
+Depuis la décision D-025, le runtime est aussi livré en ESM, sans changement cassant :
+les bundles UMD restent distribués à l’identique (`window.Drake`) et `require('drake.css')`
+continue de résoudre `dist/js/drake.js`. Avec un bundler (Vite, esbuild, webpack), la
+carte `exports` de `package.json` résout `import` vers l’arborescence de modules préservés
+`dist/esm/` ; combinée à la déclaration `sideEffects`, elle permet le tree-shaking : le
+bundler n’emporte que les modules réellement consommés. Chaque composant optionnel
+s’enregistre à l’import via `import 'drake.css/components/<nom>'` :
+
+```js
+import Drake from 'drake.css';
+
+import 'drake.css/components/filter';
+```
+
+Sans bundler, les bundles `dist/js/*.esm.js` et `dist/js/components/*.esm.js` (et leurs
+variantes `.min`) se chargent en module natif depuis le même CDN, au tag de la release
+qui livre l’ESM (`v0.2.0`, véhicule de la décision D-025) :
+
+```html
+<script
+    type="module"
+    src="https://cdn.jsdelivr.net/gh/Test-bot-cell/Drake-css-framework@v0.2.0/dist/js/drake.esm.js"
+></script>
+```
+
+Dans tous les cas, l’ESM ne couvre que le JavaScript : les feuilles CSS se chargent
+séparément, comme décrit dans [« Chargement recommandé »](#chargement-recommandé).
+
 ## Installation locale
 
 La chaîne de référence utilise Node.js 24.18.0 exact et pnpm 11.4.0 :

build/build.js

@@ -1,7 +1,7 @@
 import camelize from 'camelcase';
 import path from 'node:path';
 import pLimit from 'p-limit';
-import { args, compile, glob } from './util.js';
+import { args, compile, compileModules, glob } from './util.js';
 
 const limit = pLimit(Number(process.env.cpus || 2));
 
@@ -49,9 +49,18 @@ await Promise.all(Object.values(tasks).map((task) => limit(task)));
 
 function getBundleTasks() {
     return {
-        core: () => compile('src/js/drake-core.ts', 'dist/js/drake-core'),
+        core: () =>
+            compile('src/js/drake-core.ts', 'dist/js/drake-core', { formats: ['umd', 'es'] }),
 
-        drake: () => compile('src/js/drake.ts', 'dist/js/drake'),
+        drake: () => compile('src/js/drake.ts', 'dist/js/drake', { formats: ['umd', 'es'] }),
+
+        // Source ESM des utilitaires pour les composants (D-025 §1) : pas d'UMD,
+        // `Drake.util` reste porté par les bundles historiques.
+        'drake-util': () =>
+            compile('src/js/util/index.ts', 'dist/js/drake-util', { formats: ['es'] }),
+
+        // Arborescence de modules préservés (D-025 §1) : le tree-shaking réel.
+        esm: () => compileModules(['src/js/drake.ts', 'src/js/drake-core.ts'], 'dist/esm'),
 
         tests: async () =>
             compile('tests/js/index.ts', 'dist/js/tests/test', {
@@ -74,6 +83,10 @@ async function getComponentTasks() {
                 name,
                 external: ['drake', 'drake-util'],
                 globals: { drake: 'Drake', 'drake-util': 'Drake.util' },
+                formats: ['umd', 'es'],
+                // En ESM, les externes se résolvent en voisins de fichiers (D-025 §1) :
+                // aucune seconde instance de Drake n'est embarquée dans les composants.
+                esmPaths: { drake: './../drake.esm.js', 'drake-util': './../drake-util.esm.js' },
                 aliases: { component: path.resolve('src/js/components', `${name}.ts`) },
                 virtualModules: { 'virtual:name': `'${camelize(name)}'` },
             });

build/fork/check-consumer.js

@@ -14,7 +14,9 @@ import { promisify } from 'node:util';
 // vierge en répertoire temporaire, chargement réel du point d'entrée (le bundle UMD
 // s'exporte en CommonJS sous Node, sans DOM), cohérence de version, puis présence des
 // fichiers recommandés par le README dans l'arbre installé. Une release cassée est ainsi
-// détectée avant le tag, plus jamais après.
+// détectée avant le tag, plus jamais après. La fumée ESM (D-025) s'y ajoute : l'entrée
+// import de la carte exports et un composant réel se chargent dans un processus Node
+// vierge, require reste vert, et le passe-plat ./dist/* résout un chemin profond.
 
 const execFileAsync = promisify(execFile);
 const PROJECT_ROOT = fileURLToPath(new URL('../..', import.meta.url));
@@ -33,6 +35,11 @@ const EXPECTED_RUNTIME_SURFACES = {
 // EXPECTED_INTER_FONT_FILES dans build/fork/check-assets.js (les empreintes exactes sont
 // vérifiées là-bas ; ici, seule la présence dans l'arbre installé est en jeu). Le point
 // d'entrée des types s'y ajoute, lu dans le champ types du paquet installé.
+// Fumée ESM (D-025) : un composant réel du paquet (entrée ./components/* de la carte
+// exports) et un chemin profond représentatif servi par le passe-plat ./dist/*.
+const ESM_SMOKE_COMPONENT = 'filter';
+const DEEP_PATH_SPECIMEN = 'dist/css/drake.css';
+
 const README_RECOMMENDED_FILES = [
     'dist/css/drake.css',
     'dist/css/drake.min.css',
@@ -57,14 +64,18 @@ try {
 
     const installed = await readInstalledManifest(installedRoot, manifest);
     smokeTestRuntime(consumer, manifest);
+    await smokeTestEsmModules(consumer, manifest);
+    await checkDeepPathResolution(consumer, manifest);
     const checkedFileCount = await checkRecommendedFiles(installedRoot, installed);
 
     console.log(
         `Gate consommateur (D-024) : canal D-020 prouvé de bout en bout — ` +
             `${manifest.name}@${manifest.version} empaqueté, installé dans un consommateur ` +
             `vierge et chargé sans window ` +
             `(surfaces ${Object.keys(EXPECTED_RUNTIME_SURFACES).join(', ')}) ; ` +
-            `${checkedFileCount} fichiers recommandés présents.`,
+            `fumée ESM D-025 verte (import de l'entrée et du composant ` +
+            `${ESM_SMOKE_COMPONENT}, require inchangé, passe-plat ${DEEP_PATH_SPECIMEN} ` +
+            `résolu) ; ${checkedFileCount} fichiers recommandés présents.`,
     );
 } catch (error) {
     console.error(`Gate consommateur en échec : ${error.message}`);
@@ -197,6 +208,68 @@ function smokeTestRuntime(consumer, manifest) {
     }
 }
 
+async function smokeTestEsmModules(consumer, manifest) {
+    // Fumée ESM (D-025) : l'entrée import de la carte exports (dist/esm/drake.js) et un
+    // composant réel (dist/js/components/*.esm.js) doivent se charger depuis le
+    // consommateur vierge, dans un processus Node séparé et sans DOM — l'amorçage se
+    // retire de lui-même hors navigateur, et l'enregistrement du composant est gardé par
+    // typeof window. Les surfaces attendues sont les mêmes que pour la fumée require.
+    const script = join(consumer, 'smoke-esm.mjs');
+    const componentSpecifier = `${manifest.name}/components/${ESM_SMOKE_COMPONENT}`;
+    await writeFile(
+        script,
+        [
+            `import assert from 'node:assert/strict';`,
+            `import Drake from ${JSON.stringify(manifest.name)};`,
+            `import Component from ${JSON.stringify(componentSpecifier)};`,
+            `assert.equal(typeof globalThis.window, 'undefined', 'fumée ESM sans DOM invalide : un global window est présent');`,
+            `assert.ok(Drake !== null && (typeof Drake === 'object' || typeof Drake === 'function'), \`l'entrée ESM n'exporte pas l'objet runtime : reçu \${typeof Drake}\`);`,
+            ...Object.entries(EXPECTED_RUNTIME_SURFACES).map(
+                ([surface, expectedType]) =>
+                    `assert.ok(typeof Drake[${JSON.stringify(surface)}] === ${JSON.stringify(expectedType)} && Drake[${JSON.stringify(surface)}] !== null, \`surface runtime absente ou invalide sur l'export ESM : ${surface} (attendu ${expectedType}, reçu \${typeof Drake[${JSON.stringify(surface)}]})\`);`,
+            ),
+            `assert.equal(Drake.version, ${JSON.stringify(manifest.version)}, \`version runtime ESM incohérente : \${Drake.version} au lieu de ${manifest.version}\`);`,
+            `assert.ok(Component !== null && (typeof Component === 'object' || typeof Component === 'function'), \`le composant ${ESM_SMOKE_COMPONENT} n'exporte pas de définition : reçu \${typeof Component}\`);`,
+            ``,
+        ].join('\n'),
+    );
+
+    try {
+        await execFileAsync(process.execPath, [script], {
+            cwd: consumer,
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024,
+        });
+    } catch (error) {
+        const detail =
+            error.stderr?.trim().split('\n').slice(-5).join(' | ') || error.message || error;
+        throw new Error(
+            `La fumée ESM a échoué (import('${manifest.name}') et ` +
+                `import('${componentSpecifier}') depuis le consommateur) : ${detail}`,
+            { cause: error },
+        );
+    }
+}
+
+async function checkDeepPathResolution(consumer, manifest) {
+    // Passe-plat ./dist/* (D-025) : la carte exports ne doit casser aucun chemin profond
+    // existant — require.resolve d'une feuille CSS recommandée le prouve depuis le
+    // consommateur (une carte sans passe-plat ferait échouer cette résolution).
+    const requireFromConsumer = createRequire(join(consumer, 'smoke.cjs'));
+    const specifier = `${manifest.name}/${DEEP_PATH_SPECIMEN}`;
+    let resolved;
+    try {
+        resolved = requireFromConsumer.resolve(specifier);
+    } catch (error) {
+        throw new Error(
+            `require.resolve('${specifier}') a échoué depuis le consommateur : le ` +
+                `passe-plat ./dist/* de la carte exports est absent ou cassé (${error.message}).`,
+            { cause: error },
+        );
+    }
+    await assertNonEmptyFile(resolved, `le chemin profond résolu ${specifier}`);
+}
+
 async function checkRecommendedFiles(installedRoot, installed) {
     const files = [...README_RECOMMENDED_FILES, installed.types];
     for (const file of files) {