@vmz/vmz 0.2.4 → 0.2.6

package/dist/cli/cli.js

@@ -19,6 +19,8 @@ import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-chec
 import { registerLocaleCommands } from '../locale/locale-cmd.js';
 import { emitLocaleRouteRealization } from '../locale/locale-route-emit.js';
 import { log } from '../workspace/log.js';
+import { resolveCliLogLevel, setCliLogLevel } from '../workspace/log-level.js';
+import { parseCliLogStyle, setCliLogStyle } from '../workspace/log-style.js';
 import { packFromDeploymentIr } from '../workspace/pack.js';
 import { registerPlanCommands } from './plan-cmd.js';
 import { loadVmzConfig } from '../workspace/plugin-host.js';
@@ -63,7 +65,11 @@ function buildProductCli(opts = {}) {
         .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('check', 'cli.cmd.check'))
+        .option('--level <level>', 'cli.opt.level')
+        .option('--info', 'cli.opt.info-level')
+        .option('--style <style>', 'cli.opt.diag-style')
+        .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));
@@ -72,7 +78,11 @@ function buildProductCli(opts = {}) {
         .option('--no-rust', 'cli.opt.format-no-rust')
         .option('--no-vmz', 'cli.opt.format-no-vmz')
         .action((options) => cmdFormat(options));
-    withWorkspaceOpts(cli.command('lint', 'cli.cmd.lint')).action((options) => cmdLint(options));
+    withWorkspaceOpts(cli.command('lint', 'cli.cmd.lint'))
+        .option('--level <level>', 'cli.opt.level')
+        .option('--info', 'cli.opt.info-level')
+        .option('--style <style>', 'cli.opt.diag-style')
+        .action((options) => cmdLint(options));
     registerTestCommand(cli);
     registerDocumentCommands(cli.command('document|docs', 'cli.cmd.document'));
     registerLocaleCommands(cli.command('locale|locales', 'cli.cmd.locale'));
@@ -116,7 +126,25 @@ function cmdVersion() {
     console.log(`native host=${native.hostProtocol} compiler=${native.compilerProtocol} program_ir=${native.programIrSchema} plugin=${native.pluginProtocol}`);
     return 0;
 }
+function applyInspectLogOptions(args) {
+    const level = resolveCliLogLevel({ level: args.level, info: Boolean(args.info) });
+    if (level == null) {
+        log.errorId('cli.err.invalid_level', { level: String(args.level ?? '') });
+        return 1;
+    }
+    setCliLogLevel(level);
+    const style = parseCliLogStyle(args.style);
+    if (style == null) {
+        log.errorId('cli.err.invalid_style', { style: String(args.style ?? '') });
+        return 1;
+    }
+    setCliLogStyle(style);
+    return null;
+}
 async function cmdCheck(args) {
+    const optsErr = applyInspectLogOptions(args);
+    if (optsErr != null)
+        return optsErr;
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
         path: pathArg,
@@ -497,6 +525,9 @@ async function cmdFormat(args) {
     });
 }
 function cmdLint(args) {
+    const optsErr = applyInspectLogOptions(args);
+    if (optsErr != null)
+        return optsErr;
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
         path: pathArg,

package/dist/host-materialize/serve-host-runtime.js

@@ -24,6 +24,8 @@ export function materializeServeHostRuntime(outDir, coreDist = resolveCoreRuntim
         if (entry.rewriteVmzRuntimeImport) {
             const text = readFileSync(src, 'utf8')
                 .replace(/from\s+(['"])\.\/vmz-runtime\.js\1/g, 'from $1../../vmz-runtime.js$1')
+                .replace(/from\s+(['"])\.\.\/\.\.\/faces\/vmz-runtime\.js\1/g, 'from $1../../../vmz-runtime.js$1')
+                .replace(/from\s+(['"])\.\.\/\.\.\/faces\/server\.js\1/g, 'from $1../../../vmz-runtime.js$1')
                 .replace(/from\s+(['"])\.\.\/faces\/vmz-runtime\.js\1/g, 'from $1../../vmz-runtime.js$1')
                 .replace(/from\s+(['"])\.\.\/faces\/server\.js\1/g, 'from $1../../vmz-runtime.js$1');
             writeFileSync(dst, text, 'utf8');

package/dist/workspace/delivery-runtime-files.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Load packages/runtimes/vmz/delivery-runtime-files.json — sole browser/SSR delivery copy list.
+ */
+export type DeliveryRuntimeFileEntry = {
+    src: string;
+    out: string;
+};
+export type DeliveryRuntimeFilesManifest = {
+    schema: string;
+    flatBarrels: DeliveryRuntimeFileEntry[];
+    nested: DeliveryRuntimeFileEntry[];
+};
+export declare function loadDeliveryRuntimeFilesManifest(pathOverride?: string): DeliveryRuntimeFilesManifest;
+/** All [src, out] pairs for materialize / pack. */
+export declare function deliveryRuntimeFilePairs(manifest?: DeliveryRuntimeFilesManifest): ReadonlyArray<readonly [string, string]>;

package/dist/workspace/delivery-runtime-files.js

@@ -0,0 +1,34 @@
+/**
+ * Load packages/runtimes/vmz/delivery-runtime-files.json — sole browser/SSR delivery copy list.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const MANIFEST_BASENAME = 'delivery-runtime-files.json';
+function manifestPathFromHere() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, '..', '..', MANIFEST_BASENAME);
+}
+let cached = null;
+export function loadDeliveryRuntimeFilesManifest(pathOverride) {
+    if (!pathOverride && cached)
+        return cached;
+    const p = pathOverride || manifestPathFromHere();
+    const raw = JSON.parse(readFileSync(p, 'utf8'));
+    if (raw.schema !== 'vmz.delivery-runtime-files.v0') {
+        throw new Error(`delivery-runtime-files: unexpected schema ${raw.schema}`);
+    }
+    if (!Array.isArray(raw.flatBarrels) || !raw.flatBarrels.length) {
+        throw new Error('delivery-runtime-files: flatBarrels empty');
+    }
+    if (!Array.isArray(raw.nested) || !raw.nested.length) {
+        throw new Error('delivery-runtime-files: nested empty');
+    }
+    if (!pathOverride)
+        cached = raw;
+    return raw;
+}
+/** All [src, out] pairs for materialize / pack. */
+export function deliveryRuntimeFilePairs(manifest = loadDeliveryRuntimeFilesManifest()) {
+    return [...manifest.flatBarrels, ...manifest.nested].map((f) => [f.src, f.out]);
+}

package/dist/workspace/delivery-runtime-imports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Rewrite `@vmz/core` dist imports for flat app delivery layout.
+ * Keep in sync with `rewrite_delivery_imports` in vmz-compiler compile.rs.
+ */
+/** @param {string} text @param {string} outName delivery-relative output path */
+export declare function rewriteDeliveryImports(text: string, outName: string): string;

package/dist/workspace/delivery-runtime-imports.js

@@ -0,0 +1,87 @@
+/**
+ * Rewrite `@vmz/core` dist imports for flat app delivery layout.
+ * Keep in sync with `rewrite_delivery_imports` in vmz-compiler compile.rs.
+ */
+function replaceImportPath(text, from, to) {
+    let out = text;
+    out = out.replaceAll(`'${from}'`, `'${to}'`);
+    out = out.replaceAll(`"${from}"`, `"${to}"`);
+    return out;
+}
+function replaceQuotedPrefix(text, from, to) {
+    let out = text;
+    out = out.replaceAll(`'${from}`, `'${to}`);
+    out = out.replaceAll(`"${from}`, `"${to}`);
+    return out;
+}
+function rewriteFlatDeliveryImports(text) {
+    let out = text;
+    const pairs = [
+        ['../browser/dom-core.js', './dom-core.js'],
+        ['../browser/direct-host-box.js', './direct-host-box.js'],
+        ['../browser/unknown-component.js', './unknown-component.js'],
+        ['../shared/dom-attr-normalize.js', './dom-attr-normalize.js'],
+        ['../browser/client-nav.js', './vmz-client-nav.js'],
+        ['../ssr/dom-ssr.js', './dom-ssr.js'],
+        ['../faces/server.js', './vmz-runtime.js'],
+        ['../faces/vmz-runtime.js', './vmz-runtime.js'],
+        ['../faces/http.js', './vmz-http.js'],
+    ];
+    for (const [from, to] of pairs) {
+        out = replaceImportPath(out, from, to);
+    }
+    return out;
+}
+function rewriteNestedSsrDelivery(text) {
+    let out = text;
+    for (const [from, to] of [
+        ['../browser/dom-core.js', '../dom-core.js'],
+        ['../browser/direct-host-box.js', '../direct-host-box.js'],
+        ['../browser/unknown-component.js', '../unknown-component.js'],
+    ]) {
+        out = replaceImportPath(out, from, to);
+    }
+    return out;
+}
+function rewriteNestedBrowserDelivery(text) {
+    let out = replaceImportPath(text, '../../shared/dom-attr-normalize.js', '../../dom-attr-normalize.js');
+    for (const [from, to] of [
+        ['../direct-host-box.js', '../../direct-host-box.js'],
+        ['../unknown-component.js', '../../unknown-component.js'],
+        ['../dom-core.js', '../../dom-core.js'],
+    ]) {
+        out = replaceImportPath(out, from, to);
+    }
+    return out;
+}
+function rewriteFlatDeliveryRoot(text, outName) {
+    let out = rewriteFlatDeliveryImports(text);
+    if (outName === 'dom-core.js') {
+        for (const [from, to] of [
+            ['./diagnostics/', './browser/diagnostics/'],
+            ['./dom/', './browser/dom/'],
+            ['./reactivity/', './browser/reactivity/'],
+        ]) {
+            out = replaceQuotedPrefix(out, from, to);
+        }
+    }
+    else if (outName === 'dom-ssr.js') {
+        out = replaceImportPath(out, './render.js', './ssr/render.js');
+        out = replaceQuotedPrefix(out, '../browser/resume/', './browser/resume/');
+    }
+    else if (outName === 'vmz-client-nav.js') {
+        out = replaceQuotedPrefix(out, './navigation/', './browser/navigation/');
+    }
+    else if (outName === 'dom.browser.js') {
+        out = replaceQuotedPrefix(out, '../browser/resume/', './browser/resume/');
+    }
+    return out;
+}
+/** @param {string} text @param {string} outName delivery-relative output path */
+export function rewriteDeliveryImports(text, outName) {
+    if (outName.startsWith('ssr/'))
+        return rewriteNestedSsrDelivery(text);
+    if (outName.startsWith('browser/'))
+        return rewriteNestedBrowserDelivery(text);
+    return rewriteFlatDeliveryRoot(text, outName);
+}

package/dist/workspace/diagnostic-context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Source cache + OffsetIndex-backed PositionContext for CLI pretty diagnostics.
+ */
+import type { PositionContext } from '@vmz/diagnostic';
+/** Read and memoize a source file for snippet rendering. */
+export declare function readDiagnosticSource(path: string): string | undefined;
+/** OffsetIndex PositionContext for one source buffer (memoized per path). */
+export declare function positionContextForSource(path: string, sourceText: string): PositionContext;
+/** Clear caches between CLI invocations in long-lived hosts. */
+export declare function resetDiagnosticContext(): void;

package/dist/workspace/diagnostic-context.js

@@ -0,0 +1,53 @@
+/**
+ * Source cache + OffsetIndex-backed PositionContext for CLI pretty diagnostics.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { loadNative } from './public-api.js';
+const sourceCache = new Map();
+const positionCache = new Map();
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+/** Read and memoize a source file for snippet rendering. */
+export function readDiagnosticSource(path) {
+    const key = normalizePath(path);
+    if (sourceCache.has(key))
+        return sourceCache.get(key);
+    if (!path || !existsSync(path))
+        return undefined;
+    try {
+        const text = readFileSync(path, 'utf8');
+        sourceCache.set(key, text);
+        return text;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** OffsetIndex PositionContext for one source buffer (memoized per path). */
+export function positionContextForSource(path, sourceText) {
+    const key = normalizePath(path);
+    const cached = positionCache.get(key);
+    if (cached)
+        return cached;
+    const native = loadNative();
+    if (typeof native.offsetIndexLineCol !== 'function') {
+        const fallback = { lineCol: () => ({ line: 1, column: 1 }) };
+        positionCache.set(key, fallback);
+        return fallback;
+    }
+    const source = String(sourceText ?? '');
+    const ctx = {
+        lineCol(offset) {
+            const row = native.offsetIndexLineCol(source, Math.max(0, Number(offset) || 0) >>> 0);
+            return { line: row.line, column: row.column };
+        },
+    };
+    positionCache.set(key, ctx);
+    return ctx;
+}
+/** Clear caches between CLI invocations in long-lived hosts. */
+export function resetDiagnosticContext() {
+    sourceCache.clear();
+    positionCache.clear();
+}

package/dist/workspace/log-level.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CLI output verbosity for diagnostics and progress lines.
+ *
+ * `error` — errors only
+ * `warn`  — errors + warnings (default)
+ * `info`  — errors + warnings + advice, plus progress lines
+ */
+export type CliLogLevel = 'error' | 'warn' | 'info';
+/** Active CLI log level (default `warn`). */
+export declare function getCliLogLevel(): CliLogLevel;
+/** Set active CLI log level for the current command invocation. */
+export declare function setCliLogLevel(level: CliLogLevel): void;
+/** Parse `--level` values; `null` when unrecognized. */
+export declare function parseCliLogLevel(raw: unknown): CliLogLevel | null;
+/** Resolve level from `check` / `lint` flags (`--info` overrides `--level`). */
+export declare function resolveCliLogLevel(args: {
+    level?: unknown;
+    info?: boolean;
+}): CliLogLevel | null;
+/** Whether a diagnostic severity should be printed at `level`. */
+export declare function diagnosticVisible(severity: string | undefined, level: CliLogLevel): boolean;
+/** Progress / summary lines (`log.info`) only at `info`. */
+export declare function progressVisible(level: CliLogLevel): boolean;
+/** Non-diagnostic warn lines at `warn` and above. */
+export declare function warnVisible(level: CliLogLevel): boolean;

package/dist/workspace/log-level.js

@@ -0,0 +1,64 @@
+/**
+ * CLI output verbosity for diagnostics and progress lines.
+ *
+ * `error` — errors only
+ * `warn`  — errors + warnings (default)
+ * `info`  — errors + warnings + advice, plus progress lines
+ */
+const LEVEL_RANK = {
+    error: 0,
+    warn: 1,
+    info: 2,
+};
+let currentLevel = 'warn';
+/** Active CLI log level (default `warn`). */
+export function getCliLogLevel() {
+    return currentLevel;
+}
+/** Set active CLI log level for the current command invocation. */
+export function setCliLogLevel(level) {
+    currentLevel = level;
+}
+/** Parse `--level` values; `null` when unrecognized. */
+export function parseCliLogLevel(raw) {
+    if (raw == null || raw === '')
+        return 'warn';
+    const s = String(raw).trim().toLowerCase();
+    if (s === 'error')
+        return 'error';
+    if (s === 'warn' || s === 'warning')
+        return 'warn';
+    if (s === 'info' || s === 'advice')
+        return 'info';
+    return null;
+}
+/** Resolve level from `check` / `lint` flags (`--info` overrides `--level`). */
+export function resolveCliLogLevel(args) {
+    if (args.info)
+        return 'info';
+    return parseCliLogLevel(args.level);
+}
+function normalizeDiagnosticSeverity(severity) {
+    if (severity === 'warning')
+        return 'warning';
+    if (severity === 'advice')
+        return 'advice';
+    return 'error';
+}
+/** Whether a diagnostic severity should be printed at `level`. */
+export function diagnosticVisible(severity, level) {
+    const sev = normalizeDiagnosticSeverity(severity);
+    if (sev === 'error')
+        return true;
+    if (sev === 'warning')
+        return LEVEL_RANK[level] >= LEVEL_RANK.warn;
+    return LEVEL_RANK[level] >= LEVEL_RANK.info;
+}
+/** Progress / summary lines (`log.info`) only at `info`. */
+export function progressVisible(level) {
+    return level === 'info';
+}
+/** Non-diagnostic warn lines at `warn` and above. */
+export function warnVisible(level) {
+    return LEVEL_RANK[level] >= LEVEL_RANK.warn;
+}

package/dist/workspace/log-style.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI diagnostic layout: `pretty` (snippets) vs `compact` (single-line, CI-friendly).
+ */
+export type CliLogStyle = 'pretty' | 'compact';
+export declare function getCliLogStyle(): CliLogStyle;
+export declare function setCliLogStyle(style: CliLogStyle): void;
+export declare function parseCliLogStyle(raw: unknown): CliLogStyle | null;

package/dist/workspace/log-style.js

@@ -0,0 +1,20 @@
+/**
+ * CLI diagnostic layout: `pretty` (snippets) vs `compact` (single-line, CI-friendly).
+ */
+let currentStyle = 'pretty';
+export function getCliLogStyle() {
+    return currentStyle;
+}
+export function setCliLogStyle(style) {
+    currentStyle = style;
+}
+export function parseCliLogStyle(raw) {
+    if (raw == null || raw === '')
+        return 'pretty';
+    const s = String(raw).trim().toLowerCase();
+    if (s === 'pretty')
+        return 'pretty';
+    if (s === 'compact')
+        return 'compact';
+    return null;
+}

package/dist/workspace/log.d.ts

@@ -1,6 +1,7 @@
 /**
  * Unified CLI logging / diagnostics via `@vmz/diagnostic` + product catalog.
  */
+import { type CliLogLevel } from './log-level.js';
 export type DiagnosticLike = {
     severity?: string;
     path?: string;
@@ -12,15 +13,19 @@ export type DiagnosticLike = {
         end: number;
     };
 };
+export type DiagnosticLogOptions = {
+    denyWarnings?: boolean;
+    level?: CliLogLevel;
+};
 export declare const log: {
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
     /** Localized framework error (`cli.err.*`). */
     errorId(id: string, args?: Record<string, string>): void;
-    diagnostic(d: DiagnosticLike): void;
-    /** Failing count: errors, and warnings when `denyWarnings`. */
-    diagnostics(diagnostics: DiagnosticLike[] | null | undefined, opts?: {
-        denyWarnings?: boolean;
-    }): number;
+    diagnostic(d: DiagnosticLike, opts?: {
+        level?: CliLogLevel;
+    }): boolean;
+    /** Failing count: errors, and warnings when `denyWarnings` (independent of print level). */
+    diagnostics(diagnostics: DiagnosticLike[] | null | undefined, opts?: DiagnosticLogOptions): number;
 };

package/dist/workspace/log.js

@@ -3,32 +3,48 @@
  */
 import { formatDiagnostic } from '@vmz/diagnostic';
 import { loadCliCatalog, resolveVmzLocale, vmzCliLocalize } from '../cli/cli-localize.js';
-function stamp(level) {
-    return `vmz ${level}`;
+import { positionContextForSource, readDiagnosticSource } from './diagnostic-context.js';
+import { diagnosticVisible, getCliLogLevel, progressVisible, warnVisible } from './log-level.js';
+import { getCliLogStyle } from './log-style.js';
+function normalizeSeverity(severity) {
+    if (severity === 'warning')
+        return 'warning';
+    if (severity === 'advice')
+        return 'advice';
+    return 'error';
 }
 export const log = {
     info(...args) {
-        console.error(stamp('info'), ...args);
+        if (!progressVisible(getCliLogLevel()))
+            return;
+        console.error(...args);
     },
     warn(...args) {
-        console.error(stamp('warn'), ...args);
+        if (!warnVisible(getCliLogLevel()))
+            return;
+        console.error(...args);
     },
     error(...args) {
-        console.error(stamp('error'), ...args);
+        console.error(...args);
     },
     /** Localized framework error (`cli.err.*`). */
     errorId(id, args) {
-        console.error(stamp('error'), vmzCliLocalize.t(id, args));
+        console.error(vmzCliLocalize.t(id, args));
     },
-    diagnostic(d) {
-        const severity = d.severity === 'warning' || d.severity === 'advice' || d.severity === 'error' ? d.severity : 'error';
-        // Only invent transitional `diag.message` when wire has no code; never remap a real code.
+    diagnostic(d, opts = {}) {
+        const level = opts.level ?? getCliLogLevel();
+        const severity = normalizeSeverity(d.severity);
+        if (!diagnosticVisible(severity, level))
+            return false;
         const hasCode = Boolean(d.code && String(d.code).length);
         const code = hasCode ? String(d.code) : 'diag.message';
         const locale = resolveVmzLocale();
         const catalog = loadCliCatalog(locale);
+        const path = d.path || '';
+        const style = getCliLogStyle();
+        const sourceText = style === 'pretty' && path ? readDiagnosticSource(path) : undefined;
         const line = formatDiagnostic({
-            path: d.path || '',
+            path,
             severity,
             code,
             args: d.args ?? (!hasCode && d.message ? { message: String(d.message) } : undefined),
@@ -37,14 +53,26 @@ export const log = {
         }, {
             locale,
             catalog,
+            sourceText,
+            position: sourceText ? positionContextForSource(path, sourceText) : undefined,
+            style,
         });
-        console.error(stamp(severity === 'warning' ? 'warn' : severity === 'error' ? 'error' : 'diag'), line);
+        console.error(line);
+        return true;
     },
-    /** Failing count: errors, and warnings when `denyWarnings`. */
+    /** Failing count: errors, and warnings when `denyWarnings` (independent of print level). */
     diagnostics(diagnostics, opts = {}) {
+        const level = opts.level ?? getCliLogLevel();
+        const style = getCliLogStyle();
         let failing = 0;
-        for (const d of diagnostics ?? []) {
-            this.diagnostic(d);
+        const items = diagnostics ?? [];
+        const visible = items.filter((d) => diagnosticVisible(normalizeSeverity(d.severity), level));
+        for (let i = 0; i < visible.length; i += 1) {
+            this.diagnostic(visible[i], { level });
+            if (style === 'pretty' && i + 1 < visible.length)
+                console.error('');
+        }
+        for (const d of items) {
             if (d.severity === 'error')
                 failing += 1;
             else if (opts.denyWarnings && d.severity === 'warning')

package/dist/workspace/pack.js

@@ -8,28 +8,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { loadDeploymentIr, planBundleInputs } from './bundler-adapter.js';
 import { packClientBareImports } from './pack-client-packages.js';
+import { deliveryRuntimeFilePairs } from './delivery-runtime-files.js';
+import { rewriteDeliveryImports } from './delivery-runtime-imports.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 export const PACK_MANIFEST_SCHEMA = 'vmz.pack.manifest.v0';
-/** Keep in sync with `rewrite_flat_delivery_imports` in vmz-compiler compile.rs. */
-function rewriteFlatDeliveryImports(text) {
-    let out = text;
-    const pairs = [
-        ['../browser/dom-core.js', './dom-core.js'],
-        ['../browser/direct-host-box.js', './direct-host-box.js'],
-        ['../browser/unknown-component.js', './unknown-component.js'],
-        ['../shared/dom-attr-normalize.js', './dom-attr-normalize.js'],
-        ['../browser/client-nav.js', './vmz-client-nav.js'],
-        ['../ssr/dom-ssr.js', './dom-ssr.js'],
-        ['../faces/server.js', './vmz-runtime.js'],
-        ['../faces/vmz-runtime.js', './vmz-runtime.js'],
-        ['../faces/http.js', './vmz-http.js'],
-    ];
-    for (const [from, to] of pairs) {
-        out = out.replaceAll(`'${from}'`, `'${to}'`);
-        out = out.replaceAll(`"${from}"`, `"${to}"`);
-    }
-    return out;
-}
 /**
  * Ensure dom split companions sit next to vmz-dom.js (barrel imports ./dom-core.js).
  * Always refresh from `@vmz/core` when present so SSR/runtime fixes are not sticky in outDir.
@@ -40,22 +22,13 @@ function rewriteFlatDeliveryImports(text) {
 export function ensureRuntimeCompanions(outDir, coreDist) {
     if (!coreDist)
         return [];
-    const companions = [
-        ['browser/dom-core.js', 'dom-core.js'],
-        ['ssr/dom-ssr.js', 'dom-ssr.js'],
-        ['faces/dom.client.js', 'dom.client.js'],
-        ['faces/dom.browser.js', 'dom.browser.js'],
-        ['browser/direct-host-box.js', 'direct-host-box.js'],
-        ['browser/unknown-component.js', 'unknown-component.js'],
-        ['shared/dom-attr-normalize.js', 'dom-attr-normalize.js'],
-    ];
     const copied = [];
-    for (const [srcRel, outName] of companions) {
+    for (const [srcRel, outName] of deliveryRuntimeFilePairs()) {
         const src = path.join(coreDist, srcRel);
         if (!existsSync(src))
             continue;
         const dest = path.join(outDir, outName);
-        const text = rewriteFlatDeliveryImports(readFileSync(src, 'utf8'));
+        const text = rewriteDeliveryImports(readFileSync(src, 'utf8'), outName);
         mkdirSync(path.dirname(dest), { recursive: true });
         writeFileSync(dest, text);
         copied.push(outName);

package/locales/en-US/cli.json

@@ -62,6 +62,9 @@
     "cli.opt.build": "Build before serve",
     "cli.opt.check": "Format check-only / extract fail on CJK",
     "cli.opt.deny-warnings": "Treat warnings as errors",
+    "cli.opt.level": "Diagnostic verbosity: error | warn | info (default warn)",
+    "cli.opt.info-level": "Show advice diagnostics and progress (same as --level info)",
+    "cli.opt.diag-style": "Diagnostic layout: pretty | compact (default pretty)",
     "cli.opt.json": "Write JSON to stdout or file",
     "cli.opt.root": "Project root",
     "cli.opt.out": "Output directory",
@@ -101,6 +104,8 @@
     "cli.err.unknown_plan_kind": "unknown plan kind `{kind}` (locale | document-route)",
     "cli.err.gha.mode": "unknown --mode {mode} (status | wait)",
     "cli.err.gha.repo": "set --owner/--repo or GITHUB_REPOSITORY (owner/repo)",
+    "cli.err.invalid_level": "unknown --level `{level}` (error | warn | info)",
+    "cli.err.invalid_style": "unknown --style `{style}` (pretty | compact)",
     "cli.err.unknown_target": "unknown --target {target} (browser | mini-program-wechat)",
     "cli.err.document_build_aborted": "document build aborted due to diagnostics",
     "cli.err.locale_rename_usage": "usage: vmz locale rename <from-message-id> <to-message-id>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,16 +48,16 @@
     }
   },
   "dependencies": {
-    "@vmz/commander": "0.2.4",
-    "@vmz/core": "0.2.4",
-    "@vmz/diagnostic": "0.2.4",
-    "@vmz/plugin": "0.2.4",
-    "@vmz/protocol": "0.2.4",
+    "@vmz/commander": "0.2.6",
+    "@vmz/core": "0.2.6",
+    "@vmz/diagnostic": "0.2.6",
+    "@vmz/plugin": "0.2.6",
+    "@vmz/protocol": "0.2.6",
     "jiti": "^2.6.1"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.2.4",
-    "@vmz/test": "0.2.4",
+    "@vmz/plugin-markdown-it": "0.2.6",
+    "@vmz/test": "0.2.6",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -85,6 +85,10 @@
     "verify:list": "node --import ../../../scripts/test/resolve-ts-from-js.mjs --experimental-strip-types ./tests/conformance/run.ts --list",
     "build:js": "node ../../../scripts/build/clean-package-dist.mjs packages/runtimes/vmz/dist && tsc -p tsconfig.json"
   },
+  "publishConfig": {
+    "access": "public",
+    "name": "@vmz/vmz"
+  },
   "keywords": [
     "vmz",
     "napi",
@@ -92,15 +96,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.2.4",
-    "@vmz/vmz-win32-arm64": "0.2.4",
-    "@vmz/vmz-darwin-x64": "0.2.4",
-    "@vmz/vmz-darwin-arm64": "0.2.4",
-    "@vmz/vmz-linux-x64": "0.2.4",
-    "@vmz/vmz-linux-arm64": "0.2.4"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@vmz/vmz-win32-x64": "0.2.6",
+    "@vmz/vmz-win32-arm64": "0.2.6",
+    "@vmz/vmz-darwin-x64": "0.2.6",
+    "@vmz/vmz-darwin-arm64": "0.2.6",
+    "@vmz/vmz-linux-x64": "0.2.6",
+    "@vmz/vmz-linux-arm64": "0.2.6"
   },
   "repository": {
     "type": "git",