@vmz/vmz 0.1.17 → 0.1.18

package/dist/cdn-policy.js

@@ -2,7 +2,6 @@
  * A3-cdn: vendor-neutral CDN policy (cache / redirect / error) + local static host.
  * Provider adapters only project the same contract — they must not change RouteId/canonical/CSP.
  */
-// @ts-nocheck
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import http from 'node:http';
@@ -15,20 +14,15 @@ export const CDN_ADAPTER_PROJECTION_SCHEMA = 'vmz.cdn.adapter_projection.v0';
 export const CACHE_HTML = 'public, max-age=0, must-revalidate';
 export const CACHE_ASSET_IMMUTABLE = 'public, max-age=31536000, immutable';
 export const CACHE_META = 'public, max-age=3600';
-/**
- * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects / locale artifact).
- * Locale-prefixed HTML gets LocaleId-encoded cache keys; Accept-Language must not steal body.
- * @param {Record<string, any>} staticManifest
- * @param {{
- *   redirects?: Array<{ from: string, to: string, status?: number, reason?: string }>,
- *   localeArtifact?: Record<string, any> | null,
- * }} [opts]
- */
 export function buildCdnPolicyManifest(staticManifest, opts = {}) {
     const origin = String(staticManifest.origin || '');
     const localeArt = opts.localeArtifact || null;
     const localeRedirects = buildOmitPrefixRedirects(staticManifest, localeArt);
-    const redirects = [{ from: '/home', to: '/', status: 301, reason: 'canonical-alias' }, ...localeRedirects, ...(opts.redirects || [])];
+    const redirects = [
+        { from: '/home', to: '/', status: 301, reason: 'canonical-alias' },
+        ...localeRedirects,
+        ...(opts.redirects || []),
+    ];
     const headers = [
         { match: '**/*.html', headers: { 'cache-control': CACHE_HTML } },
         {
@@ -46,7 +40,8 @@ export function buildCdnPolicyManifest(staticManifest, opts = {}) {
     const routes = [];
     /** @type {any[]} */
     const cacheKeyDiagnostics = [];
-    for (const r of staticManifest.routes || []) {
+    const staticRoutes = Array.isArray(staticManifest.routes) ? staticManifest.routes : [];
+    for (const r of staticRoutes) {
         const localeId = r.localeId || null;
         const alternates = Array.isArray(r.seo?.alternates) ? r.seo.alternates : [];
         const cacheKey = localeId
@@ -111,14 +106,13 @@ export function buildCdnPolicyManifest(staticManifest, opts = {}) {
  * @param {Record<string, any> | null} localeArt
  */
 function buildOmitPrefixRedirects(staticManifest, localeArt) {
-    const routing = localeArt?.routing || {};
+    const routing = (localeArt?.routing || {});
     const defaultLocale = localeArt?.defaultLocale || routing.defaultLocale;
     if (!defaultLocale || routing.defaultPrefix !== 'omit')
         return [];
-    /** @type {Array<{ from: string, to: string, status: number, reason: string }>} */
     const out = [];
     const seen = new Set();
-    for (const r of staticManifest.routes || []) {
+    for (const r of (staticManifest.routes || [])) {
         if (r.localeId !== defaultLocale)
             continue;
         const canonical = String(r.path || '/');
@@ -250,7 +244,7 @@ export function listenLocalStaticHost(distDir, policy, opts = {}) {
                 port: actualPort,
                 baseUrl: `http://${host}:${actualPort}`,
                 close: () => new Promise((res, rej) => {
-                    server.close((err) => (err ? rej(err) : res()));
+                    server.close((err) => (err ? rej(err) : res(undefined)));
                 }),
             });
         });

package/dist/cli-localize.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Official CLI / diagnostic localization for `@vmz/vmz`.
+ *
+ * Mechanism (manifest / flatten / load / createLocalize) lives in `@vmz/commander`.
+ * This module only points at the product `locales/` root and prefers `VMZ_LOCALE`.
+ */
+import { flattenCatalog, type LocaleCatalog, type LocalesManifest, type LocalizePlugin } from '@vmz/commander';
+/** Package `locales/` root (shipped next to `dist/`). */
+export declare function resolveCliLocalesRoot(): string;
+/** @deprecated Prefer `loadLocalesManifest` from `@vmz/commander`. */
+export declare function loadCliLocalesManifest(root?: string): LocalesManifest;
+/** @deprecated Prefer `loadCatalog` from `@vmz/commander`. */
+export declare function loadCliCatalog(locale: string, root?: string): LocaleCatalog;
+/** @deprecated Prefer `loadCatalog('en-US', root)`. */
+export declare function getVmzCliCatalogEnUs(): LocaleCatalog;
+/** Eager default table (en-US) for callers that still import a constant. */
+export declare const VMZ_CLI_CATALOG_EN_US: LocaleCatalog;
+/** Resolve product locale (`VMZ_LOCALE` first). */
+export declare function resolveVmzLocale(env?: NodeJS.ProcessEnv, argv?: string[]): string;
+/** @deprecated Prefer `translate` / `translateWithFallback` from `@vmz/commander`. */
+export declare function translateCatalog(id: string, args: Record<string, string> | undefined, catalog: LocaleCatalog): string;
+export { flattenCatalog };
+/**
+ * Build the official Localize plugin for `@vmz/vmz`.
+ */
+export declare function createVmzCliLocalize(opts?: {
+    locale?: string;
+    catalog?: LocaleCatalog;
+    env?: NodeJS.ProcessEnv;
+    argv?: string[];
+    localesRoot?: string;
+}): LocalizePlugin;
+/** Default official plugin (locale from env; catalog from `locales/`). */
+export declare const vmzCliLocalize: LocalizePlugin;

package/dist/cli-localize.js

@@ -0,0 +1,58 @@
+/**
+ * Official CLI / diagnostic localization for `@vmz/vmz`.
+ *
+ * Mechanism (manifest / flatten / load / createLocalize) lives in `@vmz/commander`.
+ * This module only points at the product `locales/` root and prefers `VMZ_LOCALE`.
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLocalizeFromLocales, flattenCatalog, loadCatalog, loadLocalesManifest, resolveLocale, translate, } from '@vmz/commander';
+const LOCALES_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'locales');
+const VMZ_ENV_KEYS = ['VMZ_LOCALE', 'LOCALE', 'LANG', 'LC_ALL'];
+/** Package `locales/` root (shipped next to `dist/`). */
+export function resolveCliLocalesRoot() {
+    return LOCALES_ROOT;
+}
+/** @deprecated Prefer `loadLocalesManifest` from `@vmz/commander`. */
+export function loadCliLocalesManifest(root = LOCALES_ROOT) {
+    return loadLocalesManifest(root);
+}
+/** @deprecated Prefer `loadCatalog` from `@vmz/commander`. */
+export function loadCliCatalog(locale, root = LOCALES_ROOT) {
+    return loadCatalog(locale, root);
+}
+/** @deprecated Prefer `loadCatalog('en-US', root)`. */
+export function getVmzCliCatalogEnUs() {
+    return loadCatalog('en-US', LOCALES_ROOT);
+}
+/** Eager default table (en-US) for callers that still import a constant. */
+export const VMZ_CLI_CATALOG_EN_US = loadCatalog('en-US', LOCALES_ROOT);
+/** Resolve product locale (`VMZ_LOCALE` first). */
+export function resolveVmzLocale(env = process.env, argv = []) {
+    return resolveLocale({
+        argv,
+        env,
+        manifest: loadLocalesManifest(LOCALES_ROOT),
+        envKeys: VMZ_ENV_KEYS,
+    });
+}
+/** @deprecated Prefer `translate` / `translateWithFallback` from `@vmz/commander`. */
+export function translateCatalog(id, args, catalog) {
+    return translate(id, args, catalog);
+}
+export { flattenCatalog };
+/**
+ * Build the official Localize plugin for `@vmz/vmz`.
+ */
+export function createVmzCliLocalize(opts = {}) {
+    return createLocalizeFromLocales({
+        root: opts.localesRoot ?? LOCALES_ROOT,
+        locale: opts.locale,
+        catalog: opts.catalog,
+        env: opts.env,
+        argv: opts.argv,
+        envKeys: VMZ_ENV_KEYS,
+    });
+}
+/** Default official plugin (locale from env; catalog from `locales/`). */
+export const vmzCliLocalize = createVmzCliLocalize();

package/dist/cli.d.ts

@@ -1,23 +1,12 @@
 /**
  * Node CLI command implementations .
  */
-/**
- * @param {string[]} argv
- */
-export declare function parseArgs(argv: any): {
-    _: any[];
-};
-export declare function printGlobalHelp(): void;
-export declare function printProjectHelp(): void;
+export declare function printGlobalHelp(): Promise<number>;
+export declare function printProjectHelp(): Promise<number>;
 /** @deprecated use printProjectHelp / printGlobalHelp */
-export declare function printHelp(): void;
-/**
- * @param {string[]} argv
- * @param {{
- * cwd?: string,
- * thisPackageRoot?: string,
- * reexec?: (bin: string, argv: string[]) => Promise<number>,
- * }} [opts]
- * @returns {Promise<number>}
- */
-export declare function runCli(argv: any, opts?: {}): Promise<any>;
+export declare function printHelp(): Promise<number>;
+export declare function runCli(argv: string[], opts?: {
+    cwd?: string;
+    thisPackageRoot?: string;
+    reexec?: (bin: string, argv: string[]) => Promise<number>;
+}): Promise<number>;

package/dist/cli.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Node CLI command implementations .
  */
@@ -11,168 +10,82 @@ import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand
 import { log } from './log.js';
 import { findAvailablePort } from './port.js';
 import { readPackageMeta, resolveWorkspaceDirs } from './resolve.js';
-import { cmdTest } from './test-cmd.js';
-import { cmdDocument } from './document-cmd.js';
+import { registerTestCommand } from './test-cmd.js';
+import { registerDocumentCommands } from './document-cmd.js';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
-import { cmdLocale } from './locale-cmd.js';
+import { registerLocaleCommands } from './locale-cmd.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { emitLocaleRouteRealization } from './locale-route-emit.js';
-import { cmdApplication } from './application-cmd.js';
-import { cmdArtifact } from './release-cmd.js';
-import { cmdRefactor } from './refactor-cmd.js';
-import { cmdExplain } from './explain-cmd.js';
-import { resolveNativeVmzCli } from './resolve-native-cli.js';
+import { registerApplicationCommands } from './application-cmd.js';
+import { registerArtifactCommands } from './release-cmd.js';
+import { registerRefactorCommands } from './refactor-cmd.js';
+import { registerExplainCommand } from './explain-cmd.js';
+import { registerPlanCommands } from './plan-cmd.js';
 import { loadVmzConfig } from './plugin-host.js';
 import { normalizeDeliveryAuthoring, resolveProfileArtifactDir, selectBuildProfile } from './delivery-profile.js';
 import { packFromDeploymentIr } from './pack.js';
 import { assembleDelivery, emitBuildProof } from './build-assemble.js';
-/**
- * @param {string[]} argv
- */
-export function parseArgs(argv) {
-    /** @type {Record<string, string | boolean> & { _: string[] }} */
-    const out = { _: [] };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (a === '--') {
-            out._.push(...argv.slice(i + 1));
-            break;
-        }
-        if (a.startsWith('--')) {
-            const eq = a.indexOf('=');
-            if (eq !== -1) {
-                out[a.slice(2, eq)] = a.slice(eq + 1);
-                continue;
-            }
-            const key = a.slice(2);
-            const next = argv[i + 1];
-            if (next && !next.startsWith('-')) {
-                out[key] = next;
-                i += 1;
-            }
-            else {
-                out[key] = true;
-            }
-            continue;
-        }
-        if (a.startsWith('-') && a.length === 2) {
-            const key = a === '-o' ? 'out-dir' : a.slice(1);
-            const next = argv[i + 1];
-            if (next && !next.startsWith('-')) {
-                out[key] = next;
-                i += 1;
-            }
-            else {
-                out[key] = true;
-            }
-            continue;
-        }
-        out._.push(a);
-    }
-    return out;
-}
+import { createCli } from '@vmz/commander';
+import { resolveCliLocalesRoot } from './cli-localize.js';
 export function printGlobalHelp() {
-    console.log(`vmz — global mode (scaffold only)
-
-Install faces: @vmz/core (runtime) · @vmz/vmz (this CLI) · optional @vmz/ui / @vmz/plugin-*
-
-Three install modes:
-  developer  monorepo source (packages/runtimes/vmz) — full CLI
-  project    app node_modules/@vmz/vmz — full CLI
-  global     npm/pnpm -g — only new/init/help/version
-
-You are in global mode. Pin \`@vmz/vmz\` in the app so check/build/lsp
-use a traceable project install.
-
-Usage:
-  vmz new|init <dir>            Scaffold (native CLI; Node only gates + forwards)
-  vmz version                   Show host + native protocol versions
-  vmz help                      Show this help
-
-Project commands:
-  pnpm add @vmz/core && pnpm add -D @vmz/vmz
-  pnpm exec vmz check
-  # or: vmz new my-app && cd my-app && pnpm install
-
-If a project \`node_modules/@vmz/vmz\` exists, a global
-\`vmz <cmd>\` re-execs that bin.
-`);
+    return buildProductCli({ mode: 'global' }).parse(['help']);
 }
 export function printProjectHelp() {
-    console.log(`vmz — Node toolchain host (project / developer mode)
-
-Usage:
-  vmz new|init <dir>            Scaffold a minimal app (native CLI)
-  vmz check [path]              Check project via Workspace
-  vmz build [path] [options]    Build project via Workspace; --target mini-program-wechat packs dist/wechat
-  vmz serve [path] [options]    Serve dist (optional --build)
-  vmz dev [path] [options]      Rebuild session; --target mini-program-wechat packs dist/wechat
-  vmz format [path] [--check]   Format .vmz via N-API (oxc formatter + EditorConfig)
-  vmz lint [path] [--deny-warnings]  Lint (= check) via N-API
-  vmz test [path] [options]     Native test discover / report
-  vmz document|docs <cmd>       Project /documents domain 
-  vmz application <cmd>         Application Collection / Mount 
-  vmz artifact <cmd>            Release pack / publish / rollback / diff (A3)
-  vmz refactor <cmd>            DX rename plans / apply 
-  vmz explain [style] <target>  DX causal explain (style Theme chain)
-  vmz lsp [root] [--out-dir]    Language server (stdio; native CLI)
-  vmz mcp [root] [--out-dir]    MCP server (stdio; native CLI)
-  vmz version                   Show host + native protocol versions
-  vmz help                      Show this help
-
-Options:
-  --out-dir, -o <dir>   Workspace output root (default: dist). Profile artifacts land in <out-dir>/<name> (name defaults to profile id; CDN: name:'cdn' → dist/cdn)
-  --release             Release build (omit serve-host; pack minify slot; proof)
-  --profile <name>      Delivery profile (default from config; builtins: web-ssr|static|web-client|web-hybrid)
-  --target <id>         browser (default) | mini-program-wechat (pack dist/wechat for WeChat DevTools; build+dev)
-  --origin <url>        Site origin for web-static canonical/sitemap
-  --host <host>         Listen host (default: 127.0.0.1)
-  --port <port>         Listen port (dev: omit = auto from 5173; set = lock)
-  --poll-ms <ms>        Dev watch poll interval (default: 300)
-  --build               Build before serve
-  --check               Format check-only (format)
-  --deny-warnings       Treat warnings as errors (lint)
-  --list                List discovered tests (test)
-  --json [file]         Emit TestReport / DocumentManifest / ApplicationCheckReport JSON
-  --mode <modes>        compile|logic|browser|ssr|resume|deployment|all (test)
-  --filter <pattern>    Filter by test id or file (test)
-  --application <id>    Run only tests for ApplicationId (standalone scope)
-  --mounted <id>        Run relocation + host-boundary tests for ApplicationId
-  --affected            Select tests from dirty VPG units (test; DX)
-  --root <dir>          Project root (document check)
-  --strict              Strict document locale/PageKey coverage (document check)
-`);
+    return buildProductCli({ mode: 'project' }).parse(['help']);
 }
 /** @deprecated use printProjectHelp / printGlobalHelp */
 export function printHelp() {
-    printProjectHelp();
+    return printProjectHelp();
+}
+function buildProductCli(opts = {}) {
+    const mode = opts.mode === 'global' ? 'global' : 'project';
+    const introId = mode === 'global' ? 'cli.intro.global' : 'cli.intro.project';
+    const cli = createCli('vmz')
+        .locales(resolveCliLocalesRoot(), {
+        envKeys: ['VMZ_LOCALE', 'LOCALE', 'LANG', 'LC_ALL'],
+    })
+        .intro(introId);
+    // Global install: only version (help is derived). Project commands need a project bin.
+    if (mode === 'global') {
+        cli.command('version', 'cli.cmd.version').action(() => cmdVersion());
+        return cli;
+    }
+    const withWorkspaceOpts = (cmd) => cmd
+        .option('--out-dir, -o <dir>', 'cli.opt.out-dir')
+        .option('--release', 'cli.opt.release')
+        .option('--profile <name>', 'cli.opt.profile')
+        .option('--target <id>', 'cli.opt.target')
+        .option('--origin <url>', 'cli.opt.origin')
+        .option('--host <host>', 'cli.opt.host')
+        .option('--port <port>', 'cli.opt.port')
+        .option('--poll-ms <ms>', 'cli.opt.poll-ms')
+        .option('--build', 'cli.opt.build')
+        .option('--check', 'cli.opt.check')
+        .option('--deny-warnings', 'cli.opt.deny-warnings');
+    withWorkspaceOpts(cli.command('check', 'cli.cmd.check')).action((options) => cmdCheck(options));
+    withWorkspaceOpts(cli.command('build', 'cli.cmd.build')).action((options) => cmdBuild(options));
+    withWorkspaceOpts(cli.command('serve', 'cli.cmd.serve')).action((options) => cmdServe(options));
+    withWorkspaceOpts(cli.command('dev', 'cli.cmd.dev')).action((options) => cmdDev(options));
+    withWorkspaceOpts(cli.command('format', 'cli.cmd.format')).action((options) => cmdFormat(options));
+    withWorkspaceOpts(cli.command('lint', 'cli.cmd.lint')).action((options) => cmdLint(options));
+    registerTestCommand(cli);
+    registerDocumentCommands(cli.command('document|docs', 'cli.cmd.document'));
+    registerLocaleCommands(cli.command('locale|locales', 'cli.cmd.locale'));
+    registerPlanCommands(cli.command('plan', 'cli.cmd.plan'));
+    registerApplicationCommands(cli.command('application|applications|app', 'cli.cmd.application'));
+    registerArtifactCommands(cli.command('artifact|artifacts|release', 'cli.cmd.artifact'));
+    registerRefactorCommands(cli.command('refactor', 'cli.cmd.refactor'));
+    registerExplainCommand(cli);
+    cli.command('version', 'cli.cmd.version').action(() => cmdVersion());
+    return cli;
 }
-/**
- * @param {string[]} argv
- * @param {{
- * cwd?: string,
- * thisPackageRoot?: string,
- * reexec?: (bin: string, argv: string[]) => Promise<number>,
- * }} [opts]
- * @returns {Promise<number>}
- */
 export async function runCli(argv, opts = {}) {
-    const [cmd, ...rest] = argv;
+    const [cmd] = argv;
     const inv = getInvocationContext({
         cwd: opts.cwd,
         thisPackageRoot: opts.thisPackageRoot,
     });
-    if (!cmd || cmd === 'help' || cmd === '-h' || cmd === '--help') {
-        if (inv.mode === 'global')
-            printGlobalHelp();
-        else
-            printProjectHelp();
-        return 0;
-    }
-    if (cmd === 'version' || cmd === '-V' || cmd === '--version') {
-        return cmdVersion();
-    }
-    if (!isGlobalAllowedCommand(cmd)) {
+    if (cmd && !isHelpToken(cmd) && cmd !== 'version' && cmd !== '-V' && cmd !== '--version' && !isGlobalAllowedCommand(cmd)) {
         const gated = await gateGlobalProjectCommand({
             argv,
             cwd: opts.cwd,
@@ -183,85 +96,13 @@ export async function runCli(argv, opts = {}) {
         if (gated.action === 'exit')
             return gated.code;
     }
-    const args = parseArgs(rest);
-    switch (cmd) {
-        case 'new':
-        case 'init':
-            return cmdNativeForward(cmd, rest);
-        case 'check':
-            return cmdCheck(args);
-        case 'build':
-            return cmdBuild(args);
-        case 'serve':
-            return cmdServe(args);
-        case 'dev':
-            return cmdDev(args);
-        case 'format':
-            return cmdFormat(args);
-        case 'lint':
-            return cmdLint(args);
-        case 'test':
-            return cmdTest(args);
-        case 'document':
-        case 'docs':
-            return cmdDocument(rest);
-        case 'locale':
-        case 'locales':
-            return cmdLocale(rest);
-        case 'application':
-        case 'applications':
-        case 'app':
-            return cmdApplication(rest);
-        case 'artifact':
-        case 'artifacts':
-        case 'release':
-            return cmdArtifact(rest);
-        case 'refactor':
-            return cmdRefactor(rest);
-        case 'explain':
-            return cmdExplain(rest);
-        case 'lsp':
-            return cmdNativeForward('lsp', rest);
-        case 'mcp':
-            return cmdNativeForward('mcp', rest);
-        default:
-            log.error(`unknown command \`${cmd}\``);
-            if (inv.mode === 'global')
-                printGlobalHelp();
-            else
-                printProjectHelp();
-            return 1;
-    }
+    // Normalize version aliases onto the registered `version` command.
+    const normalized = cmd === '-V' || cmd === '--version' ? ['version', ...argv.slice(1)] : argv;
+    const mode = inv.mode === 'global' ? 'global' : 'project';
+    return buildProductCli({ mode }).parse(normalized);
 }
-/**
- * Forward to the single native `vmz` binary (vmz-tools).
- * Scaffold / stdio servers live in Rust — Node only gates + re-execs.
- *
- * @param {'new' | 'init' | 'lsp' | 'mcp'} sub
- * @param {string[]} argv
- * @returns {Promise<number>}
- */
-function cmdNativeForward(sub, argv) {
-    const bin = resolveNativeVmzCli();
-    if (!bin) {
-        log.error('native `vmz` CLI not found (vmz-tools).');
-        log.error('Build: cargo build -p vmz-tools');
-        log.error('Or set VMZ_NATIVE to the absolute path of that binary.');
-        return Promise.resolve(1);
-    }
-    return new Promise((resolve) => {
-        const child = spawn(bin, [sub, ...argv], { stdio: 'inherit' });
-        child.on('error', (err) => {
-            log.error(`failed to spawn ${bin}: ${err.message}`);
-            resolve(1);
-        });
-        child.on('exit', (code, signal) => {
-            if (signal)
-                resolve(1);
-            else
-                resolve(code ?? 1);
-        });
-    });
+function isHelpToken(token) {
+    return token === 'help' || token === '-h' || token === '--help';
 }
 function cmdVersion() {
     const native = getProtocolVersions();
@@ -269,10 +110,7 @@ function cmdVersion() {
     console.log(`native host=${native.hostProtocol} compiler=${native.compilerProtocol} program_ir=${native.programIrSchema} plugin=${native.pluginProtocol}`);
     return 0;
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
-function cmdCheck(args) {
+async function cmdCheck(args) {
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
         path: pathArg,
@@ -297,13 +135,9 @@ function cmdCheck(args) {
         ws.dispose();
     }
 }
-/**
- * Dedupe locale/build diagnostics by code+path+message (runtime + route emit both report missing manifest).
- * @param {Array<{ code?: string, path?: string, message?: string, severity?: string }>} list
- */
+/** Dedupe locale/build diagnostics by code+path+message (runtime + route emit both report missing manifest). */
 function dedupeDiagnostics(list) {
     const seen = new Set();
-    /** @type {typeof list} */
     const out = [];
     for (const d of list || []) {
         const key = `${d.code || ''}\0${d.path || ''}\0${d.message || ''}\0${d.severity || ''}`;
@@ -314,12 +148,6 @@ function dedupeDiagnostics(list) {
     }
     return out;
 }
-/**
- * @param {import('./index.js').Workspace} ws
- * @param {string} project
- * @param {string} outDir
- * @param {() => Promise<number> | number} fn
- */
 async function runWithPlugins(ws, project, outDir, fn) {
     const { loadVmzConfig, applyPlugins } = await import('./plugin-host.js');
     const { plugins, engines } = await loadVmzConfig(project);
@@ -328,14 +156,11 @@ async function runWithPlugins(ws, project, outDir, fn) {
     }
     return await fn();
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 async function cmdBuild(args) {
     const pathArg = args._[0] ?? '.';
     const targetRaw = typeof args.target === 'string' ? args.target : 'browser';
     if (targetRaw !== 'browser' && targetRaw !== 'mini-program-wechat') {
-        log.error(`unknown --target ${targetRaw} (browser | mini-program-wechat)`);
+        log.errorId('cli.err.unknown_target', { target: String(targetRaw) });
         return 1;
     }
     const wechatPack = targetRaw === 'mini-program-wechat';
@@ -457,7 +282,8 @@ async function cmdBuild(args) {
                 selection: selected.selection,
                 profile: {
                     ...selected.profile,
-                    sources: selected.profile.sources || (norm.table.sugar ? norm.table.profiles[norm.table.default]?.sources : null),
+                    sources: selected.profile.sources ||
+                        (norm.table.sugar ? norm.table.profiles[norm.table.default]?.sources : null),
                 },
                 siteId: cfg.application?.id || undefined,
                 origin,
@@ -559,9 +385,6 @@ async function cmdServe(args) {
         });
     });
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 async function cmdDev(args) {
     const pathArg = args._[0] ?? '.';
     const { project, outDir: outDirRoot } = resolveWorkspaceDirs({
@@ -603,7 +426,7 @@ async function cmdDev(args) {
     const pollMs = Number(args['poll-ms'] ?? 300);
     const targetRaw = typeof args.target === 'string' ? args.target : 'browser';
     if (targetRaw !== 'browser' && targetRaw !== 'mini-program-wechat') {
-        log.error(`unknown --target ${targetRaw} (browser | mini-program-wechat)`);
+        log.errorId('cli.err.unknown_target', { target: String(targetRaw) });
         return 1;
     }
     const ac = new AbortController();
@@ -638,9 +461,6 @@ async function cmdDev(args) {
         await session.stop();
     }
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 function cmdFormat(args) {
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
@@ -664,9 +484,6 @@ function cmdFormat(args) {
         ws.dispose();
     }
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 function cmdLint(args) {
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({

package/dist/content-addressed-assets.d.ts

@@ -6,6 +6,26 @@
  * resolve at dist root — never prefer hashed siblings for JS (second-hop 404).
  */
 export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
+interface ContentAddressedAssetObject {
+    logicalPath: string;
+    assetPath: string;
+    digest: string;
+    bytes: number;
+    immutable: boolean;
+}
+export interface ContentAddressedAssetsManifest {
+    schema: string;
+    layout: string;
+    immutable: boolean;
+    objectCount: number;
+    objects: ContentAddressedAssetObject[];
+    rewrittenHtml: number;
+    manifestDigest?: string;
+}
+interface EmitContentAddressedAssetsOpts {
+    candidates?: string[];
+    rewriteHtml?: boolean;
+}
 /**
  * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
  * @param {string} cssText
@@ -30,17 +50,10 @@ export declare function rewriteJsEntryRelativeImports(jsText: any, _rewrites?: {
  * @param {string} distDir
  * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
  */
-export declare function emitContentAddressedAssets(distDir: any, opts?: {}): {
-    manifest: {
-        schema: string;
-        layout: string;
-        immutable: boolean;
-        objectCount: number;
-        objects: any[];
-        rewrittenHtml: number;
-    };
+export declare function emitContentAddressedAssets(distDir: string, opts?: EmitContentAddressedAssetsOpts): {
+    manifest: ContentAddressedAssetsManifest;
     assetsDir: string;
-    rewrites: {};
+    rewrites: Record<string, string>;
     manifestPath: string;
 };
 /**
@@ -88,3 +101,4 @@ export declare function assertSharedAssetPath(distDir: any, a: any, b: any, ext?
 };
 export declare function contentAddressedAssetsDigest(manifest: any): any;
 export declare function sha256Buffer(buf: any): string;
+export {};