slicejs-web-framework 4.0.0 → 4.0.1

package/api/index.js

@@ -1,7 +1,7 @@
-// api/index.js - Punto de entrada del servidor
-import { createSliceServer } from 'slicejs-web-framework/api/framework/server.js';
-
-const server = createSliceServer();
-server.start();
-
-export default server.app;
+// api/index.js - Punto de entrada del servidor
+import { createSliceServer } from 'slicejs-web-framework/api/framework/server.js';
+
+const server = createSliceServer();
+server.start();
+
+export default server.app;

package/api/tests/dev-deps-optimizer.test.js

@@ -1,137 +1,137 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { createDevDepsOptimizer, MODULES_PREFIX } from '../framework/devDepsOptimizer.js';
-
-// projectRoot for esbuild resolution: this framework package's own root, whose
-// node_modules contains es-module-lexer (used here as a real ESM package to
-// bundle). Two dirs up from api/tests/.
-const projectRoot = new URL('../../', import.meta.url).pathname;
-
-test('rewriteBareImports rewrites bare specifiers to the virtual endpoint', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const code = [
-    "import dayjs from 'dayjs';",
-    "import { a, b } from '@scope/pkg';",
-    "import './local.js';",
-    "import '/libs/x.js';",
-    "import x from 'https://cdn/x.js';",
-    "const d = import('lodash/fp');"
-  ].join('\n');
-
-  const out = await opt.rewriteBareImports(code);
-
-  assert.match(out, new RegExp(`from '${MODULES_PREFIX}dayjs'`));
-  assert.match(out, new RegExp(`from '${MODULES_PREFIX}@scope/pkg'`));
-  assert.match(out, new RegExp(`import\\('${MODULES_PREFIX}lodash/fp'\\)`));
-  // Relative, absolute (public/) and URL imports are untouched.
-  assert.match(out, /import '\.\/local\.js'/);
-  assert.match(out, /import '\/libs\/x\.js'/);
-  assert.match(out, /from 'https:\/\/cdn\/x\.js'/);
-});
-
-test('rewriteBareImports is a no-op when disabled', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: false });
-  const code = "import dayjs from 'dayjs';";
-  assert.equal(await opt.rewriteBareImports(code), code);
-});
-
-test('rewriteBareImports returns source unchanged when there is nothing bare', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const code = "import './a.js';\nexport const x = 1;\n";
-  assert.equal(await opt.rewriteBareImports(code), code);
-});
-
-test('specifierFromRequest extracts the package from the virtual path', () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}dayjs`), 'dayjs');
-  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}@scope/pkg/sub`), '@scope/pkg/sub');
-  assert.equal(opt.specifierFromRequest('/Components/x.js'), null);
-});
-
-test('bundlePackage resolves a real ESM package to self-contained ESM', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  // es-module-lexer is a named-export ESM package (no default) — exercises the
-  // namespace-only fallback path in bundlePackage.
-  const { code } = await opt.bundlePackage('es-module-lexer');
-  assert.ok(code.length > 0, 'expected bundled code');
-  // Self-contained: no bare imports left to resolve at runtime.
-  assert.doesNotMatch(code, /^\s*import\s+.*from\s+['"][^./]/m);
-  // Exposes the package's named API.
-  assert.match(code, /\bparse\b/);
-  assert.match(code, /export\s*\{/);
-});
-
-test('bundlePackage caches and shares a single build per specifier', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const [a, b] = await Promise.all([
-    opt.bundlePackage('es-module-lexer'),
-    opt.bundlePackage('es-module-lexer')
-  ]);
-  assert.equal(a, b, 'concurrent requests should share the same cached result');
-});
-
-test('bundlePackage persists a disk cache keyed by version, reused by a fresh optimizer', async () => {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-'));
-  try {
-    // Minimal installed package in the temp project's node_modules.
-    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
-    await fsp.mkdir(pkgDir, { recursive: true });
-    await fsp.writeFile(path.join(pkgDir, 'package.json'),
-      JSON.stringify({ name: 'mini-pkg', version: '2.3.4', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const hi = () => "hi";');
-
-    const opt1 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
-    const first = await opt1.bundlePackage('mini-pkg');
-    assert.match(first.code, /hi/);
-
-    // A cache file keyed by the installed version must now exist.
-    const cacheFile = path.join(tmp, 'node_modules', '.slice-deps', 'mini-pkg@2.3.4.js');
-    const cached = await fsp.readFile(cacheFile, 'utf8');
-    assert.equal(cached, first.code);
-
-    // A brand-new optimizer (empty in-memory cache) reads the same bytes from disk.
-    const opt2 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
-    const second = await opt2.bundlePackage('mini-pkg');
-    assert.equal(second.code, first.code);
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});
-
-test('bundlePackage prunes stale cache files when a package version changes', async () => {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-gc-'));
-  try {
-    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
-    const pkgJson = path.join(pkgDir, 'package.json');
-    const cacheDir = path.join(tmp, 'node_modules', '.slice-deps');
-    await fsp.mkdir(pkgDir, { recursive: true });
-    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.0.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 1;');
-
-    // A sibling package must survive the prune (its name is not a prefix match).
-    const otherDir = path.join(tmp, 'node_modules', 'mini-pkg-extra');
-    await fsp.mkdir(otherDir, { recursive: true });
-    await fsp.writeFile(path.join(otherDir, 'package.json'), JSON.stringify({ name: 'mini-pkg-extra', version: '9.0.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(otherDir, 'index.js'), 'export const e = 1;');
-
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg-extra');
-    assert.ok(await fsp.stat(path.join(cacheDir, 'mini-pkg@1.0.0.js')).then(() => true));
-
-    // Simulate an upgrade: bump the installed version, then rebundle.
-    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.1.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 2;');
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
-
-    const remaining = (await fsp.readdir(cacheDir)).sort();
-    // Old version gone, new version present, sibling untouched.
-    assert.ok(!remaining.includes('mini-pkg@1.0.0.js'), 'stale version should be pruned');
-    assert.ok(remaining.includes('mini-pkg@1.1.0.js'), 'new version should be cached');
-    assert.ok(remaining.includes('mini-pkg-extra@9.0.0.js'), 'sibling package must not be pruned');
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { createDevDepsOptimizer, MODULES_PREFIX } from '../framework/devDepsOptimizer.js';
+
+// projectRoot for esbuild resolution: this framework package's own root, whose
+// node_modules contains es-module-lexer (used here as a real ESM package to
+// bundle). Two dirs up from api/tests/.
+const projectRoot = new URL('../../', import.meta.url).pathname;
+
+test('rewriteBareImports rewrites bare specifiers to the virtual endpoint', async () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
+  const code = [
+    "import dayjs from 'dayjs';",
+    "import { a, b } from '@scope/pkg';",
+    "import './local.js';",
+    "import '/libs/x.js';",
+    "import x from 'https://cdn/x.js';",
+    "const d = import('lodash/fp');"
+  ].join('\n');
+
+  const out = await opt.rewriteBareImports(code);
+
+  assert.match(out, new RegExp(`from '${MODULES_PREFIX}dayjs'`));
+  assert.match(out, new RegExp(`from '${MODULES_PREFIX}@scope/pkg'`));
+  assert.match(out, new RegExp(`import\\('${MODULES_PREFIX}lodash/fp'\\)`));
+  // Relative, absolute (public/) and URL imports are untouched.
+  assert.match(out, /import '\.\/local\.js'/);
+  assert.match(out, /import '\/libs\/x\.js'/);
+  assert.match(out, /from 'https:\/\/cdn\/x\.js'/);
+});
+
+test('rewriteBareImports is a no-op when disabled', async () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: false });
+  const code = "import dayjs from 'dayjs';";
+  assert.equal(await opt.rewriteBareImports(code), code);
+});
+
+test('rewriteBareImports returns source unchanged when there is nothing bare', async () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
+  const code = "import './a.js';\nexport const x = 1;\n";
+  assert.equal(await opt.rewriteBareImports(code), code);
+});
+
+test('specifierFromRequest extracts the package from the virtual path', () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
+  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}dayjs`), 'dayjs');
+  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}@scope/pkg/sub`), '@scope/pkg/sub');
+  assert.equal(opt.specifierFromRequest('/Components/x.js'), null);
+});
+
+test('bundlePackage resolves a real ESM package to self-contained ESM', async () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
+  // es-module-lexer is a named-export ESM package (no default) — exercises the
+  // namespace-only fallback path in bundlePackage.
+  const { code } = await opt.bundlePackage('es-module-lexer');
+  assert.ok(code.length > 0, 'expected bundled code');
+  // Self-contained: no bare imports left to resolve at runtime.
+  assert.doesNotMatch(code, /^\s*import\s+.*from\s+['"][^./]/m);
+  // Exposes the package's named API.
+  assert.match(code, /\bparse\b/);
+  assert.match(code, /export\s*\{/);
+});
+
+test('bundlePackage caches and shares a single build per specifier', async () => {
+  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
+  const [a, b] = await Promise.all([
+    opt.bundlePackage('es-module-lexer'),
+    opt.bundlePackage('es-module-lexer')
+  ]);
+  assert.equal(a, b, 'concurrent requests should share the same cached result');
+});
+
+test('bundlePackage persists a disk cache keyed by version, reused by a fresh optimizer', async () => {
+  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-'));
+  try {
+    // Minimal installed package in the temp project's node_modules.
+    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
+    await fsp.mkdir(pkgDir, { recursive: true });
+    await fsp.writeFile(path.join(pkgDir, 'package.json'),
+      JSON.stringify({ name: 'mini-pkg', version: '2.3.4', type: 'module', main: 'index.js' }));
+    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const hi = () => "hi";');
+
+    const opt1 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
+    const first = await opt1.bundlePackage('mini-pkg');
+    assert.match(first.code, /hi/);
+
+    // A cache file keyed by the installed version must now exist.
+    const cacheFile = path.join(tmp, 'node_modules', '.slice-deps', 'mini-pkg@2.3.4.js');
+    const cached = await fsp.readFile(cacheFile, 'utf8');
+    assert.equal(cached, first.code);
+
+    // A brand-new optimizer (empty in-memory cache) reads the same bytes from disk.
+    const opt2 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
+    const second = await opt2.bundlePackage('mini-pkg');
+    assert.equal(second.code, first.code);
+  } finally {
+    await fsp.rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('bundlePackage prunes stale cache files when a package version changes', async () => {
+  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-gc-'));
+  try {
+    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
+    const pkgJson = path.join(pkgDir, 'package.json');
+    const cacheDir = path.join(tmp, 'node_modules', '.slice-deps');
+    await fsp.mkdir(pkgDir, { recursive: true });
+    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.0.0', type: 'module', main: 'index.js' }));
+    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 1;');
+
+    // A sibling package must survive the prune (its name is not a prefix match).
+    const otherDir = path.join(tmp, 'node_modules', 'mini-pkg-extra');
+    await fsp.mkdir(otherDir, { recursive: true });
+    await fsp.writeFile(path.join(otherDir, 'package.json'), JSON.stringify({ name: 'mini-pkg-extra', version: '9.0.0', type: 'module', main: 'index.js' }));
+    await fsp.writeFile(path.join(otherDir, 'index.js'), 'export const e = 1;');
+
+    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
+    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg-extra');
+    assert.ok(await fsp.stat(path.join(cacheDir, 'mini-pkg@1.0.0.js')).then(() => true));
+
+    // Simulate an upgrade: bump the installed version, then rebundle.
+    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.1.0', type: 'module', main: 'index.js' }));
+    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 2;');
+    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
+
+    const remaining = (await fsp.readdir(cacheDir)).sort();
+    // Old version gone, new version present, sibling untouched.
+    assert.ok(!remaining.includes('mini-pkg@1.0.0.js'), 'stale version should be pruned');
+    assert.ok(remaining.includes('mini-pkg@1.1.0.js'), 'new version should be cached');
+    assert.ok(remaining.includes('mini-pkg-extra@9.0.0.js'), 'sibling package must not be pruned');
+  } finally {
+    await fsp.rm(tmp, { recursive: true, force: true });
+  }
+});

package/api/tests/dev-server-external.test.js

@@ -1,56 +1,56 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-
-// Boots the real dev server against a temp project and checks the two moving
-// parts of external-dependency support in development: bare-import rewriting of
-// served src modules, and on-demand esbuild bundling at /@slice-modules/.
-test('dev server rewrites bare imports and serves bundled packages', async () => {
-  process.env.NODE_ENV = 'development';
-  const frameworkRoot = new URL('../../', import.meta.url).pathname; // slice.js root
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-dev-'));
-
-  try {
-    await fsp.mkdir(path.join(tmp, 'src', 'Components', 'Demo'), { recursive: true });
-    await fsp.writeFile(
-      path.join(tmp, 'src', 'sliceConfig.json'),
-      JSON.stringify({ externalDependencies: { enabled: true } })
-    );
-    await fsp.writeFile(
-      path.join(tmp, 'src', 'Components', 'Demo', 'Demo.js'),
-      "import { parse } from 'es-module-lexer';\nimport './local.js';\nexport default class Demo { run(){ return typeof parse; } }\n"
-    );
-    // Make es-module-lexer resolvable from the temp project for esbuild.
-    fs.symlinkSync(path.join(frameworkRoot, 'node_modules'), path.join(tmp, 'node_modules'), 'dir');
-
-    const { createSliceServer } = await import('../framework/server.js');
-    const { app } = createSliceServer({ projectRoot: tmp });
-    const server = app.listen(0);
-    await new Promise((resolve) => server.once('listening', resolve));
-    const base = `http://127.0.0.1:${server.address().port}`;
-
-    try {
-      // 1. The component's bare import is rewritten; the relative one is not.
-      const compRes = await fetch(`${base}/Components/Demo/Demo.js`);
-      const compText = await compRes.text();
-      assert.equal(compRes.status, 200);
-      assert.match(compText, /from ['"]\/@slice-modules\/es-module-lexer['"]/);
-      assert.match(compText, /import ['"]\.\/local\.js['"]/);
-
-      // 2. The virtual endpoint returns a self-contained ESM bundle of the pkg.
-      const modRes = await fetch(`${base}/@slice-modules/es-module-lexer`);
-      const modText = await modRes.text();
-      assert.equal(modRes.status, 200);
-      assert.match(modRes.headers.get('content-type') || '', /javascript/);
-      assert.match(modText, /export\s*\{/);
-      assert.doesNotMatch(modText, /^\s*import\s+.*from\s+['"][^./]/m);
-    } finally {
-      await new Promise((resolve) => server.close(resolve));
-    }
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+// Boots the real dev server against a temp project and checks the two moving
+// parts of external-dependency support in development: bare-import rewriting of
+// served src modules, and on-demand esbuild bundling at /@slice-modules/.
+test('dev server rewrites bare imports and serves bundled packages', async () => {
+  process.env.NODE_ENV = 'development';
+  const frameworkRoot = new URL('../../', import.meta.url).pathname; // slice.js root
+  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-dev-'));
+
+  try {
+    await fsp.mkdir(path.join(tmp, 'src', 'Components', 'Demo'), { recursive: true });
+    await fsp.writeFile(
+      path.join(tmp, 'src', 'sliceConfig.json'),
+      JSON.stringify({ externalDependencies: { enabled: true } })
+    );
+    await fsp.writeFile(
+      path.join(tmp, 'src', 'Components', 'Demo', 'Demo.js'),
+      "import { parse } from 'es-module-lexer';\nimport './local.js';\nexport default class Demo { run(){ return typeof parse; } }\n"
+    );
+    // Make es-module-lexer resolvable from the temp project for esbuild.
+    fs.symlinkSync(path.join(frameworkRoot, 'node_modules'), path.join(tmp, 'node_modules'), 'dir');
+
+    const { createSliceServer } = await import('../framework/server.js');
+    const { app } = createSliceServer({ projectRoot: tmp });
+    const server = app.listen(0);
+    await new Promise((resolve) => server.once('listening', resolve));
+    const base = `http://127.0.0.1:${server.address().port}`;
+
+    try {
+      // 1. The component's bare import is rewritten; the relative one is not.
+      const compRes = await fetch(`${base}/Components/Demo/Demo.js`);
+      const compText = await compRes.text();
+      assert.equal(compRes.status, 200);
+      assert.match(compText, /from ['"]\/@slice-modules\/es-module-lexer['"]/);
+      assert.match(compText, /import ['"]\.\/local\.js['"]/);
+
+      // 2. The virtual endpoint returns a self-contained ESM bundle of the pkg.
+      const modRes = await fetch(`${base}/@slice-modules/es-module-lexer`);
+      const modText = await modRes.text();
+      assert.equal(modRes.status, 200);
+      assert.match(modRes.headers.get('content-type') || '', /javascript/);
+      assert.match(modText, /export\s*\{/);
+      assert.doesNotMatch(modText, /^\s*import\s+.*from\s+['"][^./]/m);
+    } finally {
+      await new Promise((resolve) => server.close(resolve));
+    }
+  } finally {
+    await fsp.rm(tmp, { recursive: true, force: true });
+  }
+});

package/api/tests/precompressed-static.test.js

@@ -1,119 +1,119 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { createPrecompressedStatic } from '../framework/precompressedStatic.js';
-
-function fakeRes() {
-  return {
-    headers: {},
-    body: null,
-    sent: false,
-    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
-    send(body) { this.body = body; this.sent = true; return this; }
-  };
-}
-
-function run(mw, req) {
-  const res = fakeRes();
-  let nextCalled = false;
-  mw(req, res, () => { nextCalled = true; });
-  return { res, nextCalled };
-}
-
-async function withRoot(fn) {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-precomp-'));
-  try {
-    await fn(tmp);
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-}
-
-test('serves the .br variant when the client accepts brotli', async () => {
-  await withRoot(async (root) => {
-    await fsp.mkdir(path.join(root, 'bundles'), { recursive: true });
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js.br'), 'BROTLI-BYTES');
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js.gz'), 'GZIP-BYTES');
-
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, {
-      method: 'GET', path: '/bundles/app.js', headers: { 'accept-encoding': 'gzip, br' }
-    });
-
-    assert.equal(nextCalled, false);
-    assert.equal(res.sent, true);
-    assert.equal(res.body.toString(), 'BROTLI-BYTES'); // brotli preferred over gzip
-    assert.equal(res.headers['content-encoding'], 'br');
-    assert.equal(res.headers['content-type'], 'application/javascript; charset=utf-8');
-    assert.equal(res.headers['vary'], 'Accept-Encoding');
-  });
-});
-
-test('falls back to gzip when brotli is not accepted', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'style.css'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'style.css.gz'), 'GZIP-BYTES');
-
-    const mw = createPrecompressedStatic([root]);
-    const { res } = run(mw, { method: 'GET', path: '/style.css', headers: { 'accept-encoding': 'gzip' } });
-    assert.equal(res.headers['content-encoding'], 'gzip');
-    assert.equal(res.headers['content-type'], 'text/css; charset=utf-8');
-    assert.equal(res.body.toString(), 'GZIP-BYTES');
-  });
-});
-
-test('passes through when the client accepts no encoding', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'app.js.br'), 'BROTLI-BYTES');
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: {} });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});
-
-test('passes through when no precompressed variant exists', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL'); // no .br/.gz
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: { 'accept-encoding': 'br' } });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});
-
-test('passes through for non-text extensions', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'img.png.br'), 'X');
-    const mw = createPrecompressedStatic([root]);
-    const { nextCalled } = run(mw, { method: 'GET', path: '/img.png', headers: { 'accept-encoding': 'br' } });
-    assert.equal(nextCalled, true);
-  });
-});
-
-test('honors root priority (public over dist root)', async () => {
-  await withRoot(async (root) => {
-    const pub = path.join(root, 'public');
-    await fsp.mkdir(pub, { recursive: true });
-    await fsp.writeFile(path.join(pub, 'theme.css.br'), 'PUBLIC');
-    await fsp.writeFile(path.join(root, 'theme.css.br'), 'ROOT');
-    const mw = createPrecompressedStatic([pub, root]);
-    const { res } = run(mw, { method: 'GET', path: '/theme.css', headers: { 'accept-encoding': 'br' } });
-    assert.equal(res.body.toString(), 'PUBLIC');
-  });
-});
-
-test('blocks path traversal', async () => {
-  await withRoot(async (root) => {
-    const mw = createPrecompressedStatic([path.join(root, 'public')]);
-    const { nextCalled, res } = run(mw, {
-      method: 'GET', path: '/../secret.js', headers: { 'accept-encoding': 'br' }
-    });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { createPrecompressedStatic } from '../framework/precompressedStatic.js';
+
+function fakeRes() {
+  return {
+    headers: {},
+    body: null,
+    sent: false,
+    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
+    send(body) { this.body = body; this.sent = true; return this; }
+  };
+}
+
+function run(mw, req) {
+  const res = fakeRes();
+  let nextCalled = false;
+  mw(req, res, () => { nextCalled = true; });
+  return { res, nextCalled };
+}
+
+async function withRoot(fn) {
+  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-precomp-'));
+  try {
+    await fn(tmp);
+  } finally {
+    await fsp.rm(tmp, { recursive: true, force: true });
+  }
+}
+
+test('serves the .br variant when the client accepts brotli', async () => {
+  await withRoot(async (root) => {
+    await fsp.mkdir(path.join(root, 'bundles'), { recursive: true });
+    await fsp.writeFile(path.join(root, 'bundles', 'app.js'), 'ORIGINAL');
+    await fsp.writeFile(path.join(root, 'bundles', 'app.js.br'), 'BROTLI-BYTES');
+    await fsp.writeFile(path.join(root, 'bundles', 'app.js.gz'), 'GZIP-BYTES');
+
+    const mw = createPrecompressedStatic([root]);
+    const { res, nextCalled } = run(mw, {
+      method: 'GET', path: '/bundles/app.js', headers: { 'accept-encoding': 'gzip, br' }
+    });
+
+    assert.equal(nextCalled, false);
+    assert.equal(res.sent, true);
+    assert.equal(res.body.toString(), 'BROTLI-BYTES'); // brotli preferred over gzip
+    assert.equal(res.headers['content-encoding'], 'br');
+    assert.equal(res.headers['content-type'], 'application/javascript; charset=utf-8');
+    assert.equal(res.headers['vary'], 'Accept-Encoding');
+  });
+});
+
+test('falls back to gzip when brotli is not accepted', async () => {
+  await withRoot(async (root) => {
+    await fsp.writeFile(path.join(root, 'style.css'), 'ORIGINAL');
+    await fsp.writeFile(path.join(root, 'style.css.gz'), 'GZIP-BYTES');
+
+    const mw = createPrecompressedStatic([root]);
+    const { res } = run(mw, { method: 'GET', path: '/style.css', headers: { 'accept-encoding': 'gzip' } });
+    assert.equal(res.headers['content-encoding'], 'gzip');
+    assert.equal(res.headers['content-type'], 'text/css; charset=utf-8');
+    assert.equal(res.body.toString(), 'GZIP-BYTES');
+  });
+});
+
+test('passes through when the client accepts no encoding', async () => {
+  await withRoot(async (root) => {
+    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL');
+    await fsp.writeFile(path.join(root, 'app.js.br'), 'BROTLI-BYTES');
+    const mw = createPrecompressedStatic([root]);
+    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: {} });
+    assert.equal(nextCalled, true);
+    assert.equal(res.sent, false);
+  });
+});
+
+test('passes through when no precompressed variant exists', async () => {
+  await withRoot(async (root) => {
+    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL'); // no .br/.gz
+    const mw = createPrecompressedStatic([root]);
+    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: { 'accept-encoding': 'br' } });
+    assert.equal(nextCalled, true);
+    assert.equal(res.sent, false);
+  });
+});
+
+test('passes through for non-text extensions', async () => {
+  await withRoot(async (root) => {
+    await fsp.writeFile(path.join(root, 'img.png.br'), 'X');
+    const mw = createPrecompressedStatic([root]);
+    const { nextCalled } = run(mw, { method: 'GET', path: '/img.png', headers: { 'accept-encoding': 'br' } });
+    assert.equal(nextCalled, true);
+  });
+});
+
+test('honors root priority (public over dist root)', async () => {
+  await withRoot(async (root) => {
+    const pub = path.join(root, 'public');
+    await fsp.mkdir(pub, { recursive: true });
+    await fsp.writeFile(path.join(pub, 'theme.css.br'), 'PUBLIC');
+    await fsp.writeFile(path.join(root, 'theme.css.br'), 'ROOT');
+    const mw = createPrecompressedStatic([pub, root]);
+    const { res } = run(mw, { method: 'GET', path: '/theme.css', headers: { 'accept-encoding': 'br' } });
+    assert.equal(res.body.toString(), 'PUBLIC');
+  });
+});
+
+test('blocks path traversal', async () => {
+  await withRoot(async (root) => {
+    const mw = createPrecompressedStatic([path.join(root, 'public')]);
+    const { nextCalled, res } = run(mw, {
+      method: 'GET', path: '/../secret.js', headers: { 'accept-encoding': 'br' }
+    });
+    assert.equal(nextCalled, true);
+    assert.equal(res.sent, false);
+  });
+});