@vmz/vmz 0.3.12 → 0.3.14

package/bin/vmz.js

@@ -9,4 +9,8 @@ if (major < 24 || (major === 24 && minor < 12)) {
 }
 const { runCli } = await import('../dist/cli/cli.js');
 const code = await runCli(process.argv.slice(2));
+// POSIX pipes flush asynchronously, so `process.exit` can drop queued
+// diagnostics before CI captures them. Drain both streams first.
+await new Promise((resolve) => process.stderr.write('', resolve));
+await new Promise((resolve) => process.stdout.write('', resolve));
 process.exit(code ?? 0);

package/delivery-runtime-files.json

@@ -11,6 +11,7 @@
         { "src": "browser/direct-host-box.js", "out": "direct-host-box.js" },
         { "src": "browser/unknown-component.js", "out": "unknown-component.js" },
         { "src": "shared/dom-attr-normalize.js", "out": "dom-attr-normalize.js" },
+        { "src": "shared/html-digest.js", "out": "html-digest.js" },
         { "src": "faces/http.js", "out": "vmz-http.js" },
         { "src": "browser/client-nav.js", "out": "vmz-client-nav.js" }
     ],
@@ -33,6 +34,7 @@
         { "src": "browser/resume/resume.js", "out": "browser/resume/resume.js" },
         { "src": "ssr/render.js", "out": "ssr/render.js" },
         { "src": "ssr/serialize.js", "out": "ssr/serialize.js" },
+        { "src": "ssr/onmount.js", "out": "ssr/onmount.js" },
         { "src": "ssr/document.js", "out": "ssr/document.js" }
     ]
 }

package/dist/cli/cli.js

@@ -2,6 +2,7 @@
  * Node CLI command implementations .
  */
 import { spawn } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { createCli } from '@vmz/commander';
 import { registerApplicationCommands } from './application-cmd.js';
@@ -14,7 +15,7 @@ import { buildIntegratedDocuments, projectHasDocuments } from '../document/docum
 import { registerExplainCommand } from './explain-cmd.js';
 import { registerGithubActionsCommand } from './github-actions-cmd.js';
 import { registerInitCommands } from './init-cmd.js';
-import { createWorkspace, getProtocolVersions, HOST_PROTOCOL, materializeServeHostRuntime, materializeWechatPackaging, resolveCoreRuntimeDist, resolveNativePath, } from '../workspace/public-api.js';
+import { createWorkspace, getProtocolVersions, HOST_PROTOCOL, materializeServeHostRuntime, materializeWechatPackaging, resolveNativePath, } from '../workspace/public-api.js';
 import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from '../workspace/invocation.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-check.js';
 import { registerLocaleCommands } from '../locale/locale-cmd.js';
@@ -22,15 +23,17 @@ 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 { ensureRuntimeCompanions, packFromDeploymentIr, packSsrFromDeploymentIr } from '../workspace/pack.js';
 import { registerPlanCommands } from './plan-cmd.js';
 import { loadVmzConfig } from '../workspace/plugin-host.js';
 import { findAvailablePort } from '../workspace/port.js';
 import { registerRefactorCommands } from './refactor-cmd.js';
 import { registerArtifactCommands } from './release-cmd.js';
-import { readPackageMeta, resolveWorkspaceDirs } from '../workspace/resolve.js';
+import { findPackageJson, readPackageMeta, resolveWorkspaceDirs } from '../workspace/resolve.js';
 import { emitRouteCatalog } from '../workspace/route-catalog-emit.js';
+import { resolveCoreRuntimeDist } from '../workspace/runtime-dist.js';
 import { registerTestCommand } from './test-cmd.js';
+import { emitStaticBootstrapEntries } from '../workspace/static-emit.js';
 export function printGlobalHelp() {
     return buildProductCli({ mode: 'global' }).parse(['help']);
 }
@@ -75,6 +78,7 @@ function buildProductCli(opts = {}) {
     withServeExtras(withCoreOpts(cli.command('serve', 'cli.cmd.serve'))).action((options) => cmdServe(options));
     withServeExtras(withCoreOpts(cli.command('dev', 'cli.cmd.dev'))).action((options) => cmdDev(options));
     withCoreOpts(cli.command('format', 'cli.cmd.format'))
+        .option('--rust', 'cli.opt.format-rust')
         .option('--no-javascript', 'cli.opt.format-no-javascript')
         .option('--no-rust', 'cli.opt.format-no-rust')
         .option('--no-vmz', 'cli.opt.format-no-vmz')
@@ -269,8 +273,21 @@ async function cmdBuild(args) {
         if (routeCatalog.written.length) {
             log.info(`route catalog (${routeCatalog.written.length} artifact(s))`);
         }
+        if (!wechatPack) {
+            try {
+                // Node graph must be packed before any SSR consumer (document
+                // build, static emit, render host) imports a compiled chunk.
+                ensureRuntimeCompanions(outDir, resolveCoreRuntimeDist());
+                const nodePack = packSsrFromDeploymentIr(outDir, { projectRoot: project });
+                log.info(`node pack ok (entries=${nodePack.manifest.entryCount}, chunks=${nodePack.manifest.chunkCount}, digest=${String(nodePack.manifest.packDigest).slice(0, 12)}…)`);
+            }
+            catch (err) {
+                log.error(`node pack failed: ${err instanceof Error ? err.message : String(err)}`);
+                return 1;
+            }
+        }
         if (projectHasDocuments(project)) {
-            const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+            const docs = await buildIntegratedDocuments({ projectRoot: project, outDir, engines: cfg.engines });
             if (!docs.ok)
                 return 1;
         }
@@ -299,21 +316,16 @@ async function cmdBuild(args) {
         }
         let pack = null;
         try {
+            // Browser pack entries are the static bootstrap modules; static emit
+            // runs after pack (HTML resolves `_vmz/pack/`), so write them first.
+            emitStaticBootstrapEntries(outDir);
             pack = packFromDeploymentIr(outDir, {
                 release: Boolean(args.release),
                 profileId: selected.selection.profileId,
                 assembly: selected.selection.assembly,
-                coreDist: resolveCoreRuntimeDist(),
                 projectRoot: project,
             });
-            const lower = pack.manifest?.clientPackageLowering;
-            if (lower?.bareSpecs?.length) {
-                log.info(`pack client packages (${lower.bareSpecs.length} bare → vendor; rewritten=${lower.rewrittenFiles})`);
-            }
-            if (lower?.remainingBareSpecs?.length) {
-                log.warn(`pack client packages: ${lower.remainingBareSpecs.length} bare specifier(s) still unresolved for browser: ${lower.remainingBareSpecs.slice(0, 8).join(', ')}${lower.remainingBareSpecs.length > 8 ? '…' : ''}`);
-            }
-            log.info(`pack ok (units=${pack.manifest.unitCount}, digest=${String(pack.manifest.packDigest).slice(0, 12)}…)`);
+            log.info(`pack ok (entries=${pack.manifest.entryCount}, chunks=${pack.manifest.chunkCount}, digest=${String(pack.manifest.packDigest).slice(0, 12)}…)`);
         }
         catch (err) {
             log.error(`pack failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -513,24 +525,35 @@ async function cmdDev(args) {
     }
 }
 async function cmdFormat(args) {
-    const pathArg = args._[0] ?? '.';
-    const { project, outDir } = resolveWorkspaceDirs({
-        path: pathArg,
-        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
-    });
+    const rawPath = args._[0];
+    if (typeof rawPath !== 'string' || rawPath.trim() === '') {
+        log.error('format: explicit <file|dir> path required — no implicit workspace scope (pass `.` for the current directory)');
+        return 1;
+    }
+    const target = path.resolve(process.cwd(), rawPath);
+    if (!existsSync(target)) {
+        log.error(`format: path does not exist: ${target}`);
+        return 1;
+    }
+    if (args.rust && args['no-rust']) {
+        log.error('format: conflicting `--rust` and `--no-rust`');
+        return 1;
+    }
+    const startDir = statSync(target).isDirectory() ? target : path.dirname(target);
+    const pkg = findPackageJson(startDir);
+    const configRoot = pkg ? path.dirname(pkg) : startDir;
     const checkOnly = Boolean(args.check);
-    log.info(`format ${project}${checkOnly ? ' --check' : ''}`);
+    log.info(`format ${target}${checkOnly ? ' --check' : ''}`);
     const { runFormatCommand } = await import('./format-cmd.js');
     return runFormatCommand({
-        project,
-        outDir,
+        target,
+        configRoot,
         check: checkOnly,
         overrides: {
             javascript: args['no-javascript'] ? false : undefined,
-            rust: args['no-rust'] ? false : undefined,
+            rust: args.rust ? true : args['no-rust'] ? false : undefined,
             vmz: args['no-vmz'] ? false : undefined,
         },
-        createWorkspace,
     });
 }
 function cmdLint(args) {

package/dist/cli/format-cmd.d.ts

@@ -1,28 +1,20 @@
 /**
- * `vmz format` — workspace surfaces (JS/TS + Rust) + `.vmz` authoring formatter.
+ * `vmz format` — explicit-path formatter.
+ *
+ * Scope contract: the positional path is the whole scope. A file formats only
+ * itself; a directory is walked locally. Nothing ever falls back to a
+ * workspace-wide pass, and Rust runs per-file `rustfmt` — never `cargo fmt`.
  */
 export type FormatCommandOptions = {
-    project: string;
-    outDir: string;
+    /** Absolute explicit file or directory (already validated to exist). */
+    target: string;
+    /** Project root used to load `vmz.config` and the style config. */
+    configRoot: string;
     check: boolean;
     overrides?: {
         javascript?: boolean;
         rust?: boolean;
         vmz?: boolean;
     };
-    createWorkspace: (opts: {
-        root: string;
-        outDir: string;
-    }) => {
-        format: (checkOnly?: boolean) => {
-            filesChecked: number;
-            filesWritten: number;
-            filesNeedWrite: number;
-            diagnostics?: Array<{
-                severity?: string;
-            }>;
-        };
-        dispose: () => void;
-    };
 };
 export declare function runFormatCommand(opts: FormatCommandOptions): Promise<number>;

package/dist/cli/format-cmd.js

@@ -1,65 +1,53 @@
 /**
- * `vmz format` — workspace surfaces (JS/TS + Rust) + `.vmz` authoring formatter.
+ * `vmz format` — explicit-path formatter.
+ *
+ * Scope contract: the positional path is the whole scope. A file formats only
+ * itself; a directory is walked locally. Nothing ever falls back to a
+ * workspace-wide pass, and Rust runs per-file `rustfmt` — never `cargo fmt`.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import { loadNative } from '../workspace/public-api.js';
 import { loadVmzConfig } from '../workspace/plugin-host.js';
 import { log } from '../workspace/log.js';
 import { resolveFormatConfig } from './format-config.js';
 export async function runFormatCommand(opts) {
-    const { project, outDir, check, createWorkspace } = opts;
-    const { format: formatConfig } = await loadVmzConfig(project);
-    const resolved = resolveFormatConfig(project, formatConfig);
-    if (opts.overrides?.javascript !== undefined)
-        resolved.javascript = opts.overrides.javascript;
-    if (opts.overrides?.rust !== undefined)
-        resolved.rust = opts.overrides.rust;
-    if (opts.overrides?.vmz !== undefined)
-        resolved.vmz = opts.overrides.vmz;
+    const { target, configRoot, check } = opts;
+    const { format: formatConfig } = await loadVmzConfig(configRoot);
+    const resolved = resolveFormatConfig(formatConfig);
     const native = loadNative();
-    let exit = 0;
-    if (resolved.javascript || resolved.rust) {
-        const report = native.formatWorkspaceRun({
-            cwd: project,
+    let report;
+    try {
+        report = native.formatTargetsRun({
+            targets: [target],
             check,
-            includes: resolved.includes,
+            rust: opts.overrides?.rust,
+            javascript: opts.overrides?.javascript,
+            vmz: opts.overrides?.vmz,
             excludes: resolved.excludes,
-            rust: resolved.rust,
-            javascript: resolved.javascript,
-            styleConfig: resolved.style,
+            styleConfig: path.resolve(configRoot, resolved.style),
         });
-        if (report.errors.length > 0) {
-            for (const message of report.errors) {
-                log.error(message);
-            }
+    }
+    catch (err) {
+        log.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    let exit = 0;
+    for (const message of report.errors) {
+        log.error(message);
+    }
+    if (report.errors.length > 0)
+        exit = 1;
+    if (log.diagnostics(report.diagnostics ?? []))
+        exit = 1;
+    const scope = fs.statSync(target).isDirectory() ? `${target}${path.sep}` : target;
+    if (check) {
+        log.info(`format ${scope}: ${report.needWrite} file(s) would change, ${report.unchanged} unchanged`);
+        if (report.needWrite > 0)
             exit = 1;
-        }
-        else if (check && report.formatted === 0 && report.unchanged > 0) {
-            log.info(`workspace format: no changes needed (${report.unchanged} file(s) checked)`);
-        }
-        else if (!check) {
-            log.info(`workspace format: ${report.formatted} file(s) updated, ${report.unchanged} unchanged`);
-        }
     }
-    if (resolved.vmz) {
-        log.info(`format .vmz ${project}${check ? ' --check' : ''}`);
-        const ws = createWorkspace({ root: project, outDir });
-        try {
-            const report = ws.format(check);
-            const errors = log.diagnostics(report.diagnostics ?? []);
-            if (check) {
-                log.info(`checked ${report.filesChecked} .vmz file(s); ${report.filesNeedWrite} need write`);
-                if (report.filesNeedWrite > 0)
-                    exit = 1;
-            }
-            else {
-                log.info(`formatted ${report.filesWritten}/${report.filesChecked} .vmz file(s)`);
-            }
-            if (errors)
-                exit = 1;
-        }
-        finally {
-            ws.dispose();
-        }
+    else {
+        log.info(`format ${scope}: ${report.formatted} file(s) updated, ${report.unchanged} unchanged`);
     }
     return exit;
 }

package/dist/cli/format-config.d.ts

@@ -1,16 +1,13 @@
 /**
  * `vmz.config` `format` resolution for `vmz format`.
+ *
+ * Scope always comes from the explicit CLI path — config only narrows
+ * (`excludes`) and styles. There are no config-driven `includes`.
  */
-import type { VmzFormatConfig } from '@vmz/plugin';
+import type { VmzFormatConfig } from '../workspace/user-config.js';
 export type ResolvedFormatOptions = {
-    includes?: string[];
     excludes: string[];
-    rust: boolean;
-    javascript: boolean;
-    vmz: boolean;
     style: string;
 };
-/** VMZ hybrid monorepo — JS/TS surfaces only, never whole-repo walk. */
-export declare const VMZ_FRAMEWORK_INCLUDES: readonly ["scripts/**", "packages/runtimes/**", "packages/examples/**", "packages/editors/**", "packages/ui/**", "packages/plugins/**", "packages/content/**", "packages/homepage/**", "package.json", "biome.json", "vmz.config.ts", "nifty.config.ts"];
-/** Merge `vmz.config` `format` with framework monorepo defaults. */
-export declare function resolveFormatConfig(projectRoot: string, format?: VmzFormatConfig): ResolvedFormatOptions;
+/** Merge `vmz.config` `format` excludes / style with the defaults. */
+export declare function resolveFormatConfig(format?: VmzFormatConfig | null): ResolvedFormatOptions;

package/dist/cli/format-config.js

@@ -1,38 +1,14 @@
 /**
  * `vmz.config` `format` resolution for `vmz format`.
+ *
+ * Scope always comes from the explicit CLI path — config only narrows
+ * (`excludes`) and styles. There are no config-driven `includes`.
  */
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-/** VMZ hybrid monorepo — JS/TS surfaces only, never whole-repo walk. */
-export const VMZ_FRAMEWORK_INCLUDES = [
-    'scripts/**',
-    'packages/runtimes/**',
-    'packages/examples/**',
-    'packages/editors/**',
-    'packages/ui/**',
-    'packages/plugins/**',
-    'packages/content/**',
-    'packages/homepage/**',
-    'package.json',
-    'biome.json',
-    'vmz.config.ts',
-    'nifty.config.ts',
-];
 const DEFAULT_EXCLUDES = ['**/fixtures/**', '**/dist/**', '**/node_modules/**', '**/target/**'];
-function isFrameworkMonorepoRoot(projectRoot) {
-    return existsSync(path.join(projectRoot, 'packages', 'runtimes'));
-}
-/** Merge `vmz.config` `format` with framework monorepo defaults. */
-export function resolveFormatConfig(projectRoot, format) {
-    const frameworkRoot = isFrameworkMonorepoRoot(projectRoot);
-    const hasCargo = existsSync(path.join(projectRoot, 'Cargo.toml'));
-    const hasFormatSection = format !== undefined;
+/** Merge `vmz.config` `format` excludes / style with the defaults. */
+export function resolveFormatConfig(format) {
     return {
-        includes: format?.includes ?? (frameworkRoot ? [...VMZ_FRAMEWORK_INCLUDES] : undefined),
         excludes: [...DEFAULT_EXCLUDES, ...(format?.excludes ?? [])],
-        rust: format?.rust ?? (hasCargo && (frameworkRoot || hasFormatSection)),
-        javascript: format?.javascript ?? (frameworkRoot || hasFormatSection),
-        vmz: format?.vmz ?? true,
         style: format?.style ?? 'biome.json',
     };
 }

package/dist/delivery/delivery-profile.js

@@ -391,7 +391,7 @@ export function semanticIdsForAssembly(assembly) {
         case 'rust-embedded':
             return ['site-fallback', 'asset-graph'];
         case 'local-static':
-            return ['asset-graph'];
+            return ['static-delivery', 'asset-graph'];
         default:
             return [];
     }

package/dist/dev/dev-incremental.d.ts

@@ -36,14 +36,12 @@ export interface DevReloadPayload {
     islandHmr?: boolean;
     rerunLoaders?: string[];
     staticRevision?: string;
-    skipEntryRewrite?: boolean;
     outputRevision?: string;
 }
 export declare function parseHmrPlan(raw: string | object | null | undefined): HmrPlanWire | null;
 export declare function hmrRerunLoaders(plan: HmrPlanWire | null | undefined): string[];
 export declare function buildReloadPayload(report: BuildReportWire, hmrPlan: HmrPlanWire | null, opts?: {
     staticRevision?: string;
-    skipEntryRewrite?: boolean;
 }): DevReloadPayload;
 export declare function shouldSoftReload(report: BuildReportWire, lastOutputRevision: string | null, opts?: {
     force?: boolean;

package/dist/dev/dev-incremental.js

@@ -38,7 +38,6 @@ export function buildReloadPayload(report, hmrPlan, opts = {}) {
         islandHmr: islandHmr && !full,
         rerunLoaders,
         staticRevision: opts.staticRevision,
-        skipEntryRewrite: opts.skipEntryRewrite,
         outputRevision: report.outputRevision ?? report.output_revision,
     };
 }

package/dist/dev/dev-session.d.ts

@@ -11,6 +11,7 @@
  */
 import { createWorkspace } from '../workspace/public-api.js';
 import { type ConfigCycle } from './config-cycle.js';
+import { packFromDeploymentIr } from '../workspace/pack.js';
 interface DevSessionOptions {
     project: string;
     outDir: string;
@@ -28,7 +29,9 @@ interface DevSessionOptions {
         host: string;
         port: number;
     }) => import('node:child_process').ChildProcess;
-    softReloadFn?: (host: string, port: number, payload?: object) => Promise<void>;
+    softReloadFn?: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    /** Test seam for the browser pack stage (defaults to `packFromDeploymentIr`). */
+    packFn?: typeof packFromDeploymentIr;
     /** Override the detached config build process (tests). */
     configCycleFn?: (opts: {
         project: string;
@@ -38,6 +41,55 @@ interface DevSessionOptions {
     /** Built config cycle worker path (defaults to `dist/dev/config-cycle-worker.js`). */
     configCycleWorkerPath?: string;
 }
+export interface PackManifestView {
+    chunks?: Array<{
+        fileName?: string;
+        sourceMap?: string;
+        modules?: unknown[];
+    }>;
+    styles?: Array<{
+        fileName?: string;
+        sourcePaths?: unknown[];
+    }>;
+    assets?: Array<{
+        fileName?: string;
+    }>;
+    entryFiles?: Array<{
+        file?: string;
+    }>;
+    dynamicFiles?: Array<{
+        from?: string;
+        to?: string;
+    }>;
+    unitChunks?: Array<{
+        fileName?: string | null;
+    }>;
+}
+export interface PackInputSnapshot {
+    files: Array<{
+        path: string;
+        digest: string;
+    }>;
+    listings: Array<{
+        dir: string;
+        names: string[];
+    }>;
+    deploymentOrigins: string;
+    lockfile: {
+        path: string;
+        digest: string;
+    };
+    manifest: {
+        path: string;
+        digest: string;
+    };
+}
+/** 记下决定 pack 产物的全部输入；任何一项取不到就放弃快照（等同于永远重打包）。 */
+export declare function capturePackInputSnapshot(manifest: PackManifestView, outDir: string, project: string): PackInputSnapshot | null;
+/** 返回 null 表示全部输入字节全等；否则返回第一个变化原因。 */
+export declare function packInputsChangedReason(snapshot: PackInputSnapshot, outDir: string): string | null;
+/** 复用上次 manifest 前确认 entry/chunk/island 查表指向的文件仍在盘上；缺任何一个就退回真实 pack。 */
+export declare function missingPackOutput(manifest: PackManifestView, outDir: string): string | null;
 export declare function createDevSession(options: DevSessionOptions): {
     ws: any;
     rebuild: (changes?: Array<{