@vmz/vmz 0.1.22 → 0.1.24

package/dist/cli.js

@@ -21,6 +21,7 @@ import { registerArtifactCommands } from './release-cmd.js';
 import { registerRefactorCommands } from './refactor-cmd.js';
 import { registerExplainCommand } from './explain-cmd.js';
 import { registerPlanCommands } from './plan-cmd.js';
+import { registerGithubActionsCommand } from './github-actions-cmd.js';
 import { loadVmzConfig } from './plugin-host.js';
 import { normalizeDeliveryAuthoring, resolveProfileArtifactDir, selectBuildProfile } from './delivery-profile.js';
 import { packFromDeploymentIr } from './pack.js';
@@ -76,6 +77,7 @@ function buildProductCli(opts = {}) {
     registerArtifactCommands(cli.command('artifact|artifacts|release', 'cli.cmd.artifact'));
     registerRefactorCommands(cli.command('refactor', 'cli.cmd.refactor'));
     registerExplainCommand(cli);
+    registerGithubActionsCommand(cli);
     cli.command('version', 'cli.cmd.version').action(() => cmdVersion());
     return cli;
 }

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

@@ -1,9 +1,10 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
- * Logical paths stay available for serve/dev; static HTML rewrites to hashed URLs.
- * CSS aggregators (vmz.css) rewrite `@import` to hashed sibling paths under assets/.
- * JS under assets/ always rewrites ESM `./` → `../` so barrels (vmz-dom → dom-core)
- * resolve at dist root — never prefer hashed siblings for JS (second-hop 404).
+ * Logical paths stay available for serve/dev. Static HTML must receive hashed
+ * `cssEntry` / `moduleScriptSrc` at shell emit time — this module does **not**
+ * post-rewrite HTML. CSS aggregators rewrite `@import` before hash. JS under
+ * `assets/` rewrites ESM `./` → `../` via oxc (plus dynamic `import("./"+)` form)
+ * so barrels resolve at dist root.
  */
 export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
 interface ContentAddressedAssetObject {
@@ -24,7 +25,6 @@ export interface ContentAddressedAssetsManifest {
 }
 interface EmitContentAddressedAssetsOpts {
     candidates?: string[];
-    rewriteHtml?: boolean;
 }
 /**
  * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
@@ -46,9 +46,10 @@ export declare function rewriteCssImports(cssText: any, rewrites: any): any;
  */
 export declare function rewriteJsEntryRelativeImports(jsText: any, _rewrites?: {}): string;
 /**
- * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * Emit `assets/<sha256>.<ext>` copies and return logical→hashed rewrites.
+ * Callers must pass hashed URLs into `generatePageShell` — HTML is never rewritten here.
  * @param {string} distDir
- * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ * @param {{ candidates?: string[] }} [opts]
  */
 export declare function emitContentAddressedAssets(distDir: string, opts?: EmitContentAddressedAssetsOpts): {
     manifest: ContentAddressedAssetsManifest;
@@ -99,6 +100,8 @@ export declare function assertSharedAssetPath(distDir: any, a: any, b: any, ext?
     digestB?: undefined;
     rel?: undefined;
 };
+/** Resolve `/logical` → hashed href from emit rewrites (`/assets/<sha>.ext`). */
+export declare function hashedAssetHref(rewrites: Record<string, string>, logical: string | null | undefined): string | null;
 export declare function contentAddressedAssetsDigest(manifest: any): any;
 export declare function sha256Buffer(buf: any): string;
 export {};

package/dist/content-addressed-assets.js

@@ -1,13 +1,15 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
- * Logical paths stay available for serve/dev; static HTML rewrites to hashed URLs.
- * CSS aggregators (vmz.css) rewrite `@import` to hashed sibling paths under assets/.
- * JS under assets/ always rewrites ESM `./` → `../` so barrels (vmz-dom → dom-core)
- * resolve at dist root — never prefer hashed siblings for JS (second-hop 404).
+ * Logical paths stay available for serve/dev. Static HTML must receive hashed
+ * `cssEntry` / `moduleScriptSrc` at shell emit time — this module does **not**
+ * post-rewrite HTML. CSS aggregators rewrite `@import` before hash. JS under
+ * `assets/` rewrites ESM `./` → `../` via oxc (plus dynamic `import("./"+)` form)
+ * so barrels resolve at dist root.
  */
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { requireNativeAddon } from './native-addon.js';
 import { canonicalJson, sha256Hex } from './release-pack.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
@@ -59,26 +61,25 @@ export function rewriteCssImports(cssText, rewrites) {
  * @param {Record<string, string>} [_rewrites]
  */
 export function rewriteJsEntryRelativeImports(jsText, _rewrites = {}) {
-    let out = String(jsText || '');
-    // Dynamic: import("./" + id) → import("../" + id)
+    const native = requireNativeAddon();
+    if (typeof native.rewriteModuleSpecifiers !== 'function') {
+        throw new Error('native missing rewriteModuleSpecifiers — run `pnpm napi:build`');
+    }
+    // Static import/export specs via oxc AST (`./x` → `../x`). Dynamic
+    // `import("./"+id)` is not a literal specifier — rewrite that codegen form only.
+    let out = String(native.rewriteModuleSpecifiers(String(jsText ?? ''), JSON.stringify({
+        tsExtToJs: false,
+        dotSlashToParent: true,
+    })));
     out = out.replace(/import\(\s*"\.\/"\s*\+/g, 'import("../"+');
     out = out.replace(/import\(\s*'\.\/'\s*\+/g, "import('../'+");
-    const rewriteSpec = (spec) => {
-        const logical = String(spec || '').replace(/^\.\//, '');
-        if (!logical || logical.startsWith('../') || logical.startsWith('/'))
-            return spec;
-        return `../${logical}`;
-    };
-    // import/export … from "./x"  |  import("./x")
-    out = out.replace(/\b((?:import|export)\s+[^'"\n]*?\s+from\s+|import\s*\(\s*)(['"])(\.\/[^'"]+)\2/g, (match, prefix, quote, spec) => `${prefix}${quote}${rewriteSpec(spec)}${quote}`);
-    // side-effect: import "./x.js"
-    out = out.replace(/(^|[;\s])(import\s*)(['"])(\.\/[^'"]+)\3/gm, (match, lead, kw, quote, spec) => `${lead}${kw}${quote}${rewriteSpec(spec)}${quote}`);
     return out;
 }
 /**
- * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * Emit `assets/<sha256>.<ext>` copies and return logical→hashed rewrites.
+ * Callers must pass hashed URLs into `generatePageShell` — HTML is never rewritten here.
  * @param {string} distDir
- * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ * @param {{ candidates?: string[] }} [opts]
  */
 export function emitContentAddressedAssets(distDir, opts = {}) {
     const abs = path.resolve(distDir);
@@ -141,17 +142,13 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
         });
     }
     objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
-    let rewrittenHtml = 0;
-    if (opts.rewriteHtml !== false) {
-        rewrittenHtml = rewriteHtmlReferences(abs, rewrites);
-    }
     const manifest = {
         schema: CONTENT_ADDRESSED_ASSETS_SCHEMA,
         layout: 'assets/<sha256>.<ext>',
         immutable: true,
         objectCount: objects.length,
         objects,
-        rewrittenHtml,
+        rewrittenHtml: 0,
     };
     manifest.manifestDigest = sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));
     const vmzDir = path.join(abs, '_vmz');
@@ -299,45 +296,16 @@ function walk(root, dir, onFile) {
             onFile(path.relative(root, full).replace(/\\/g, '/'));
     }
 }
-/**
- * @param {string} distDir
- * @param {Record<string, string>} rewrites map `/logical` → `/assets/hash.ext`
- */
-function rewriteHtmlReferences(distDir, rewrites) {
-    const pairs = Object.entries(rewrites)
-        .filter(([from]) => from.startsWith('/'))
-        .sort((a, b) => b[0].length - a[0].length);
-    if (!pairs.length)
-        return 0;
-    let count = 0;
-    walkHtml(distDir, (file) => {
-        let text = fs.readFileSync(file, 'utf8');
-        let next = text;
-        for (const [from, to] of pairs) {
-            next = next.split(from).join(to);
-        }
-        if (next !== text) {
-            fs.writeFileSync(file, next, 'utf8');
-            count += 1;
-        }
-    });
-    return count;
-}
-function walkHtml(dir, onFile) {
-    const stack = [dir];
-    while (stack.length) {
-        const cur = stack.pop();
-        for (const name of fs.readdirSync(cur)) {
-            if (name === 'assets' || name === '_vmz' || name === 'node_modules')
-                continue;
-            const full = path.join(cur, name);
-            const st = fs.statSync(full);
-            if (st.isDirectory())
-                stack.push(full);
-            else if (name.endsWith('.html'))
-                onFile(full);
-        }
-    }
+/** Resolve `/logical` → hashed href from emit rewrites (`/assets/<sha>.ext`). */
+export function hashedAssetHref(rewrites, logical) {
+    if (!logical)
+        return null;
+    const raw = String(logical).replace(/\\/g, '/');
+    const key = raw.startsWith('/') ? raw : `/${raw.replace(/^\.\//, '')}`;
+    const hit = rewrites[key] || rewrites[key.slice(1)];
+    if (!hit)
+        return key.startsWith('/') ? key : `/${key}`;
+    return hit.startsWith('/') ? hit : `/${hit}`;
 }
 export function contentAddressedAssetsDigest(manifest) {
     return manifest.manifestDigest || sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));

package/dist/dev-incremental.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dev incremental state helpers (0.1.24): HMR plan parsing, reload decisions, static revision.
+ */
+export interface HmrPlanWire {
+    mode?: string;
+    islandOnly?: boolean;
+    island_only?: boolean;
+    rerunLoaders?: string[];
+    rerun_loaders?: string[];
+    affectedChunks?: string[];
+    affected_chunks?: string[];
+    seedChunks?: string[];
+    seed_chunks?: string[];
+}
+export interface BuildReportWire {
+    full?: boolean;
+    islandHmr?: boolean;
+    island_hmr?: boolean;
+    affectedChunks?: string[];
+    affected_chunks?: string[];
+    seedChunks?: string[];
+    seed_chunks?: string[];
+    emitted?: string[];
+    outputRevision?: string;
+    output_revision?: string;
+    writtenOutputs?: string[];
+    written_outputs?: string[];
+    reloadRequired?: boolean;
+    reload_required?: boolean;
+}
+export interface DevReloadPayload {
+    affectedChunks?: string[];
+    seedChunks?: string[];
+    emitted?: string[];
+    full?: boolean;
+    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;
+}): boolean;
+export declare function staticRevisionFromArtifact(artifact: {
+    files?: Array<{
+        path: string;
+        bytes?: number;
+    }>;
+    fileCount?: number;
+} | null): string;
+export declare function filterGenerationIgnore(changed: string[], ignore: Set<string>): string[];
+export declare function devPathNormalize(p: string): string;
+export declare function registerWrittenOutputsIgnore(writtenOutputs: string[] | undefined, outDir: string, projectRoot: string, ignore: Set<string>): void;

package/dist/dev-incremental.js

@@ -0,0 +1,86 @@
+/**
+ * Dev incremental state helpers (0.1.24): HMR plan parsing, reload decisions, static revision.
+ */
+import path from 'node:path';
+export function parseHmrPlan(raw) {
+    if (!raw)
+        return null;
+    try {
+        const doc = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        return doc && typeof doc === 'object' ? doc : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function hmrRerunLoaders(plan) {
+    if (!plan)
+        return [];
+    const list = plan.rerunLoaders ?? plan.rerun_loaders ?? [];
+    return Array.isArray(list) ? list.map(String) : [];
+}
+export function buildReloadPayload(report, hmrPlan, opts = {}) {
+    const rerunLoaders = hmrRerunLoaders(hmrPlan);
+    const affectedChunks = report.affectedChunks ?? report.affected_chunks ?? [];
+    const islandHmr = Boolean(report.islandHmr ?? report.island_hmr);
+    const mode = String(hmrPlan?.mode ?? '').toLowerCase();
+    let full = Boolean(report.full);
+    if (mode === 'full')
+        full = true;
+    if (islandHmr && rerunLoaders.length === 0 && affectedChunks.length > 0) {
+        full = true;
+    }
+    return {
+        affectedChunks,
+        seedChunks: report.seedChunks ?? report.seed_chunks ?? [],
+        emitted: report.emitted ?? [],
+        full,
+        islandHmr: islandHmr && !full,
+        rerunLoaders,
+        staticRevision: opts.staticRevision,
+        skipEntryRewrite: opts.skipEntryRewrite,
+        outputRevision: report.outputRevision ?? report.output_revision,
+    };
+}
+export function shouldSoftReload(report, lastOutputRevision, opts = {}) {
+    if (opts.force)
+        return true;
+    const reloadRequired = report.reloadRequired ?? report.reload_required;
+    if (reloadRequired === false)
+        return false;
+    const rev = report.outputRevision ?? report.output_revision ?? '';
+    if (lastOutputRevision && rev && rev === lastOutputRevision)
+        return false;
+    return true;
+}
+export function staticRevisionFromArtifact(artifact) {
+    if (!artifact || artifact.fileCount === 0)
+        return 'empty';
+    const parts = (artifact.files ?? []).map((f) => `${f.path}:${f.bytes ?? 0}`);
+    parts.sort();
+    let h = 0xcbf29ce484222325n;
+    for (const p of parts) {
+        for (const b of Buffer.from(p)) {
+            h = (h * 0x100000001b3n + BigInt(b)) & 0xffffffffffffffffn;
+        }
+    }
+    return h.toString(16);
+}
+export function filterGenerationIgnore(changed, ignore) {
+    if (!ignore.size)
+        return changed;
+    return changed.filter((p) => !ignore.has(devPathNormalize(p)));
+}
+export function devPathNormalize(p) {
+    return String(p).replace(/\\/g, '/');
+}
+export function registerWrittenOutputsIgnore(writtenOutputs, outDir, projectRoot, ignore) {
+    for (const rel of writtenOutputs ?? []) {
+        const abs = path.isAbsolute(rel) ? rel : path.join(outDir, rel);
+        ignore.add(devPathNormalize(abs));
+        const underProject = devPathNormalize(abs);
+        if (underProject.startsWith(devPathNormalize(projectRoot))) {
+            ignore.add(underProject);
+        }
+    }
+}

package/dist/dev-session.js

@@ -16,7 +16,8 @@ import { buildIntegratedDocuments, projectHasDocuments } from './document-integr
 import { createWorkspace, resolveNativePath } from './index.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { log } from './log.js';
-import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets } from './dev-watch-roots.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectDevConfigPaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { buildReloadPayload, filterGenerationIgnore, parseHmrPlan, registerWrittenOutputsIgnore, shouldSoftReload, staticRevisionFromArtifact, } from './dev-incremental.js';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
 /** Track serve-host so a failed/killed launcher cannot leave an orphan port. */
 const DEV_HOST_PID = '.vmz-dev-host.pid';
@@ -33,10 +34,57 @@ export function createDevSession(options) {
     const ws = createWs({ root: project, outDir });
     let child = null;
     let stopped = false;
-    function rebuild(changes) {
+    let lastOutputRevision = null;
+    let lastStaticRevision = null;
+    const generationIgnore = new Set();
+    function planAndRebuild(changes) {
         if (changes?.length)
             ws.updateFiles(changes);
-        return ws.build();
+        let hmrPlan = null;
+        try {
+            if (typeof ws.queryHmrPlan === 'function') {
+                hmrPlan = parseHmrPlan(ws.queryHmrPlan());
+            }
+        }
+        catch {
+            hmrPlan = null;
+        }
+        const report = ws.build();
+        return { report, hmrPlan };
+    }
+    function rebuild(changes) {
+        return planAndRebuild(changes).report;
+    }
+    async function emitPublicAndTrack() {
+        const { emitPublicStaticAssets } = await import('./public-static-assets.js');
+        const artifact = emitPublicStaticAssets(outDir, { projectRoot: project });
+        lastStaticRevision = staticRevisionFromArtifact(artifact);
+        return artifact;
+    }
+    async function maybeReloadAfterBuild(report, hmrPlan, opts = {}) {
+        const rev = report.outputRevision ?? report.output_revision ?? null;
+        const skipEntry = Boolean(rev && rev === lastOutputRevision);
+        if (!opts.force && !opts.staticOnly && !shouldSoftReload(report, lastOutputRevision)) {
+            log.info('rebuild ok — artifact unchanged, skip soft reload');
+            if (rev)
+                lastOutputRevision = rev;
+            registerWrittenOutputsIgnore(report.writtenOutputs ?? report.written_outputs, outDir, project, generationIgnore);
+            return 'skip';
+        }
+        const payload = buildReloadPayload(report, hmrPlan, {
+            staticRevision: lastStaticRevision ?? undefined,
+            skipEntryRewrite: skipEntry && !opts.force,
+        });
+        if (opts.staticOnly) {
+            payload.full = false;
+            payload.islandHmr = false;
+            payload.skipEntryRewrite = true;
+        }
+        const kind = await reloadAfterBuild(payload);
+        if (rev)
+            lastOutputRevision = rev;
+        registerWrittenOutputsIgnore(report.writtenOutputs ?? report.written_outputs, outDir, project, generationIgnore);
+        return kind;
     }
     function emitLocales() {
         const localeEmit = emitLocaleRuntimeModules(project, outDir);
@@ -154,16 +202,14 @@ export function createDevSession(options) {
             }
         }
         log.info('initial build (N-API workspace, full)…');
-        const initial = rebuild();
+        const initialPair = planAndRebuild();
+        const initial = initialPair.report;
         if (!printReport(initial, 'build')) {
             throw new Error('vmz dev: initial build failed');
         }
+        lastOutputRevision = initial.outputRevision ?? initial.output_revision ?? null;
         // `vmz build` assemble copies `public/**` → outDir; soft `ws.build()` does not.
-        // Without this, marketing images and other opaque assets 404 under `vmz dev`.
-        {
-            const { emitPublicStaticAssets } = await import('./public-static-assets.js');
-            emitPublicStaticAssets(outDir, { projectRoot: project });
-        }
+        await emitPublicAndTrack();
         // Reclaim orphan serve-host from a previous crashed launcher (same outDir).
         reclaimStaleDevHost(outDir);
         if (projectHasDocuments(project)) {
@@ -191,6 +237,8 @@ export function createDevSession(options) {
         const localesRoot = path.join(project, 'locales');
         const designsRoot = path.join(project, 'designs');
         const watched = collectDevWatchRoots({ project, outDir });
+        const publicRoot = watched.publicRoot;
+        const configPaths = watched.configPaths.length ? watched.configPaths : collectDevConfigPaths(project);
         /** @type {string[]} */
         const watchRoots = [...watched.roots];
         /** @type {string[]} */
@@ -209,6 +257,7 @@ export function createDevSession(options) {
         for (const root of watchRoots) {
             fingerprints.set(root, fileFingerprintMap(root));
         }
+        let configFingerprints = configFingerprintMap(configPaths);
         const signal = options.signal;
         const onAbort = () => {
             void stop();
@@ -218,7 +267,7 @@ export function createDevSession(options) {
          * Scan all watch roots into a batch. Does not update fingerprints.
          */
         function scanBatch() {
-            /** @type {{ srcChanged: string[], srcDeleted: string[], depChanged: string[], depDeleted: string[], designsChanged: string[], designsDeleted: string[], docsDirty: boolean, localesDirty: boolean, designsDirty: boolean }} */
+            /** @type {{ srcChanged: string[], srcDeleted: string[], depChanged: string[], depDeleted: string[], designsChanged: string[], designsDeleted: string[], publicChanged: string[], docsDirty: boolean, localesDirty: boolean, designsDirty: boolean, configDirty: boolean }} */
             const batch = {
                 srcChanged: [],
                 srcDeleted: [],
@@ -226,11 +275,13 @@ export function createDevSession(options) {
                 depDeleted: [],
                 designsChanged: [],
                 designsDeleted: [],
+                publicChanged: [],
                 docsDirty: false,
                 localesDirty: false,
                 designsDirty: false,
+                configDirty: false,
             };
-            const watchCtx = { src, docsRoot, localesRoot, designsRoot, dependencyRoots };
+            const watchCtx = { src, docsRoot, localesRoot, designsRoot, publicRoot, dependencyRoots };
             for (const root of watchRoots) {
                 const prev = fingerprints.get(root) || new Map();
                 const next = fileFingerprintMap(root);
@@ -242,6 +293,9 @@ export function createDevSession(options) {
                     batch.srcChanged.push(...diff.changed);
                     batch.srcDeleted.push(...diff.deleted);
                 }
+                else if (kind === 'public') {
+                    batch.publicChanged.push(...diff.changed);
+                }
                 else if (kind === 'locales') {
                     batch.localesDirty = true;
                 }
@@ -282,16 +336,51 @@ export function createDevSession(options) {
                 let batch;
                 try {
                     batch = scanBatch();
+                    const nextConfigFp = configFingerprintMap(configPaths);
+                    const configDiff = diffFingerprints(configFingerprints, nextConfigFp);
+                    if (configDiff.changed.length || configDiff.deleted.length) {
+                        batch.configDirty = true;
+                    }
                 }
                 catch (err) {
                     log.warn('watch error:', err);
                     continue;
                 }
+                if (generationIgnore.size) {
+                    batch.srcChanged = filterGenerationIgnore(batch.srcChanged, generationIgnore);
+                    batch.srcDeleted = filterGenerationIgnore(batch.srcDeleted, generationIgnore);
+                    generationIgnore.clear();
+                }
                 const srcDirty = batch.srcChanged.length + batch.srcDeleted.length;
                 const depDirty = batch.depChanged.length + batch.depDeleted.length;
                 const designsDirty = batch.designsDirty || batch.designsChanged.length + batch.designsDeleted.length;
-                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty && !designsDirty)
+                const publicDirty = batch.publicChanged.length;
+                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty && !designsDirty && !publicDirty && !batch.configDirty) {
                     continue;
+                }
+                if (batch.configDirty) {
+                    log.info('vmz.config change detected — respawn required (devControl)');
+                    configFingerprints = configFingerprintMap(configPaths);
+                    commitFingerprints();
+                    await respawnHost('config-changed');
+                    const report = rebuild();
+                    if (printReport(report, 'rebuild')) {
+                        lastOutputRevision = report.outputRevision ?? report.output_revision ?? null;
+                        await emitPublicAndTrack();
+                    }
+                    continue;
+                }
+                if (publicDirty && !srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty && !designsDirty) {
+                    log.info(`public change detected (${publicDirty} file(s)) — re-emit static assets…`);
+                    await emitPublicAndTrack();
+                    commitFingerprints();
+                    if (!wechatPreview) {
+                        const kind = await maybeReloadAfterBuild({ reloadRequired: true }, null, { force: true, staticOnly: true });
+                        if (kind !== 'skip')
+                            log.info('soft reload ok (public assets)');
+                    }
+                    continue;
+                }
                 // Coalesce multi-file bursts without dropping the initial dirty set.
                 if (srcDirty > 1) {
                     const coalesced = await coalesceRootBurst(src, fingerprints, {
@@ -344,7 +433,6 @@ export function createDevSession(options) {
                     batch.designsChanged = designsMerged.changed;
                     batch.designsDeleted = designsMerged.deleted;
                 }
-                commitFingerprints();
                 if (!batch.srcChanged.length &&
                     !batch.srcDeleted.length &&
                     !batch.depChanged.length &&
@@ -357,11 +445,12 @@ export function createDevSession(options) {
                 // Dependency changes: conservative full rebuild + full reload (v0.1.5).
                 if (batch.depChanged.length || batch.depDeleted.length) {
                     log.info(`dependency change detected (${batch.depChanged.length} update, ${batch.depDeleted.length} delete) — full rebuild…`);
-                    const report = rebuild();
+                    const { report, hmrPlan } = planAndRebuild();
                     if (!printReport(report, 'rebuild')) {
                         log.warn('rebuild failed — keeping previous server');
                         continue;
                     }
+                    await emitPublicAndTrack();
                     // Refresh watch roots in case the graph gained new packages.
                     const refreshed = collectDevWatchRoots({ project, outDir });
                     for (const r of refreshed.roots) {
@@ -381,14 +470,11 @@ export function createDevSession(options) {
                             log.warn('wechat pack failed — keeping previous dist/wechat');
                         continue;
                     }
-                    const kind = await reloadAfterBuild({
-                        affectedChunks: report.affectedChunks ?? [],
-                        seedChunks: report.seedChunks ?? [],
-                        emitted: report.emitted ?? [],
-                        full: true,
-                        islandHmr: false,
-                    });
-                    log.info(kind === 'respawn' ? 'reload ok (respawned; deps)' : 'soft reload ok (full page; deps)');
+                    const kind = await maybeReloadAfterBuild(report, hmrPlan, { force: true });
+                    commitFingerprints();
+                    if (kind !== 'skip') {
+                        log.info(kind === 'respawn' ? 'reload ok (respawned; deps)' : 'soft reload ok (full page; deps)');
+                    }
                     continue;
                 }
                 let needFullReload = batch.docsDirty || batch.designsDirty;
@@ -398,11 +484,12 @@ export function createDevSession(options) {
                         ...batch.srcChanged.map((p) => ({ path: p, kind: /** @type {'update'} */ ('update') })),
                         ...batch.srcDeleted.map((p) => ({ path: p, kind: /** @type {'delete'} */ ('delete') })),
                     ];
-                    const report = rebuild(changes);
+                    const { report, hmrPlan } = planAndRebuild(changes);
                     if (!printReport(report, 'rebuild')) {
                         log.warn('rebuild failed — keeping previous server');
                         continue;
                     }
+                    await emitPublicAndTrack();
                     if (batch.docsDirty || projectHasDocuments(project)) {
                         const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
                         if (!docs.ok) {
@@ -418,20 +505,19 @@ export function createDevSession(options) {
                         }
                         continue;
                     }
-                    const kind = await reloadAfterBuild({
-                        affectedChunks: report.affectedChunks ?? [],
-                        seedChunks: report.seedChunks ?? [],
-                        emitted: report.emitted ?? [],
-                        full: Boolean(report.full) || needFullReload,
-                        islandHmr: Boolean(report.islandHmr) && !needFullReload,
+                    const kind = await maybeReloadAfterBuild(report, hmrPlan, {
+                        force: needFullReload,
                     });
-                    log.info(kind === 'respawn'
-                        ? 'reload ok (respawned serve-host)'
-                        : needFullReload
-                            ? 'soft reload ok (full page; docs)'
-                            : report.islandHmr
-                                ? 'soft reload ok (island HMR)'
-                                : 'soft reload ok');
+                    commitFingerprints();
+                    if (kind !== 'skip') {
+                        log.info(kind === 'respawn'
+                            ? 'reload ok (respawned serve-host)'
+                            : needFullReload
+                                ? 'soft reload ok (full page; docs)'
+                                : report.islandHmr
+                                    ? 'soft reload ok (island HMR)'
+                                    : 'soft reload ok');
+                    }
                     continue;
                 }
                 if (batch.designsChanged.length || batch.designsDeleted.length || batch.designsDirty) {
@@ -440,11 +526,12 @@ export function createDevSession(options) {
                         ...batch.designsChanged.map((p) => ({ path: p, kind: /** @type {'update'} */ ('update') })),
                         ...batch.designsDeleted.map((p) => ({ path: p, kind: /** @type {'delete'} */ ('delete') })),
                     ];
-                    const report = rebuild(changes.length ? changes : undefined);
+                    const { report, hmrPlan } = planAndRebuild(changes.length ? changes : undefined);
                     if (!printReport(report, 'rebuild')) {
                         log.warn('designs rebuild failed — keeping previous styles');
                         continue;
                     }
+                    await emitPublicAndTrack();
                     if (batch.docsDirty || projectHasDocuments(project)) {
                         const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
                         if (!docs.ok)
@@ -455,14 +542,11 @@ export function createDevSession(options) {
                             log.warn('wechat pack failed — keeping previous dist/wechat');
                         continue;
                     }
-                    const kind = await reloadAfterBuild({
-                        affectedChunks: report.affectedChunks ?? [],
-                        seedChunks: report.seedChunks ?? [],
-                        emitted: report.emitted ?? [],
-                        full: true,
-                        islandHmr: false,
-                    });
-                    log.info(kind === 'respawn' ? 'reload ok (respawned; designs)' : 'soft reload ok (full page; designs)');
+                    const kind = await maybeReloadAfterBuild(report, hmrPlan, { force: true });
+                    commitFingerprints();
+                    if (kind !== 'skip') {
+                        log.info(kind === 'respawn' ? 'reload ok (respawned; designs)' : 'soft reload ok (full page; designs)');
+                    }
                     continue;
                 }
                 if (batch.localesDirty) {
@@ -479,8 +563,11 @@ export function createDevSession(options) {
                             continue;
                     }
                     else {
-                        const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
-                        log.info(kind === 'respawn' ? 'reload ok (respawned; locales)' : 'soft reload ok (full page; locales)');
+                        const kind = await maybeReloadAfterBuild({ reloadRequired: true, full: true }, null, { force: true });
+                        commitFingerprints();
+                        if (kind !== 'skip') {
+                            log.info(kind === 'respawn' ? 'reload ok (respawned; locales)' : 'soft reload ok (full page; locales)');
+                        }
                         if (!batch.docsDirty)
                             continue;
                     }
@@ -498,8 +585,11 @@ export function createDevSession(options) {
                         }
                     }
                     else {
-                        const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
-                        log.info(kind === 'respawn' ? 'reload ok (respawned; docs)' : 'soft reload ok (full page; docs)');
+                        const kind = await maybeReloadAfterBuild({ reloadRequired: true, full: true }, null, { force: true });
+                        commitFingerprints();
+                        if (kind !== 'skip') {
+                            log.info(kind === 'respawn' ? 'reload ok (respawned; docs)' : 'soft reload ok (full page; docs)');
+                        }
                     }
                 }
             }

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

@@ -1,7 +1,16 @@
 /**
  * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
  * and derive extra watch roots from the compile graph (deployment unit sources).
+ *
+ * DevInput layers (0.1.24): author · dependency · public · devControl.
+ * Never watch `dist/`, generated indexes, or generation write-set paths.
  */
+/** Author-facing vs generated dev input bucket. */
+export type DevInputKind = 'author' | 'dependency' | 'public' | 'devControl' | 'locales' | 'docs' | 'designs' | 'other';
+/** `vmz.config.*` at project root (devControl). */
+export declare function collectDevConfigPaths(project: string): string[];
+/** Fingerprint map for explicit config files (not directory walks). */
+export declare function configFingerprintMap(configPaths: string[]): Map<string, string>;
 export interface DirtySet {
     changed: string[];
     deleted: string[];
@@ -59,7 +68,11 @@ export declare function collectDevWatchRoots(opts: CollectDevWatchRootsOpts): {
     roots: string[];
     dependencyRoots: string[];
     applicationRoots: string[];
+    publicRoot: string | null;
+    configPaths: string[];
 };
+/** Map watch bucket to DevInput layer. */
+export declare function devInputKindForWatchBucket(bucket: ReturnType<typeof classifyWatchRoot>): DevInputKind;
 /**
  * Classify which watch bucket a root belongs to.
  * @param {string} root
@@ -77,9 +90,10 @@ export interface ClassifyWatchRootCtx {
     docsRoot: string;
     localesRoot: string;
     designsRoot: string;
+    publicRoot?: string | null;
     dependencyRoots: string[];
 }
-export declare function classifyWatchRoot(root: string, ctx: ClassifyWatchRootCtx): 'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'other';
+export declare function classifyWatchRoot(root: string, ctx: ClassifyWatchRootCtx): 'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'public' | 'other';
 /**
  * Classify whether a changed file lives under a dependency watch root (not app src).
  * @param {string} file

package/dist/dev-watch-roots.js

@@ -1,10 +1,33 @@
 /**
  * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
  * and derive extra watch roots from the compile graph (deployment unit sources).
+ *
+ * DevInput layers (0.1.24): author · dependency · public · devControl.
+ * Never watch `dist/`, generated indexes, or generation write-set paths.
  */
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
+const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+/** `vmz.config.*` at project root (devControl). */
+export function collectDevConfigPaths(project) {
+    const root = path.resolve(project);
+    return CONFIG_BASENAMES.map((name) => path.join(root, name)).filter((p) => existsSync(p));
+}
+/** Fingerprint map for explicit config files (not directory walks). */
+export function configFingerprintMap(configPaths) {
+    const map = new Map();
+    for (const p of configPaths) {
+        try {
+            const st = statSync(p);
+            map.set(p, `${st.mtimeMs}:${st.size}`);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return map;
+}
 export function mergeDirtySets(a, b) {
     const changed = new Set(a?.changed || []);
     const deleted = new Set(a?.deleted || []);
@@ -135,10 +158,14 @@ export function localLinkDependencyRoots(project) {
 export function collectDevWatchRoots(opts) {
     const project = path.resolve(opts.project);
     const outDir = path.resolve(opts.outDir);
+    void outDir;
     const src = path.join(project, 'src');
     const docsRoot = path.join(project, 'documents');
     const localesRoot = path.join(project, 'locales');
     const designsRoot = path.join(project, 'designs');
+    const publicRootPath = path.join(project, 'public');
+    const publicRoot = existsSync(publicRootPath) && statSync(publicRootPath).isDirectory() ? publicRootPath : null;
+    const configPaths = collectDevConfigPaths(project);
     const applicationRoots = [];
     if (existsSync(src))
         applicationRoots.push(src);
@@ -148,6 +175,8 @@ export function collectDevWatchRoots(opts) {
         applicationRoots.push(localesRoot);
     if (existsSync(designsRoot))
         applicationRoots.push(designsRoot);
+    if (publicRoot)
+        applicationRoots.push(publicRoot);
     const depSet = new Set();
     const depJson = path.join(outDir, 'vmz-deployment.json');
     if (existsSync(depJson)) {
@@ -188,11 +217,29 @@ export function collectDevWatchRoots(opts) {
         if (!roots.includes(r))
             roots.push(r);
     }
-    return { roots, dependencyRoots, applicationRoots };
+    return { roots, dependencyRoots, applicationRoots, publicRoot, configPaths };
+}
+/** Map watch bucket to DevInput layer. */
+export function devInputKindForWatchBucket(bucket) {
+    if (bucket === 'src')
+        return 'author';
+    if (bucket === 'dep')
+        return 'dependency';
+    if (bucket === 'public')
+        return 'public';
+    if (bucket === 'locales')
+        return 'locales';
+    if (bucket === 'docs')
+        return 'docs';
+    if (bucket === 'designs')
+        return 'designs';
+    return 'other';
 }
 export function classifyWatchRoot(root, ctx) {
     if (root === ctx.src)
         return 'src';
+    if (ctx.publicRoot && root === ctx.publicRoot)
+        return 'public';
     if (root === ctx.localesRoot)
         return 'locales';
     if (root === ctx.docsRoot)

package/dist/github-actions-cmd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `vmz github-actions` — monitor workflow runs via N-API → Rust `vmz-github` (octocrab).
+ */
+import type { Cli, ParsedOptions } from '@vmz/commander';
+export declare function registerGithubActionsCommand(cli: Cli): void;
+export declare function cmdGithubActions(args: ParsedOptions): number;

package/dist/github-actions-cmd.js

@@ -0,0 +1,120 @@
+/**
+ * `vmz github-actions` — monitor workflow runs via N-API → Rust `vmz-github` (octocrab).
+ */
+import { loadNative } from './index.js';
+import { log } from './log.js';
+import { emitPrettyJson } from './pretty-json.js';
+export function registerGithubActionsCommand(cli) {
+    cli.command('github-actions|gha', 'cli.cmd.github-actions')
+        .option('--mode <mode>', 'cli.opt.gha.mode')
+        .option('--workflow <id>', 'cli.opt.gha.workflow')
+        .option('--run-id <id>', 'cli.opt.gha.run-id')
+        .option('--ref <sha>', 'cli.opt.gha.ref')
+        .option('--branch <name>', 'cli.opt.gha.branch')
+        .option('--owner <owner>', 'cli.opt.gha.owner')
+        .option('--repo <repo>', 'cli.opt.gha.repo')
+        .option('--token <token>', 'cli.opt.gha.token')
+        .option('--timeout-minutes <n>', 'cli.opt.gha.timeout-minutes')
+        .option('--interval-seconds <n>', 'cli.opt.gha.interval-seconds')
+        .option('--required-conclusion <c>', 'cli.opt.gha.required-conclusion')
+        .option('--json [file]', 'cli.opt.json')
+        .action((options) => cmdGithubActions(options));
+}
+export function cmdGithubActions(args) {
+    const native = loadNative();
+    if (typeof native.githubActionsMonitorJson !== 'function') {
+        log.error('githubActionsMonitorJson missing — rebuild native (`pnpm napi:build`)');
+        return 1;
+    }
+    const modeRaw = String(args.mode ?? 'status')
+        .trim()
+        .toLowerCase();
+    if (modeRaw !== 'status' && modeRaw !== 'wait') {
+        log.errorId('cli.err.gha.mode', { mode: modeRaw });
+        return 1;
+    }
+    const { owner, repo } = resolveOwnerRepo(args);
+    if (!owner || !repo) {
+        log.errorId('cli.err.gha.repo');
+        return 1;
+    }
+    const token = (typeof args.token === 'string' && args.token.trim()) || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || undefined;
+    const timeoutMinutes = positiveNumber(args['timeout-minutes'], 45);
+    const intervalSeconds = positiveNumber(args['interval-seconds'], 15);
+    const request = {
+        owner,
+        repo,
+        token: token || null,
+        mode: modeRaw,
+        workflow: strOrNull(args.workflow),
+        runId: parseRunId(args['run-id']),
+        headSha: strOrNull(args.ref),
+        branch: strOrNull(args.branch),
+        timeoutSecs: Math.round(timeoutMinutes * 60),
+        intervalSecs: Math.round(intervalSeconds),
+        requiredConclusion: String(args['required-conclusion'] ?? 'success'),
+    };
+    let resultJson;
+    try {
+        resultJson = native.githubActionsMonitorJson(JSON.stringify(request));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(msg);
+        return 1;
+    }
+    let result;
+    try {
+        result = JSON.parse(resultJson);
+    }
+    catch {
+        log.error('githubActionsMonitorJson returned invalid JSON');
+        return 1;
+    }
+    log.info(`github-actions: run_id=${result.runId} status=${result.status} conclusion=${result.conclusion ?? 'null'} html_url=${result.htmlUrl}`);
+    if (args.json !== undefined && args.json !== false) {
+        emitPrettyJson(typeof args.json === 'string' ? args.json : true, result);
+    }
+    return 0;
+}
+function resolveOwnerRepo(args) {
+    let owner = typeof args.owner === 'string' ? args.owner.trim() : '';
+    let repo = typeof args.repo === 'string' ? args.repo.trim() : '';
+    if (!owner || !repo) {
+        const fromEnv = (process.env.GITHUB_REPOSITORY || '').trim();
+        const slash = fromEnv.indexOf('/');
+        if (slash > 0) {
+            if (!owner)
+                owner = fromEnv.slice(0, slash);
+            if (!repo)
+                repo = fromEnv.slice(slash + 1);
+        }
+    }
+    if (!owner || !repo) {
+        const fallback = (process.env.VMZ_GITHUB_REPO || 'doki-land/vmz-framework').trim();
+        const slash = fallback.indexOf('/');
+        if (slash > 0) {
+            if (!owner)
+                owner = fallback.slice(0, slash);
+            if (!repo)
+                repo = fallback.slice(slash + 1);
+        }
+    }
+    return { owner, repo };
+}
+function strOrNull(v) {
+    if (typeof v !== 'string')
+        return null;
+    const t = v.trim();
+    return t ? t : null;
+}
+function parseRunId(v) {
+    if (v === undefined || v === null || v === true || v === false)
+        return null;
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? Math.trunc(n) : null;
+}
+function positiveNumber(v, fallback) {
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}

package/dist/pack-client-packages.d.ts

@@ -3,7 +3,8 @@
  *
  * Bare npm/workspace imports are legal on the author surface (01/04).
  * Browser ESM cannot resolve them. Pack materializes reachable package
- * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths.
+ * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths
+ * via oxc AST (N-API `rewriteModuleSpecifiers`) — no import-text regex.
  *
  * Not full oxc chunk-split/minify (`oxc-pending` remains for release minify).
  */
@@ -25,5 +26,6 @@ export declare function packClientBareImports(outDir: string, opts?: PackClientB
 };
 /** @param {string} js */
 export declare function collectBareSpecs(js: any): unknown[];
-export declare function rewriteRelativeTsSpecs(js: any): any;
+/** oxc AST module specifier rewrite (`.ts`→`.js` + optional exact map). */
+export declare function rewriteRelativeTsSpecs(js: any, exactMap?: any): any;
 export {};

package/dist/pack-client-packages.js

@@ -3,7 +3,8 @@
  *
  * Bare npm/workspace imports are legal on the author surface (01/04).
  * Browser ESM cannot resolve them. Pack materializes reachable package
- * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths.
+ * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths
+ * via oxc AST (N-API `rewriteModuleSpecifiers`) — no import-text regex.
  *
  * Not full oxc chunk-split/minify (`oxc-pending` remains for release minify).
  */
@@ -11,6 +12,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSy
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { resolvePackageRoot } from './packages.js';
+import { requireNativeAddon } from './native-addon.js';
 const VENDOR_DIR = 'vendor';
 const SKIP_PREFIXES = ['node:', 'nodejs:', 'cloudflare:', 'data:', 'http:', 'https:', 'vmz:', '#'];
 export function packClientBareImports(outDir, opts = {}) {
@@ -327,16 +329,22 @@ function transpileTs(source, filename) {
     }
 }
 function rewriteTsExt(p) {
+    // Path basename only (output layout) — not ESM source rewrite.
     return String(p)
         .replace(/\.tsx$/i, '.js')
         .replace(/\.ts$/i, '.js');
 }
-export function rewriteRelativeTsSpecs(js) {
-    return js
-        .replace(/(from\s+['"])(\.[^'"]+)\.tsx(['"])/g, '$1$2.js$3')
-        .replace(/(from\s+['"])(\.[^'"]+)\.ts(['"])/g, '$1$2.js$3')
-        .replace(/(import\s*\(\s*['"])(\.[^'"]+)\.tsx(['"]\s*\))/g, '$1$2.js$3')
-        .replace(/(import\s*\(\s*['"])(\.[^'"]+)\.ts(['"]\s*\))/g, '$1$2.js$3');
+/** oxc AST module specifier rewrite (`.ts`→`.js` + optional exact map). */
+export function rewriteRelativeTsSpecs(js, exactMap = null) {
+    const native = requireNativeAddon();
+    if (typeof native.rewriteModuleSpecifiers !== 'function') {
+        throw new Error('native missing rewriteModuleSpecifiers — run `pnpm napi:build`');
+    }
+    const rules = {
+        tsExtToJs: true,
+        exact: exactMap && typeof exactMap === 'object' ? exactMap : {},
+    };
+    return native.rewriteModuleSpecifiers(String(js ?? ''), JSON.stringify(rules));
 }
 function resolveRelativeSource(fromDir, rel) {
     const cleaned = rel.replace(/\?.*$/, '').replace(/#.*$/, '');
@@ -361,33 +369,15 @@ function resolveRelativeSource(fromDir, rel) {
     return null;
 }
 function rewriteBareImports(js, fromFile, bareToVendor) {
-    const toRel = (spec) => {
-        const dest = bareToVendor.get(spec);
-        if (!dest)
-            return null;
+    /** @type {Record<string, string>} */
+    const exact = {};
+    for (const [spec, dest] of bareToVendor.entries()) {
+        if (isRelativeOrAbsolute(spec) || shouldSkipBare(spec))
+            continue;
         let rel = path.relative(path.dirname(fromFile), dest).replace(/\\/g, '/');
         if (!rel.startsWith('.'))
             rel = `./${rel}`;
-        return rel;
-    };
-    let out = js;
-    out = out.replace(/\bimport\s*\(\s*(['"])([^'"]+)\1\s*\)/g, (full, quote, spec) => {
-        if (isRelativeOrAbsolute(spec) || shouldSkipBare(spec))
-            return full;
-        const rel = toRel(spec);
-        return rel ? `import(${quote}${rel}${quote})` : full;
-    });
-    out = out.replace(/\bfrom\s+(['"])([^'"]+)\1/g, (full, quote, spec) => {
-        if (isRelativeOrAbsolute(spec) || shouldSkipBare(spec))
-            return full;
-        const rel = toRel(spec);
-        return rel ? `from ${quote}${rel}${quote}` : full;
-    });
-    out = out.replace(/\bimport\s+(['"])([^'"]+)\1/g, (full, quote, spec) => {
-        if (isRelativeOrAbsolute(spec) || shouldSkipBare(spec))
-            return full;
-        const rel = toRel(spec);
-        return rel ? `import ${quote}${rel}${quote}` : full;
-    });
-    return out;
+        exact[spec] = rel;
+    }
+    return rewriteRelativeTsSpecs(js, exact);
 }

package/dist/static-emit.js

@@ -10,7 +10,7 @@ import { createRenderHost } from '@vmz/core/render-host';
 import { resolveRouteLayoutChain } from '@vmz/core/route-layout-chain';
 import { listClientComponentsSync } from '@vmz/core/component-registry';
 import { emitCdnPolicy } from './cdn-policy.js';
-import { emitContentAddressedAssets } from './content-addressed-assets.js';
+import { emitContentAddressedAssets, hashedAssetHref } from './content-addressed-assets.js';
 import { absoluteUrl, buildLocalePageMeta, localizeBodyLinks } from './locale-router.js';
 import { requireNativeAddon } from './native-addon.js';
 import { writePrettyJsonFile } from './pretty-json.js';
@@ -33,6 +33,13 @@ export async function emitWebStatic(distDir, opts = {}) {
     const pageCatalog = listPageClientFiles(distDir);
     const generations = [];
     const skipped = [];
+    // Hash immutable assets before any HTML write so shell slots carry final URLs
+    // (no post-emit HTML split/join rewrite).
+    emitStaticClientEntries(distDir, pageCatalog);
+    const assets = emitContentAddressedAssets(distDir);
+    const cssLogical = readCssEntry(distDir);
+    const cssEntry = hashedAssetHref(assets.rewrites, cssLogical) || hashedAssetHref(assets.rewrites, 'vmz.css');
+    const moduleScriptSrc = hashedAssetHref(assets.rewrites, 'entry-client.js') || '/entry-client.js';
     for (const page of pageCatalog) {
         const pattern = page.pathPattern || patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
@@ -118,7 +125,8 @@ export async function emitWebStatic(distDir, opts = {}) {
                 layoutChain,
                 props,
                 meta: gen.meta,
-                cssEntry: readCssEntry(distDir),
+                cssEntry,
+                moduleScriptSrc,
                 headExtraHtml: faviconHead,
             });
             fs.writeFileSync(absHtml, html, 'utf8');
@@ -149,7 +157,8 @@ export async function emitWebStatic(distDir, opts = {}) {
             robots: 'noindex,nofollow',
             lang: 'en',
         },
-        cssEntry: readCssEntry(distDir),
+        cssEntry,
+        moduleScriptSrc: '',
         isErrorDocument: true,
         headExtraHtml: faviconHead,
     });
@@ -208,22 +217,16 @@ export async function emitWebStatic(distDir, opts = {}) {
             fileCount: publicAssets.fileCount ?? 0,
             source: 'source' in publicAssets && typeof publicAssets.source === 'string' ? publicAssets.source : null,
         },
+        contentAddressedAssets: {
+            schema: assets.manifest.schema,
+            manifestDigest: assets.manifest.manifestDigest,
+            objectCount: assets.manifest.objectCount,
+            layout: assets.manifest.layout,
+        },
     };
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
     writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
-    emitStaticClientEntries(distDir, pageCatalog);
-    const assets = emitContentAddressedAssets(distDir);
-    manifest.contentAddressedAssets = {
-        schema: assets.manifest.schema,
-        manifestDigest: assets.manifest.manifestDigest,
-        objectCount: assets.manifest.objectCount,
-        layout: assets.manifest.layout,
-    };
-    // Re-stamp static manifest after linking asset digest (HTML already rewritten on disk).
-    delete manifest.manifestDigest;
-    manifest.manifestDigest = sha256Hex(canonicalJson(manifest));
-    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
     const cdn = emitCdnPolicy(distDir, manifest);
     return {
         manifest,
@@ -463,6 +466,7 @@ function readCssEntry(distDir) {
  *   props: Record<string, unknown>,
  *   meta: { title: string, description: string, canonical: string, robots: string, lang: string, dir?: string, alternates?: Array<{ hreflang: string, href: string }> },
  *   cssEntry: string | null,
+ *   moduleScriptSrc?: string,
  *   isErrorDocument?: boolean,
  *   headExtraHtml?: string,
  * }} input
@@ -493,6 +497,7 @@ function wrapDocument(input) {
         ...(input.cssEntry ? { cssEntry: String(input.cssEntry) } : {}),
         isErrorDocument: !!input.isErrorDocument,
         ...(input.headExtraHtml ? { headExtraHtml: String(input.headExtraHtml) } : {}),
+        ...(input.moduleScriptSrc !== undefined ? { moduleScriptSrc: String(input.moduleScriptSrc) } : {}),
     });
 }
 /**

package/locales/en-US/cli.json

@@ -43,6 +43,7 @@
     "cli.cmd.refactor": "DX rename plans / apply",
     "cli.cmd.refactor.rename": "Plan or apply a workspace rename",
     "cli.cmd.explain": "DX causal explain",
+    "cli.cmd.github-actions": "Monitor GitHub Actions via Rust octocrab (status|wait)",
     "cli.cmd.plan": "Dump frozen Rust plans via N-API",
     "cli.cmd.plan.locale": "LocalePlan from locales/",
     "cli.cmd.plan.document-route": "DocumentRoutePlan from documents/",
@@ -83,7 +84,20 @@
     "cli.opt.apply": "Apply workspace edit plan",
     "cli.opt.explain": "Include rename explain chain",
     "cli.opt.explain.target": "Generic Workspace.explain target",
+    "cli.opt.gha.mode": "status (one-shot) or wait (poll until completed)",
+    "cli.opt.gha.workflow": "Workflow file name (e.g. ci.yml) or numeric id",
+    "cli.opt.gha.run-id": "Watch a specific workflow run id",
+    "cli.opt.gha.ref": "Commit SHA filter (head_sha)",
+    "cli.opt.gha.branch": "Branch name filter",
+    "cli.opt.gha.owner": "Repository owner (default GITHUB_REPOSITORY)",
+    "cli.opt.gha.repo": "Repository name (default GITHUB_REPOSITORY)",
+    "cli.opt.gha.token": "GitHub token (default GITHUB_TOKEN / GH_TOKEN)",
+    "cli.opt.gha.timeout-minutes": "Max wait minutes for mode=wait",
+    "cli.opt.gha.interval-seconds": "Poll interval seconds for mode=wait",
+    "cli.opt.gha.required-conclusion": "Required conclusion when mode=wait (default success)",
     "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.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/locales/en-US/diag.json

@@ -2,7 +2,6 @@
     "diag.message": "{message}",
     "diag.detail": "{detail}",
 
-    "vmz::template::jsx_rejected": "JSX / single-brace expressions are rejected in `<template>`: {detail}",
     "vmz::template::illegal_directive": "Illegal or unsupported directive in `<template>`: {detail}",
     "vmz::template::parse_failed": "Failed to parse `<template>`: {detail}",
     "vmz::template::invalid_expr": "Invalid template expression: {detail}",

package/locales/zh-CN/diag.json

@@ -2,7 +2,6 @@
     "diag.message": "{message}",
     "diag.detail": "{detail}",
 
-    "vmz::template::jsx_rejected": "`<template>` 拒绝 JSX / 单花括号表达式：{detail}",
     "vmz::template::illegal_directive": "`<template>` 中存在非法或不支持的指令：{detail}",
     "vmz::template::parse_failed": "解析 `<template>` 失败：{detail}",
     "vmz::template::invalid_expr": "模板表达式无效：{detail}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "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.1.22",
-    "@vmz/core": "0.1.22",
-    "@vmz/diagnostic": "0.1.22",
-    "@vmz/plugin": "0.1.22",
-    "@vmz/protocol": "0.1.22",
+    "@vmz/commander": "0.1.24",
+    "@vmz/core": "0.1.24",
+    "@vmz/diagnostic": "0.1.24",
+    "@vmz/plugin": "0.1.24",
+    "@vmz/protocol": "0.1.24",
     "jiti": "^2.6.1"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.22",
-    "@vmz/test": "0.1.22",
+    "@vmz/plugin-markdown-it": "0.1.24",
+    "@vmz/test": "0.1.24",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -92,12 +92,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.22",
-    "@vmz/vmz-win32-arm64": "0.1.22",
-    "@vmz/vmz-darwin-x64": "0.1.22",
-    "@vmz/vmz-darwin-arm64": "0.1.22",
-    "@vmz/vmz-linux-x64": "0.1.22",
-    "@vmz/vmz-linux-arm64": "0.1.22"
+    "@vmz/vmz-win32-x64": "0.1.24",
+    "@vmz/vmz-win32-arm64": "0.1.24",
+    "@vmz/vmz-darwin-x64": "0.1.24",
+    "@vmz/vmz-darwin-arm64": "0.1.24",
+    "@vmz/vmz-linux-x64": "0.1.24",
+    "@vmz/vmz-linux-arm64": "0.1.24"
   },
   "publishConfig": {
     "access": "public"