@atolljs/cli 0.1.8 → 0.1.9

package/dist/cli.js

@@ -209,6 +209,9 @@ var NPMRC = `# Supply-chain hardening \u2014 read by every npm command run in th
 # lockfile (requires npm >= 11.10 \u2014 shipped with Node 26; older npm
 # silently ignores this key).
 min-release-age=7
+# First-party packages must install even inside the age window (npm 11.10+;
+# older npm silently ignores the key).
+min-release-age-exclude[]=@atolljs/*
 # Install lifecycle scripts are the dominant malware vector \u2014 none run
 # during install/ci. If a native dep ever legitimately needs one:
 #   npm rebuild <pkg> --ignore-scripts=false
@@ -222,7 +225,7 @@ dist/
 `;
 function memoryContract(name) {
   const c = camel(name);
-  return `import { defineSharedMemory, field, mz } from '@atolljs/core';
+  return `import { defineSharedMemory, field, reef } from '@atolljs/core';
 
 /**
  * ${c} shared memory \u2014 the single source of truth for state both threads
@@ -238,10 +241,10 @@ export const ${c}Memory = defineSharedMemory({
   // Structured snapshots \u2014 one inline record, rewritten wholesale.
   state: {
     summary: field.object({
-      schema: mz.object({
-        total: mz.f64(),
-        errors: mz.f64(),
-        updatedAt: mz.u32(),
+      schema: reef.object({
+        total: reef.f64(),
+        errors: reef.f64(),
+        updatedAt: reef.u32(),
       }),
     }),
   },
@@ -1789,8 +1792,10 @@ ${serviceImport}${memImport}
   imports: [
     AtollModule.registerPool({
       name: '${name}',
-      // webpack emits the worker entry as its own chunk \u2014 keep the URL inline
-      worker: () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+      // the emitted worker bundle \u2014 keep the URL inline. Under a Vite SSR
+      // build declare ${name}.worker.ts as a build input; on webpack point
+      // this at the './${name}.worker.ts' source instead.
+      worker: () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
 ${memLine}      poolSize: 'auto',
     }),
   ],
@@ -1881,7 +1886,7 @@ function nestjsHousedFiles(name, dir) {
 // runs in. Message-only by default; to share another pool's buffer, wrap
 // the factory:
 //   worker: withSharedBuffer(
-//     () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+//     () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
 //     () => getAtollPool('<other-pool>')?.sharedBuffer,
 //   )
 import { Module } from '@nestjs/common';
@@ -1892,7 +1897,10 @@ import { AtollModule } from '@atolljs/nestjs';
   imports: [
     AtollModule.registerPool({
       name: '${name}',
-      worker: () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+      // the emitted worker bundle \u2014 keep the URL inline. Under a Vite SSR
+      // build declare ${name}.worker.ts as a build input; on webpack point
+      // this at the './${name}.worker.ts' source instead.
+      worker: () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
       poolSize: 2,
     }),
   ],
@@ -2245,6 +2253,63 @@ initDevtools({
 initDevtools({ session: { name: '${name}' } });
 `;
 }
+function nestjsViteConfig() {
+  return `import { readdirSync } from 'node:fs';
+import { basename } from 'node:path';
+import { defineConfig } from 'vite';
+
+// Every *.worker.ts under src/ is its own entry \u2014 pool configs reference the
+// emitted './x.worker.js' via new URL(..., import.meta.url). Keys are
+// basenames, so output is flat and the literal resolves from dist/main.js.
+const workerInputs = Object.fromEntries(
+  readdirSync('src', { recursive: true, withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith('.worker.ts'))
+    .map((e) => {
+      const dir = (e.parentPath ?? e.path).replaceAll('\\\\', '/');
+      return [basename(e.name, '.ts'), \`\${dir}/\${e.name}\`];
+    }),
+);
+
+export default defineConfig({
+  build: {
+    // Node SSR build: node builtins + node_modules stay external.
+    ssr: true,
+    outDir: 'dist',
+    rollupOptions: {
+      input: { main: 'src/main.ts', ...workerInputs },
+      // Flat layout: a './x.worker.js' literal resolves to dist/<name>.worker.js
+      // whether it lands in main.js or a shared chunk (the default assets/
+      // subdir would put chunks one level too deep).
+      output: { entryFileNames: '[name].js', chunkFileNames: '[name]-[hash].js' },
+    },
+  },
+});
+`;
+}
+function devServerScript() {
+  return `// Dev loop: vite's Rollup watcher rebuilds main + worker bundles on change
+// while \`node --watch\` restarts the app whenever dist/ updates \u2014 a worker
+// reload is a respawn anyway. Programmatic API: no npx/.cmd spawn (Node
+// 20.12+ blocks .cmd spawn without shell:true on Windows \u2192 EINVAL).
+import { spawn } from 'node:child_process';
+import { build } from 'vite';
+
+await build(); // initial build \u2014 throws and exits on failure
+await build({ build: { watch: {} } }); // keeps the process alive
+
+const child = spawn(process.execPath, ['--watch', 'dist/main.js'], {
+  stdio: 'inherit',
+});
+
+const shutdown = () => {
+  child.kill();
+  process.exit(0);
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('exit', () => child.kill());
+`;
+}
 
 // src/commands.ts
 var NODE_HOSTS = ["node", "nestjs"];
@@ -2272,7 +2337,14 @@ async function offerInstall(ctx, project, pkgs, installAll = false) {
     cwd: project.root ?? ctx.cwd,
     stdio: "inherit"
   });
-  if (r.status !== 0) throw new Error(`install failed \u2014 run \`${cmd}\` manually`);
+  if (r.status !== 0) {
+    if (project.framework === "nestjs") {
+      ctx.io.warn(
+        "if npm reported ERESOLVE: the installed @nestjs/* major may be outside the range @atolljs/nestjs supports (@nestjs/common and @nestjs/core 11.x or 12.x). Align all @nestjs/* packages to a supported major, or rerun the install with --legacy-peer-deps."
+      );
+    }
+    throw new Error(`install failed \u2014 run \`${cmd}\` manually`);
+  }
 }
 async function runInit(ctx) {
   const project = detectProject(ctx.cwd);
@@ -2289,36 +2361,54 @@ async function runInit(ctx) {
   await writeTree(ctx.io, ctx.cwd, [{ path: rel(join3(project.root, ".npmrc")), content: NPMRC }], {
     force: hasFlag(ctx.args, "force")
   });
-  await offerInstall(ctx, project, ATOLL_DEPS[project.framework]);
   const atollDir = join3(project.srcDir, "atoll");
   const host = hostOf(project.framework);
   const name = flag(ctx.args, "name") ?? "app";
   const files = [
-    { path: `${rel(atollDir)}/${name}.memory.ts`, content: memoryContract(name) },
-    {
-      path: `${rel(atollDir)}/${name}.worker.ts`,
-      content: workerEntry(name, {
-        host,
-        memoryImport: `./${name}.memory`,
-        memoryName: `${camel(name)}Memory`,
-        demoMemoryWrite: true
-      })
-    },
-    {
-      path: `${rel(atollDir)}/${name}.ts`,
-      content: workerClientFile(name, {
-        host,
-        memoryImport: `./${name}.memory`,
-        memoryName: `${camel(name)}Memory`,
-        // src/atoll/x.ts → <root>/dist/x.worker.js
-        distUrl: `${relative(atollDir, join3(project.root, "dist")).replaceAll("\\", "/")}/${name}.worker.js`
-      })
-    }
+    { path: `${rel(atollDir)}/${name}.memory.ts`, content: memoryContract(name) }
   ];
+  if (project.framework === "nestjs") {
+    files.push(
+      ...nestjsServiceFiles(name, rel(atollDir), {
+        import_: `./${name}.memory`,
+        export_: `${camel(name)}Memory`
+      })
+    );
+  } else {
+    files.push(
+      {
+        path: `${rel(atollDir)}/${name}.worker.ts`,
+        content: workerEntry(name, {
+          host,
+          memoryImport: `./${name}.memory`,
+          memoryName: `${camel(name)}Memory`,
+          demoMemoryWrite: true
+        })
+      },
+      {
+        path: `${rel(atollDir)}/${name}.ts`,
+        content: workerClientFile(name, {
+          host,
+          memoryImport: `./${name}.memory`,
+          memoryName: `${camel(name)}Memory`,
+          // src/atoll/x.ts → <root>/dist/x.worker.js
+          distUrl: `${relative(atollDir, join3(project.root, "dist")).replaceAll("\\", "/")}/${name}.worker.js`
+        })
+      }
+    );
+  }
   await writeTree(ctx.io, ctx.cwd, files, { force: hasFlag(ctx.args, "force") });
+  await offerInstall(ctx, project, ATOLL_DEPS[project.framework]);
   ctx.io.print("");
   ctx.io.print(ctx.io.fmt.strong("next steps:"));
-  if (host === "node") {
+  if (project.framework === "nestjs") {
+    ctx.io.print(
+      `  import ${ctx.io.fmt.accent(`${pascal(name)}Module`)} into AppModule, then inject ${ctx.io.fmt.accent(`${pascal(name)}Service`)} \u2014 ${ctx.io.fmt.accent(`service.echo('hi')`)} runs in a worker`
+    );
+    ctx.io.print(
+      `  worker entries emit as ${ctx.io.fmt.accent(`${name}.worker.js`)} \u2014 declare them as build inputs (see docs/frameworks/nestjs.md)`
+    );
+  } else if (host === "node") {
     ctx.io.print(
       `  bundle the worker entry (see the comment in ${name}.ts), then call ${ctx.io.fmt.accent(`${camel(name)}.echo('hi')`)}`
     );
@@ -2332,6 +2422,115 @@ async function runInit(ctx) {
   );
   return 0;
 }
+function rewriteWorkerUrls(srcDir) {
+  const urlRe = /(new URL\(\s*['"`][^'"`]*?\.worker)\.ts(['"`])/g;
+  const changed = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join3(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith(".ts")) {
+        const src = readFileSync2(p, "utf8");
+        const next = src.replace(urlRe, "$1.js$2");
+        if (next !== src) {
+          writeFileSync2(p, next);
+          changed.push(p);
+        }
+      }
+    }
+  };
+  walk(srcDir);
+  return changed;
+}
+async function runConvert(ctx) {
+  const target = ctx.args._[1];
+  if (target !== "vite") {
+    ctx.io.error(
+      `unknown convert target ${ctx.io.fmt.accent(target ?? "(missing)")} \u2014 expected 'vite'`
+    );
+    return 1;
+  }
+  const project = detectProject(ctx.cwd);
+  if (!project.root || !project.pkg) {
+    ctx.io.error("no package.json found \u2014 cd into the project to convert");
+    return 1;
+  }
+  if (project.framework !== "nestjs") {
+    ctx.io.error(
+      `convert vite supports nestjs projects \u2014 detected "${project.framework}"`
+    );
+    return 1;
+  }
+  const root = project.root;
+  const rel = (abs) => relative(ctx.cwd, abs).replaceAll("\\", "/");
+  const force = hasFlag(ctx.args, "force");
+  const srcDir = project.srcDir;
+  await writeTree(
+    ctx.io,
+    ctx.cwd,
+    [
+      { path: rel(join3(root, "vite.config.ts")), content: nestjsViteConfig() },
+      { path: rel(join3(root, "dev.mjs")), content: devServerScript() }
+    ],
+    { force }
+  );
+  const rewritten = rewriteWorkerUrls(srcDir);
+  for (const p of rewritten) ctx.io.print(`  rewrote worker URL \u2014 ${rel(p)}`);
+  const pkgPath = join3(root, "package.json");
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+  pkg.type = "module";
+  pkg.scripts = {
+    ...pkg.scripts,
+    dev: "node dev.mjs",
+    build: "tsc --noEmit && vite build",
+    start: "node dist/main.js"
+  };
+  pkg.devDependencies = { ...pkg.devDependencies, vite: pkg.devDependencies?.vite ?? "^8.3.1" };
+  writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  ctx.io.print(`  package.json \u2014 type:module, dev/build/start scripts, vite devDep`);
+  const tsconfigPath = join3(root, "tsconfig.json");
+  try {
+    const raw = readFileSync2(tsconfigPath, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1").replace(/,(\s*[}\]])/g, "$1");
+    const tsconfig = JSON.parse(raw);
+    tsconfig.compilerOptions ??= {};
+    Object.assign(tsconfig.compilerOptions, {
+      module: "ESNext",
+      moduleResolution: "bundler",
+      noEmit: true
+    });
+    tsconfig.include = [.../* @__PURE__ */ new Set([...tsconfig.include ?? ["src"], "vite.config.ts"])];
+    writeFileSync2(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+    ctx.io.print(`  tsconfig.json \u2014 module ESNext, moduleResolution bundler, noEmit`);
+  } catch {
+    ctx.io.warn(
+      "could not patch tsconfig.json \u2014 set module: ESNext, moduleResolution: bundler, noEmit: true manually"
+    );
+  }
+  const mainTs = join3(srcDir, "main.ts");
+  if (existsSync3(mainTs)) {
+    const src = readFileSync2(mainTs, "utf8");
+    if (!src.includes("reflect-metadata")) {
+      writeFileSync2(mainTs, `import 'reflect-metadata';
+${src}`);
+      ctx.io.print(`  main.ts \u2014 prepended import 'reflect-metadata'`);
+    }
+  }
+  for (const leftover of ["nest-cli.json", "webpack.config.js", "webpack.config.cjs"]) {
+    if (existsSync3(join3(root, leftover))) {
+      ctx.io.print(ctx.io.fmt.dim(`  ${leftover} is no longer used \u2014 safe to delete`));
+    }
+  }
+  await offerInstall(ctx, project, ["vite"], true);
+  ctx.io.print("");
+  ctx.io.print(ctx.io.fmt.strong("converted to a Vite SSR build:"));
+  ctx.io.print(
+    `  ${ctx.io.fmt.accent("npm run dev")} \u2014 vite build --watch + node --watch dist/main.js`
+  );
+  ctx.io.print(
+    `  ${ctx.io.fmt.accent("npm run build")} \u2192 dist/ \xB7 ${ctx.io.fmt.accent("npm start")} \u2014 node dist/main.js`
+  );
+  return 0;
+}
 var ADD_KINDS = [
   "worker",
   "memory",
@@ -2883,6 +3082,11 @@ var HELP = (fmt) => `${fmt.strong("atoll")} \u2014 bootstrap multithreading ${fm
       Frameworks: react vue solid svelte angular nestjs nextjs node
       [--dir <path>] [--memory <name>|--no-memory] [--variant <v>] [--force]
 
+  ${fmt.accent("atoll convert vite")} [--force]
+      Convert a NestJS project from the webpack build to a Vite SSR build \u2014
+      vite.config.ts + dev.mjs, worker URLs repointed at emitted bundles,
+      package.json/tsconfig patched.
+
   ${fmt.accent("atoll doctor")} [--fix]
       Check the setup \u2014 deps, lockfile, .npmrc policy, bundler-detectable
       worker entries, COOP/COEP headers. --fix writes a hardened .npmrc.
@@ -2910,6 +3114,8 @@ async function runCli(argv, io, cwd) {
         return await runInit(ctx);
       case "add":
         return await runAdd(ctx);
+      case "convert":
+        return await runConvert(ctx);
       case "doctor":
         return runDoctor(ctx);
       case "devtools":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolljs/cli",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "atoll — scaffold worker pools, shared-memory contracts, and framework islands (experimental)",
   "homepage": "https://jwhenry3.github.io/atolljs/consumer/quickstart/",
   "type": "module",

package/src/cli.ts

@@ -12,7 +12,7 @@
  */
 import { consoleIo, type Fmt, type Io } from './io.ts';
 import { hasFlag, parseArgs } from './parse.ts';
-import { runAdd, runCreate, runDevtools, runDoctor, runInit, type Ctx } from './commands.ts';
+import { runAdd, runConvert, runCreate, runDevtools, runDoctor, runInit, type Ctx } from './commands.ts';
 
 const HELP = (fmt: Fmt) => `${fmt.strong('atoll')} — bootstrap multithreading ${fmt.dim('(experimental)')}
 
@@ -44,6 +44,11 @@ const HELP = (fmt: Fmt) => `${fmt.strong('atoll')} — bootstrap multithreading
       Frameworks: react vue solid svelte angular nestjs nextjs node
       [--dir <path>] [--memory <name>|--no-memory] [--variant <v>] [--force]
 
+  ${fmt.accent('atoll convert vite')} [--force]
+      Convert a NestJS project from the webpack build to a Vite SSR build —
+      vite.config.ts + dev.mjs, worker URLs repointed at emitted bundles,
+      package.json/tsconfig patched.
+
   ${fmt.accent('atoll doctor')} [--fix]
       Check the setup — deps, lockfile, .npmrc policy, bundler-detectable
       worker entries, COOP/COEP headers. --fix writes a hardened .npmrc.
@@ -77,6 +82,8 @@ export async function runCli(argv: readonly string[], io: Io, cwd: string): Prom
         return await runInit(ctx);
       case 'add':
         return await runAdd(ctx);
+      case 'convert':
+        return await runConvert(ctx);
       case 'doctor':
         return runDoctor(ctx);
       case 'devtools':

package/src/commands.ts

@@ -61,7 +61,14 @@ async function offerInstall(
     cwd: project.root ?? ctx.cwd,
     stdio: 'inherit',
   });
-  if (r.status !== 0) throw new Error(`install failed — run \`${cmd}\` manually`);
+  if (r.status !== 0) {
+    if (project.framework === 'nestjs') {
+      ctx.io.warn(
+        'if npm reported ERESOLVE: the installed @nestjs/* major may be outside the range @atolljs/nestjs supports (@nestjs/common and @nestjs/core 11.x or 12.x). Align all @nestjs/* packages to a supported major, or rerun the install with --legacy-peer-deps.',
+      );
+    }
+    throw new Error(`install failed — run \`${cmd}\` manually`);
+  }
 }
 
 /* ── atoll init ─────────────────────────────────────────────────────────── */
@@ -84,39 +91,60 @@ export async function runInit(ctx: Ctx): Promise<number> {
     force: hasFlag(ctx.args, 'force'),
   });
 
-  await offerInstall(ctx, project, ATOLL_DEPS[project.framework]);
-
-  // A working spine: contract + worker + client, already wired together.
+  // A working spine — written BEFORE the install so a failed install still
+  // leaves a complete, retryable scaffold. NestJS gets the DI-native spine
+  // (service facade + registerPool module + worker entry); other hosts get
+  // the contract + worker + client trio.
   const atollDir = join(project.srcDir, 'atoll');
   const host = hostOf(project.framework);
   const name = flag(ctx.args, 'name') ?? 'app';
   const files: OutFile[] = [
     { path: `${rel(atollDir)}/${name}.memory.ts`, content: T.memoryContract(name) },
-    {
-      path: `${rel(atollDir)}/${name}.worker.ts`,
-      content: T.workerEntry(name, {
-        host,
-        memoryImport: `./${name}.memory`,
-        memoryName: `${camel(name)}Memory`,
-        demoMemoryWrite: true,
-      }),
-    },
-    {
-      path: `${rel(atollDir)}/${name}.ts`,
-      content: T.workerClientFile(name, {
-        host,
-        memoryImport: `./${name}.memory`,
-        memoryName: `${camel(name)}Memory`,
-        // src/atoll/x.ts → <root>/dist/x.worker.js
-        distUrl: `${relative(atollDir, join(project.root, 'dist')).replaceAll('\\', '/')}/${name}.worker.js`,
-      }),
-    },
   ];
+  if (project.framework === 'nestjs') {
+    files.push(
+      ...T.nestjsServiceFiles(name, rel(atollDir), {
+        import_: `./${name}.memory`,
+        export_: `${camel(name)}Memory`,
+      }),
+    );
+  } else {
+    files.push(
+      {
+        path: `${rel(atollDir)}/${name}.worker.ts`,
+        content: T.workerEntry(name, {
+          host,
+          memoryImport: `./${name}.memory`,
+          memoryName: `${camel(name)}Memory`,
+          demoMemoryWrite: true,
+        }),
+      },
+      {
+        path: `${rel(atollDir)}/${name}.ts`,
+        content: T.workerClientFile(name, {
+          host,
+          memoryImport: `./${name}.memory`,
+          memoryName: `${camel(name)}Memory`,
+          // src/atoll/x.ts → <root>/dist/x.worker.js
+          distUrl: `${relative(atollDir, join(project.root, 'dist')).replaceAll('\\', '/')}/${name}.worker.js`,
+        }),
+      },
+    );
+  }
   await writeTree(ctx.io, ctx.cwd, files, { force: hasFlag(ctx.args, 'force') });
 
+  await offerInstall(ctx, project, ATOLL_DEPS[project.framework]);
+
   ctx.io.print('');
   ctx.io.print(ctx.io.fmt.strong('next steps:'));
-  if (host === 'node') {
+  if (project.framework === 'nestjs') {
+    ctx.io.print(
+      `  import ${ctx.io.fmt.accent(`${pascal(name)}Module`)} into AppModule, then inject ${ctx.io.fmt.accent(`${pascal(name)}Service`)} — ${ctx.io.fmt.accent(`service.echo('hi')`)} runs in a worker`,
+    );
+    ctx.io.print(
+      `  worker entries emit as ${ctx.io.fmt.accent(`${name}.worker.js`)} — declare them as build inputs (see docs/frameworks/nestjs.md)`,
+    );
+  } else if (host === 'node') {
     ctx.io.print(
       `  bundle the worker entry (see the comment in ${name}.ts), then call ${ctx.io.fmt.accent(`${camel(name)}.echo('hi')`)}`,
     );
@@ -131,6 +159,139 @@ export async function runInit(ctx: Ctx): Promise<number> {
   return 0;
 }
 
+/* ── atoll convert vite ─────────────────────────────────────────────────── */
+
+/** Repoint `new URL('./x.worker.ts', import.meta.url)` literals at the emitted
+ * bundles — Vite SSR build takes workers as explicit inputs, so pool
+ * factories reference `./x.worker.js`. Returns the files it changed. */
+function rewriteWorkerUrls(srcDir: string): string[] {
+  const urlRe = /(new URL\(\s*['"`][^'"`]*?\.worker)\.ts(['"`])/g;
+  const changed: string[] = [];
+  const walk = (dir: string) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith('.ts')) {
+        const src = readFileSync(p, 'utf8');
+        const next = src.replace(urlRe, '$1.js$2');
+        if (next !== src) {
+          writeFileSync(p, next);
+          changed.push(p);
+        }
+      }
+    }
+  };
+  walk(srcDir);
+  return changed;
+}
+
+export async function runConvert(ctx: Ctx): Promise<number> {
+  const target = ctx.args._[1];
+  if (target !== 'vite') {
+    ctx.io.error(
+      `unknown convert target ${ctx.io.fmt.accent(target ?? '(missing)')} — expected 'vite'`,
+    );
+    return 1;
+  }
+  const project = detectProject(ctx.cwd);
+  if (!project.root || !project.pkg) {
+    ctx.io.error('no package.json found — cd into the project to convert');
+    return 1;
+  }
+  if (project.framework !== 'nestjs') {
+    ctx.io.error(
+      `convert vite supports nestjs projects — detected "${project.framework}"`,
+    );
+    return 1;
+  }
+  const root = project.root;
+  const rel = (abs: string) => relative(ctx.cwd, abs).replaceAll('\\', '/');
+  const force = hasFlag(ctx.args, 'force');
+  const srcDir = project.srcDir;
+
+  // Build files: SSR multi-entry config + the watch dev loop.
+  await writeTree(
+    ctx.io,
+    ctx.cwd,
+    [
+      { path: rel(join(root, 'vite.config.ts')), content: T.nestjsViteConfig() },
+      { path: rel(join(root, 'dev.mjs')), content: T.devServerScript() },
+    ],
+    { force },
+  );
+
+  // Pool factories reference the emitted worker bundles now.
+  const rewritten = rewriteWorkerUrls(srcDir);
+  for (const p of rewritten) ctx.io.print(`  rewrote worker URL — ${rel(p)}`);
+
+  // package.json: ESM, vite scripts, vite devDep.
+  const pkgPath = join(root, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  pkg.type = 'module';
+  pkg.scripts = {
+    ...pkg.scripts,
+    dev: 'node dev.mjs',
+    build: 'tsc --noEmit && vite build',
+    start: 'node dist/main.js',
+  };
+  pkg.devDependencies = { ...pkg.devDependencies, vite: pkg.devDependencies?.vite ?? '^8.3.1' };
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  ctx.io.print(`  package.json — type:module, dev/build/start scripts, vite devDep`);
+
+  // tsconfig: bundler resolution so extensionless imports keep typechecking;
+  // typecheck-only (noEmit) since vite owns emit.
+  const tsconfigPath = join(root, 'tsconfig.json');
+  try {
+    const raw = readFileSync(tsconfigPath, 'utf8')
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/(^|\s)\/\/.*$/gm, '$1')
+      .replace(/,(\s*[}\]])/g, '$1');
+    const tsconfig = JSON.parse(raw);
+    tsconfig.compilerOptions ??= {};
+    Object.assign(tsconfig.compilerOptions, {
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      noEmit: true,
+    });
+    tsconfig.include = [...new Set([...(tsconfig.include ?? ['src']), 'vite.config.ts'])];
+    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n');
+    ctx.io.print(`  tsconfig.json — module ESNext, moduleResolution bundler, noEmit`);
+  } catch {
+    ctx.io.warn(
+      'could not patch tsconfig.json — set module: ESNext, moduleResolution: bundler, noEmit: true manually',
+    );
+  }
+
+  // esbuild drops the metadata decorators need only when emitDecoratorMetadata
+  // carries injections — the shim is still required before any decorated class.
+  const mainTs = join(srcDir, 'main.ts');
+  if (existsSync(mainTs)) {
+    const src = readFileSync(mainTs, 'utf8');
+    if (!src.includes('reflect-metadata')) {
+      writeFileSync(mainTs, `import 'reflect-metadata';\n${src}`);
+      ctx.io.print(`  main.ts — prepended import 'reflect-metadata'`);
+    }
+  }
+
+  for (const leftover of ['nest-cli.json', 'webpack.config.js', 'webpack.config.cjs']) {
+    if (existsSync(join(root, leftover))) {
+      ctx.io.print(ctx.io.fmt.dim(`  ${leftover} is no longer used — safe to delete`));
+    }
+  }
+
+  await offerInstall(ctx, project, ['vite'], true);
+
+  ctx.io.print('');
+  ctx.io.print(ctx.io.fmt.strong('converted to a Vite SSR build:'));
+  ctx.io.print(
+    `  ${ctx.io.fmt.accent('npm run dev')} — vite build --watch + node --watch dist/main.js`,
+  );
+  ctx.io.print(
+    `  ${ctx.io.fmt.accent('npm run build')} → dist/ · ${ctx.io.fmt.accent('npm start')} — node dist/main.js`,
+  );
+  return 0;
+}
+
 /* ── atoll add [framework] <kind> [variant] [name] ───────────────────────── */
 
 const ADD_KINDS = [

package/src/templates.ts

@@ -9,6 +9,9 @@ export const NPMRC = `# Supply-chain hardening — read by every npm command run
 # lockfile (requires npm >= 11.10 — shipped with Node 26; older npm
 # silently ignores this key).
 min-release-age=7
+# First-party packages must install even inside the age window (npm 11.10+;
+# older npm silently ignores the key).
+min-release-age-exclude[]=@atolljs/*
 # Install lifecycle scripts are the dominant malware vector — none run
 # during install/ci. If a native dep ever legitimately needs one:
 #   npm rebuild <pkg> --ignore-scripts=false
@@ -26,7 +29,7 @@ dist/
 
 export function memoryContract(name: string): string {
   const c = camel(name);
-  return `import { defineSharedMemory, field, mz } from '@atolljs/core';
+  return `import { defineSharedMemory, field, reef } from '@atolljs/core';
 
 /**
  * ${c} shared memory — the single source of truth for state both threads
@@ -42,10 +45,10 @@ export const ${c}Memory = defineSharedMemory({
   // Structured snapshots — one inline record, rewritten wholesale.
   state: {
     summary: field.object({
-      schema: mz.object({
-        total: mz.f64(),
-        errors: mz.f64(),
-        updatedAt: mz.u32(),
+      schema: reef.object({
+        total: reef.f64(),
+        errors: reef.f64(),
+        updatedAt: reef.u32(),
       }),
     }),
   },
@@ -1705,8 +1708,10 @@ ${serviceImport}${memImport}
   imports: [
     AtollModule.registerPool({
       name: '${name}',
-      // webpack emits the worker entry as its own chunk — keep the URL inline
-      worker: () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+      // the emitted worker bundle — keep the URL inline. Under a Vite SSR
+      // build declare ${name}.worker.ts as a build input; on webpack point
+      // this at the './${name}.worker.ts' source instead.
+      worker: () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
 ${memLine}      poolSize: 'auto',
     }),
   ],
@@ -1817,7 +1822,7 @@ export function nestjsHousedFiles(name: string, dir: string): OutFile[] {
 // runs in. Message-only by default; to share another pool's buffer, wrap
 // the factory:
 //   worker: withSharedBuffer(
-//     () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+//     () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
 //     () => getAtollPool('<other-pool>')?.sharedBuffer,
 //   )
 import { Module } from '@nestjs/common';
@@ -1828,7 +1833,10 @@ import { AtollModule } from '@atolljs/nestjs';
   imports: [
     AtollModule.registerPool({
       name: '${name}',
-      worker: () => new Worker(new URL('./${name}.worker.ts', import.meta.url)),
+      // the emitted worker bundle — keep the URL inline. Under a Vite SSR
+      // build declare ${name}.worker.ts as a build input; on webpack point
+      // this at the './${name}.worker.ts' source instead.
+      worker: () => new Worker(new URL('./${name}.worker.js', import.meta.url)),
       poolSize: 2,
     }),
   ],
@@ -2226,3 +2234,77 @@ initDevtools({
 initDevtools({ session: { name: '${name}' } });
 `;
 }
+
+/* ── `atoll convert vite` (nestjs → Vite SSR build) ─────────────────────── */
+
+/**
+ * Consumer-facing vite.config.ts for a converted NestJS project — no repo
+ * aliases (published @atolljs/* packages resolve from node_modules). Every
+ * src/**\/*.worker.ts is an explicit rollup input; output is flat so a
+ * './x.worker.js' literal resolves from dist/main.js or a shared chunk.
+ * Uses readdirSync recursive (Node 20.1+) rather than globSync (Node 22+).
+ */
+export function nestjsViteConfig(): string {
+  return `import { readdirSync } from 'node:fs';
+import { basename } from 'node:path';
+import { defineConfig } from 'vite';
+
+// Every *.worker.ts under src/ is its own entry — pool configs reference the
+// emitted './x.worker.js' via new URL(..., import.meta.url). Keys are
+// basenames, so output is flat and the literal resolves from dist/main.js.
+const workerInputs = Object.fromEntries(
+  readdirSync('src', { recursive: true, withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith('.worker.ts'))
+    .map((e) => {
+      const dir = (e.parentPath ?? e.path).replaceAll('\\\\', '/');
+      return [basename(e.name, '.ts'), \`\${dir}/\${e.name}\`];
+    }),
+);
+
+export default defineConfig({
+  build: {
+    // Node SSR build: node builtins + node_modules stay external.
+    ssr: true,
+    outDir: 'dist',
+    rollupOptions: {
+      input: { main: 'src/main.ts', ...workerInputs },
+      // Flat layout: a './x.worker.js' literal resolves to dist/<name>.worker.js
+      // whether it lands in main.js or a shared chunk (the default assets/
+      // subdir would put chunks one level too deep).
+      output: { entryFileNames: '[name].js', chunkFileNames: '[name]-[hash].js' },
+    },
+  },
+});
+`;
+}
+
+/**
+ * `node --watch` + vite watcher dev loop for the converted project — a
+ * worker reload is a respawn anyway, so watching dist/ is enough. Uses
+ * vite's programmatic build API: no npx/.cmd spawn (Node 20.12+ blocks .cmd
+ * spawn without shell:true on Windows → EINVAL).
+ */
+export function devServerScript(): string {
+  return `// Dev loop: vite's Rollup watcher rebuilds main + worker bundles on change
+// while \`node --watch\` restarts the app whenever dist/ updates — a worker
+// reload is a respawn anyway. Programmatic API: no npx/.cmd spawn (Node
+// 20.12+ blocks .cmd spawn without shell:true on Windows → EINVAL).
+import { spawn } from 'node:child_process';
+import { build } from 'vite';
+
+await build(); // initial build — throws and exits on failure
+await build({ build: { watch: {} } }); // keeps the process alive
+
+const child = spawn(process.execPath, ['--watch', 'dist/main.js'], {
+  stdio: 'inherit',
+});
+
+const shutdown = () => {
+  child.kill();
+  process.exit(0);
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('exit', () => child.kill());
+`;
+}