@preact-mvc/cli 0.0.0-stage → 0.0.0

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@preact-mvc/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.0",
+  "description": "Project scaffolding and maintenance CLI for preact-mvc: new, generate, serve/build/test, add, update",
+  "type": "module",
+  "bin": {
+    "pmvc": "./src/cli.mjs",
+    "preact-mvc": "./src/cli.mjs"
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "license": "MIT"
+}

package/src/cli.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * pmvc — the preact-mvc CLI. Angular-CLI-shaped: new / generate /
+ * serve / build / test / add / update / version / docs.
+ *
+ * Dependency-free on purpose: the CLI must run before a project has
+ * node_modules, and it ships runnable .mjs (other @preact-mvc packages
+ * ship ./src/*.ts for bundler resolution — a bin needs JS).
+ */
+import { execSync } from 'node:child_process';
+import { args, cliVersion, findProjectRoot, frameworkDeps, log } from './lib.mjs';
+import { cmdNew } from './commands/new.mjs';
+import { cmdGenerate } from './commands/generate.mjs';
+import { cmdBuild, cmdServe, cmdTest } from './commands/run.mjs';
+import { cmdAdd, cmdUpdate } from './commands/update.mjs';
+const HELP = `pmvc — the preact-mvc CLI
+
+Usage: pmvc <command> [args] [flags]
+
+Project creation
+  new <dir>                 Scaffold a new application
+    --islands                 include a worker-island demo (contract + worker + route)
+    --tailwind                wire Tailwind v4 (deps + vite plugin + styles)
+    --skip-install            don't npm install
+    --skip-tests              don't emit the sample test
+    -d, --dry-run             print what would be created
+    --force                   overwrite existing files
+
+Generators
+  g|generate <kind> <name>  Scaffold into an existing project (run inside one)
+    view|component            src/app/<name>/<name>.view.tsx (+ .test.tsx)
+    controller                <name>.controller.ts — @Controller view logic
+    service                   <name>.service.ts — @Injectable model/service
+    module                    <name>.module.ts — feature module
+    island                    islands/<name>.contract.ts + workers/<name>.worker.tsx
+    --path <dir>              override the target directory
+    --skip-tests / -d / --force
+
+Build & dev (delegates to the project's vite/vitest)
+  serve|dev [vite args]     Dev server
+  build [vite args]         tsc --noEmit + vite build (--no-typecheck to skip)
+  test [vitest args]        vitest run (--watch for watch mode)
+
+Maintenance
+  add <recipe>              Install + wire an integration: tailwind | islands
+  update                    Bump @preact-mvc/* deps to latest (or --to <ver>)
+    --include-atoll           also bump @atolljs/* deps
+    -d / --skip-install
+
+Other
+  version|v|(--version|-v)  CLI + detected project versions
+  docs [--open]             Where the docs live
+  help|(--help|-h)          This message
+`;
+
+function cmdVersion() {
+  log(`@preact-mvc/cli ${cliVersion()}`);
+  const found = findProjectRoot();
+  if (found) {
+    const deps = { ...found.pkg.dependencies, ...found.pkg.devDependencies };
+    for (const dep of frameworkDeps(found.pkg)) {
+      log(`  ${dep}: ${deps[dep]}`);
+    }
+    if (deps['@atolljs/core']) log(`  @atolljs/core: ${deps['@atolljs/core']}`);
+    if (deps.preact) log(`  preact: ${deps.preact}`);
+    if (deps.vite) log(`  vite: ${deps.vite}`);
+  }
+}
+
+function cmdDocs(a) {
+  const url = 'https://github.com/jwhenry3/preact-mvc';
+  if (a.open) {
+    try {
+      const opener =
+        process.platform === 'win32'
+          ? `start "" "${url}"`
+          : process.platform === 'darwin'
+            ? `open "${url}"`
+            : `xdg-open "${url}"`;
+      execSync(opener, { stdio: 'ignore', shell: true });
+      return;
+    } catch {
+      // fall through to printing
+    }
+  }
+  log(`Docs site lives in this repo (docs-consumer/) — sources of truth:`);
+  log(`  repo:      ${url}`);
+  log(`  local:     npm run dev:docs  (in the framework checkout)`);
+}
+
+const COMMANDS = {
+  new: cmdNew,
+  g: cmdGenerate,
+  generate: cmdGenerate,
+  add: cmdAdd,
+  update: cmdUpdate,
+  docs: cmdDocs,
+};
+
+// serve/build/test pass ALL args through to vite/vitest — raw argv, not
+// parsed flags (a `--port 3000` belongs to vite, not pmvc).
+const RAW_COMMANDS = { serve: cmdServe, dev: cmdServe, build: cmdBuild, test: cmdTest };
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+
+if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  process.stdout.write(HELP);
+} else if (cmd === 'version' || cmd === 'v' || cmd === '--version' || cmd === '-v') {
+  cmdVersion();
+} else if (RAW_COMMANDS[cmd]) {
+  RAW_COMMANDS[cmd](argv.slice(1));
+} else if (COMMANDS[cmd]) {
+  const a = args(argv.slice(1), { d: 'dry-run', h: 'help' });
+  if (a.help) {
+    process.stdout.write(HELP);
+  } else {
+    COMMANDS[cmd](a);
+  }
+} else {
+  console.error(`Unknown command "${cmd}".\n`);
+  process.stdout.write(HELP);
+  process.exit(1);
+}

package/src/commands/generate.mjs

@@ -0,0 +1,120 @@
+/**
+ * `pmvc generate|g <schematic> <name>` — file generators, the `ng g`
+ * equivalent. Schematics: view|component, controller, service, module,
+ * island. Flags: --path <dir>, --skip-tests, -d/--dry-run, --force.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  featureName,
+  findProjectRoot,
+  render,
+  toCamel,
+  toPascal,
+  writeFile,
+  fail,
+  warn,
+  log,
+} from '../lib.mjs';
+import * as T from '../templates.mjs';
+
+/** words → sentence case for <h1>s: 'user-card' → 'User card' */
+function title(kebab) {
+  const s = kebab.replace(/-/g, ' ');
+  return s[0].toUpperCase() + s.slice(1);
+}
+
+function tokensFor(name, dirName) {
+  const KEBAB = name;
+  const CAMEL = toCamel(name);
+  const CLASS = toPascal(name);
+  return { KEBAB, CAMEL, CLASS, TITLE: title(dirName ?? name) };
+}
+
+const SCHEMATICS = {
+  view: (root, name, a) => {
+    const dir = a.path ?? `src/app/${name}`;
+    const tk = tokensFor(name);
+    writeFile(root, `${dir}/${name}.view.tsx`, render(T.G_VIEW, tk), a);
+    if (!a['skip-tests']) {
+      writeFile(root, `${dir}/${name}.view.test.tsx`, render(T.G_VIEW_TEST, tk), a);
+    }
+    log(`\nMount it: add a route in src/app/app.routes.ts, or declare it in a module's \`components\`.`);
+  },
+
+  component: (root, name, a) => SCHEMATICS.view(root, name, a),
+
+  controller: (root, name, a) => {
+    const dir = a.path ?? `src/app/${name}`;
+    const tk = tokensFor(name);
+    writeFile(root, `${dir}/${name}.controller.ts`, render(T.G_CONTROLLER, tk), a);
+    log(`\nUse it: @Component({ controllers: [${tk.CLASS}Controller] }) or inject(${tk.CLASS}Controller) (transient).`);
+  },
+
+  service: (root, name, a) => {
+    const dir = a.path ?? `src/app/${name}`;
+    const tk = tokensFor(name);
+    writeFile(root, `${dir}/${name}.service.ts`, render(T.G_SERVICE, tk), a);
+    log(`\nInject it: inject(${tk.CLASS}Service) inside a view or controller constructor/field.`);
+  },
+
+  module: (root, name, a) => {
+    const dir = a.path ?? `src/app/${name}`;
+    const tk = tokensFor(name);
+    writeFile(root, `${dir}/${name}.module.ts`, render(T.G_MODULE, tk), a);
+    log(`\nRegister it: imports: [${tk.CLASS}Module] on the root module, or { path, module: ${tk.CLASS}Module } on a route.`);
+  },
+
+  island: (root, name, a) => {
+    const tk = tokensFor(name);
+    const contract = `src/islands/${name}.contract.ts`;
+    const worker = `src/workers/${name}.worker.tsx`;
+    writeFile(root, contract, render(T.T_ISLAND_CONTRACT, tk), a);
+    writeFile(root, worker, render(T.T_ISLAND_WORKER, tk), a);
+    log(`
+Mount it from any view:
+
+  import { islandComponent } from '@preact-mvc/atoll-island';
+  import { ${tk.CAMEL}Contract } from '../../islands/${name}.contract';
+
+  const ${tk.CLASS}Island = islandComponent(${tk.CAMEL}Contract);
+  // <${tk.CLASS}Island onEvent={(n, p) => …} />`);
+  },
+};
+
+export function cmdGenerate(a) {
+  const schematic = a._[0];
+  const rawName = a._[1];
+  if (!schematic || !rawName) {
+    fail(
+      'usage: pmvc generate <view|controller|service|module|island> <name>\n' +
+        `       schematics: ${Object.keys(SCHEMATICS).join(', ')}`,
+    );
+  }
+  const gen = SCHEMATICS[schematic];
+  if (!gen) {
+    fail(`unknown schematic "${schematic}" — expected one of: ${Object.keys(SCHEMATICS).join(', ')}`);
+  }
+
+  const found = findProjectRoot();
+  if (!found) fail('not inside a preact-mvc project (no @preact-mvc/core dependency found)');
+  const name = featureName(rawName);
+
+  if (schematic === 'island') {
+    const deps = { ...found.pkg.dependencies, ...found.pkg.devDependencies };
+    if (!deps['@preact-mvc/atoll-island']) {
+      warn(
+        '@preact-mvc/atoll-island is not a dependency — run `pmvc add islands` first.',
+      );
+    }
+  }
+
+  log('');
+  gen(found.root, name, {
+    dry: !!a['dry-run'],
+    force: !!a.force,
+    'skip-tests': !!a['skip-tests'],
+    path: a.path,
+  });
+  log('');
+}

package/src/commands/new.mjs

@@ -0,0 +1,140 @@
+/**
+ * `pmvc new <dir>` — scaffold a preact-mvc application, the `ng new`
+ * equivalent. Flags: --islands, --tailwind, --skip-install,
+ * --skip-tests, -d/--dry-run, --force (overwrite existing files).
+ */
+import { resolve } from 'node:path';
+import {
+  VERSIONS,
+  frameworkRange,
+  render,
+  run,
+  toKebab,
+  writeFile,
+  fail,
+  log,
+} from '../lib.mjs';
+import * as T from '../templates.mjs';
+
+export function cmdNew(argv) {
+  const a = argv; // pre-parsed by cli.mjs
+  const dir = a._[0];
+  if (!dir) fail('usage: pmvc new <directory> [--islands] [--tailwind] [--skip-install]');
+  const name = toKebab(dir.split(/[\\/]/).pop());
+  const root = resolve(dir);
+  const opts = {
+    dry: !!a['dry-run'],
+    force: !!a.force,
+  };
+  const islands = !!a.islands;
+  const tailwind = !!a.tailwind;
+  const skipTests = !!a['skip-tests'];
+
+  const fw = frameworkRange();
+  const dependencies = {
+    '@preact-mvc/core': fw,
+    preact: VERSIONS.preact,
+    '@preact/signals': VERSIONS['@preact/signals'],
+  };
+  const devDependencies = {
+    '@preact/preset-vite': VERSIONS['@preact/preset-vite'],
+    '@testing-library/preact': VERSIONS['@testing-library/preact'],
+    '@types/node': VERSIONS['@types/node'],
+    jsdom: VERSIONS.jsdom,
+    typescript: VERSIONS.typescript,
+    vite: VERSIONS.vite,
+    vitest: VERSIONS.vitest,
+  };
+  if (islands) {
+    dependencies['@preact-mvc/atoll'] = fw;
+    dependencies['@preact-mvc/atoll-island'] = fw;
+    dependencies['@atolljs/core'] = VERSIONS['@atolljs/core'];
+  }
+  if (tailwind) {
+    devDependencies.tailwindcss = VERSIONS.tailwindcss;
+    devDependencies['@tailwindcss/vite'] = VERSIONS['@tailwindcss/vite'];
+  }
+
+  const packageJson = JSON.stringify(
+    {
+      name,
+      version: '0.1.0',
+      private: true,
+      type: 'module',
+      scripts: {
+        dev: 'vite',
+        build: 'tsc --noEmit && vite build',
+        preview: 'vite preview',
+        test: 'vitest run',
+        'test:watch': 'vitest',
+        typecheck: 'tsc --noEmit',
+      },
+      dependencies,
+      devDependencies,
+    },
+    null,
+    2,
+  );
+
+  const tokens = {
+    NAME: name,
+    TITLE: name,
+    TAILWIND_IMPORT: tailwind ? "import tailwindcss from '@tailwindcss/vite';\n" : '',
+    TAILWIND_PLUGIN: tailwind ? ', tailwindcss()' : '',
+    ISLANDS_IMPORT: islands
+      ? "import { TickerDemoView } from './island-demo/island-demo.view';\n"
+      : '',
+    ISLANDS_ROUTE: islands ? "  { path: '/island', component: TickerDemoView },\n" : '',
+    ISLANDS_NAV: islands ? "  { to: '/island', match: '/island', label: 'Island' },\n" : '',
+    KEBAB: 'ticker',
+    CAMEL: 'ticker',
+    CLASS: 'Ticker',
+  };
+
+  const files = {
+    'package.json': packageJson + '\n',
+    'tsconfig.json': T.T_TSCONFIG,
+    'vite.config.ts': render(T.T_VITE_CONFIG, tokens),
+    'index.html': render(T.T_INDEX_HTML, tokens),
+    '.gitignore': T.T_GITIGNORE,
+    '.npmrc': T.T_NPMRC,
+    'README.md': render(T.T_README, tokens),
+    'src/main.tsx': T.T_MAIN,
+    'src/styles.css': tailwind ? T.T_STYLES_TAILWIND : T.T_STYLES,
+    'src/test-setup.ts': T.T_TEST_SETUP,
+    'src/app/app.module.ts': render(T.T_APP_MODULE, tokens),
+    'src/app/app.shell.tsx': render(T.T_APP_SHELL, tokens),
+    'src/app/app.routes.ts': render(T.T_APP_ROUTES, tokens),
+    'src/app/core/tokens.ts': T.T_TOKENS,
+    'src/app/hello/hello.view.tsx': T.T_HELLO_VIEW,
+    'src/app/counter/counter.view.tsx': T.T_COUNTER_VIEW,
+  };
+  if (!skipTests) files['src/app/hello/hello.view.test.tsx'] = T.T_HELLO_TEST;
+  if (islands) {
+    files['src/islands/ticker.contract.ts'] = render(T.T_ISLAND_CONTRACT, tokens);
+    files['src/workers/ticker.worker.tsx'] = render(T.T_ISLAND_WORKER, tokens);
+    files['src/app/island-demo/island-demo.view.tsx'] = render(
+      T.T_ISLAND_DEMO_VIEW,
+      tokens,
+    );
+  }
+
+  log(`\nScaffolding a preact-mvc app in ${root}\n`);
+  for (const [rel, contents] of Object.entries(files)) {
+    writeFile(root, rel, contents, opts);
+  }
+
+  if (!a['skip-install']) {
+    log('\nInstalling dependencies…');
+    const code = run('npm', ['install'], { cwd: root, dry: opts.dry });
+    if (code !== 0) fail('npm install failed — run it manually in the new directory.');
+  }
+
+  log(`
+Done. Next:
+
+  cd ${dir}
+  ${a['skip-install'] ? 'npm install\n  ' : ''}pmvc serve       # start the dev server
+  pmvc g view my-page   # scaffold a new view
+`);
+}

package/src/commands/run.mjs

@@ -0,0 +1,64 @@
+/**
+ * `pmvc serve|build|test` — delegate to the project's vite/vitest, the
+ * `ng serve` / `ng build` / `ng test` equivalents. All args pass through
+ * to the underlying tool except the few pmvc owns (--watch for test,
+ * --no-typecheck for build).
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { findProjectRoot, readJson, run, fail } from '../lib.mjs';
+
+function projectRoot() {
+  const found = findProjectRoot();
+  if (!found) fail('not inside a preact-mvc project (no @preact-mvc/core dependency found)');
+  return found.root;
+}
+
+/**
+ * Run a devDependency's bin via `node <bin>` — resolves through the
+ * package's own manifest, so it works cross-platform without npx/shell
+ * shims and never falls back to a registry download.
+ */
+function execBin(pkg, argv, cwd) {
+  const pkgJson = join(cwd, 'node_modules', pkg, 'package.json');
+  if (!existsSync(pkgJson)) {
+    fail(`${pkg} is not installed — run \`npm install\` (or check package.json devDependencies)`);
+  }
+  const manifest = readJson(pkgJson);
+  const bin =
+    typeof manifest.bin === 'string'
+      ? manifest.bin
+      : (manifest.bin?.[pkg] ?? manifest.bin?.[Object.keys(manifest.bin ?? {})[0]]);
+  if (!bin) fail(`${pkg} declares no executable bin`);
+  return run('node', [join(cwd, 'node_modules', pkg, bin), ...argv], { cwd });
+}
+
+/** Strip pmvc-owned flags from a passthrough argv; returns {rest, had}. */
+function take(argv, flag) {
+  const i = argv.indexOf(flag);
+  return { rest: argv.filter((_, j) => j !== i), had: i !== -1 };
+}
+
+export function cmdServe(argv) {
+  process.exitCode = execBin('vite', argv, projectRoot());
+}
+
+export function cmdBuild(argv) {
+  const root = projectRoot();
+  const { rest, had: noTypecheck } = take(argv, '--no-typecheck');
+  // Mirror the repo convention: typecheck is part of the build.
+  if (!noTypecheck) {
+    const code = execBin('typescript', ['--noEmit'], root);
+    if (code !== 0) {
+      process.exitCode = code;
+      return;
+    }
+  }
+  process.exitCode = execBin('vite', ['build', ...rest], root);
+}
+
+export function cmdTest(argv) {
+  const root = projectRoot();
+  const { rest, had: watch } = take(argv, '--watch');
+  process.exitCode = execBin('vitest', [...(watch ? [] : ['run']), ...rest], root);
+}

package/src/commands/update.mjs

@@ -0,0 +1,159 @@
+/**
+ * `pmvc update` — bump @preact-mvc/* dependencies, the `ng update`
+ * equivalent. Flags: --to <version>, --include-atoll, -d/--dry-run,
+ * --skip-install.
+ *
+ * `pmvc add <recipe>` — install + wire an integration, the `ng add`
+ * equivalent. Recipes: tailwind, islands.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  VERSIONS,
+  frameworkDeps,
+  frameworkRange,
+  findProjectRoot,
+  npmViewVersion,
+  run,
+  writeFile,
+  fail,
+  warn,
+  log,
+} from '../lib.mjs';
+import * as T from '../templates.mjs';
+
+function project() {
+  const found = findProjectRoot();
+  if (!found) fail('not inside a preact-mvc project (no @preact-mvc/core dependency found)');
+  return found;
+}
+
+/* ── update ───────────────────────────────────────────────────────── */
+
+// Future migrations: { to: 'x.y.z', run(root, pkg) {} }. When a release
+// needs a code mod, append an entry here — `pmvc update` applies every
+// migration whose `to` is newer than the dep's current range.
+const MIGRATIONS = [];
+
+export function cmdUpdate(a) {
+  const { root, pkg } = project();
+  const dry = !!a['dry-run'];
+  const targets = new Set(frameworkDeps(pkg));
+  if (a['include-atoll']) {
+    for (const d of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
+      if (d.startsWith('@atolljs/')) targets.add(d);
+    }
+  }
+  if (targets.size === 0) fail('no @preact-mvc/* dependencies in this project');
+
+  const to = a.to === true ? null : a.to; // `--to v` or nothing
+  const changes = [];
+  for (const dep of targets) {
+    const next = to ?? npmViewVersion(dep) ?? 'latest';
+    for (const field of ['dependencies', 'devDependencies']) {
+      const cur = pkg[field]?.[dep];
+      if (!cur) continue;
+      // Semver-ish targets get a caret; dist-tags like 'latest' pass bare.
+      const range = /^[\d^~>=]/.test(next) ? `^${next.replace(/^[\^~]/, '')}` : next;
+      if (cur !== range) changes.push({ field, dep, cur, range });
+    }
+  }
+
+  if (changes.length === 0) {
+    log('All @preact-mvc dependencies are already at the target version.');
+    return;
+  }
+  log('');
+  for (const c of changes) log(`  ${c.dep}: ${c.cur} → ${c.range}`);
+  log('');
+
+  if (!dry) {
+    for (const c of changes) pkg[c.field][c.dep] = c.range;
+    writeFileSync(join(root, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+  }
+
+  if (MIGRATIONS.length) {
+    for (const m of MIGRATIONS) {
+      log(`  migration → ${m.to}`);
+      if (!dry) m.run(root, pkg);
+    }
+  }
+
+  if (!a['skip-install']) {
+    const code = run('npm', ['install'], { cwd: root, dry });
+    if (code !== 0) fail('npm install failed — resolve and re-run, or use --skip-install.');
+  }
+  log('Update complete.');
+}
+
+/* ── add ──────────────────────────────────────────────────────────── */
+
+function installDeps(root, deps, { dev = true, dry = false } = {}) {
+  const args = ['install', ...(dev ? ['-D'] : [])];
+  for (const [name, range] of Object.entries(deps)) args.push(`${name}@${range}`);
+  const code = run('npm', args, { cwd: root, dry });
+  if (code !== 0) fail('npm install failed');
+}
+
+/** Insert the tailwind plugin into a generated-shape vite.config. */
+function patchViteConfig(root, dry) {
+  const path = join(root, 'vite.config.ts');
+  if (!existsSync(path)) {
+    warn('no vite.config.ts — add `tailwindcss()` to your plugins manually');
+    return;
+  }
+  let src = readFileSync(path, 'utf8');
+  if (src.includes('@tailwindcss/vite')) {
+    log('      SKIP     vite.config.ts (tailwindcss already configured)');
+    return;
+  }
+  const next = src
+    .replace(
+      /(import preact from '@preact\/preset-vite';)/,
+      `$1\nimport tailwindcss from '@tailwindcss/vite';`,
+    )
+    .replace(/plugins:\s*\[preact\(\)/, 'plugins: [preact(), tailwindcss()');
+  if (next === src) {
+    warn('vite.config.ts has an unrecognized shape — add `tailwindcss()` to plugins manually');
+    return;
+  }
+  log(`      UPDATE   vite.config.ts`);
+  if (!dry) writeFileSync(path, next);
+}
+
+const RECIPES = {
+  tailwind(root, a) {
+    installDeps(root, {
+      tailwindcss: VERSIONS.tailwindcss,
+      '@tailwindcss/vite': VERSIONS['@tailwindcss/vite'],
+    }, { dev: true, dry: a['dry-run'] });
+    patchViteConfig(root, a['dry-run']);
+    writeFile(root, 'src/styles.css', T.T_STYLES_TAILWIND, {
+      dry: a['dry-run'],
+      force: false,
+    });
+    log('\nTailwind v4 is wired. Utility classes are now available in views.');
+  },
+
+  islands(root, a) {
+    const fw = frameworkRange();
+    installDeps(root, {
+      '@preact-mvc/atoll': fw,
+      '@preact-mvc/atoll-island': fw,
+      '@atolljs/core': VERSIONS['@atolljs/core'],
+    }, { dev: false, dry: a['dry-run'] });
+    log('\nWorker islands installed. Scaffold your first one:');
+    log('  pmvc g island ticker');
+  },
+};
+
+export function cmdAdd(a) {
+  const recipe = a._[0];
+  if (!recipe || !RECIPES[recipe]) {
+    fail(`usage: pmvc add <${Object.keys(RECIPES).join('|')}>`);
+  }
+  const { root } = project();
+  log('');
+  RECIPES[recipe](root, a);
+  log('');
+}

package/src/lib.mjs

@@ -0,0 +1,223 @@
+/**
+ * Shared helpers: naming transforms, file writing with dry-run logging,
+ * package.json IO, project-root discovery, version maps, process spawn.
+ */
+import { spawnSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const CLI_ROOT = dirname(fileURLToPath(import.meta.url));
+
+/* ── Versions ───────────────────────────────────────────────────────
+ * External dep ranges for generated projects. @preact-mvc/* ranges come
+ * from the CLI's own version (the published package releases in
+ * lockstep) — 0.0.0 means "unreleased checkout", so fall back to
+ * `latest` for local/linked runs.
+ */
+export const VERSIONS = {
+  preact: '^10.24.0',
+  '@preact/signals': '^1.3.0',
+  '@preact/preset-vite': '^2.9.0',
+  '@atolljs/core': '0.1.11',
+  typescript: '~5.5.0',
+  vite: '^6.4.3',
+  vitest: '^3.2.4',
+  jsdom: '^25.0.0',
+  '@types/node': '^24.19.2',
+  '@testing-library/preact': '^3.2.4',
+  tailwindcss: '^4.3.3',
+  '@tailwindcss/vite': '^4.3.3',
+};
+
+export function cliVersion() {
+  const pkg = JSON.parse(
+    readFileSync(join(CLI_ROOT, '..', 'package.json'), 'utf8'),
+  );
+  return pkg.version;
+}
+
+/** The range a generated project should use for @preact-mvc/* deps. */
+export function frameworkRange() {
+  const v = cliVersion();
+  return v === '0.0.0' ? 'latest' : `^${v}`;
+}
+
+/* ── Naming ──────────────────────────────────────────────────────── */
+
+/** `FooBar` / `fooBar` / `foo_bar` / `fooBar-baz` → `foo-bar` */
+export function toKebab(name) {
+  return String(name)
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .toLowerCase()
+    .replace(/^-|-$/g, '');
+}
+
+/** `foo-bar` → `FooBar` */
+export function toPascal(name) {
+  return toKebab(name)
+    .split('-')
+    .filter(Boolean)
+    .map((w) => w[0].toUpperCase() + w.slice(1))
+    .join('');
+}
+
+/** `foo-bar` → `fooBar` */
+export function toCamel(name) {
+  const p = toPascal(name);
+  return p ? p[0].toLowerCase() + p.slice(1) : p;
+}
+
+/* ── FS / logging ────────────────────────────────────────────────── */
+
+export const log = (...a) => console.log(...a);
+export const warn = (...a) => console.warn(`WARN`, ...a);
+export const fail = (msg) => {
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+};
+
+/**
+ * Write `contents` at `root/rel`, mkdir -p'ing parents. `--dry-run`
+ * prints instead. Existing files are skipped unless `force`; never
+ * silently clobber user code.
+ */
+export function writeFile(root, rel, contents, { dry = false, force = false } = {}) {
+  const abs = join(root, rel);
+  if (existsSync(abs) && !force) {
+    const tag = dry ? 'SKIP (dry)' : 'SKIP';
+    log(`      ${tag}  ${rel} (already exists)`);
+    return false;
+  }
+  const tag = dry ? 'CREATE (dry)' : 'CREATE';
+  log(`      ${tag}  ${rel} (${Buffer.byteLength(contents)} bytes)`);
+  if (!dry) {
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, contents);
+  }
+  return true;
+}
+
+/** Render a %%TOKEN%% template. Tokens are uppercase-only. */
+export function render(tpl, tokens) {
+  let out = tpl;
+  for (const [k, v] of Object.entries(tokens)) {
+    out = out.replaceAll(`%%${k}%%`, String(v));
+  }
+  const leftovers = out.match(/%%[A-Z_]+%%/g);
+  if (leftovers) fail(`unfilled template tokens: ${leftovers.join(', ')}`);
+  return out;
+}
+
+/* ── Project discovery ───────────────────────────────────────────── */
+
+export function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+/** Walk up from `dir` to the nearest package.json depending on
+ *  @preact-mvc/core — the project's root. Returns {root, pkg} or null. */
+export function findProjectRoot(dir = process.cwd()) {
+  let cur = resolve(dir);
+  for (;;) {
+    const pkgPath = join(cur, 'package.json');
+    if (existsSync(pkgPath)) {
+      const pkg = readJson(pkgPath);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps['@preact-mvc/core']) return { root: cur, pkg };
+    }
+    const parent = dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+
+/** All @preact-mvc/* dep names declared in a package.json object. */
+export function frameworkDeps(pkg) {
+  return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).filter(
+    (d) => d.startsWith('@preact-mvc/'),
+  );
+}
+
+/* ── Process ─────────────────────────────────────────────────────── */
+
+/** Spawn a command in the foreground. Joins into a single shell string
+ *  so npm's .cmd shims resolve on Windows (args with spaces are quoted).
+ *  Returns the exit code. */
+export function run(cmd, args = [], { cwd = process.cwd(), dry = false } = {}) {
+  const shown = [cmd, ...args]
+    .map((a) => (/[\s"']/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a))
+    .join(' ');
+  if (dry) {
+    log(`      RUN (dry)   ${shown}`);
+    return 0;
+  }
+  const res = spawnSync(shown, { cwd, stdio: 'inherit', shell: true });
+  return res.status ?? 1;
+}
+
+/** `npm view <pkg> version` → string, or null on failure/offline. */
+export function npmViewVersion(name) {
+  const res = spawnSync('npm', ['view', name, 'version'], {
+    encoding: 'utf8',
+    shell: true,
+  });
+  if (res.status !== 0) return null;
+  return res.stdout.trim() || null;
+}
+
+/* ── Arg parsing (tiny, dependency-free) ─────────────────────────── */
+
+/**
+ * parseArgs-lite: returns { _: [positionals], flags }. Supports
+ * `--flag`, `--flag value`, `--flag=value`, `-x` (boolean shorts only),
+ * and `--no-flag` negation.
+ */
+export function args(argv, flags = {}) {
+  const out = { _: [] };
+  const aliases = { ...flags };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--') {
+      out._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith('--no-')) {
+      out[a.slice(5)] = false;
+    } else if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq !== -1) {
+        out[a.slice(2, eq)] = a.slice(eq + 1);
+      } else if (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) {
+        out[a.slice(2)] = argv[++i];
+      } else {
+        out[a.slice(2)] = true;
+      }
+    } else if (a.startsWith('-') && a.length > 1) {
+      const key = aliases[a.slice(1)] ?? a.slice(1);
+      out[key] = true;
+    } else {
+      out._.push(a);
+    }
+  }
+  for (const [short, long] of Object.entries(flags)) {
+    if (out[short] !== undefined && out[long] === undefined) out[long] = out[short];
+  }
+  return out;
+}
+
+/** Normalize to a kebab-cased feature name; rejects paths/empties. */
+export function featureName(raw) {
+  const name = toKebab(raw ?? '');
+  if (!name || name.includes('..') || name.includes('/') || name.includes(sep)) {
+    fail(`"${raw}" is not a valid name — expected something like "user-card"`);
+  }
+  return name;
+}

package/src/templates.mjs

@@ -0,0 +1,523 @@
+/**
+ * File templates for `pmvc new` and `pmvc generate`. Tokens use the
+ * %%UPPER_SNAKE%% form — safe inside JSX braces. Every template is
+ * plain text; render() substitutes tokens and fails on leftovers.
+ */
+
+/* ── pmvc new ──────────────────────────────────────────────────────── */
+
+export const T_TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "types": ["vite/client", "node"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src", "vite.config.ts"]
+}
+`;
+
+export const T_VITE_CONFIG = `/// <reference types="vitest" />
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'vite';
+import preact from '@preact/preset-vite';
+%%TAILWIND_IMPORT%%export default defineConfig({
+  plugins: [preact()%%TAILWIND_PLUGIN%%],
+  resolve: {
+    alias: [{ find: '@', replacement: fileURLToPath(new URL('./src', import.meta.url)) }],
+  },
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['src/test-setup.ts'],
+    // @preact-mvc/* ship .ts sources, so vitest inlines them while plain
+    // JS deps externalize natively — splitting preact (and its
+    // jsx-runtime) into two module realms. The view interceptor patches
+    // one shared options object, so the whole preact graph must stay in
+    // the vite realm during tests.
+    server: {
+      deps: {
+        inline: [
+          /@preact-mvc[/]/,
+          'preact',
+          'preact/jsx-runtime',
+          '@preact/signals',
+          '@testing-library/preact',
+          'preact-router',
+        ],
+      },
+    },
+  },
+});
+`;
+
+export const T_INDEX_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="data:," />
+    <title>%%TITLE%%</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+
+export const T_GITIGNORE = `node_modules
+dist
+dist-ssr
+*.local
+.DS_Store
+`;
+
+// Consumer-friendly subset of the repo's installable-project policy:
+// no min-release-age — it would ETARGET whenever a dep release is
+// younger than the window, which is a bad first-run failure mode.
+export const T_NPMRC = `ignore-scripts=true
+save-exact=true
+`;
+
+export const T_README = `# %%NAME%%
+
+A [preact-mvc](https://github.com/jwhenry3/preact-mvc) application —
+Angular-style modules, DI, and MVC on class-based JSX views rendered by
+Preact, with signal reactivity.
+
+\`\`\`bash
+pmvc serve      # dev server (vite)
+pmvc build      # production build
+pmvc test       # vitest
+pmvc g view my-page     # scaffold a view
+pmvc g module admin     # scaffold a feature module
+\`\`\`
+`;
+
+export const T_MAIN = `import { bootstrap } from '@preact-mvc/core';
+import { AppModule } from './app/app.module';
+import './styles.css';
+
+bootstrap(AppModule, document.getElementById('app')!);
+`;
+
+export const T_STYLES = `body {
+  margin: 0;
+  font-family: ui-sans-serif, system-ui, sans-serif;
+}
+
+.nav-link {
+  opacity: 0.7;
+  color: inherit;
+  text-decoration: none;
+}
+.nav-link.active {
+  opacity: 1;
+  font-weight: 600;
+}
+`;
+
+export const T_STYLES_TAILWIND = `@import "tailwindcss";
+
+.nav-link {
+  opacity: 0.7;
+  color: inherit;
+  text-decoration: none;
+}
+.nav-link.active {
+  opacity: 1;
+  font-weight: 600;
+}
+`;
+
+// jsdom test stubs — the same pattern the repo itself uses.
+export const T_TEST_SETUP = `// Node 22+ exposes an experimental \`localStorage\` global that is
+// undefined unless --localstorage-file is passed. It shadows jsdom's
+// storage (window === globalThis in vitest's jsdom env), so redefine it
+// with a minimal in-memory Storage implementation for tests.
+class MemoryStorage implements Storage {
+  private map = new Map<string, string>();
+  get length() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+  }
+  getItem(key: string) {
+    return this.map.has(key) ? this.map.get(key)! : null;
+  }
+  key(index: number) {
+    return [...this.map.keys()][index] ?? null;
+  }
+  removeItem(key: string) {
+    this.map.delete(key);
+  }
+  setItem(key: string, value: string) {
+    this.map.set(key, String(value));
+  }
+}
+
+Object.defineProperty(globalThis, 'localStorage', {
+  value: new MemoryStorage(),
+  configurable: true,
+});
+Object.defineProperty(globalThis, 'sessionStorage', {
+  value: new MemoryStorage(),
+  configurable: true,
+});
+
+// jsdom has no matchMedia — a fixed "light" stub suffices for tests.
+if (typeof globalThis.matchMedia !== 'function') {
+  Object.defineProperty(globalThis, 'matchMedia', {
+    value: (query: string): MediaQueryList =>
+      ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: () => {},
+        removeListener: () => {},
+        addEventListener: () => {},
+        removeEventListener: () => {},
+        dispatchEvent: () => false,
+      }) as MediaQueryList,
+    configurable: true,
+  });
+}
+`;
+
+export const T_APP_MODULE = `import { Module, RouterModule } from '@preact-mvc/core';
+import { AppShell } from './app.shell';
+import { routes } from './app.routes';
+import { APP_TITLE } from './core/tokens';
+
+@Module({
+  imports: [RouterModule.forRoot(routes)],
+  providers: [{ provide: APP_TITLE, useValue: '%%TITLE%%' }],
+  bootstrap: [AppShell],
+})
+export class AppModule {}
+`;
+
+export const T_TOKENS = `import { InjectionToken } from '@preact-mvc/core';
+
+export const APP_TITLE = new InjectionToken<string>('app title');
+`;
+
+export const T_APP_SHELL = `import { Component, View, inject, RouterOutlet, Link, Router } from '@preact-mvc/core';
+import { APP_TITLE } from './core/tokens';
+
+const NAV = [
+  { to: '/hello/world', match: '/hello', label: 'Hello' },
+  { to: '/counter', match: '/counter', label: 'Counter' },
+%%ISLANDS_NAV%%];
+
+@Component()
+export class AppShell extends View {
+  private router = inject(Router);
+  private title = inject(APP_TITLE);
+
+  render() {
+    const url = this.router.url.value;
+    return (
+      <div style="min-height:100vh;display:flex;flex-direction:column">
+        <header style="display:flex;align-items:center;gap:1rem;padding:0 1.25rem;height:3.5rem;border-bottom:1px solid #e2e2e8">
+          <strong>{this.title}</strong>
+          <nav style="display:flex;gap:1rem">
+            {NAV.map((n) => (
+              <Link
+                to={n.to}
+                class={url.startsWith(n.match) ? 'nav-link active' : 'nav-link'}
+              >
+                {n.label}
+              </Link>
+            ))}
+          </nav>
+        </header>
+        <main style="flex:1;padding:1.5rem">
+          <RouterOutlet />
+        </main>
+      </div>
+    );
+  }
+}
+`;
+
+export const T_APP_ROUTES = `import { h } from 'preact';
+import type { Route } from '@preact-mvc/core';
+import { HelloView } from './hello/hello.view';
+import { CounterView } from './counter/counter.view';
+%%ISLANDS_IMPORT%%
+export const routes: Route[] = [
+  { path: '/', component: HelloView },
+  { path: '/hello/:name', component: HelloView },
+  { path: '/counter', component: CounterView },
+%%ISLANDS_ROUTE%%  { path: '*', component: () => h('p', null, 'Not found.') },
+];
+`;
+
+export const T_HELLO_VIEW = `import { Component, View, inject, computed, Router } from '@preact-mvc/core';
+
+// Standalone view: declared by no module, mounts by route. Route params
+// arrive on the injected Router's params signal.
+@Component()
+export class HelloView extends View {
+  private router = inject(Router);
+  private name = computed(() => this.router.params.value.name ?? 'world');
+
+  render() {
+    return (
+      <section>
+        <h1>Hello, {this.name.value}!</h1>
+        <p>
+          Try <code>/hello/ada</code> — the name is a <code>:name</code> route param.
+        </p>
+      </section>
+    );
+  }
+}
+`;
+
+export const T_HELLO_TEST = `import { h } from 'preact';
+import { render } from '@testing-library/preact';
+import { describe, expect, it } from 'vitest';
+import { Injector, InjectorContext, Router } from '@preact-mvc/core';
+import { routes } from '../app.routes';
+import { HelloView } from './hello.view';
+
+// Views mount inside an injector scope — stand in for bootstrap() with a
+// bare injector providing whatever the view injects (HelloView needs the
+// Router for its :name param).
+function mount(node: any, injector = new Injector()) {
+  return render(h(InjectorContext.Provider, { value: injector }, node));
+}
+
+describe('HelloView', () => {
+  it('renders a greeting', () => {
+    const inj = new Injector();
+    inj.provide({ provide: Router, useValue: new Router(routes) });
+    const { container } = mount(<HelloView />, inj);
+    expect(container.querySelector('h1')?.textContent).toContain('Hello');
+  });
+});
+`;
+
+export const T_COUNTER_VIEW = `import { Component, View, signal, computed } from '@preact-mvc/core';
+import type { OnInit } from '@preact-mvc/core';
+
+@Component()
+export class CounterView extends View implements OnInit {
+  count = signal(0);
+  doubled = computed(() => this.count.value * 2);
+
+  onInit() {}
+
+  render() {
+    return (
+      <section>
+        <h1>Counter</h1>
+        <div style="display:flex;align-items:center;gap:1rem">
+          <button onClick={() => (this.count.value -= 1)}>−</button>
+          <span style="font-size:1.5rem;font-variant-numeric:tabular-nums">
+            {this.count.value}
+          </span>
+          <button onClick={() => (this.count.value += 1)}>+</button>
+        </div>
+        <p>doubled: {this.doubled.value}</p>
+      </section>
+    );
+  }
+}
+`;
+
+/* ── pmvc new --islands ────────────────────────────────────────────── */
+
+export const T_ISLAND_CONTRACT = `/**
+ * %%CLASS%% island contract — the one module BOTH sides import. It names
+ * the registry app, declares the emit payload shape (validated
+ * worker-side), and carries the worker factory, so the shell mounts
+ * islandComponent(%%CAMEL%%Contract) with no worker plumbing.
+ *
+ * Never import the .worker.tsx entry here: defining a worker installs
+ * instance globals. The URL literal inside new Worker(...) stays
+ * bundler-detectable — do not hoist or compute it.
+ */
+import { defineIslandContract, z } from '@preact-mvc/atoll-island';
+
+export const %%CAMEL%%Contract = defineIslandContract({
+  app: '%%KEBAB%%',
+  events: {
+    'worker-ping': z.object({ count: z.number() }),
+  },
+  worker: () =>
+    new Worker(new URL('../workers/%%KEBAB%%.worker.tsx', import.meta.url), {
+      type: 'module',
+    }),
+});
+`;
+
+export const T_ISLAND_WORKER = `/**
+ * Worker entry — bundler-detectable (spawned with the literal
+ * new URL(..., import.meta.url) form in %%KEBAB%%.contract). Hosts the
+ * island apps below; everything here runs inside the worker against the
+ * proxy DOM, View classes and all.
+ */
+import { Component, View, signal } from '@preact-mvc/core';
+import {
+  defineViewPolyWorker,
+  viewIslandApp,
+  emit,
+} from '@preact-mvc/atoll-island/worker';
+import { %%CAMEL%%Contract } from '../islands/%%KEBAB%%.contract';
+
+@Component()
+export class %%CLASS%%Island extends View {
+  private count = signal(0);
+  private timer: ReturnType<typeof setInterval> | undefined;
+
+  onInit() {
+    // Out-of-task signal writes: each tick re-renders in the worker and
+    // pushes an op batch — the shell never coordinates it.
+    this.timer = setInterval(() => {
+      this.count.value++;
+      if (this.count.value % 10 === 0) emit('worker-ping', { count: this.count.value });
+    }, 1000);
+  }
+  onDestroy() {
+    clearInterval(this.timer);
+  }
+
+  render() {
+    return (
+      <div style="font-variant-numeric:tabular-nums">
+        <strong>%%KEBAB%% island</strong> — worker uptime: {this.count.value}s
+      </div>
+    );
+  }
+}
+
+export const worker = defineViewPolyWorker({
+  apps: { '%%KEBAB%%': viewIslandApp(%%CLASS%%Island, { contract: %%CAMEL%%Contract }) },
+});
+`;
+
+export const T_ISLAND_DEMO_VIEW = `import { Component, View } from '@preact-mvc/core';
+import { islandComponent } from '@preact-mvc/atoll-island';
+import { %%CAMEL%%Contract } from '../../islands/%%KEBAB%%.contract';
+
+// The contract carries the worker factory — no worker plumbing here.
+const %%CLASS%%Island = islandComponent(%%CAMEL%%Contract);
+
+@Component()
+export class %%CLASS%%DemoView extends View {
+  render() {
+    return (
+      <section>
+        <h1>Worker island</h1>
+        <p>
+          This box renders inside a Web Worker and emits typed events back
+          to the shell.
+        </p>
+        <%%CLASS%%Island
+          onEvent={(name, payload) => console.log('island event', name, payload)}
+        />
+      </section>
+    );
+  }
+}
+`;
+
+/* ── pmvc generate ─────────────────────────────────────────────────── */
+
+export const G_VIEW = `import { Component, View, signal } from '@preact-mvc/core';
+import type { OnInit, OnDestroy } from '@preact-mvc/core';
+
+@Component()
+export class %%CLASS%%View extends View implements OnInit, OnDestroy {
+  // Signals drive rendering — reads inside render() are auto-tracked.
+  private loading = signal(true);
+
+  onInit() {
+    this.loading.value = false;
+  }
+
+  onDestroy() {}
+
+  render() {
+    return (
+      <section>
+        <h1>%%TITLE%%</h1>
+        {this.loading.value ? <p>Loading…</p> : <p>Ready.</p>}
+      </section>
+    );
+  }
+}
+`;
+
+export const G_VIEW_TEST = `import { h } from 'preact';
+import { render } from '@testing-library/preact';
+import { describe, expect, it } from 'vitest';
+import { Injector, InjectorContext } from '@preact-mvc/core';
+import { %%CLASS%%View } from './%%KEBAB%%.view';
+
+// Views mount inside an injector scope — a bare Injector stands in for
+// bootstrap(). provide() whatever the view injects.
+function mount(node: any, injector = new Injector()) {
+  return render(h(InjectorContext.Provider, { value: injector }, node));
+}
+
+describe('%%CLASS%%View', () => {
+  it('renders', () => {
+    const { container } = mount(<%%CLASS%%View />);
+    expect(container.querySelector('h1')?.textContent).toBe('%%TITLE%%');
+  });
+});
+`;
+
+export const G_CONTROLLER = `import { Controller } from '@preact-mvc/core';
+import type { OnInit, OnDestroy } from '@preact-mvc/core';
+
+// Injectable view logic. Declare it on a view (@Component({ controllers }))
+// or module (@Module({ controllers })) to share one instance down that
+// scope — injected undeclared, it is transient per injecting scope.
+@Controller()
+export class %%CLASS%%Controller implements OnInit, OnDestroy {
+  onInit() {}
+
+  onDestroy() {}
+}
+`;
+
+export const G_SERVICE = `import { Injectable, inject, DestroyRef } from '@preact-mvc/core';
+
+// Root-provided by default via @Injectable. inject() and scope-bound
+// effects work in field initializers and the constructor.
+@Injectable()
+export class %%CLASS%%Service {
+  private destroyRef = inject(DestroyRef);
+}
+`;
+
+export const G_MODULE = `import { Module } from '@preact-mvc/core';
+
+// Declare views under \`components\` so ownership is enforced, and view
+// logic under \`controllers\` to share one instance across this scope.
+@Module({
+  providers: [],
+  components: [],
+  controllers: [],
+})
+export class %%CLASS%%Module {}
+`;

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.