bank20baht-cli 0.5.0 → 0.7.0

package/README.md

@@ -20,9 +20,12 @@ steps.
 | ---------------------------------------- | ----------------------------------------------------------------- |
 | `bahtui new <name>`                      | Bare bun workspace in `./<name>` — toolchain only, no apps         |
 | `bahtui create <name>`                   | Full DDD monorepo in `./<name>` — React + Elysia + Eden           |
+| `bahtui create <name> --angular`         | Angular Native Federation host + one remote + Elysia + shared kit |
 | `bahtui init`                            | Write `bahtui.json` into an existing repo (enables the generators) |
 | `bahtui g model <domain>`                | `libs/domain/<domain>/model` package                              |
 | `bahtui g form <domain>/<name> --fields` | Engine-validated `FormDefinition` JSON inside that model package  |
+| `bahtui g remote <name>`                 | Angular workspace: another remote, wired into the host and checks |
+| `bahtui g deploy [nginx]`                | Angular workspace: nginx + systemd deploy, release/deploy/preview |
 
 ### `bahtui new <name>`
 
@@ -72,7 +75,7 @@ Add a matching entry to `knip.ts` so dead-code checks cover it.
 Same flags as `new`, but scaffolds a complete stack:
 
 ```
-apps/web                 React 19 + Vite
+apps/web                 React 19 + Vite on bank20baht-ui (tokens, <baht-*> elements, dark toggle)
 apps/api                 Elysia — exports `type App`, the Eden type anchor
 libs/shared/eden         treaty<App> — the one typed HTTP client
 bahtui.json              generator config (see below)
@@ -84,6 +87,62 @@ cd shop
 bun run dev              # web on :5173, api on :3001
 ```
 
+### `bahtui create <name> --angular`
+
+Same flags. The `new` toolchain, plus microfrontends on
+[Native Federation](https://www.npmjs.com/package/@angular-architects/native-federation):
+
+```
+apps/shell        host (:4200): bank20baht-ui-angular app shell, navigator built from the
+                  federation manifest, a fallback page for each remote that cannot load
+apps/hello-web    remote (:4201): one page calling GET /api/hello, exposed as ./Routes
+apps/server       Elysia under /api; exports `type App`, emitted to dist/types for the web apps
+packages/kit      typed ngx-eden client + error text, compiled into each app as @<name>/kit
+bahtui.json       { "frontend": "angular", "apps": { "web": "apps/shell", ... } }
+```
+
+`eslint.config.ts` adds the `angular()` and `bahtui()` presets for the web apps, `knip.ts` a
+workspace per app, `.dependency-cruiser.mjs` "apps never import each other", "core/, services/,
+shared/ know no page" and "packages know no app". The generated repo passes its own
+`bun run check` (`bun run --filter bank20baht-cli accept:angular` proves it: scaffold, install,
+`g remote`, check). What it gets right on purpose:
+
+- `features.ignoreUnusedDeps: false` in every `federation.config.mjs` (its scan refuses the kit,
+  which lives outside the app folder), so every dependency is shared and each app lists
+  bank20baht-ui's optional peers `marked`, `dompurify`, `flatpickr`; `/^marked\/bin/` is skipped.
+- `fileReplacements` on `esbuild:development`, not `build:development`.
+- Server types reach the web apps as built declarations, and the server's imports are
+  extensionless (Angular's compiler rejects `./x.ts` specifiers).
+- A remote that is down at boot gets a fallback page under its URL prefix.
+
+### `bahtui g remote <name>`
+
+In a `create --angular` workspace: `apps/<name>-web` on the next free port, mounted at
+`/<name>`, plus a line in `eslint.config.ts`, `knip.ts`, `.dependency-cruiser.mjs`, the dev
+manifest (`apps/shell/src/environments/environment.development.ts`) and the deployed one
+(`apps/shell/public/federation.manifest.json`). The TS/JS files carry a `// bahtui:remotes` line
+the entry goes above; if one is gone, nothing is written and the error names the file. Run
+`bun install` afterwards.
+
+### `bahtui g deploy [nginx]`
+
+In a `create --angular` workspace, one web server for everything:
+
+```
+deploy/nginx.conf        host at /, remotes at /remotes/<app>/, /federation.manifest.json from
+                         /etc/<name>/ (edit it there to add or repoint a remote), /api/ proxied
+deploy/<name>.service    systemd unit running the bundled server as the <name> user
+deploy/env.example       /etc/<name>/env, written once
+deploy/install.sh        runs on the target as root: nginx, bun and the user on the first run,
+                         then swaps the release in and restarts (safe to rerun)
+scripts/release.ts       bun run release: build, lay the result out in .release/
+scripts/deploy.ts        bun run deploy root@host: release, tar over ssh, install.sh
+scripts/preview.ts       bun run preview: serve .release/ like nginx does, on :8080
+```
+
+It adds the three scripts to `package.json` and `.release` to `.gitignore`, `.prettierignore` and
+the eslint ignores. It refuses an existing `deploy/` (or existing script names) without `--force`.
+
 ### `bahtui init`
 
 Writes `bahtui.json` into the current directory so `bahtui g …` knows where things live.
@@ -126,7 +185,7 @@ Field DSL — comma-separated `key:type[:modifier…]`:
 | Part       | Values                                                                                                         |
 | ---------- | -------------------------------------------------------------------------------------------------------------- |
 | `key`      | `[a-z][a-z0-9_]*`; the label is derived (`due_date` → "Due Date")                                              |
-| `type`     | `text` `textarea` `markdown` `number` `email` `password` `dropdown` `multiselect` `checkbox` `radio` `toggle` `date` `file` `rating` `range` `reference` |
+| `type`     | `text` `textarea` `markdown` `number` `currency` `email` `password` `dropdown` `multiselect` `checkbox` `radio` `toggle` `date` `file` `rating` `range` `reference` `tags` |
 | modifiers  | `required` · `options=a\|b\|c` · `min=N` · `max=N` · `step=N` · `ref=LOOKUP` · `flag=NAME`                                               |
 
 Invalid DSL (unknown type, empty options, non-numeric `min`) fails before anything is

package/dist/application/create.js

@@ -1,4 +1,5 @@
-import { planCreate, PRESET_TEMPLATE_SET } from '../domain/create-plan.js';
+import { ANGULAR_HOST, overlayTemplates, planCreate, PRESET_TEMPLATE_SETS, } from '../domain/create-plan.js';
+import { withFirstRemote } from '../domain/remote-plan.js';
 import { validateProjectName } from '../domain/naming.js';
 function logDryRun(blueprint, deps) {
     deps.log.info(`dry-run — would create in ${blueprint.root}:`);
@@ -35,7 +36,12 @@ export function runCreate(input, deps) {
             deps.log.error(e);
         throw new CreateError('Invalid project name.');
     }
-    const blueprint = planCreate(input, deps.templates.load(PRESET_TEMPLATE_SET[input.preset]), (raw, data) => deps.renderer.render(raw, data));
+    const render = (raw, data) => deps.renderer.render(raw, data);
+    const sets = PRESET_TEMPLATE_SETS[input.preset].map((set) => deps.templates.load(set));
+    const planned = planCreate(input, overlayTemplates(sets), render);
+    const blueprint = input.preset === 'angular'
+        ? withFirstRemote(planned, input.name, ANGULAR_HOST, deps.templates.load('remote'), render)
+        : planned;
     if (input.dryRun) {
         logDryRun(blueprint, deps);
         return;
@@ -51,6 +57,11 @@ const NEXT_STEPS = {
         'bun run dev        # web :5173 + api :3001',
         'bun run lint && bun run test && bun run build',
     ],
+    angular: [
+        'bun run dev        # shell :4200, hello-web :4201, server :3000',
+        'bahtui g remote <name>   # add another remote',
+        'bun run check      # lint + format:check + typecheck + madge + deps + knip + dup + build + test',
+    ],
     workspace: [
         'mkdir -p apps/<name> && add a package.json with dev/build/typecheck scripts',
         'bun run dev        # runs every apps/*/ dev script in parallel',

package/dist/application/generate.js

@@ -1,5 +1,7 @@
 import { buildFormDefinition, FormDslError } from '../domain/form-dsl.js';
 import { DEFAULT_CONFIG, modelDir, planForm, planInit, planModel, validateDomainName, } from '../domain/generate-plan.js';
+import { DEFAULT_API_PORT, DeployPlanError, planDeploy } from '../domain/deploy-plan.js';
+import { nextRemotePort, planRemoteFiles, remoteFor, RemoteWiringError, validateRemoteName, wireRemote, wiringPaths, } from '../domain/remote-plan.js';
 export class GenerateError extends Error {
 }
 /**
@@ -119,3 +121,96 @@ export function runGenerate(input, deps) {
     }
     emit(planForm(input.root, config, domain, name, form), input.dryRun, deps);
 }
+function readWiring(root, host, reader) {
+    const paths = wiringPaths(host);
+    const read = (path) => {
+        const text = reader.read(`${root}/${path}`);
+        if (text === null)
+            throw new GenerateError(`${path} is missing — g remote edits it.`);
+        return text;
+    };
+    return {
+        eslint: read(paths.eslint),
+        knip: read(paths.knip),
+        depcruise: read(paths.depcruise),
+        devManifest: read(paths.devManifest),
+        manifest: read(paths.manifest),
+    };
+}
+function projectName(root, reader) {
+    const raw = reader.read(`${root}/package.json`);
+    const name = raw === null ? undefined : JSON.parse(raw).name;
+    if (typeof name !== 'string' || !/^[a-z][a-z0-9-]*$/.test(name)) {
+        throw new GenerateError('package.json needs the project name (it scopes the @<name>/kit path).');
+    }
+    return name;
+}
+/**
+ * `bahtui g remote <name>` in an Angular workspace (`bahtui create --angular`): a new Native
+ * Federation remote under `apps/<name>-web`, added to the host's manifests, eslint, knip and
+ * dependency-cruiser. Nothing is written when any of those files cannot take it.
+ */
+export function runGenerateRemote(input, deps) {
+    const config = loadConfig(input.root, deps.reader);
+    if (config.frontend !== 'angular') {
+        throw new GenerateError('g remote needs an Angular workspace (bahtui.json "frontend": "angular", from bahtui create --angular).');
+    }
+    const host = config.apps.web;
+    if (host === undefined)
+        throw new GenerateError('bahtui.json needs "apps.web", the host app.');
+    validateConfigPath('apps.web', host);
+    const errors = validateRemoteName(input.name);
+    if (errors.length > 0)
+        throw new GenerateError(errors.join(' '));
+    const current = readWiring(input.root, host, deps.reader);
+    const remote = remoteFor(input.name, nextRemotePort(current.devManifest));
+    if (deps.reader.exists(`${input.root}/apps/${remote.app}`) && !input.force) {
+        throw new GenerateError(`apps/${remote.app} already exists — use --force.`);
+    }
+    const files = planned(RemoteWiringError, () => [
+        ...planRemoteFiles(remote, projectName(input.root, deps.reader), deps.templates.load('remote'), (raw, data) => deps.renderer.render(raw, data)),
+        ...wireRemote(current, host, remote),
+    ]);
+    emitThen(input, files, deps, `apps/${remote.app} is on :${remote.port} and mounted at /${remote.name}. Run bun install, then bun run dev.`);
+}
+/** Runs a domain plan, reporting its own error class as a GenerateError. */
+function planned(domainError, plan) {
+    try {
+        return plan();
+    }
+    catch (err) {
+        if (err instanceof domainError)
+            throw new GenerateError(err.message);
+        throw err;
+    }
+}
+/** Writes (or, on --dry-run, lists) the files, then says what comes next. */
+function emitThen(input, files, deps, next) {
+    emit({ root: input.root, files, postCommands: [] }, input.dryRun, deps);
+    if (!input.dryRun)
+        deps.log.info(next);
+}
+/**
+ * `bahtui g deploy [nginx]` in an Angular workspace: `deploy/` (nginx.conf, a systemd unit,
+ * env.example, install.sh) and `scripts/{release,deploy,preview}.ts`, wired into package.json,
+ * `.gitignore`, `.prettierignore` and eslint. Nothing is written when an edit cannot apply.
+ */
+export function runGenerateDeploy(input, deps) {
+    const config = loadConfig(input.root, deps.reader);
+    if (config.frontend !== 'angular' || config.apps.web === undefined) {
+        throw new GenerateError('g deploy needs an Angular workspace (bahtui.json "frontend": "angular", from bahtui create --angular).');
+    }
+    validateConfigPath('apps.web', config.apps.web);
+    const host = config.apps.web.split('/').pop() ?? config.apps.web;
+    if (deps.reader.exists(`${input.root}/deploy`) && !input.force) {
+        throw new GenerateError('deploy/ already exists — use --force.');
+    }
+    const read = (path) => deps.reader.read(`${input.root}/${path}`) ?? '';
+    const files = planned(DeployPlanError, () => planDeploy({ project: projectName(input.root, deps.reader), host, apiPort: DEFAULT_API_PORT }, {
+        packageJson: read('package.json'),
+        gitignore: read('.gitignore'),
+        prettierignore: read('.prettierignore'),
+        eslint: read('eslint.config.ts'),
+    }, deps.templates.load('deploy'), (raw, data) => deps.renderer.render(raw, data), input.force));
+    emitThen(input, files, deps, 'Next: bun run release (builds .release/), bun run preview (serves it on :8080), bun run deploy root@<host>.');
+}

package/dist/args.js

@@ -10,6 +10,7 @@ export const KNOWN_FLAGS = new Set([
     '--no-git',
     '--skip-install',
     '--skip-git',
+    '--angular',
 ]);
 /**
  * Value-carrying flags pulled out before positional parsing. Supports both

package/dist/cli.js

@@ -3,28 +3,35 @@ import { resolve } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { runCreate, CreateError } from './application/create.js';
-import { runGenerate, runInit, GenerateError } from './application/generate.js';
+import { runGenerate, runGenerateDeploy, runGenerateRemote, runInit, GenerateError, } from './application/generate.js';
 import { DiskTemplateSource } from './infrastructure/template-source.js';
 import { TemplateRenderer } from './infrastructure/template-renderer.js';
 import { DiskFileWriter } from './infrastructure/fs-writer.js';
 import { DiskFileReader } from './infrastructure/fs-reader.js';
 import { ShellRunner } from './infrastructure/shell-runner.js';
 import { KNOWN_FLAGS, parseArgs } from './args.js';
-const HELP = `bahtui — bun-workspace DDD scaffolding (React + Elysia + Eden)
+const HELP = `bahtui — bun-workspace DDD scaffolding (React or Angular + Elysia + Eden)
 
 Usage:
   bahtui new <name> [options]           bare bun workspace in ./<name> — toolchain only
                                         (eslint, prettier, knip, husky, commitlint, gitleaks, jscpd, depcruise, CI), no apps
   bahtui create <name> [options]        full monorepo in ./<name> (React + Elysia + Eden)
+  bahtui create <name> --angular        Angular Native Federation host + one remote + Elysia
+                                        server + shared web kit, on the new toolchain
   bahtui init [options]                 write bahtui.json into an existing repo
   bahtui g model <domain>               libs/domain/<d>/model package
   bahtui g form <domain>/<name> --fields "key:type:mod,…"
                                         engine-validated FormDefinition JSON
+  bahtui g remote <name>                Angular workspace: apps/<name>-web remote, added to the
+                                        host manifests, eslint, knip and dependency-cruiser
+  bahtui g deploy [nginx]               Angular workspace: deploy/ (nginx, systemd, install.sh)
+                                        and release / deploy / preview scripts
 Field DSL:
   title:text:required,priority:dropdown:options=low|medium|high,qty:number:min=1
 
 Options:
   --fields <dsl>       g form: the field list (required)
+  --angular      create: the Angular Native Federation scaffold instead of React
   --frontend <react|none>  init: default react
   --backend <elysia|none>  init: default elysia
   --dry-run      print what would be generated, write nothing
@@ -73,6 +80,11 @@ function preflight({ flags }) {
     }
     return null;
 }
+function presetFor(a, command) {
+    if (command === 'new')
+        return 'workspace';
+    return a.flags.has('--angular') ? 'angular' : 'full';
+}
 function commandCreate(a, command) {
     if (!a.name) {
         log.error(`${command} needs a project name: bahtui ${command} <name>`);
@@ -80,7 +92,7 @@ function commandCreate(a, command) {
     }
     runCreate({
         name: a.name,
-        preset: command === 'new' ? 'workspace' : 'full',
+        preset: presetFor(a, command),
         targetDir: resolve(process.cwd(), a.name),
         install: !a.flags.has('--no-install') && !a.flags.has('--skip-install'),
         git: !a.flags.has('--no-git') && !a.flags.has('--skip-git'),
@@ -107,8 +119,12 @@ function commandInit(a, generateDeps) {
 }
 function commandGenerate(a, generateDeps) {
     const { name, sub } = a;
+    if (name === 'remote')
+        return commandRemote(a, generateDeps);
+    if (name === 'deploy')
+        return commandDeploy(a, generateDeps);
     if (name !== 'model' && name !== 'form') {
-        log.error('Unknown generator — bahtui g model <domain> | g form <domain>/<name>.');
+        log.error('Unknown generator — bahtui g model <domain> | g form <domain>/<name> | g remote <name> | g deploy.');
         return 1;
     }
     if (!sub) {
@@ -125,6 +141,27 @@ function commandGenerate(a, generateDeps) {
     }, generateDeps);
     return 0;
 }
+function commandRemote(a, generateDeps) {
+    if (!a.sub) {
+        log.error('g remote needs a name: bahtui g remote <name>');
+        return 1;
+    }
+    runGenerateRemote({
+        root: process.cwd(),
+        name: a.sub,
+        dryRun: a.flags.has('--dry-run'),
+        force: a.flags.has('--force'),
+    }, { ...generateDeps, templates: new DiskTemplateSource(), renderer: new TemplateRenderer() });
+    return 0;
+}
+function commandDeploy(a, generateDeps) {
+    if (a.sub !== undefined && a.sub !== 'nginx') {
+        log.error(`g deploy knows one target, nginx (got "${a.sub}").`);
+        return 1;
+    }
+    runGenerateDeploy({ root: process.cwd(), dryRun: a.flags.has('--dry-run'), force: a.flags.has('--force') }, { ...generateDeps, templates: new DiskTemplateSource(), renderer: new TemplateRenderer() });
+    return 0;
+}
 function dispatch(a, command) {
     const generateDeps = {
         reader: new DiskFileReader(),

package/dist/domain/create-plan.js

@@ -1,7 +1,25 @@
-export const PRESET_TEMPLATE_SET = {
-    full: 'create',
-    workspace: 'new',
+/** Template sets per preset; a later set's file replaces an earlier one at the same path. */
+export const PRESET_TEMPLATE_SETS = {
+    full: ['create'],
+    workspace: ['new'],
+    angular: ['new', 'angular'],
 };
+/** The Angular preset's host app folder. */
+export const ANGULAR_HOST = 'apps/shell';
+/**
+ * Lays template sets over each other by output path (`x.hbs` and `x` are the same file). A
+ * `_gitkeep` placeholder is dropped from any folder a later set puts files in.
+ */
+export function overlayTemplates(sets) {
+    const byPath = new Map();
+    for (const set of sets)
+        for (const t of set)
+            byPath.set(t.relPath.replace(/\.hbs$/, ''), t);
+    const all = [...byPath.values()];
+    const dirOf = (p) => p.slice(0, p.lastIndexOf('/') + 1);
+    return all.filter((t) => !t.relPath.endsWith('_gitkeep') ||
+        !all.some((o) => o !== t && o.relPath.startsWith(dirOf(t.relPath))));
+}
 /**
  * Template naming conventions (the whole contract between templates/ and here):
  * - `*.hbs`            → rendered with the data below, suffix stripped.

package/dist/domain/deploy-plan.js

@@ -0,0 +1,82 @@
+/** The server template listens on `PORT`, 3000 unless set. */
+export const DEFAULT_API_PORT = 3000;
+export class DeployPlanError extends Error {
+}
+const SCRIPTS = {
+    release: 'bun run scripts/release.ts',
+    deploy: 'bun run scripts/deploy.ts',
+    preview: 'bun run scripts/preview.ts',
+};
+const RELEASE_DIR = '.release';
+const ESLINT_IGNORE = [
+    '// What `bun run release` builds: bundled output, not source.',
+    "{ ignores: ['.release/**'] },",
+];
+function withLine(text, line) {
+    if (text.split('\n').some((l) => l.trim() === line))
+        return text;
+    return `${text.endsWith('\n') || text === '' ? text : `${text}\n`}${line}\n`;
+}
+function withScripts(text) {
+    let pkg;
+    try {
+        pkg = JSON.parse(text);
+    }
+    catch {
+        throw new DeployPlanError('package.json is not valid JSON.');
+    }
+    if (typeof pkg !== 'object' || pkg === null || Array.isArray(pkg)) {
+        throw new DeployPlanError('package.json must hold a JSON object.');
+    }
+    const record = pkg;
+    const scripts = (record.scripts ?? {});
+    const taken = Object.keys(SCRIPTS).filter((name) => name in scripts);
+    if (taken.length > 0) {
+        throw new DeployPlanError(`package.json already has ${taken.map((t) => `"${t}"`).join(', ')} — remove them or use --force.`);
+    }
+    return JSON.stringify({ ...record, scripts: { ...scripts, ...SCRIPTS } }, null, 2) + '\n';
+}
+function withEslintIgnore(text) {
+    if (text.includes("'.release/**'"))
+        return text;
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => l.includes('defineConfig(['));
+    if (at === -1) {
+        throw new DeployPlanError(`eslint.config.ts has no "defineConfig([" to add the release folder to. Add this by hand:\n${ESLINT_IGNORE.join('\n')}`);
+    }
+    lines.splice(at + 1, 0, ...ESLINT_IGNORE.map((l) => `  ${l}`));
+    return lines.join('\n');
+}
+/**
+ * The deploy files rendered from `templates/deploy` (`__project__` in a path is the project
+ * name), plus the edits: package.json scripts, `.release` in `.gitignore` / `.prettierignore`, and
+ * an eslint ignore for it. `force` replaces existing release/deploy/preview scripts.
+ */
+export function planDeploy(target, current, templates, render, force = false) {
+    const files = templates.map((t) => {
+        const isTemplate = t.relPath.endsWith('.hbs');
+        const rel = isTemplate ? t.relPath.slice(0, -'.hbs'.length) : t.relPath;
+        return {
+            path: rel.replaceAll('__project__', target.project),
+            contents: isTemplate ? render(t.raw, { ...target }) : t.raw,
+        };
+    });
+    const packageJson = force ? withoutScripts(current.packageJson) : current.packageJson;
+    return [
+        ...files,
+        { path: 'package.json', contents: withScripts(packageJson) },
+        { path: '.gitignore', contents: withLine(current.gitignore, RELEASE_DIR) },
+        { path: '.prettierignore', contents: withLine(current.prettierignore, RELEASE_DIR) },
+        { path: 'eslint.config.ts', contents: withEslintIgnore(current.eslint) },
+    ];
+}
+function withoutScripts(text) {
+    try {
+        const pkg = JSON.parse(text);
+        const scripts = Object.entries(pkg.scripts ?? {}).filter(([name]) => !(name in SCRIPTS));
+        return JSON.stringify({ ...pkg, scripts: Object.fromEntries(scripts) });
+    }
+    catch {
+        return text;
+    }
+}

package/dist/domain/form-dsl.js

@@ -15,6 +15,7 @@ const FIELD_TYPES = new Set([
     'textarea',
     'markdown',
     'number',
+    'currency',
     'email',
     'password',
     'dropdown',
@@ -27,6 +28,7 @@ const FIELD_TYPES = new Set([
     'rating',
     'range',
     'reference',
+    'tags',
 ]);
 const KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
 const titleCase = (key) => key

package/dist/domain/remote-plan.js

@@ -0,0 +1,156 @@
+const REMOTE_MARKER = '// bahtui:remotes';
+/** The host serves on 4200; remotes take the ports after it. */
+const FIRST_REMOTE_PORT = 4201;
+/** Template paths spell the remote's name `__name__`. */
+const NAME_TOKEN = '__name__';
+const REMOTE_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+export function validateRemoteName(name) {
+    if (!REMOTE_NAME.test(name)) {
+        return [
+            `"${name}" is not a valid remote name — lowercase letters, digits and single dashes, starting with a letter.`,
+        ];
+    }
+    if (name.endsWith('-web')) {
+        return [`"${name}": leave "-web" off, the app folder adds it (apps/${name}).`];
+    }
+    return [];
+}
+export function remoteFor(name, port) {
+    const words = name.split('-');
+    const cap = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+    return {
+        name,
+        app: `${name}-web`,
+        title: words.map(cap).join(' '),
+        pascal: words.map(cap).join(''),
+        port,
+    };
+}
+/** Where the remote wiring lives, relative to the workspace root, for a host app folder. */
+export function wiringPaths(host) {
+    return {
+        eslint: 'eslint.config.ts',
+        knip: 'knip.ts',
+        depcruise: '.dependency-cruiser.mjs',
+        devManifest: `${host}/src/environments/environment.development.ts`,
+        manifest: `${host}/public/federation.manifest.json`,
+    };
+}
+export class RemoteWiringError extends Error {
+}
+/** The port after the highest one the dev manifest already uses. */
+export function nextRemotePort(devManifest) {
+    const ports = [...devManifest.matchAll(/localhost:(\d+)\//g)].map((m) => Number(m[1]));
+    return ports.length === 0 ? FIRST_REMOTE_PORT : Math.max(...ports) + 1;
+}
+/** Renders `templates/remote` for one remote, under `apps/<name>-web/`. */
+export function planRemoteFiles(remote, project, templates, render) {
+    const data = { ...remote, project };
+    return templates.map((t) => {
+        const isTemplate = t.relPath.endsWith('.hbs');
+        const rel = (isTemplate ? t.relPath.slice(0, -'.hbs'.length) : t.relPath).replaceAll(NAME_TOKEN, remote.name);
+        return {
+            path: `apps/${remote.app}/${rel}`,
+            contents: isTemplate ? render(t.raw, data) : t.raw,
+        };
+    });
+}
+function insertAtMarker(text, file, lines) {
+    const at = text.split('\n').findIndex((l) => l.trim() === REMOTE_MARKER);
+    if (at === -1) {
+        throw new RemoteWiringError(`${file} has no "${REMOTE_MARKER}" line to add the remote above. Add it back, or add this by hand:\n${lines.join('\n')}`);
+    }
+    const all = text.split('\n');
+    const indent = /^\s*/.exec(all[at] ?? '')?.[0] ?? '';
+    all.splice(at, 0, ...lines.map((l) => (l === '' ? l : indent + l)));
+    return all.join('\n');
+}
+function addToManifest(text, file, remote) {
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new RemoteWiringError(`${file} is not valid JSON.`);
+    }
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        throw new RemoteWiringError(`${file} must hold a JSON object of remotes.`);
+    }
+    const entry = {
+        entry: `/remotes/${remote.app}/remoteEntry.json`,
+        title: remote.title,
+        base: remote.name,
+        nav: [{ label: remote.title, path: remote.name }],
+    };
+    return JSON.stringify({ ...json, [remote.app]: entry }, null, 2) + '\n';
+}
+/**
+ * Adds a remote to the host workspace: the eslint and knip workspaces, the dependency-cruiser
+ * app list, and both federation manifests (dev ports, deployed paths).
+ */
+export function wireRemote(current, host, remote) {
+    const paths = wiringPaths(host);
+    if (current.knip.includes(`'apps/${remote.app}'`)) {
+        throw new RemoteWiringError(`${paths.knip} already lists apps/${remote.app}.`);
+    }
+    return [
+        {
+            path: paths.eslint,
+            contents: insertAtMarker(current.eslint, paths.eslint, [`'apps/${remote.app}/src/**',`]),
+        },
+        {
+            path: paths.knip,
+            contents: insertAtMarker(current.knip, paths.knip, [
+                `'apps/${remote.app}': remote('${remote.name}'),`,
+            ]),
+        },
+        {
+            path: paths.depcruise,
+            contents: insertAtMarker(current.depcruise, paths.depcruise, [`'${remote.app}',`]),
+        },
+        {
+            path: paths.devManifest,
+            contents: insertAtMarker(current.devManifest, paths.devManifest, [
+                `'${remote.app}': {`,
+                `  entry: 'http://localhost:${remote.port}/remoteEntry.json',`,
+                `  title: '${remote.title}',`,
+                `  base: '${remote.name}',`,
+                `  nav: [{ label: '${remote.title}', path: '${remote.name}' }],`,
+                `},`,
+            ]),
+        },
+        { path: paths.manifest, contents: addToManifest(current.manifest, paths.manifest, remote) },
+    ];
+}
+/** Replaces or adds files by path, keeping codepoint order. */
+function mergeFiles(base, changes) {
+    const byPath = new Map(base.map((f) => [f.path, f]));
+    for (const f of changes)
+        byPath.set(f.path, f);
+    return [...byPath.values()].sort((a, b) => (a.path < b.path ? -1 : 1));
+}
+/** The Angular scaffold's first remote, wired into the files `planCreate` produced. */
+export function withFirstRemote(blueprint, project, host, remoteTemplates, render, name = 'hello') {
+    const paths = wiringPaths(host);
+    const read = (path) => {
+        const file = blueprint.files.find((f) => f.path === path);
+        if (!file)
+            throw new RemoteWiringError(`template set lacks ${path}`);
+        return file.contents;
+    };
+    const current = {
+        eslint: read(paths.eslint),
+        knip: read(paths.knip),
+        depcruise: read(paths.depcruise),
+        devManifest: read(paths.devManifest),
+        manifest: read(paths.manifest),
+    };
+    const remote = remoteFor(name, nextRemotePort(current.devManifest));
+    return {
+        ...blueprint,
+        files: mergeFiles(blueprint.files, [
+            ...planRemoteFiles(remote, project, remoteTemplates, render),
+            ...wireRemote(current, host, remote),
+        ]),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "Scaffold bun workspaces (bahtui new) and DDD monorepos (React + Elysia + Eden, bahtui create) plus bahtui generators.",
   "license": "MIT",
@@ -41,10 +41,11 @@
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "accept:angular": "bun scripts/accept-angular.ts"
   },
   "dependencies": {
-    "bank20baht-validator": "^0.6.0"
+    "bank20baht-validator": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "^22",