@vmz/vmz 0.1.10 → 0.1.12

package/dist/content-addressed-assets.js

@@ -154,7 +154,8 @@ function ingestCandidate(absDist, rel, rewrites, objects, opts) {
     else {
         const existing = sha256Hex(fs.readFileSync(dest));
         if (existing !== digest) {
-            throw new Error(`content-address collision at ${assetRel}`);
+            // Stale assets/ from a prior partial build can reuse hash filenames with different bytes.
+            fs.writeFileSync(dest, buf);
         }
     }
     objects.push({

package/dist/dev-session.js

@@ -17,7 +17,7 @@ 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, isDependencyPath, mergeDirtySets } from './dev-watch-roots.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets } from './dev-watch-roots.js';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
 /**
  * @typedef {object} DevSessionOptions
@@ -190,6 +190,7 @@ export function createDevSession(options) {
         }
         const docsRoot = path.join(project, 'documents');
         const localesRoot = path.join(project, 'locales');
+        const designsRoot = path.join(project, 'designs');
         const watched = collectDevWatchRoots({ project, outDir });
         /** @type {string[]} */
         const watchRoots = [...watched.roots];
@@ -218,37 +219,46 @@ 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[], docsDirty: boolean, localesDirty: boolean }} */
+            /** @type {{ srcChanged: string[], srcDeleted: string[], depChanged: string[], depDeleted: string[], designsChanged: string[], designsDeleted: string[], docsDirty: boolean, localesDirty: boolean, designsDirty: boolean }} */
             const batch = {
                 srcChanged: [],
                 srcDeleted: [],
                 depChanged: [],
                 depDeleted: [],
+                designsChanged: [],
+                designsDeleted: [],
                 docsDirty: false,
                 localesDirty: false,
+                designsDirty: false,
             };
+            const watchCtx = { src, docsRoot, localesRoot, designsRoot, dependencyRoots };
             for (const root of watchRoots) {
                 const prev = fingerprints.get(root) || new Map();
                 const next = fileFingerprintMap(root);
                 const diff = diffFingerprints(prev, next);
                 if (!diff.changed.length && !diff.deleted.length)
                     continue;
-                if (root === src) {
+                const kind = classifyWatchRoot(root, watchCtx);
+                if (kind === 'src') {
                     batch.srcChanged.push(...diff.changed);
                     batch.srcDeleted.push(...diff.deleted);
                 }
-                else if (root === localesRoot) {
+                else if (kind === 'locales') {
                     batch.localesDirty = true;
                 }
-                else if (root === docsRoot) {
+                else if (kind === 'docs') {
                     batch.docsDirty = true;
                 }
-                else if (dependencyRoots.includes(root)) {
+                else if (kind === 'designs') {
+                    batch.designsDirty = true;
+                    batch.designsChanged.push(...diff.changed);
+                    batch.designsDeleted.push(...diff.deleted);
+                }
+                else if (kind === 'dep') {
                     batch.depChanged.push(...diff.changed);
                     batch.depDeleted.push(...diff.deleted);
                 }
                 else {
-                    // designs or other application roots → treat like docs (full reload)
                     batch.docsDirty = true;
                 }
             }
@@ -280,7 +290,8 @@ export function createDevSession(options) {
                 }
                 const srcDirty = batch.srcChanged.length + batch.srcDeleted.length;
                 const depDirty = batch.depChanged.length + batch.depDeleted.length;
-                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty)
+                const designsDirty = batch.designsDirty || batch.designsChanged.length + batch.designsDeleted.length;
+                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty && !designsDirty)
                     continue;
                 // Coalesce multi-file bursts without dropping the initial dirty set.
                 if (srcDirty > 1) {
@@ -329,6 +340,10 @@ export function createDevSession(options) {
                     batch.depDeleted = depMerged.deleted;
                     batch.docsDirty = batch.docsDirty || residual.docsDirty;
                     batch.localesDirty = batch.localesDirty || residual.localesDirty;
+                    batch.designsDirty = batch.designsDirty || residual.designsDirty;
+                    const designsMerged = mergeDirtySets({ changed: batch.designsChanged, deleted: batch.designsDeleted }, { changed: residual.designsChanged, deleted: residual.designsDeleted });
+                    batch.designsChanged = designsMerged.changed;
+                    batch.designsDeleted = designsMerged.deleted;
                 }
                 commitFingerprints();
                 if (!batch.srcChanged.length &&
@@ -336,7 +351,8 @@ export function createDevSession(options) {
                     !batch.depChanged.length &&
                     !batch.depDeleted.length &&
                     !batch.docsDirty &&
-                    !batch.localesDirty) {
+                    !batch.localesDirty &&
+                    !(batch.designsDirty || batch.designsChanged.length || batch.designsDeleted.length)) {
                     continue;
                 }
                 // Dependency changes: conservative full rebuild + full reload (v0.1.5).
@@ -376,7 +392,7 @@ export function createDevSession(options) {
                     log.info(kind === 'respawn' ? 'reload ok (respawned; deps)' : 'soft reload ok (full page; deps)');
                     continue;
                 }
-                let needFullReload = batch.docsDirty;
+                let needFullReload = batch.docsDirty || batch.designsDirty;
                 if (batch.srcChanged.length || batch.srcDeleted.length) {
                     log.info(`change detected (${batch.srcChanged.length} update, ${batch.srcDeleted.length} delete) — affected rebuild…`);
                     const changes = [
@@ -419,6 +435,37 @@ export function createDevSession(options) {
                                 : 'soft reload ok');
                     continue;
                 }
+                if (batch.designsChanged.length || batch.designsDeleted.length || batch.designsDirty) {
+                    log.info(`designs change detected (${batch.designsChanged.length} update, ${batch.designsDeleted.length} delete) — rebuilding styles…`);
+                    const changes = [
+                        ...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);
+                    if (!printReport(report, 'rebuild')) {
+                        log.warn('designs rebuild failed — keeping previous styles');
+                        continue;
+                    }
+                    if (batch.docsDirty || projectHasDocuments(project)) {
+                        const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                        if (!docs.ok)
+                            log.warn('document mount rebuild failed — keeping previous docs');
+                    }
+                    if (wechatPreview) {
+                        if (!packWechatPreview())
+                            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)');
+                    continue;
+                }
                 if (batch.localesDirty) {
                     log.info('locales change detected — re-emitting #locales runtime…');
                     if (!emitLocales()) {

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

@@ -59,6 +59,19 @@ export declare function collectDevWatchRoots(opts: any): {
     dependencyRoots: unknown[];
     applicationRoots: any[];
 };
+/**
+ * Classify which watch bucket a root belongs to.
+ * @param {string} root
+ * @param {{
+ *   src: string,
+ *   docsRoot: string,
+ *   localesRoot: string,
+ *   designsRoot: string,
+ *   dependencyRoots: string[],
+ * }} ctx
+ * @returns {'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'other'}
+ */
+export declare function classifyWatchRoot(root: any, ctx: any): "src" | "locales" | "docs" | "designs" | "dep" | "other";
 /**
  * Classify whether a changed file lives under a dependency watch root (not app src).
  * @param {string} file

package/dist/dev-watch-roots.js

@@ -209,6 +209,31 @@ export function collectDevWatchRoots(opts) {
     }
     return { roots, dependencyRoots, applicationRoots };
 }
+/**
+ * Classify which watch bucket a root belongs to.
+ * @param {string} root
+ * @param {{
+ *   src: string,
+ *   docsRoot: string,
+ *   localesRoot: string,
+ *   designsRoot: string,
+ *   dependencyRoots: string[],
+ * }} ctx
+ * @returns {'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'other'}
+ */
+export function classifyWatchRoot(root, ctx) {
+    if (root === ctx.src)
+        return 'src';
+    if (root === ctx.localesRoot)
+        return 'locales';
+    if (root === ctx.docsRoot)
+        return 'docs';
+    if (root === ctx.designsRoot)
+        return 'designs';
+    if ((ctx.dependencyRoots || []).includes(root))
+        return 'dep';
+    return 'other';
+}
 /**
  * Classify whether a changed file lives under a dependency watch root (not app src).
  * @param {string} file

package/dist/document-build.d.ts

@@ -1,5 +1,5 @@
 /**
- * @param {{ projectRoot: string, outDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
+ * @param {{ projectRoot: string, outDir?: string, appDistDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
  */
 export declare function buildDocuments(opts: any): Promise<{
     ok: boolean;
@@ -57,6 +57,7 @@ export declare function buildDocuments(opts: any): Promise<{
             outDir: string;
             designs: string;
             designsCss: any;
+            hostShell: string;
             pages: any[];
             evidence: string;
             search: string;

package/dist/document-build.js

@@ -9,23 +9,27 @@ import { resolveDocumentDesignsCss } from './document-designs.js';
 import { enrichDocumentContent, pageHtmlRel } from './document-enrich.js';
 import { enrichDocumentEvidence } from './document-evidence.js';
 import { artifactHrefFromHtml, buildDocumentIslands, buildDocumentSearch, collectFenceBodies, renderIslandShellsHtml, } from './document-interactive.js';
+import { assertIntegratedDistReady, renderCompiledDocumentLayout } from './document-layout-render.js';
 import { resolveMarkdownEngine } from './document-markdown.js';
+import { loadLocalesRouting } from './document-routing-config.js';
 import { DOCUMENT_VIEW_SCHEMA } from './document-schema.js';
 import { createWorkspace } from './index.js';
 import { requireNativeAddon } from './native-addon.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 /**
- * @param {{ projectRoot: string, outDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
+ * @param {{ projectRoot: string, outDir?: string, appDistDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
  */
 export async function buildDocuments(opts) {
     const projectRoot = path.resolve(opts.projectRoot);
     const outDir = path.resolve(opts.outDir || path.join(projectRoot, 'dist', 'documents'));
     const strict = Boolean(opts.strict);
     const manifest = checkDocuments({ projectRoot, strict });
+    const routing = loadLocalesRouting(projectRoot) || { strategy: 'prefix' };
     const engine = await resolveMarkdownEngine({ engines: opts.engines, projectRoot });
     const enriched = enrichDocumentContent(manifest, {
         analyzeMarkdown: engine.analyzeMarkdown,
         projectRoot,
+        routing,
     });
     manifest.diagnostics = enriched.diagnostics;
     const evidence = await enrichDocumentEvidence(manifest, {
@@ -60,8 +64,12 @@ export async function buildDocuments(opts) {
     });
     manifest.search = search;
     manifest.islands = islands;
-    const hostChrome = resolveHostSiteChrome(projectRoot);
-    const useHostShell = Boolean(hostChrome) && (manifest.mounts || []).some((m) => m.mode === 'integrated');
+    const integratedMount = (manifest.mounts || []).some((m) => m.mode === 'integrated');
+    const appDistDir = resolveAppDistDir(opts, outDir);
+    const useCompiledShell = Boolean(integratedMount && appDistDir);
+    if (integratedMount && appDistDir) {
+        assertIntegratedDistReady(appDistDir);
+    }
     fs.mkdirSync(outDir, { recursive: true });
     const designs = resolveDocumentDesignsCss(projectRoot);
     /** @type {string | null} */
@@ -92,6 +100,20 @@ export async function buildDocuments(opts) {
             pageKey: page.identity.pageKey,
             locale: page.identity.locale,
         });
+        const slotHtml = buildDocumentSlotHtml({
+            nav,
+            bodyHtml: info.html,
+            headings: info.headings,
+            htmlRel,
+            route: info.route,
+            routing,
+            searchShellHtml: shells.searchHtml,
+            playgroundShellHtml: shells.playgroundHtml,
+        });
+        let compiledLayoutHtml = null;
+        if (useCompiledShell) {
+            compiledLayoutHtml = await renderCompiledDocumentLayout(appDistDir, page.identity.locale, slotHtml);
+        }
         const view = {
             schema: DOCUMENT_VIEW_SCHEMA,
             pageKey: page.identity.pageKey,
@@ -105,7 +127,7 @@ export async function buildDocuments(opts) {
             designsCss: designsHref,
             noJsReadable: true,
             hydrate: 'island-only',
-            hostShell: useHostShell,
+            hostShell: useCompiledShell ? 'compiled-layout' : false,
             islands: ['DocumentSearch'].concat((islands.islands || [])
                 .filter((isl) => isl.kind === 'playground' &&
                 isl.fence?.locale === page.identity.locale &&
@@ -127,7 +149,9 @@ export async function buildDocuments(opts) {
             htmlRel,
             searchShellHtml: shells.searchHtml,
             playgroundShellHtml: shells.playgroundHtml,
-            hostChrome: useHostShell ? hostChrome : null,
+            routing,
+            compiledLayoutHtml,
+            useCompiledShell,
         });
         fs.writeFileSync(htmlAbs, html, 'utf8');
         written.push({ route: info.route, htmlPath: htmlRel, viewPath: viewRel });
@@ -143,6 +167,7 @@ export async function buildDocuments(opts) {
             outDir: path.relative(projectRoot, outDir).replace(/\\/g, '/') || '.',
             designs: designs.source,
             designsCss: designsHref,
+            hostShell: useCompiledShell ? 'compiled-layout' : 'standalone',
             pages: written,
             evidence: 'document.evidence.json',
             search: 'document.search.json',
@@ -156,25 +181,24 @@ export async function buildDocuments(opts) {
     return { ok: true, manifest: manifestOut, outDir, pages: written, search, islands };
 }
 /**
- * No-JS readable static HTML: nav + main landmarks, Island shells without scripts.
- * Integrated mounts reuse host SiteHeader/SiteFooter templates when present.
+ * @param {{ appDistDir?: string }} opts
+ * @param {string} outDir
  */
-function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, designsHref, htmlRel, searchShellHtml = '', playgroundShellHtml = '', hostChrome = null, }) {
-    const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-    const depth = htmlRel.split('/').length - 1;
-    const prefix = depth > 0 ? '../'.repeat(depth) : './';
-    /** @type {string[]} */
-    const cssHrefs = [];
-    if (hostChrome) {
-        // Integrated documents are served with pretty directory URLs. Root
-        // absolute assets remain correct for both emitted files and rewrites.
-        cssHrefs.push('/vmz.css');
+function resolveAppDistDir(opts, outDir) {
+    if (opts.appDistDir) {
+        const p = path.resolve(opts.appDistDir);
+        return fs.existsSync(path.join(p, 'vmz-dom.js')) ? p : null;
     }
-    if (designsHref)
-        cssHrefs.push(hostChrome ? `/${designsHref}` : prefix + designsHref);
+    return fs.existsSync(path.join(outDir, 'vmz-dom.js')) ? outDir : null;
+}
+/**
+ * Document main column + sidebar (injected into DocumentLayout slot).
+ */
+function buildDocumentSlotHtml({ nav, bodyHtml, headings, htmlRel, route, routing, searchShellHtml = '', playgroundShellHtml = '' }) {
+    const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
     const navItems = nav
         .map((n) => {
-        const href = relativeHref(htmlRel, n.href, route);
+        const href = routing.strategy === 'none' || routing.strategy === 'domain' ? n.href : relativeHref(htmlRel, n.href, route);
         const current = n.href === route ? ' aria-current="page"' : '';
         return `      <li><a href="${esc(href)}"${current}>${esc(n.title)}</a></li>`;
     })
@@ -189,15 +213,7 @@ function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, desig
 ${navItems}
     </ul>
   </nav>`;
-    /** @type {string} */
-    let bodyInner;
-    if (hostChrome) {
-        const header = hostChrome.header.replace(/(<a\s+href="\/d\/?")([^>]*>文档<\/a>)/, '$1 aria-current="page"$2');
-        bodyInner = `  <div class="site site--docs">
-  <a class="skip-link" href="#main">Skip to content</a>
-${header}
-  <div class="doc-body">
-    <aside class="doc-sidebar">
+    return `    <aside class="doc-sidebar">
 ${docsNav}
 ${searchShellHtml}
     </aside>
@@ -206,15 +222,47 @@ ${searchShellHtml}
 ${bodyHtml}
 ${playgroundShellHtml}
   </main>
-    </div>
-  </div>
-${hostChrome.footer}
-  </div>
-`;
+    </div>`;
+}
+/**
+ * No-JS readable static HTML: nav + main landmarks, Island shells without scripts.
+ * Integrated mounts wrap content in compiled DocumentLayout (SiteHeader/SiteFooter SSR).
+ */
+function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, designsHref, htmlRel, searchShellHtml = '', playgroundShellHtml = '', routing = { strategy: 'prefix' }, compiledLayoutHtml, useCompiledShell = false, }) {
+    const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const depth = htmlRel.split('/').length - 1;
+    const prefix = depth > 0 ? '../'.repeat(depth) : './';
+    /** @type {string[]} */
+    const cssHrefs = [];
+    if (useCompiledShell) {
+        cssHrefs.push('/vmz.css');
+    }
+    if (designsHref)
+        cssHrefs.push(useCompiledShell ? `/${designsHref}` : prefix + designsHref);
+    /** @type {string} */
+    let bodyInner;
+    if (useCompiledShell) {
+        bodyInner = compiledLayoutHtml;
     }
     else {
+        const navItems = nav
+            .map((n) => {
+            const href = routing.strategy === 'none' || routing.strategy === 'domain' ? n.href : relativeHref(htmlRel, n.href, route);
+            const current = n.href === route ? ' aria-current="page"' : '';
+            return `      <li><a href="${esc(href)}"${current}>${esc(n.title)}</a></li>`;
+        })
+            .join('\n');
+        const toc = headings.length > 1
+            ? `<nav aria-label="On this page" class="toc">\n    <ol>\n${headings
+                .map((h) => `      <li class="h${h.level}"><a href="#${esc(h.id)}">${esc(h.text)}</a></li>`)
+                .join('\n')}\n    </ol>\n  </nav>\n`
+            : '';
         bodyInner = `  <a class="skip-link" href="#main">Skip to content</a>
-${docsNav}
+  <nav aria-label="Documents" class="doc-subnav">
+    <ul>
+${navItems}
+    </ul>
+  </nav>
 ${searchShellHtml}
   ${toc}<main id="main">
 ${bodyHtml}
@@ -234,28 +282,6 @@ ${playgroundShellHtml}
         bodyAttrs: ['data-vmz-hydrate', 'island-only'],
     });
 }
-/**
- * Integrated DocumentMount: reuse host SiteHeader / SiteFooter .vmz templates.
- * @param {string} projectRoot
- * @returns {{ header: string, footer: string } | null}
- */
-function resolveHostSiteChrome(projectRoot) {
-    const headerPath = path.join(projectRoot, 'src', 'components', 'SiteHeader.vmz');
-    const footerPath = path.join(projectRoot, 'src', 'components', 'SiteFooter.vmz');
-    if (!fs.existsSync(headerPath) || !fs.existsSync(footerPath))
-        return null;
-    const header = extractVmzTemplateHtml(headerPath);
-    const footer = extractVmzTemplateHtml(footerPath);
-    if (!header || !footer)
-        return null;
-    return { header, footer };
-}
-/** @param {string} filePath */
-function extractVmzTemplateHtml(filePath) {
-    const src = fs.readFileSync(filePath, 'utf8');
-    const m = src.match(/<template>([\s\S]*?)<\/template>/);
-    return m ? m[1].trim() : '';
-}
 function relativeHref(fromHtmlRel, toRoute, _fromRoute) {
     const toParts = String(toRoute).replace(/^\//, '').split('/').filter(Boolean);
     let toRel;

package/dist/document-enrich.d.ts

@@ -2,8 +2,9 @@
  * @param {string} routeBase e.g. /docs
  * @param {string} locale
  * @param {string} pageKey
+ * @param {{ strategy?: string }} [routing]
  */
-export declare function pageRoute(routeBase: any, locale: any, pageKey: any): string;
+export declare function pageRoute(routeBase: any, locale: any, pageKey: any, routing?: {}): string;
 /**
  * Static file path relative to out dir (posix).
  * @param {string} routeBase

package/dist/document-enrich.js

@@ -9,10 +9,16 @@ import { DIAG } from './document-schema.js';
  * @param {string} routeBase e.g. /docs
  * @param {string} locale
  * @param {string} pageKey
+ * @param {{ strategy?: string }} [routing]
  */
-export function pageRoute(routeBase, locale, pageKey) {
+export function pageRoute(routeBase, locale, pageKey, routing = {}) {
     const base = String(routeBase || '/').replace(/\/$/, '') || '';
     const key = pageKey === 'index' ? '' : pageKey.replace(/\\/g, '/');
+    const strategy = routing.strategy || 'prefix';
+    if (strategy === 'none' || strategy === 'domain') {
+        const parts = [base.replace(/^\//, ''), key].filter((p) => p !== '');
+        return '/' + (parts.length ? parts.join('/') : '');
+    }
     const parts = [base.replace(/^\//, ''), locale, key].filter((p) => p !== '');
     return '/' + parts.join('/');
 }
@@ -35,6 +41,7 @@ export function pageHtmlRel(routeBase, locale, pageKey) {
  */
 export function enrichDocumentContent(manifest, ctx) {
     const routeBase = manifest.mounts?.[0]?.routeBase || '/docs';
+    const routing = ctx.routing || { strategy: 'prefix' };
     /** @type {Map<string, { html: string, headings: any[], links: any[], title: string, route: string, anchors: string[] }>} */
     const byId = new Map();
     /** @type {import('./document-schema.js').DocumentDiagnostic[]} */
@@ -45,7 +52,7 @@ export function enrichDocumentContent(manifest, ctx) {
         const abs = path.isAbsolute(page.sourcePath) ? page.sourcePath : path.join(manifest.root, page.sourcePath);
         const source = fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
         const analyzed = ctx.analyzeMarkdown(source);
-        const route = pageRoute(routeBase, page.identity.locale, page.identity.pageKey);
+        const route = pageRoute(routeBase, page.identity.locale, page.identity.pageKey, routing);
         const anchors = analyzed.headings.map((h) => h.id);
         const title = analyzed.headings.find((h) => h.level === 1)?.text || analyzed.headings[0]?.text || page.identity.pageKey;
         // Duplicate anchors on page
@@ -61,7 +68,11 @@ export function enrichDocumentContent(manifest, ctx) {
             }
             seen.add(id);
         }
-        if (routeOwners.has(route)) {
+        const owner = `${page.identity.locale}:${page.identity.pageKey}`;
+        if (routing.strategy === 'none' || routing.strategy === 'domain') {
+            routeOwners.set(route, owner);
+        }
+        else if (routeOwners.has(route)) {
             diagnostics.push({
                 code: DIAG.ROUTE_DUPLICATE,
                 severity: 'error',
@@ -70,7 +81,7 @@ export function enrichDocumentContent(manifest, ctx) {
             });
         }
         else {
-            routeOwners.set(route, `${page.identity.locale}:${page.identity.pageKey}`);
+            routeOwners.set(route, owner);
         }
         page.route = route;
         page.anchors = anchors;

package/dist/document-integrate.js

@@ -7,6 +7,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { buildDocuments } from './document-build.js';
 import { resolveDocumentsRoot } from './document-check.js';
+import { loadLocalesRouting } from './document-routing-config.js';
+import { pageHtmlRel } from './document-enrich.js';
 import { log } from './log.js';
 import { requireNativeAddon } from './native-addon.js';
 /**
@@ -31,6 +33,7 @@ export async function buildIntegratedDocuments(opts) {
         const result = await buildDocuments({
             projectRoot,
             outDir,
+            appDistDir: outDir,
             strict: Boolean(opts.strict),
         });
         if (!result.ok) {
@@ -40,7 +43,7 @@ export async function buildIntegratedDocuments(opts) {
             }
             return { ok: false, error: 'document diagnostics', pages: 0 };
         }
-        writeMountRootRedirects(result.manifest, outDir);
+        writeMountRootRedirects(result.manifest, outDir, projectRoot);
         log.info(`document mount: pages=${result.pages.length} → ${path.relative(process.cwd(), outDir) || '.'}`);
         return { ok: true, pages: result.pages.length };
     }
@@ -51,22 +54,34 @@ export async function buildIntegratedDocuments(opts) {
     }
 }
 /**
- * Emit `{routeBase}/index.html` → defaultLocale landing (for /d/ and /docs/).
+ * Emit `{routeBase}/index.html` for integrated mounts.
+ * `routing.strategy: none` → copy default-locale docs index (LocaleId is Host state).
+ * prefix strategy → redirect HTML to `{routeBase}/{defaultLocale}/`.
  * @param {import('./document-schema.js').DocumentManifest} manifest
  * @param {string} outDir
+ * @param {string} projectRoot
  */
-function writeMountRootRedirects(manifest, outDir) {
+function writeMountRootRedirects(manifest, outDir, projectRoot) {
     const defaultLocale = manifest.defaultLocale || manifest.locales?.[0];
     if (!defaultLocale)
         return;
+    const routing = loadLocalesRouting(projectRoot) || { strategy: 'prefix' };
     for (const mount of manifest.mounts || []) {
         if (!mount?.routeBase || mount.routeBase === '/')
             continue;
         const base = String(mount.routeBase).replace(/\/$/, '');
-        const target = `${base}/${defaultLocale}/`;
         const relDir = base.replace(/^\//, '');
         const abs = path.join(outDir, relDir, 'index.html');
         fs.mkdirSync(path.dirname(abs), { recursive: true });
+        if (routing.strategy === 'none' || routing.strategy === 'domain') {
+            const srcRel = pageHtmlRel(base, defaultLocale, 'index');
+            const srcAbs = path.join(outDir, srcRel);
+            if (fs.existsSync(srcAbs)) {
+                fs.copyFileSync(srcAbs, abs);
+            }
+            continue;
+        }
+        const target = `${base}/${defaultLocale}/`;
         const native = requireNativeAddon();
         if (typeof native.generateRedirectHtml !== 'function') {
             throw new Error('vmz native addon missing generateRedirectHtml — rebuild with `pnpm napi:build`');

package/dist/document-layout-render.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Integrated DocumentMount — compile host chrome via DocumentLayout + createRenderHost.
+ * Replaces the removed regex template lowering in document-host-chrome.ts.
+ */
+/** @param {string} distDir */
+export declare function resolveDocumentLayoutChunkId(distDir: any): string;
+/**
+ * @param {string} distDir
+ */
+export declare function assertIntegratedDistReady(distDir: any): string;
+/**
+ * @param {string} html
+ */
+export declare function assertCompiledShellHtml(html: any): void;
+/**
+ * @param {string} distDir
+ * @param {string} localeId
+ * @param {string} slotHtml
+ */
+export declare function renderCompiledDocumentLayout(distDir: any, localeId: any, slotHtml: any): Promise<any>;

package/dist/document-layout-render.js

@@ -0,0 +1,87 @@
+// @ts-nocheck
+/**
+ * Integrated DocumentMount — compile host chrome via DocumentLayout + createRenderHost.
+ * Replaces the removed regex template lowering in document-host-chrome.ts.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRenderHost } from '@vmz/core/render-host';
+/** @param {string} distDir */
+export function resolveDocumentLayoutChunkId(distDir) {
+    for (const chunkId of ['layouts/DocumentLayout', 'components/DocumentLayout']) {
+        if (fs.existsSync(path.join(distDir, `${chunkId}.client.js`)))
+            return chunkId;
+    }
+    return null;
+}
+/**
+ * @param {string} distDir
+ */
+export function assertIntegratedDistReady(distDir) {
+    const dom = path.join(distDir, 'vmz-dom.js');
+    if (!fs.existsSync(dom)) {
+        throw new Error('integrated document mount requires vmz build output (vmz-dom.js in app dist). Run `vmz build` before document emit.');
+    }
+    const chunkId = resolveDocumentLayoutChunkId(distDir);
+    if (!chunkId) {
+        throw new Error('integrated document mount requires compiled DocumentLayout (add src/layouts/DocumentLayout.vmz and rebuild)');
+    }
+    return chunkId;
+}
+/**
+ * @param {string} html
+ */
+export function assertCompiledShellHtml(html) {
+    const header = html.match(/<header[^>]*data-vmz-fixture="site-header"[\s\S]*?<\/header>/i)?.[0] ?? '';
+    const footer = html.match(/<footer[^>]*data-vmz-fixture="site-footer"[\s\S]*?<\/footer>/i)?.[0] ?? '';
+    for (const part of [header, footer]) {
+        const leak = part.match(/\{[A-Za-z][A-Za-z0-9]*\}/);
+        if (leak) {
+            throw new Error(`document layout SSR leaked binding placeholder ${leak[0]}`);
+        }
+        if (/<(?:Link|Button|Icon)\b/.test(part)) {
+            throw new Error('document layout SSR leaked uncompiled VMZ component tag in chrome');
+        }
+    }
+    if (!header || !footer) {
+        throw new Error('document layout SSR missing compiled SiteHeader/SiteFooter fixtures');
+    }
+}
+/**
+ * @param {string} distDir
+ * @param {string} chunkId
+ */
+async function loadCtor(distDir, chunkId) {
+    const href = pathToFileURL(path.join(distDir, `${chunkId}.client.js`)).href;
+    const mod = await import(`${href}?t=${Date.now()}`);
+    return mod.default;
+}
+/**
+ * @param {string} distDir
+ * @param {string} localeId
+ * @param {string} slotHtml
+ */
+export async function renderCompiledDocumentLayout(distDir, localeId, slotHtml) {
+    const chunkId = assertIntegratedDistReady(distDir);
+    const prevHint = globalThis.__vmzLocaleIdHint;
+    globalThis.__vmzLocaleIdHint = localeId;
+    try {
+        if (typeof globalThis.document !== 'undefined' && globalThis.document?.documentElement) {
+            globalThis.document.documentElement.setAttribute('data-locale', localeId);
+            globalThis.document.documentElement.setAttribute('lang', localeId);
+        }
+        const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
+        await host.ensureComponents([chunkId]);
+        const Layout = await loadCtor(distDir, chunkId);
+        const html = await host.renderToString(Layout, {}, { slotHtml });
+        assertCompiledShellHtml(html);
+        return html;
+    }
+    finally {
+        if (prevHint === undefined)
+            delete globalThis.__vmzLocaleIdHint;
+        else
+            globalThis.__vmzLocaleIdHint = prevHint;
+    }
+}

package/dist/document-routing-config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Project locale routing config for document mount (locales/locales.json5).
+ */
+/**
+ * @param {string} projectRoot
+ * @returns {{ strategy?: string, defaultLocale?: string } | null}
+ */
+export declare function loadLocalesRouting(projectRoot: any): any;
+/**
+ * @param {string} routeBase
+ * @param {string} pageKey
+ */
+export declare function docsRouteNone(routeBase: any, pageKey: any): string;

package/dist/document-routing-config.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+/**
+ * Project locale routing config for document mount (locales/locales.json5).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * @param {string} projectRoot
+ * @returns {{ strategy?: string, defaultLocale?: string } | null}
+ */
+export function loadLocalesRouting(projectRoot) {
+    const p = path.join(projectRoot, 'locales', 'locales.json5');
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const raw = fs.readFileSync(p, 'utf8');
+        let s = raw.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+        const m = s.match(/routing\s*:\s*\{([\s\S]*?)\}/);
+        if (!m)
+            return null;
+        let block = `{${m[1]}}`;
+        block = block.replace(/([,{]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
+        block = block.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_, inner) => JSON.stringify(inner));
+        block = block.replace(/,\s*([}\]])/g, '$1');
+        return JSON.parse(block);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @param {string} routeBase
+ * @param {string} pageKey
+ */
+export function docsRouteNone(routeBase, pageKey) {
+    const base = String(routeBase || '/').replace(/\/$/, '') || '';
+    const key = pageKey === 'index' ? '' : pageKey.replace(/\\/g, '/');
+    const parts = [base.replace(/^\//, ''), key].filter((p) => p !== '');
+    return '/' + (parts.length ? parts.join('/') : '');
+}

package/dist/index.js

@@ -150,6 +150,7 @@ export const SERVE_HOST_RUNTIME_FILES = [
     ['list-client-components.js', 'list-client-components.js'],
     ['deployment-registry.js', 'deployment-registry.js'],
     ['render-host.js', 'render-host.js'],
+    ['route-layout-chain.js', 'route-layout-chain.js'],
 ];
 /**
  * Copy serve-host + registry bootstrap modules from `@vmz/core` into app outDir.

package/dist/static-emit.js

@@ -8,6 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 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';
@@ -100,7 +101,7 @@ export async function emitWebStatic(distDir, opts = {}) {
             }
         }
         const meta = await resolvePageMeta(Page, { params, props, pathname: pattern, origin });
-        const layoutChain = resolveLayoutChain(distDir, page.chunkId);
+        const layoutChain = resolveRouteLayoutChain(distDir, page.chunkId);
         await host.ensureComponents([page.chunkId, ...layoutChain]);
         let bodyHtml = '';
         for await (const chunk of renderToStream(Page, props, {})) {
@@ -353,24 +354,6 @@ async function loadCtor(distDir, chunkId) {
     const mod = await import(`${href}?t=${Date.now()}`);
     return mod.default;
 }
-/**
- * @param {string} distDir
- * @param {string} pageChunkId
- */
-function resolveLayoutChain(distDir, pageChunkId) {
-    const rel = pageChunkId.replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    parts.pop();
-    /** @type {string[]} */
-    const chain = [];
-    for (let i = parts.length; i >= 0; i--) {
-        const dirParts = parts.slice(0, i);
-        const layoutChunk = ['pages', ...dirParts, 'Layout'].join('/');
-        if (fs.existsSync(path.join(distDir, `${layoutChunk}.client.js`)))
-            chain.unshift(layoutChunk);
-    }
-    return chain;
-}
 /**
  * @param {string} distDir
  * @param {string} chunkId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,15 +48,15 @@
     }
   },
   "dependencies": {
-    "@vmz/core": "0.1.10",
-    "@vmz/plugin": "0.1.10",
-    "@vmz/protocol": "0.1.10",
+    "@vmz/core": "0.1.12",
+    "@vmz/plugin": "0.1.12",
+    "@vmz/protocol": "0.1.12",
     "jiti": "^2.6.1",
     "json5": "^2.2.3"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.10",
-    "@vmz/test": "0.1.10",
+    "@vmz/plugin-markdown-it": "0.1.12",
+    "@vmz/test": "0.1.12",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -90,12 +90,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.10",
-    "@vmz/vmz-win32-arm64": "0.1.10",
-    "@vmz/vmz-darwin-x64": "0.1.10",
-    "@vmz/vmz-darwin-arm64": "0.1.10",
-    "@vmz/vmz-linux-x64": "0.1.10",
-    "@vmz/vmz-linux-arm64": "0.1.10"
+    "@vmz/vmz-win32-x64": "0.1.12",
+    "@vmz/vmz-win32-arm64": "0.1.12",
+    "@vmz/vmz-darwin-x64": "0.1.12",
+    "@vmz/vmz-darwin-arm64": "0.1.12",
+    "@vmz/vmz-linux-x64": "0.1.12",
+    "@vmz/vmz-linux-arm64": "0.1.12"
   },
   "publishConfig": {
     "access": "public"