@vmz/vmz 0.3.5 → 0.3.7

package/README.md

@@ -1,5 +1,8 @@
 # `@vmz/vmz` (bin: `vmz`)
 
+Requires Node `>=24.12.0`. Project `vmz.config.ts|mts` loads through native ESM (erasable TypeScript only, no runtime
+transpiler).
+
 CLI / N-API toolchain host. Runtime mental entry is **`@vmz/core`**; optional official UI is **`@vmz/ui`**; plugins are
 **`@vmz/plugin-*`**. Shelved umbrella name: `@vmz/vmz`.
 

package/bin/vmz.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
-import { runCli } from '../dist/cli/cli.js';
+const [major = 0, minor = 0] = process.versions.node.split('.').map((part) => Number.parseInt(part, 10));
+if (major < 24 || (major === 24 && minor < 12)) {
+    process.stderr.write(
+        `vmz: Node >=24.12.0 is required (found ${process.versions.node}).\n` +
+            '  Why: project `vmz.config.*` and plugin entries load through native ESM type stripping.\n',
+    );
+    process.exit(1);
+}
+const { runCli } = await import('../dist/cli/cli.js');
 const code = await runCli(process.argv.slice(2));
 process.exit(code ?? 0);

package/dist/cli/cli.js

@@ -13,7 +13,7 @@ import { registerDocumentCommands } from '../document/document-cmd.js';
 import { buildIntegratedDocuments, projectHasDocuments } from '../document/document-integrate.js';
 import { registerExplainCommand } from './explain-cmd.js';
 import { registerGithubActionsCommand } from './github-actions-cmd.js';
-import { createWorkspace, getProtocolVersions, HOST_PROTOCOL, materializeServeHostRuntime, resolveCoreRuntimeDist, resolveNativePath, } from '../workspace/public-api.js';
+import { createWorkspace, getProtocolVersions, HOST_PROTOCOL, materializeServeHostRuntime, materializeWechatPackaging, resolveCoreRuntimeDist, 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';
@@ -46,6 +46,9 @@ function buildProductCli(opts = {}) {
     const cli = createCli('vmz')
         .locales(resolveCliLocalesRoot(), {
         envKeys: ['VMZ_LOCALE', 'LOCALE', 'LANG', 'LC_ALL'],
+    })
+        .onDiagnostic((diagnostic, context) => {
+        log.diagnostic(diagnostic, { locale: context.locale });
     })
         .intro(introId);
     // Global install: only version (help is derived). Project commands need a project bin.
@@ -53,32 +56,29 @@ function buildProductCli(opts = {}) {
         cli.command('version', 'cli.cmd.version').action(() => cmdVersion());
         return cli;
     }
-    const withWorkspaceOpts = (cmd) => cmd
+    const withCoreOpts = (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'))
+    const withServeExtras = (cmd) => cmd.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');
+    withCoreOpts(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));
-    withWorkspaceOpts(cli.command('format', 'cli.cmd.format'))
+    withCoreOpts(cli.command('build', 'cli.cmd.build')).action((options) => cmdBuild(options));
+    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('--no-javascript', 'cli.opt.format-no-javascript')
         .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'))
+    withCoreOpts(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')
@@ -152,9 +152,10 @@ async function cmdCheck(args) {
     });
     const meta = readPackageMeta(project);
     log.info(`check ${project}${meta?.name ? ` (${meta.name})` : ''}`);
+    const cfg = await loadVmzConfig(project);
     const ws = createWorkspace({ root: project, outDir });
     try {
-        return runWithPlugins(ws, project, outDir, async () => {
+        return runWithPlugins(ws, cfg, project, outDir, async () => {
             const report = ws.check();
             const { checkLocales, localeHasErrors } = await import('../locale/locale-check.js');
             const localeReport = checkLocales({ projectRoot: project, checkUnused: false });
@@ -182,9 +183,9 @@ function dedupeDiagnostics(list) {
     }
     return out;
 }
-async function runWithPlugins(ws, project, outDir, fn) {
-    const { loadVmzConfig, applyPlugins } = await import('../workspace/plugin-host.js');
-    const { plugins, engines } = await loadVmzConfig(project);
+async function runWithPlugins(ws, cfg, project, outDir, fn) {
+    const { applyPlugins } = await import('../workspace/plugin-host.js');
+    const { plugins, engines } = cfg;
     if (plugins.length) {
         await applyPlugins(ws, plugins, { project, outDir, engines });
     }
@@ -218,10 +219,12 @@ async function cmdBuild(args) {
     }
     const outDir = resolveProfileArtifactDir(outDirRoot, selected.profile);
     log.info(`build ${project} → ${outDir}${wechatPack ? ' (target=mini-program-wechat)' : ''} (out-dir=${outDirRoot}, name=${selected.profile.name})`);
+    if (wechatPack)
+        materializeWechatPackaging(project, cfg.delivery);
     const ws = createWorkspace({ root: project, outDir });
     try {
         log.info(`delivery profile ${selected.selection.profileId} (assembly=${selected.selection.assembly}, name=${selected.profile.name})`);
-        const code = await runWithPlugins(ws, project, outDir, () => {
+        const code = await runWithPlugins(ws, cfg, project, outDir, () => {
             const report = ws.build(Boolean(args.release));
             const errors = log.diagnostics(report.diagnostics ?? []);
             if (errors)
@@ -485,6 +488,7 @@ async function cmdDev(args) {
         port,
         pollMs,
         target: targetRaw,
+        delivery: cfg.delivery,
         signal: ac.signal,
     });
     try {
@@ -494,6 +498,9 @@ async function cmdDev(args) {
     catch (err) {
         if (ac.signal.aborted)
             return 0;
+        // Config/plugin failures carry a product diagnostic: let the CLI boundary print once.
+        if (err && typeof err === 'object' && 'diagnostic' in err)
+            throw err;
         log.error(String(err));
         return 1;
     }

package/dist/dev/config-cycle-worker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Child process for one dev config build cycle.
+ *
+ * Evaluates `vmz.config.*`, applies plugin contributions into the workspace,
+ * then writes a data-only report (no functions across the process boundary).
+ */
+export {};

package/dist/dev/config-cycle-worker.js

@@ -0,0 +1,83 @@
+/**
+ * Child process for one dev config build cycle.
+ *
+ * Evaluates `vmz.config.*`, applies plugin contributions into the workspace,
+ * then writes a data-only report (no functions across the process boundary).
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { applyPlugins, loadVmzConfig } from '../workspace/plugin-host.js';
+import { createWorkspace } from '../workspace/public-api.js';
+function errorDetail(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const cause = err instanceof Error && err.cause ? `: ${errorDetail(err.cause)}` : '';
+    return `${message}${cause}`;
+}
+function writeReport(reportPath, report) {
+    let text;
+    try {
+        text = JSON.stringify(report, (_key, value) => (typeof value === 'function' ? undefined : value));
+    }
+    catch (err) {
+        text = JSON.stringify({
+            ok: false,
+            configPath: null,
+            pluginPath: null,
+            plugins: [],
+            engines: {},
+            delivery: null,
+            error: {
+                code: 'vmz::config::load_failed',
+                severity: 'error',
+                args: { detail: `config report is not serializable: ${errorDetail(err)}` },
+            },
+        });
+    }
+    writeFileSync(reportPath, text);
+}
+const [inputPath, reportPath] = process.argv.slice(2);
+if (!inputPath || !reportPath) {
+    process.stderr.write('config-cycle-worker: <input.json> <report.json> required\n');
+    process.exit(2);
+}
+const input = JSON.parse(readFileSync(inputPath, 'utf8'));
+let ws = null;
+try {
+    const cfg = await loadVmzConfig(input.project);
+    ws = createWorkspace({ root: input.project, outDir: input.outDir });
+    if (cfg.plugins.length) {
+        await applyPlugins(ws, cfg.plugins, { project: input.project, outDir: input.outDir, engines: cfg.engines });
+    }
+    writeReport(reportPath, {
+        ok: true,
+        configPath: cfg.path,
+        pluginPath: cfg.pluginPath,
+        plugins: cfg.plugins.map((p) => ({
+            name: p.manifest.name,
+            version: p.manifest.version,
+            stages: p.manifest.stages ?? [],
+        })),
+        engines: cfg.engines,
+        delivery: cfg.delivery ?? null,
+    });
+}
+catch (err) {
+    const diagnostic = err?.diagnostic ?? {
+        code: 'vmz::config::load_failed',
+        severity: 'error',
+        path: path.join(input.project, 'vmz.config.ts'),
+        args: { detail: errorDetail(err) },
+    };
+    writeReport(reportPath, {
+        ok: false,
+        configPath: null,
+        pluginPath: null,
+        plugins: [],
+        engines: {},
+        delivery: null,
+        error: diagnostic,
+    });
+}
+finally {
+    ws?.dispose();
+}

package/dist/dev/config-cycle.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Dev config build cycle.
+ *
+ * Each cycle runs config evaluation + plugin contribution in its own Node process.
+ * Functions and plugin objects stay in that process; the parent receives data only.
+ * Config/IPS changes restart the cycle: the old process is cancelled and awaited
+ * before a new one may write plugin artifacts.
+ */
+export interface ConfigCycleDiagnostic {
+    code: string;
+    severity?: 'error';
+    path?: string;
+    args?: Record<string, string>;
+}
+export interface ConfigCycleReport {
+    ok: boolean;
+    configPath: string | null;
+    pluginPath: string | null;
+    plugins: Array<{
+        name: string;
+        version: string;
+        stages: string[];
+    }>;
+    engines: Record<string, string>;
+    delivery: unknown;
+    error?: ConfigCycleDiagnostic;
+}
+export interface ConfigCycleOptions {
+    project: string;
+    outDir: string;
+    /** Built worker (`dist/dev/config-cycle-worker.js`); defaults next to this module. */
+    workerPath?: string;
+    nodePath?: string;
+    timeoutMs?: number;
+}
+export interface ConfigCycle {
+    start(): Promise<ConfigCycleReport>;
+    restart(): Promise<ConfigCycleReport>;
+    cancel(): Promise<void>;
+    running(): boolean;
+}
+export declare class ConfigCycleCancelledError extends Error {
+    constructor();
+}
+export declare function createConfigCycle(options: ConfigCycleOptions): ConfigCycle;

package/dist/dev/config-cycle.js

@@ -0,0 +1,152 @@
+/**
+ * Dev config build cycle.
+ *
+ * Each cycle runs config evaluation + plugin contribution in its own Node process.
+ * Functions and plugin objects stay in that process; the parent receives data only.
+ * Config/IPS changes restart the cycle: the old process is cancelled and awaited
+ * before a new one may write plugin artifacts.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export class ConfigCycleCancelledError extends Error {
+    constructor() {
+        super('vmz dev: config build process cancelled');
+        this.name = 'ConfigCycleCancelledError';
+    }
+}
+function defaultWorkerPath() {
+    return fileURLToPath(new URL('./config-cycle-worker.js', import.meta.url));
+}
+function emptyReport(project, error) {
+    return {
+        ok: !error,
+        configPath: null,
+        pluginPath: null,
+        plugins: [],
+        engines: {},
+        delivery: null,
+        ...(error ? { error } : {}),
+    };
+}
+function syntheticFailure(project, detail, configPath) {
+    return emptyReport(project, {
+        code: 'vmz::config::load_failed',
+        severity: 'error',
+        path: configPath ?? path.join(project, 'vmz.config.ts'),
+        args: { detail },
+    });
+}
+export function createConfigCycle(options) {
+    const project = path.resolve(options.project);
+    const outDir = path.resolve(options.outDir);
+    const workerPath = options.workerPath ?? defaultWorkerPath();
+    const nodePath = options.nodePath ?? process.env.VMZ_NODE ?? process.execPath;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    let child = null;
+    let exited = null;
+    let cancelled = false;
+    async function cancel() {
+        if (!child)
+            return;
+        cancelled = true;
+        const proc = child;
+        const done = exited;
+        try {
+            proc.kill();
+        }
+        catch {
+            /* already gone */
+        }
+        if (done)
+            await Promise.race([done, new Promise((r) => setTimeout(r, 5000))]);
+        if (proc.exitCode == null && proc.signalCode == null) {
+            try {
+                proc.kill('SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+            if (done)
+                await Promise.race([done, new Promise((r) => setTimeout(r, 2000))]);
+        }
+    }
+    async function start() {
+        if (child)
+            throw new Error('vmz dev: config build process already running');
+        if (!existsSync(workerPath)) {
+            throw new Error(`vmz dev: missing config cycle worker ${workerPath} — run build:js`);
+        }
+        cancelled = false;
+        const tmp = mkdtempSync(path.join(os.tmpdir(), 'vmz-config-cycle-'));
+        const inputPath = path.join(tmp, 'input.json');
+        const reportPath = path.join(tmp, 'report.json');
+        writeFileSync(inputPath, JSON.stringify({ project, outDir }));
+        let stderr = '';
+        let timedOut = false;
+        const proc = spawn(nodePath, [workerPath, inputPath, reportPath], {
+            cwd: project,
+            env: { ...process.env, VMZ_PROJECT_ROOT: project, VMZ_DIST: outDir },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        child = proc;
+        proc.stderr?.on('data', (chunk) => {
+            if (stderr.length < 16_384)
+                stderr += chunk.toString();
+        });
+        exited = new Promise((resolve) => {
+            proc.once('exit', (code, signal) => resolve({ code, signal }));
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                proc.kill();
+            }
+            catch {
+                /* already gone */
+            }
+        }, timeoutMs);
+        const result = await exited;
+        clearTimeout(timer);
+        child = null;
+        exited = null;
+        let report = null;
+        if (!cancelled) {
+            try {
+                report = JSON.parse(readFileSync(reportPath, 'utf8'));
+            }
+            catch {
+                report = null;
+            }
+        }
+        rmSync(tmp, { recursive: true, force: true });
+        if (cancelled)
+            throw new ConfigCycleCancelledError();
+        if (!report) {
+            const detail = timedOut
+                ? `config build process timed out after ${timeoutMs}ms`
+                : `config build process exited with code ${String(result.code)}${result.signal ? ` (${result.signal})` : ''}${stderr.trim() ? `: ${stderr.trim().split('\n').slice(0, 4).join(' | ')}` : ''}`;
+            return syntheticFailure(project, detail);
+        }
+        if (!report.ok && report.error) {
+            if (!report.error.args?.detail && stderr.trim()) {
+                report.error.args = { ...(report.error.args ?? {}), detail: stderr.trim().split('\n').slice(0, 4).join(' | ') };
+            }
+            return report;
+        }
+        return report;
+    }
+    async function restart() {
+        await cancel();
+        return start();
+    }
+    return {
+        start,
+        restart,
+        cancel,
+        running: () => child != null,
+    };
+}

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

@@ -10,6 +10,7 @@
  * 3. Soft reload failure → **auto-respawn** serve-host (fresh ESM graph), not "keep broken host".
  */
 import { createWorkspace } from '../workspace/public-api.js';
+import { type ConfigCycle } from './config-cycle.js';
 interface DevSessionOptions {
     project: string;
     outDir: string;
@@ -17,6 +18,8 @@ interface DevSessionOptions {
     port?: number;
     pollMs?: number;
     target?: 'browser' | 'mini-program-wechat';
+    /** Delivery snapshot evaluated by the config host; the package contract is prepared from it. */
+    delivery?: unknown;
     signal?: AbortSignal;
     createWorkspaceFn?: typeof createWorkspace;
     spawnHostFn?: (opts: {
@@ -26,6 +29,14 @@ interface DevSessionOptions {
         port: number;
     }) => import('node:child_process').ChildProcess;
     softReloadFn?: (host: string, port: number, payload?: object) => Promise<void>;
+    /** Override the detached config build process (tests). */
+    configCycleFn?: (opts: {
+        project: string;
+        outDir: string;
+        workerPath?: string;
+    }) => ConfigCycle;
+    /** Built config cycle worker path (defaults to `dist/dev/config-cycle-worker.js`). */
+    configCycleWorkerPath?: string;
 }
 export declare function createDevSession(options: DevSessionOptions): {
     ws: any;

package/dist/dev/dev-session.js

@@ -14,13 +14,20 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { buildIntegratedDocuments, projectHasDocuments } from '../document/document-integrate.js';
 import { createWorkspace, resolveNativePath } from '../workspace/public-api.js';
+import { materializeWechatPackaging } from '../workspace/wechat-packaging.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-check.js';
 import { log } from '../workspace/log.js';
-import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectDevConfigPaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectConfigDependencies, configCandidatePaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { createConfigCycle } from './config-cycle.js';
 import { buildReloadPayload, filterGenerationIgnore, parseHmrPlan, registerWrittenOutputsIgnore, shouldSoftReload, staticRevisionFromArtifact, } from './dev-incremental.js';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
 /** Track serve-host so a failed/killed launcher cannot leave an orphan port. */
 const DEV_HOST_PID = '.vmz-dev-host.pid';
+function cycleFailure(report) {
+    const detail = report.error?.args?.detail ?? 'config build process failed';
+    const error = new Error(detail);
+    return report.error ? Object.assign(error, { diagnostic: report.error }) : error;
+}
 export function createDevSession(options) {
     const project = options.project;
     const outDir = options.outDir;
@@ -28,9 +35,13 @@ export function createDevSession(options) {
     const port = options.port ?? 5173;
     const pollMs = Math.max(50, options.pollMs ?? 300);
     const wechatPreview = options.target === 'mini-program-wechat';
+    let delivery = options.delivery ?? null;
     const createWs = options.createWorkspaceFn ?? createWorkspace;
     const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
     const softReload = options.softReloadFn ?? defaultSoftReload;
+    const makeConfigCycle = options.configCycleFn ?? createConfigCycle;
+    const configCandidates = configCandidatePaths(project);
+    let configCycle = null;
     const ws = createWs({ root: project, outDir });
     let child = null;
     let stopped = false;
@@ -119,6 +130,8 @@ export function createDevSession(options) {
         }
         let report;
         try {
+            // Same prepared snapshot for this build cycle; native pack never reads config.
+            materializeWechatPackaging(project, delivery);
             const raw = ws.lowerMiniprogramWechatPackaging();
             report = typeof raw === 'string' ? JSON.parse(raw) : raw;
         }
@@ -191,15 +204,15 @@ export function createDevSession(options) {
         if (!existsSync(src)) {
             throw new Error(`vmz dev: missing src/ under ${project}`);
         }
-        // Same as `vmz build`: materialize plugin sources (e.g. `<Shiki>`) before compile.
-        // Soft rebuilds reuse the workspace; config/plugin changes still need a process restart
-        // until `vmz.config.*` is watched.
-        {
-            const { loadVmzConfig, applyPlugins } = await import('../workspace/plugin-host.js');
-            const { plugins, engines } = await loadVmzConfig(project);
-            if (plugins.length) {
-                await applyPlugins(ws, plugins, { project, outDir, engines });
-            }
+        // Config evaluation + plugin contributions run in a detached build process.
+        // Functions/plugin objects never cross the boundary; only the data report does.
+        if (configCandidates.some((p) => existsSync(p))) {
+            configCycle = makeConfigCycle({ project, outDir, ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}) });
+            const report = await configCycle.start();
+            if (!report.ok)
+                throw cycleFailure(report);
+            delivery = report.delivery ?? delivery;
+            log.info(`config build process ready${report.plugins.length ? ` (${report.plugins.map((p) => p.name).join(', ')})` : ''}`);
         }
         log.info('initial build (N-API workspace, full)…');
         const initialPair = planAndRebuild();
@@ -238,7 +251,14 @@ export function createDevSession(options) {
         const designsRoot = path.join(project, 'designs');
         const watched = collectDevWatchRoots({ project, outDir });
         const publicRoot = watched.publicRoot;
-        const configPaths = watched.configPaths.length ? watched.configPaths : collectDevConfigPaths(project);
+        /** Candidate config files plus their local reachable deps; refreshed after each cycle. */
+        const refreshConfigPaths = () => {
+            const deps = configCandidates
+                .filter((p) => existsSync(p))
+                .flatMap((p) => collectConfigDependencies(p, project));
+            return [...new Set([...configCandidates, ...deps])];
+        };
+        let configPaths = refreshConfigPaths();
         /** @type {string[]} */
         const watchRoots = [...watched.roots];
         /** @type {string[]} */
@@ -359,14 +379,66 @@ export function createDevSession(options) {
                     continue;
                 }
                 if (batch.configDirty) {
-                    log.info('vmz.config change detected — respawn required (devControl)');
-                    configFingerprints = configFingerprintMap(configPaths);
-                    commitFingerprints();
-                    await respawnHost('config-changed');
+                    log.info('vmz.config change detected — restarting the config build process…');
+                    let cycleReport = null;
+                    if (configCandidates.some((p) => existsSync(p))) {
+                        let failure = null;
+                        try {
+                            if (!configCycle) {
+                                configCycle = makeConfigCycle({
+                                    project,
+                                    outDir,
+                                    ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}),
+                                });
+                                cycleReport = await configCycle.start();
+                            }
+                            else {
+                                // Old process is cancelled and awaited before the new one writes artifacts.
+                                cycleReport = await configCycle.restart();
+                            }
+                        }
+                        catch (err) {
+                            failure = err instanceof Error ? err : new Error(String(err));
+                        }
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        if (failure) {
+                            log.warn(`config build process restart failed: ${failure.message}`);
+                            continue;
+                        }
+                        if (cycleReport && !cycleReport.ok) {
+                            if (cycleReport.error)
+                                log.diagnostic(cycleReport.error);
+                            else
+                                log.error('config build process failed');
+                            continue;
+                        }
+                        if (cycleReport)
+                            delivery = cycleReport.delivery ?? delivery;
+                    }
+                    else if (configCycle) {
+                        await configCycle.cancel();
+                        configCycle = null;
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        log.warn('vmz.config removed — config build process stopped, last artifacts kept');
+                        continue;
+                    }
+                    else {
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        continue;
+                    }
                     const report = rebuild();
                     if (printReport(report, 'rebuild')) {
                         lastOutputRevision = report.outputRevision ?? report.output_revision ?? null;
                         await emitPublicAndTrack();
+                        if (wechatPreview)
+                            packWechatPreview();
+                        else
+                            await respawnHost('config-changed');
                     }
                     continue;
                 }
@@ -605,6 +677,8 @@ export function createDevSession(options) {
         stopped = true;
         killChild(child);
         child = null;
+        await configCycle?.cancel().catch(() => { });
+        configCycle = null;
         clearDevHostPid(outDir, null);
         try {
             ws.dispose();

package/dist/dev/dev-watch-roots.d.ts

@@ -7,8 +7,15 @@
  */
 /** Author-facing vs generated dev input bucket. */
 export type DevInputKind = 'author' | 'dependency' | 'public' | 'devControl' | 'locales' | 'docs' | 'designs' | 'other';
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export declare function configCandidatePaths(project: string): string[];
 /** `vmz.config.*` at project root (devControl). */
 export declare function collectDevConfigPaths(project: string): string[];
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export declare function collectConfigDependencies(configPath: string, project: string): string[];
 /** Fingerprint map for explicit config files (not directory walks). */
 export declare function configFingerprintMap(configPaths: string[]): Map<string, string>;
 export interface DirtySet {

package/dist/dev/dev-watch-roots.js

@@ -8,11 +8,74 @@
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
-const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const LOCAL_MODULE_EXTENSIONS = ['.ts', '.mts', '.js', '.mjs', '.cts', '.cjs'];
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export function configCandidatePaths(project) {
+    const root = path.resolve(project);
+    return CONFIG_BASENAMES.map((name) => path.join(root, name));
+}
 /** `vmz.config.*` at project root (devControl). */
 export function collectDevConfigPaths(project) {
+    return configCandidatePaths(project).filter((p) => existsSync(p));
+}
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export function collectConfigDependencies(configPath, project) {
     const root = path.resolve(project);
-    return CONFIG_BASENAMES.map((name) => path.join(root, name)).filter((p) => existsSync(p));
+    const underRoot = (file) => file === root || file.startsWith(root + path.sep);
+    const seen = new Set();
+    const out = [];
+    const visit = (file, depth) => {
+        if (depth > 24 || seen.size > 200 || !existsSync(file) || !underRoot(file))
+            return;
+        if (seen.has(file))
+            return;
+        seen.add(file);
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const specs = new Set();
+        for (const match of text.matchAll(/\b(?:import|export)\s+(?:[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const match of text.matchAll(/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const spec of specs) {
+            if (!spec.startsWith('.'))
+                continue;
+            const base = path.resolve(path.dirname(file), spec);
+            const candidates = [
+                base,
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => base + ext),
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => path.join(base, `index${ext}`)),
+            ];
+            for (const candidate of candidates) {
+                try {
+                    if (existsSync(candidate) && statSync(candidate).isFile()) {
+                        if (!seen.has(candidate))
+                            out.push(candidate);
+                        visit(candidate, depth + 1);
+                        break;
+                    }
+                }
+                catch {
+                    /* keep looking */
+                }
+            }
+        }
+    };
+    visit(path.resolve(configPath), 0);
+    return out;
 }
 /** Fingerprint map for explicit config files (not directory walks). */
 export function configFingerprintMap(configPaths) {

package/dist/document/document-integrate.js

@@ -9,6 +9,8 @@ import { resolveDocumentsRoot } from './document-check.js';
 import { pageHtmlRel } from './document-enrich.js';
 import { loadLocalesRouting } from './document-routing-config.js';
 import { ensureLocaleImportsRewritten } from '../locale/locale-check.js';
+import { ensureRuntimeCompanions } from '../workspace/pack.js';
+import { resolveCoreRuntimeDist } from '../workspace/runtime-dist.js';
 import { log } from '../workspace/log.js';
 import { requireNativeAddon } from '../workspace/native-addon.js';
 export function projectHasDocuments(projectRoot) {
@@ -30,6 +32,10 @@ export async function buildIntegratedDocuments(opts) {
             log.error(locales.error || 'locale import rewrite incomplete');
             return { ok: false, error: locales.error || 'locale rewrite', pages: 0 };
         }
+        // Document layout chunks import the delivery runtime (dom-core.js) at mount
+        // time, but pack only materializes it afterwards. Ensure companions first so
+        // a clean or partially-written outDir does not fail with an opaque module error.
+        ensureRuntimeCompanions(outDir, resolveCoreRuntimeDist());
         const result = await buildDocuments({
             projectRoot,
             outDir,

package/dist/document/document-markdown.d.ts

@@ -1,5 +1,5 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
 export interface ResolveMarkdownEngineOpts {
     engines?: {

package/dist/document/document-markdown.js

@@ -1,36 +1,22 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { importMaybeTs } from '../workspace/plugin-host.js';
-const require = createRequire(import.meta.url);
 export async function resolveMarkdownEngine(opts = {}) {
     const id = opts.engines?.markdown || 'markdown-it';
     if (id !== 'markdown-it') {
         throw new Error(`unsupported engines.markdown ${JSON.stringify(id)} (markdown-it only)`);
     }
-    let runtimeFile = null;
+    let mod;
     try {
-        const pkg = require.resolve('@vmz/plugin-markdown-it/package.json');
-        runtimeFile = path.join(path.dirname(pkg), 'runtime.ts');
+        // Public JS runtime export of the plugin package; never read the package directory.
+        mod = await import('@vmz/plugin-markdown-it/runtime');
     }
-    catch {
-        // Developer mode: monorepo source checkout.
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const fallback = path.resolve(here, '../../../plugins/vmz-plugin-markdown-it/runtime.ts');
-        if (existsSync(fallback))
-            runtimeFile = fallback;
-    }
-    if (!runtimeFile || !existsSync(runtimeFile)) {
+    catch (err) {
         throw new Error('markdown engine needs `@vmz/plugin-markdown-it` (optional peer of `@vmz/vmz`).\n' +
-            '  Install:  pnpm add -D @vmz/plugin-markdown-it');
+            '  Install:  pnpm add -D @vmz/plugin-markdown-it', { cause: err });
     }
-    const mod = await importMaybeTs(runtimeFile);
     if (typeof mod.analyzeMarkdown !== 'function') {
-        throw new Error(`cannot load markdown engine markdown-it from ${runtimeFile}`);
+        throw new Error('cannot load markdown engine markdown-it: runtime export is missing analyzeMarkdown');
     }
     return {
         engine: id,

package/dist/workspace/log.d.ts

@@ -16,6 +16,7 @@ export type DiagnosticLike = {
 export type DiagnosticLogOptions = {
     denyWarnings?: boolean;
     level?: CliLogLevel;
+    locale?: string;
 };
 export declare const log: {
     info(...args: unknown[]): void;
@@ -25,6 +26,7 @@ export declare const log: {
     errorId(id: string, args?: Record<string, string>): void;
     diagnostic(d: DiagnosticLike, opts?: {
         level?: CliLogLevel;
+        locale?: string;
     }): 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

@@ -38,7 +38,7 @@ export const log = {
             return false;
         const hasCode = Boolean(d.code && String(d.code).length);
         const code = hasCode ? String(d.code) : 'diag.message';
-        const locale = resolveVmzLocale();
+        const locale = opts.locale ?? resolveVmzLocale();
         const catalog = loadCliCatalog(locale);
         const path = d.path || '';
         const style = getCliLogStyle();
@@ -68,7 +68,7 @@ export const log = {
         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 });
+            this.diagnostic(visible[i], { level, locale: opts.locale });
             if (style === 'pretty' && i + 1 < visible.length)
                 console.error('');
         }

package/dist/workspace/plugin-host.d.ts

@@ -4,11 +4,9 @@
 import { contentHash, defineConfig, definePlugin } from '@vmz/plugin';
 export { contentHash, defineConfig, definePlugin };
 export declare const PLUGIN_PROTOCOL = "0.1.0";
-/**
- * @param {string} full
- * @returns {Promise<any>}
- */
-export declare function importMaybeTs(full: any): Promise<any>;
+export declare const CONFIG_NAMES: string[];
+export declare const CONFIG_LOAD_FAILED = "vmz::config::load_failed";
+export declare const PLUGIN_ENTRY_INVALID = "vmz::plugin::invalid_entry";
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project

package/dist/workspace/plugin-host.js

@@ -4,30 +4,57 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { createJiti } from 'jiti';
 import { PLUGIN_PROTOCOL as PLUGIN_PROTOCOL_PKG, contentHash, defineConfig, definePlugin } from '@vmz/plugin';
 import { log } from './log.js';
 import { resolveWorkspacePackages } from './packages.js';
 export { contentHash, defineConfig, definePlugin };
 export const PLUGIN_PROTOCOL = PLUGIN_PROTOCOL_PKG;
-const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
+export const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
 const ROOT_PLUGIN_NAMES = ['vmz.plugin.ts', 'vmz.plugin.mts', 'vmz.plugin.mjs', 'vmz.plugin.js'];
+export const CONFIG_LOAD_FAILED = 'vmz::config::load_failed';
+export const PLUGIN_ENTRY_INVALID = 'vmz::plugin::invalid_entry';
 /**
+ * Load an ES module through the Node host (native `import()`).
+ * Project config and plugin entries must be erasable TS or JS: the host never
+ * runs a runtime TypeScript transpiler.
  * @param {string} full
  * @returns {Promise<any>}
  */
-export async function importMaybeTs(full) {
-    const ext = path.extname(full).toLowerCase();
-    if (ext === '.ts' || ext === '.mts') {
-        const jiti = createJiti(import.meta.url, {
-            interopDefault: true,
-            moduleCache: false,
-        });
-        return jiti(full);
-    }
+async function importHostModule(full) {
     const mod = await import(pathToFileURL(full).href);
     return mod.default ?? mod;
 }
+function errorDetail(err) {
+    const parts = [];
+    let cur = err;
+    for (let i = 0; cur && i < 4; i += 1) {
+        const message = cur instanceof Error ? cur.message : String(cur);
+        if (message && !parts.includes(message))
+            parts.push(message);
+        cur = cur && typeof cur === 'object' && 'cause' in cur ? cur.cause : null;
+    }
+    return parts.join(' ← ') || 'unknown error';
+}
+/**
+ * Build a host error carrying a product diagnostic (one print at the CLI boundary).
+ * @param {string} code
+ * @param {string} sourcePath
+ * @param {unknown} err
+ */
+function configDiagnosticError(code, sourcePath, err) {
+    const detail = errorDetail(err);
+    const error = new Error(detail);
+    if (err instanceof Error)
+        error.cause = err;
+    return Object.assign(error, {
+        diagnostic: {
+            code,
+            severity: 'error',
+            path: sourcePath,
+            args: { detail },
+        },
+    });
+}
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project
@@ -61,7 +88,13 @@ export async function loadVmzConfig(project) {
         if (!existsSync(full))
             continue;
         configPath = full;
-        const cfg = await importMaybeTs(full);
+        let cfg;
+        try {
+            cfg = await importHostModule(full);
+        }
+        catch (err) {
+            throw configDiagnosticError(CONFIG_LOAD_FAILED, full, err);
+        }
         const raw = cfg?.plugins ?? [];
         engines = cfg?.engines && typeof cfg.engines === 'object' ? { ...cfg.engines } : {};
         if (cfg?.delivery && typeof cfg.delivery === 'object') {
@@ -96,9 +129,11 @@ async function resolvePluginEntry(project, entry) {
     let value = entry;
     if (typeof value === 'string') {
         const resolved = path.isAbsolute(value) ? value : path.join(project, value);
-        value = await importMaybeTs(resolved);
-        if (value && typeof value === 'object' && 'default' in value && value.default) {
-            value = value.default;
+        try {
+            value = await importHostModule(resolved);
+        }
+        catch (err) {
+            throw configDiagnosticError(PLUGIN_ENTRY_INVALID, resolved, err);
         }
     }
     value = await value;
@@ -106,7 +141,8 @@ async function resolvePluginEntry(project, entry) {
         return value;
     if (value?.name && value?.stages)
         return definePlugin(value);
-    throw new Error(`invalid vmz plugin entry: ${String(entry)}`);
+    const sourcePath = typeof entry === 'string' ? (path.isAbsolute(entry) ? entry : path.join(project, entry)) : '';
+    throw configDiagnosticError(PLUGIN_ENTRY_INVALID, sourcePath, new Error(`invalid vmz plugin entry: ${String(entry)}`));
 }
 /**
  * Collect + apply contribution batches for the given stages onto a Workspace.

package/dist/workspace/public-api.d.ts

@@ -46,6 +46,10 @@ export declare function lowerMiniprogramBindingEventJson(rootPath: string): stri
 export declare function lowerMiniprogramStructureJson(rootPath: string): string;
 export declare function lowerMiniprogramRouteServerStyleJson(rootPath: string): string;
 export declare function lowerMiniprogramToolingDeployJson(rootPath: string): string;
+/**
+ * Consume the prepared `dist/_vmz/wechat-packaging.json` snapshot.
+ * Callers that start from a config must `await prepareWechatPackaging(rootPath)` first.
+ */
 export declare function lowerMiniprogramWechatPackagingJson(rootPath: string): string;
 export declare function lowerMiniprogramMultiAdapterJson(rootPath: string): string;
 import { createMiniHost } from './mini-host.js';
@@ -99,7 +103,7 @@ export { CDN_POLICY_MANIFEST_SCHEMA, CDN_ADAPTER_PROJECTION_SCHEMA, CACHE_HTML,
 export { SITE_DELIVERY_CONTRACT_SCHEMA, SITE_DELIVERY_RESOLUTION_SCHEMA, defineSite, normalizeSiteDelivery, normalizeSourceProbe, resolveSiteRelease, probeReleaseDirectory, emitSiteDelivery, } from './site-delivery.js';
 export { EMBEDDED_RESOURCE_INDEX_SCHEMA, emitEmbeddedPackaging } from './embedded-packaging.js';
 export { SERVER_LANG_IDS, SERVER_LANG_ALIASES, SERVER_LANGUAGE_BACKENDS, resolveServerLanguage, assertLangRuntimePair, } from './server-language-backend.js';
-export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging } from './wechat-packaging.js';
+export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging, prepareWechatPackaging, } from './wechat-packaging.js';
 export { DELIVERY_PROFILE_AUTHORING_SCHEMA, BUILD_PROFILE_SELECTION_SCHEMA, ASSEMBLIES, SERVER_RUNTIMES, BUILTIN_PROFILES, pickSiteAuthoring, pickDeliveryPackaging, normalizeProfileArtifactName, resolveProfileArtifactDir, normalizeDeliveryAuthoring, selectBuildProfile, semanticIdsForAssembly, } from '../delivery/delivery-profile.js';
 export { PACK_MANIFEST_SCHEMA, packFromDeploymentIr, ensureRuntimeCompanions } from './pack.js';
 export { SERVER_ARTIFACT_SCHEMA, HTTP_CONTRACT_SCHEMA, SERVER_RUNTIME_ADAPTER_SCHEMA, emitServerArtifact, projectServerRuntimeAdapter, } from './server-artifact.js';

package/dist/workspace/public-api.js

@@ -8,7 +8,6 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { materializeServeHostRuntime, SERVE_HOST_RUNTIME_FILES } from '../host-materialize/serve-host-runtime.js';
 import { resolveCoreRuntimeDist } from './runtime-dist.js';
-import { materializeWechatPackaging } from './wechat-packaging.js';
 export { resolveCoreRuntimeDist } from './runtime-dist.js';
 export { loadHostRuntimeFilesManifest, serveHostRuntimeFilePairs } from '../host-materialize/host-runtime-files.js';
 export { materializeServeHostRuntime, SERVE_HOST_RUNTIME_FILES } from '../host-materialize/serve-host-runtime.js';
@@ -125,25 +124,7 @@ export function createWorkspace(options) {
             pluginProtocol: protocol.pluginProtocol,
         },
     });
-    const pack = ws.lowerMiniprogramWechatPackaging.bind(ws);
-    const wrappedPack = () => {
-        materializeWechatPackaging(options.root);
-        return pack();
-    };
-    try {
-        ws.lowerMiniprogramWechatPackaging = wrappedPack;
-        return ws;
-    }
-    catch {
-        return new Proxy(ws, {
-            get(target, prop, receiver) {
-                if (prop === 'lowerMiniprogramWechatPackaging')
-                    return wrappedPack;
-                const value = Reflect.get(target, prop, receiver);
-                return typeof value === 'function' ? value.bind(target) : value;
-            },
-        });
-    }
+    return ws;
 }
 /** frozen application composition protocol catalog. */
 export function queryApplicationProtocolCatalog() {
@@ -183,9 +164,12 @@ export function lowerMiniprogramToolingDeployJson(rootPath) {
     const native = loadNative();
     return native.lowerMiniprogramToolingDeployJson(rootPath);
 }
+/**
+ * Consume the prepared `dist/_vmz/wechat-packaging.json` snapshot.
+ * Callers that start from a config must `await prepareWechatPackaging(rootPath)` first.
+ */
 export function lowerMiniprogramWechatPackagingJson(rootPath) {
     const native = loadNative();
-    materializeWechatPackaging(rootPath);
     return native.lowerMiniprogramWechatPackagingJson(rootPath);
 }
 export function lowerMiniprogramMultiAdapterJson(rootPath) {
@@ -307,7 +291,7 @@ export { CDN_POLICY_MANIFEST_SCHEMA, CDN_ADAPTER_PROJECTION_SCHEMA, CACHE_HTML,
 export { SITE_DELIVERY_CONTRACT_SCHEMA, SITE_DELIVERY_RESOLUTION_SCHEMA, defineSite, normalizeSiteDelivery, normalizeSourceProbe, resolveSiteRelease, probeReleaseDirectory, emitSiteDelivery, } from './site-delivery.js';
 export { EMBEDDED_RESOURCE_INDEX_SCHEMA, emitEmbeddedPackaging } from './embedded-packaging.js';
 export { SERVER_LANG_IDS, SERVER_LANG_ALIASES, SERVER_LANGUAGE_BACKENDS, resolveServerLanguage, assertLangRuntimePair, } from './server-language-backend.js';
-export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging } from './wechat-packaging.js';
+export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging, prepareWechatPackaging, } from './wechat-packaging.js';
 export { DELIVERY_PROFILE_AUTHORING_SCHEMA, BUILD_PROFILE_SELECTION_SCHEMA, ASSEMBLIES, SERVER_RUNTIMES, BUILTIN_PROFILES, pickSiteAuthoring, pickDeliveryPackaging, normalizeProfileArtifactName, resolveProfileArtifactDir, normalizeDeliveryAuthoring, selectBuildProfile, semanticIdsForAssembly, } from '../delivery/delivery-profile.js';
 export { PACK_MANIFEST_SCHEMA, packFromDeploymentIr, ensureRuntimeCompanions } from './pack.js';
 export { SERVER_ARTIFACT_SCHEMA, HTTP_CONTRACT_SCHEMA, SERVER_RUNTIME_ADAPTER_SCHEMA, emitServerArtifact, projectServerRuntimeAdapter, } from './server-artifact.js';

package/dist/workspace/wechat-packaging.d.ts

@@ -16,8 +16,15 @@ interface WechatPackagingSpec {
 }
 export declare function wechatPackagingFromDelivery(delivery: unknown): WechatPackagingSpec;
 /**
- * Load `vmz.config.*` and write the WeChat packaging contract for the Rust packer.
+ * Write the WeChat packaging contract from an already-evaluated delivery snapshot.
+ * Sync by contract: the native packer must consume prepared data, never read a config.
+ * @param {string} project
+ * @param {unknown} delivery
+ */
+export declare function materializeWechatPackaging(project: string, delivery: unknown): WechatPackagingSpec;
+/**
+ * Async host entry: evaluate `vmz.config.*` once, then prepare the packaging snapshot.
  * @param {string} project
  */
-export declare function materializeWechatPackaging(project: any): WechatPackagingSpec;
+export declare function prepareWechatPackaging(project: string): Promise<WechatPackagingSpec>;
 export {};

package/dist/workspace/wechat-packaging.js

@@ -2,27 +2,13 @@
  * Materialize `defineConfig({ delivery: { packaging: { wechat } } })` for wechat_pack.
  * Pure data only. Writes `dist/_vmz/wechat-packaging.json` (not a second config entry).
  */
-import { existsSync, mkdirSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { createJiti } from 'jiti';
 import { pickDeliveryPackaging } from '../delivery/delivery-profile.js';
 import { writePrettyJsonFile } from './pretty-json.js';
+import { loadVmzConfig } from './plugin-host.js';
 export const WECHAT_PACKAGING_SCHEMA = 'vmz.target.wechat_packaging.v0';
 export const WECHAT_PACKAGING_REL = 'dist/_vmz/wechat-packaging.json';
-const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
-function loadConfigSync(project) {
-    for (const name of CONFIG_NAMES) {
-        const full = path.join(project, name);
-        if (!existsSync(full))
-            continue;
-        const jiti = createJiti(import.meta.url, {
-            interopDefault: true,
-            moduleCache: false,
-        });
-        return jiti(full);
-    }
-    return null;
-}
 export function wechatPackagingFromDelivery(delivery) {
     const diagnostics = [];
     const packaging = pickDeliveryPackaging(delivery && typeof delivery === 'object' ? delivery : {}, diagnostics);
@@ -40,14 +26,23 @@ export function wechatPackagingFromDelivery(delivery) {
     return out;
 }
 /**
- * Load `vmz.config.*` and write the WeChat packaging contract for the Rust packer.
+ * Write the WeChat packaging contract from an already-evaluated delivery snapshot.
+ * Sync by contract: the native packer must consume prepared data, never read a config.
  * @param {string} project
+ * @param {unknown} delivery
  */
-export function materializeWechatPackaging(project) {
-    const cfg = loadConfigSync(project);
-    const spec = wechatPackagingFromDelivery(cfg?.delivery);
+export function materializeWechatPackaging(project, delivery) {
+    const spec = wechatPackagingFromDelivery(delivery);
     const abs = path.join(project, WECHAT_PACKAGING_REL);
     mkdirSync(path.dirname(abs), { recursive: true });
     writePrettyJsonFile(abs, spec);
     return spec;
 }
+/**
+ * Async host entry: evaluate `vmz.config.*` once, then prepare the packaging snapshot.
+ * @param {string} project
+ */
+export async function prepareWechatPackaging(project) {
+    const cfg = await loadVmzConfig(project);
+    return materializeWechatPackaging(project, cfg.delivery);
+}

package/locales/en-US/diag.json

@@ -1,6 +1,11 @@
 {
     "diag.message": "{message}",
     "diag.detail": "{detail}",
+    "commander::action_failed": "Command failed: {message}",
+    "commander::unknown_command": "Unknown command `{cmd}`.",
+    "commander::unknown_option": "Unknown option `{option}`.",
+    "commander::missing_option_value": "Missing value for option `{option}`.",
+    "commander::parse_failed": "Parse failed: {detail}",
 
     "vmz::template::illegal_directive": "Illegal or unsupported directive in `<template>`: {detail}",
     "vmz::template::parse_failed": "Failed to parse `<template>`: {detail}",
@@ -149,5 +154,7 @@
     "vmz::target::mini_platform_private_schema": "{detail}",
     "vmz::target::mini_shared_fork": "{detail}",
     "vmz::target::mini_static_slice_catalog_only": "{detail}",
-    "vmz::target::mini_route_server_style_catalog_only": "{detail}"
+    "vmz::target::mini_route_server_style_catalog_only": "{detail}",
+    "vmz::config::load_failed": "failed to load project config: {detail}",
+    "vmz::plugin::invalid_entry": "invalid plugin entry: {detail}"
 }

package/locales/zh-CN/diag.json

@@ -1,6 +1,7 @@
 {
     "diag.message": "{message}",
     "diag.detail": "{detail}",
+    "commander::action_failed": "命令执行失败：{message}",
 
     "vmz::template::illegal_directive": "`<template>` 中存在非法或不支持的指令：{detail}",
     "vmz::template::parse_failed": "解析 `<template>` 失败：{detail}",
@@ -149,5 +150,7 @@
     "vmz::target::mini_platform_private_schema": "{detail}",
     "vmz::target::mini_shared_fork": "{detail}",
     "vmz::target::mini_static_slice_catalog_only": "{detail}",
-    "vmz::target::mini_route_server_style_catalog_only": "{detail}"
+    "vmz::target::mini_route_server_style_catalog_only": "{detail}",
+    "vmz::config::load_failed": "无法加载项目配置：{detail}",
+    "vmz::plugin::invalid_entry": "插件入口无效：{detail}"
 }

package/package.json

@@ -3,24 +3,26 @@
     "vmz": "./bin/vmz.js"
   },
   "dependencies": {
-    "@vmz/commander": "0.3.5",
-    "@vmz/core": "0.3.5",
-    "@vmz/diagnostic": "0.3.5",
-    "@vmz/plugin": "0.3.5",
-    "@vmz/protocol": "0.3.5",
-    "jiti": "^2.6.1"
+    "@vmz/commander": "0.3.7",
+    "@vmz/core": "0.3.7",
+    "@vmz/diagnostic": "0.3.7",
+    "@vmz/plugin": "0.3.7",
+    "@vmz/protocol": "0.3.7"
   },
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "devDependencies": {
     "@types/node": "^22.15.0",
-    "@vmz/plugin": "0.3.5",
-    "@vmz/plugin-katex": "0.3.5",
-    "@vmz/plugin-markdown-it": "0.3.5",
-    "@vmz/plugin-shiki": "0.3.5",
-    "@vmz/test": "0.3.5",
+    "@vmz/plugin": "0.3.7",
+    "@vmz/plugin-katex": "0.3.7",
+    "@vmz/plugin-markdown-it": "0.3.7",
+    "@vmz/plugin-shiki": "0.3.7",
+    "@vmz/test": "0.3.7",
     "linkedom": "^0.18.13",
     "typescript": "^5.8.3",
-    "vmz-plugin-conformance": "0.3.5"
+    "vmz-plugin-conformance": "0.3.7"
+  },
+  "engines": {
+    "node": ">=24.12.0"
   },
   "exports": {
     ".": {
@@ -78,16 +80,16 @@
   "main": "./dist/index.js",
   "name": "@vmz/vmz",
   "optionalDependencies": {
-    "@vmz/vmz-darwin-arm64": "0.3.5",
-    "@vmz/vmz-darwin-x64": "0.3.5",
-    "@vmz/vmz-linux-arm64": "0.3.5",
-    "@vmz/vmz-linux-x64": "0.3.5",
-    "@vmz/vmz-win32-arm64": "0.3.5",
-    "@vmz/vmz-win32-x64": "0.3.5"
+    "@vmz/vmz-darwin-arm64": "0.3.7",
+    "@vmz/vmz-darwin-x64": "0.3.7",
+    "@vmz/vmz-linux-arm64": "0.3.7",
+    "@vmz/vmz-linux-x64": "0.3.7",
+    "@vmz/vmz-win32-arm64": "0.3.7",
+    "@vmz/vmz-win32-x64": "0.3.7"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.3.5",
-    "@vmz/test": "0.3.5",
+    "@vmz/plugin-markdown-it": "0.3.7",
+    "@vmz/test": "0.3.7",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -120,5 +122,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.3.5"
+  "version": "0.3.7"
 }