@vmz/vmz 0.3.12 → 0.3.14

package/dist/document/document-enrich.js

@@ -230,3 +230,58 @@ function normalizePageKey(pageKey) {
 function escapeRe(s) {
     return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Author link → route-form href for emitted pages (document layer link form:
+ * `/d/<locale>/<pageKey>` without `.html`, matching application routes).
+ *
+ * Returns `null` for links that must stay as-authored: external/mailto, API
+ * refs, pure anchors, absolute application routes outside the document mount,
+ * and unresolvable relatives (the check pass reports those as broken).
+ */
+export function routeHrefForDocLink(href, fromPageKey, locale, routeBase, pageKeySet, routing = {}) {
+    const raw = String(href || '').trim();
+    if (!raw)
+        return null;
+    if (raw.startsWith('#'))
+        return null;
+    if (/^(mailto:|https?:\/\/)/i.test(raw))
+        return null;
+    if (raw.startsWith('vmz-api:') || raw.startsWith('api:'))
+        return null;
+    // Split anchor first; both branches reattach it.
+    let pathPart = raw;
+    let anchor = '';
+    const hash = raw.indexOf('#');
+    if (hash >= 0) {
+        pathPart = raw.slice(0, hash);
+        anchor = raw.slice(hash);
+    }
+    if (pathPart.startsWith('/')) {
+        // Absolute: normalize only when it lands on a known document page.
+        const want = pathPart.replace(/\/$/, '') || '/';
+        for (const [loc, keys] of pageKeySet) {
+            for (const pk of keys) {
+                const r = pageRoute(routeBase, loc, pk, routing).replace(/\/$/, '');
+                if (r === want)
+                    return r + anchor;
+            }
+        }
+        return null;
+    }
+    // Relative author link (usually `./x.md` / `../y/z.md`): resolve to PageKey.
+    const cleaned = pathPart.replace(/\.md$/i, '').replace(/\\/g, '/');
+    const fromDir = pageKeyDir(fromPageKey);
+    const joined = path.posix.normalize(path.posix.join(fromDir || '.', cleaned));
+    let pk = joined === '.' || joined === '' ? 'index' : joined.replace(/^\.\//, '');
+    pk = normalizePageKey(pk);
+    const keys = pageKeySet.get(locale) || new Set();
+    if (!keys.has(pk)) {
+        const indexJoined = path.posix.normalize(path.posix.join(fromPageKey || '.', cleaned));
+        const indexPk = normalizePageKey(indexJoined.replace(/^\.\//, ''));
+        if (keys.has(indexPk))
+            pk = indexPk;
+        else
+            return null;
+    }
+    return pageRoute(routeBase, locale, pk, routing) + anchor;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Document code highlight — wire `engines.code` (author surface) into the
+ * markdown pipeline. Shiki is prewarmed once per build; fences render static
+ * highlighted HTML through markdown-it's `highlight` callback (inline spans,
+ * the document chrome owns the `<pre>` surface).
+ *
+ * No `engines.code` (or the plugin missing) means honest plain `<pre><code>` —
+ * never an error, never a fake colored block.
+ */
+import { type DocumentDiagnostic } from './document-schema.js';
+export interface DocumentCodeHighlighter {
+    /** Sync inline highlight for one fence body. '' → renderer falls back to escaped code. */
+    highlightFenceInline(code: string, lang: string): string;
+}
+export interface ResolveDocumentHighlighterOpts {
+    /** `engines.code` from the project plugin host (`'shiki'` supported). */
+    code?: string | null;
+    /** Themes to prewarm (defaults to the plugin default theme). */
+    themes?: string[];
+}
+/**
+ * Resolve the build-time code highlighter. `null` engine → `null` highlighter
+ * (plain fences). Unknown engine → an explicit diagnostic (no silent fallback
+ * to a different engine).
+ */
+export declare function resolveDocumentCodeHighlighter(opts: ResolveDocumentHighlighterOpts, diagnostics: DocumentDiagnostic[]): Promise<DocumentCodeHighlighter | null>;

package/dist/document/document-highlight.js

@@ -0,0 +1,54 @@
+/**
+ * Document code highlight — wire `engines.code` (author surface) into the
+ * markdown pipeline. Shiki is prewarmed once per build; fences render static
+ * highlighted HTML through markdown-it's `highlight` callback (inline spans,
+ * the document chrome owns the `<pre>` surface).
+ *
+ * No `engines.code` (or the plugin missing) means honest plain `<pre><code>` —
+ * never an error, never a fake colored block.
+ */
+import { DIAG } from './document-schema.js';
+const SUPPORTED_CODE_ENGINES = new Set(['shiki']);
+/**
+ * Resolve the build-time code highlighter. `null` engine → `null` highlighter
+ * (plain fences). Unknown engine → an explicit diagnostic (no silent fallback
+ * to a different engine).
+ */
+export async function resolveDocumentCodeHighlighter(opts, diagnostics) {
+    const engine = typeof opts.code === 'string' ? opts.code.trim() : '';
+    if (!engine)
+        return null;
+    if (!SUPPORTED_CODE_ENGINES.has(engine)) {
+        diagnostics.push({
+            code: DIAG.FENCE_UNSUPPORTED,
+            severity: 'error',
+            message: `unsupported engines.code ${JSON.stringify(engine)} (supported: ${[...SUPPORTED_CODE_ENGINES].join(', ')})`,
+        });
+        return null;
+    }
+    let runtime;
+    try {
+        runtime = await import('@vmz/plugin-shiki/runtime');
+    }
+    catch {
+        diagnostics.push({
+            code: DIAG.FENCE_UNSUPPORTED,
+            severity: 'error',
+            message: 'engines.code "shiki" needs `@vmz/plugin-shiki` (optional peer of `@vmz/vmz`).\n' +
+                '  Install:  pnpm add -D @vmz/plugin-shiki',
+        });
+        return null;
+    }
+    try {
+        await runtime.prewarmShiki(opts.themes?.length ? { themes: opts.themes } : {});
+    }
+    catch {
+        // Bootstrap failure must not fail the build: fences degrade to plain code.
+        return {
+            highlightFenceInline: () => '',
+        };
+    }
+    return {
+        highlightFenceInline: (code, lang) => runtime.highlightInline(code, lang),
+    };
+}

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

@@ -7,6 +7,11 @@ export interface BuildIntegratedDocumentsOpts {
     projectRoot: string;
     outDir: string;
     strict?: boolean;
+    /** Project plugin host engines (`engines.code` wires build-time fence highlight). */
+    engines?: {
+        markdown?: string;
+        code?: string;
+    };
 }
 export interface BuildIntegratedDocumentsResult {
     ok: boolean;

package/dist/document/document-integrate.js

@@ -41,6 +41,7 @@ export async function buildIntegratedDocuments(opts) {
             outDir,
             appDistDir: outDir,
             strict: Boolean(opts.strict),
+            engines: opts.engines,
         });
         if (!result.ok) {
             const errs = (result.manifest?.diagnostics || []).filter((d) => d.severity === 'error');

package/dist/document/document-interactive.js

@@ -182,15 +182,23 @@ export function collectFenceBodies(analyzedByPageId, pages) {
 /** Render SSR island shells (no script — resume later). */
 export function renderIslandShellsHtml(opts) {
     const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const zh = opts.locale.toLowerCase().startsWith('zh');
+    const label = zh ? '搜索文档' : 'Search docs';
+    const hint = zh ? '搜索需要 JavaScript；无脚本时请使用导航。' : 'Search needs JavaScript; use the navigation without it.';
+    // Static form skeleton: readable without JS; `assets/vmz-document.js`
+    // wires it to the search index (framework-owned enhancement module).
     const search = `
   <div
     data-vmz-island="DocumentSearch"
     data-vmz-resume="island"
     data-vmz-search-index="${esc(opts.searchIndexHref)}"
+    class="doc-search"
     role="search"
-    aria-label="Document search"
+    aria-label="${esc(label)}"
   >
-    <p class="doc-search-fallback">Search requires Island resume; use navigation without JavaScript.</p>
+    <input type="search" class="doc-search__input" placeholder="${esc(label)}" aria-label="${esc(label)}" autocomplete="off" aria-expanded="false" />
+    <ol class="doc-search__results" role="listbox" hidden></ol>
+    <p class="doc-search__hint">${esc(hint)}</p>
   </div>`;
     const playgrounds = (opts.islands?.islands || [])
         .filter((isl) => isl.kind === 'playground' && isl.fence?.locale === opts.locale && isl.fence?.pageKey === opts.pageKey)

package/dist/document/document-layout-render.js

@@ -6,6 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createRenderHost } from '@vmz/core/render-host';
+import { packNodeEntryFile } from '../workspace/pack.js';
 export function resolveDocumentLayoutChunkId(distDir) {
     for (const chunkId of ['layouts/DocumentLayout', 'components/DocumentLayout']) {
         if (fs.existsSync(path.join(distDir, `${chunkId}.client.js`)))
@@ -46,8 +47,11 @@ export function assertCompiledShellHtml(html) {
     }
 }
 async function loadCtor(distDir, chunkId) {
-    const href = pathToFileURL(path.join(distDir, `${chunkId}.client.js`)).href;
-    const mod = await import(`${href}?t=${Date.now()}`);
+    // Node chunk identity comes from `_vmz/pack-node-manifest.json`; the
+    // unpacked root `${chunkId}.client.js` is not a fallback. No `?t=` cache
+    // bust: packed chunks are shared instance URLs.
+    const href = pathToFileURL(packNodeEntryFile(distDir, chunkId)).href;
+    const mod = await import(href);
     return mod.default;
 }
 export async function renderCompiledDocumentLayout(distDir, localeId, slotHtml) {

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

@@ -139,7 +139,12 @@ export interface DocumentBuildMeta {
     engine?: string;
     outDir?: string;
     designs?: string | null;
+    /** Site token stylesheet href (`assets/vmz-designs.css`), null when none. */
     designsCss?: string | null;
+    /** Framework document base stylesheet href (`assets/vmz-document.css`). */
+    documentCss?: string | null;
+    /** Framework client enhancement href (`assets/vmz-document.js`). */
+    clientJs?: string | null;
     hostShell?: string;
     pages?: Array<{
         route: string;

package/dist/workspace/build-assemble.js

@@ -9,7 +9,7 @@ import { emitEmbeddedPackaging } from './embedded-packaging.js';
 import { emitSiteDelivery } from './site-delivery.js';
 import { emitSiteFavicon } from './site-favicon.js';
 import { emitPublicStaticAssets } from './public-static-assets.js';
-import { emitWebStatic } from './static-emit.js';
+import { emitWebStatic, pruneWebStaticDelivery } from './static-emit.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 export const BUILD_PROOF_SCHEMA = 'vmz.build.proof.v0';
 export const ASSEMBLE_MANIFEST_SCHEMA = 'vmz.assemble.manifest.v0';
@@ -24,10 +24,11 @@ export async function assembleDelivery(outDir, ctx) {
         serverRuntime: selection.serverRuntime || null,
         steps: [],
     };
-    if (assembly === 'web-static' || assembly === 'cdn+server') {
+    if (assembly === 'web-static' || assembly === 'cdn+server' || assembly === 'local-static') {
         const staticResult = await emitWebStatic(outDir, {
             origin: ctx.origin,
             projectRoot: ctx.projectRoot,
+            deliveryProfile: assembly === 'local-static' ? 'local-static' : undefined,
         });
         result.steps.push({
             kind: 'web-static',
@@ -40,9 +41,20 @@ export async function assembleDelivery(outDir, ctx) {
             htmlFiles: staticResult.htmlFiles,
             skipped: staticResult.skipped,
         };
+        if (assembly === 'web-static') {
+            // Final browser set only: Node-only host material and unpacked module JS
+            // superseded by `_vmz/pack/` chunks are stripped after HTML emit.
+            const pruned = pruneWebStaticDelivery(outDir);
+            result.steps.push({
+                kind: 'web-static-prune',
+                status: 'pruned',
+                note: `removed=${pruned.removed} faces=${pruned.keptFaces.length}`,
+            });
+        }
     }
-    else if (assembly === 'server-host' || assembly === 'local-static') {
-        // SSR / local packs: favicon + opaque public/ for serve-host.
+    else if (assembly === 'server-host') {
+        // SSR host: favicon + opaque public/ (local-static shares the static
+        // document emit above, so it no longer joins this branch).
         emitSiteFavicon(outDir, { projectRoot: ctx.projectRoot });
         emitPublicStaticAssets(outDir, { projectRoot: ctx.projectRoot });
     }
@@ -50,7 +62,7 @@ export async function assembleDelivery(outDir, ctx) {
         result.steps.push({
             kind: 'local-static',
             status: 'modules-ready',
-            note: 'client modules packed; no ServerArtifact',
+            note: 'entry HTML emitted; full module tree kept for local embed (no prune, no ServerArtifact)',
         });
     }
     if (assembly === 'server-host' || assembly === 'cdn+server') {
@@ -174,7 +186,7 @@ export function emitBuildProof(outDir, ctx) {
             slots[id] = {
                 status: packCtx?.packDigest ? 'pack-digest' : 'pending',
                 detail: packCtx?.packDigest
-                    ? `pack=${String(packCtx.packDigest).slice(0, 12)} units=${packCtx.unitCount ?? '?'}`
+                    ? `pack=${String(packCtx.packDigest).slice(0, 12)} chunks=${packCtx.chunkCount ?? '?'}`
                     : 'pack missing',
             };
         }

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

@@ -1,10 +1,12 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
  * 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.
+ * `cssEntry` at shell emit time — this module does **not** post-rewrite HTML.
+ * CSS aggregators rewrite `@import` before hash.
+ *
+ * Browser JS is NOT handled here: `vmz-pack` emits the final content-hashed
+ * chunk set under `_vmz/pack/` and the pack manifest `entryFiles` is the only
+ * logical→physical mapping. This layer only covers non-packed static assets.
  */
 export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
 export declare const ASSET_PLAN_SCHEMA = "vmz.asset.plan.v0";
@@ -33,19 +35,6 @@ interface EmitContentAddressedAssetsOpts {
  * @param {Record<string, string>} rewrites logical (no leading slash) or `/logical` → `assets/hash.ext`
  */
 export declare function rewriteCssImports(cssText: any, rewrites: any): any;
-/**
- * Rewrite relative ESM so a file served from `/assets/<hash>.js` resolves against
- * dist root (static `from "./x"` / `export * from "./x"` + dynamic `import("./"+…)`).
- *
- * Always use `../…` (Fix A). Do **not** prefer hashed siblings under `assets/`:
- * barrels like `vmz-dom.js` (`export * from './dom-core.js'`) would then resolve
- * as `/assets/dom-core.js` and 404. `rewrites` is accepted for API parity with CSS
- * but intentionally ignored for JS path choice.
- *
- * @param {string} jsText
- * @param {Record<string, string>} [_rewrites]
- */
-export declare function rewriteJsEntryRelativeImports(jsText: any, _rewrites?: {}): string;
 /**
  * Emit `assets/<sha256>.<ext>` copies and return logical→hashed rewrites.
  * Callers must pass hashed URLs into `generatePageShell` — HTML is never rewritten here.

package/dist/workspace/content-addressed-assets.js

@@ -1,10 +1,12 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
  * 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.
+ * `cssEntry` at shell emit time — this module does **not** post-rewrite HTML.
+ * CSS aggregators rewrite `@import` before hash.
+ *
+ * Browser JS is NOT handled here: `vmz-pack` emits the final content-hashed
+ * chunk set under `_vmz/pack/` and the pack manifest `entryFiles` is the only
+ * logical→physical mapping. This layer only covers non-packed static assets.
  */
 import crypto from 'node:crypto';
 import fs from 'node:fs';
@@ -13,22 +15,10 @@ import { canonicalJson, sha256Hex } from './release-pack.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
 export const ASSET_PLAN_SCHEMA = 'vmz.asset.plan.v0';
-/** Immutable delivery candidates (client-facing bytes). */
-const DEFAULT_CANDIDATES = [
-    'entry-client.js',
-    'entry-event.js',
-    'vmz.css',
-    'vmz-designs.css',
-    'vmz-style.css',
-    'vmz-dom.js',
-    'vmz-runtime.js',
-    'vmz-http.js',
-    'vmz-client-nav.js',
-];
+/** Immutable delivery candidates (non-packed static bytes; browser JS is final-named by vmz-pack). */
+const DEFAULT_CANDIDATES = ['vmz.css', 'vmz-designs.css', 'vmz-style.css'];
 /** CSS files that may @import other logical CSS; processed after leaf CSS is hashed. */
 const CSS_AGGREGATORS = new Set(['vmz.css']);
-/** JS entry shells hashed under assets/; relative ESM must be rewritten first. */
-const JS_ENTRY_AGGREGATORS = new Set(['entry-client.js', 'entry-event.js']);
 const CSS_IMPORT_RE = /@import\s*(?:url\()?['"]?(\.\/)?([^'")\s;]+)['"]?\)?/gi;
 /**
  * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
@@ -48,29 +38,6 @@ export function rewriteCssImports(cssText, rewrites) {
         return `@import"${sibling}"`;
     });
 }
-/**
- * Rewrite relative ESM so a file served from `/assets/<hash>.js` resolves against
- * dist root (static `from "./x"` / `export * from "./x"` + dynamic `import("./"+…)`).
- *
- * Always use `../…` (Fix A). Do **not** prefer hashed siblings under `assets/`:
- * barrels like `vmz-dom.js` (`export * from './dom-core.js'`) would then resolve
- * as `/assets/dom-core.js` and 404. `rewrites` is accepted for API parity with CSS
- * but intentionally ignored for JS path choice.
- *
- * @param {string} jsText
- * @param {Record<string, string>} [_rewrites]
- */
-export function rewriteJsEntryRelativeImports(jsText, _rewrites = {}) {
-    // These files are already generated JavaScript. Re-parsing them through
-    // the native module parser here creates a second parser boundary during
-    // static assembly and can re-enter the generated graph indefinitely.
-    // Restrict the rewrite to import/export module-specifier positions and
-    // keep it bounded to the source text.
-    let out = String(jsText ?? '').replace(/(\b(?:from|import)\s*)(["'])\.\/([^"'\\]+)\2/g, (_match, prefix, quote, specifier) => `${prefix}${quote}../${specifier}${quote}`);
-    out = out.replace(/import\(\s*(["'])\.\/([^"'\\]+)\1\s*\)/g, (_match, quote, specifier) => `import(${quote}../${specifier}${quote})`);
-    out = out.replace(/import\(\s*(["'])\.\/\1\s*\+/g, (_match, quote) => `import(${quote}../${quote}+`);
-    return out;
-}
 /**
  * Emit `assets/<sha256>.<ext>` copies and return logical→hashed rewrites.
  * Callers must pass hashed URLs into `generatePageShell` — HTML is never rewritten here.
@@ -97,22 +64,6 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
         candidates: ordered,
     });
     for (const rel of ordered) {
-        // Aggregators are replaced in later passes; leaf JS must rewrite ./ → ../ so a
-        // hashed barrel under assets/ never 404s on second-hop relative re-exports.
-        if (CSS_AGGREGATORS.has(rel) || JS_ENTRY_AGGREGATORS.has(rel)) {
-            ingestCandidate(abs, rel, rewrites, objects, { transform: null });
-            continue;
-        }
-        if (/\.m?js$/i.test(rel)) {
-            const src = path.join(abs, rel);
-            if (!fs.existsSync(src))
-                continue;
-            const rewritten = rewriteJsEntryRelativeImports(fs.readFileSync(src, 'utf8'), {});
-            ingestCandidate(abs, rel, rewrites, objects, {
-                transform: () => Buffer.from(rewritten, 'utf8'),
-            });
-            continue;
-        }
         ingestCandidate(abs, rel, rewrites, objects, { transform: null });
     }
     // Aggregator CSS (vmz.css) must import hashed leaf files — rewrite then hash.
@@ -130,21 +81,6 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
             transform: () => Buffer.from(rewritten, 'utf8'),
         });
     }
-    // JS entry shells: rewrite relative ESM (static + dynamic) then re-hash.
-    for (const rel of ordered) {
-        if (!JS_ENTRY_AGGREGATORS.has(rel))
-            continue;
-        const src = path.join(abs, rel);
-        if (!fs.existsSync(src))
-            continue;
-        const rewritten = rewriteJsEntryRelativeImports(fs.readFileSync(src, 'utf8'), rewrites);
-        removeLogicalObject(objects, rel);
-        delete rewrites[`/${rel}`];
-        delete rewrites[rel];
-        ingestCandidate(abs, rel, rewrites, objects, {
-            transform: () => Buffer.from(rewritten, 'utf8'),
-        });
-    }
     objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
     const manifest = {
         schema: CONTENT_ADDRESSED_ASSETS_SCHEMA,
@@ -168,20 +104,15 @@ function orderCandidates(candidates) {
     const set = new Set(candidates.map((c) => String(c).replace(/\\/g, '/').replace(/^\//, '')));
     const out = [];
     for (const name of DEFAULT_CANDIDATES) {
-        if (set.has(name) && !CSS_AGGREGATORS.has(name) && !JS_ENTRY_AGGREGATORS.has(name))
+        if (set.has(name) && !CSS_AGGREGATORS.has(name))
             out.push(name);
     }
     for (const name of [...set].sort()) {
-        if (!CSS_AGGREGATORS.has(name) && !JS_ENTRY_AGGREGATORS.has(name) && !out.includes(name)) {
+        if (!CSS_AGGREGATORS.has(name) && !out.includes(name))
             out.push(name);
-        }
     }
     if (set.has('vmz.css'))
         out.push('vmz.css');
-    for (const name of ['entry-client.js', 'entry-event.js']) {
-        if (set.has(name))
-            out.push(name);
-    }
     return out;
 }
 /**
@@ -282,24 +213,8 @@ function collectCandidates(distDir) {
         if (fs.existsSync(path.join(distDir, name)))
             out.push(name);
     }
-    walk(distDir, distDir, (rel) => {
-        if (/\.client\.js$/i.test(rel))
-            out.push(rel);
-    });
     return [...new Set(out)].sort();
 }
-function walk(root, dir, onFile) {
-    for (const name of fs.readdirSync(dir)) {
-        if (name === 'assets' || name === '_vmz' || name === 'node_modules')
-            continue;
-        const full = path.join(dir, name);
-        const st = fs.statSync(full);
-        if (st.isDirectory())
-            walk(root, full, onFile);
-        else
-            onFile(path.relative(root, full).replace(/\\/g, '/'));
-    }
-}
 /** Resolve `/logical` → hashed href from emit rewrites (`/assets/<sha>.ext`). */
 export function hashedAssetHref(rewrites, logical) {
     if (!logical)

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

@@ -21,6 +21,7 @@ function rewriteFlatDeliveryImports(text) {
         ['../browser/direct-host-box.js', './direct-host-box.js'],
         ['../browser/unknown-component.js', './unknown-component.js'],
         ['../shared/dom-attr-normalize.js', './dom-attr-normalize.js'],
+        ['../shared/html-digest.js', './html-digest.js'],
         ['../browser/client-nav.js', './vmz-client-nav.js'],
         ['../ssr/dom-ssr.js', './dom-ssr.js'],
         ['../faces/server.js', './vmz-runtime.js'],
@@ -34,6 +35,10 @@ function rewriteFlatDeliveryImports(text) {
 }
 function rewriteNestedSsrDelivery(text) {
     let out = text;
+    // `shared/` is flattened to the delivery root, so nested SSR files must
+    // reach the root copy one level up.
+    out = replaceImportPath(out, '../shared/dom-attr-normalize.js', '../dom-attr-normalize.js');
+    out = replaceImportPath(out, '../shared/html-digest.js', '../html-digest.js');
     for (const [from, to] of [
         ['../browser/dom-core.js', '../dom-core.js'],
         ['../browser/direct-host-box.js', '../direct-host-box.js'],
@@ -45,6 +50,10 @@ function rewriteNestedSsrDelivery(text) {
 }
 function rewriteNestedBrowserDelivery(text) {
     let out = replaceImportPath(text, '../../shared/dom-attr-normalize.js', '../../dom-attr-normalize.js');
+    out = replaceImportPath(out, '../../shared/html-digest.js', '../../html-digest.js');
+    // `dom-ssr.js` 只交付在根（flat barrel），nested `ssr/` 下没有它：
+    // island resume 的动态边必须指向根级产物。
+    out = replaceImportPath(out, '../../ssr/dom-ssr.js', '../../dom-ssr.js');
     for (const [from, to] of [
         ['../direct-host-box.js', '../../direct-host-box.js'],
         ['../unknown-component.js', '../../unknown-component.js'],

package/dist/workspace/native-addon.d.ts

@@ -3,6 +3,10 @@ export interface NativeAddon {
     authorJson5ToCanonicalJson?: (source: string) => string;
     loadLocalePlan?: (projectRoot: string) => string;
     loadDocumentRoutePlan?: (projectRoot: string) => string;
+    /** vmz-pack v0 contract — synchronous plan request/response over JSON strings. */
+    packPlan?: (requestJson: string) => string;
+    /** vmz-pack v0 contract — plan plus artifact write under `outDir`. */
+    packWrite?: (requestJson: string, outDir: string) => string;
     [key: string]: unknown;
 }
 /** Load the N-API addon or throw (production printers must not fall back to TS). */