@vmz/vmz 0.1.13 → 0.1.15

package/dist/document-check.js

@@ -1,11 +1,14 @@
 // @ts-nocheck
 /**
  * Build DocumentManifest + run / --strict checks.
+ *
+ * Author documents config is parsed by Rust DocumentRoutePlan; TS only
+ * merges filesystem scan (pageKeys) and coverage diagnostics.
  */
-import fs from 'node:fs';
 import path from 'node:path';
-import { DIAG, DOCUMENT_MANIFEST_SCHEMA } from './document-schema.js';
+import { loadDocumentRoutePlan, mapPlanDiagnostics } from './author-input.js';
 import { scanDocumentsTree } from './document-scan.js';
+import { DIAG, DOCUMENT_MANIFEST_SCHEMA } from './document-schema.js';
 /**
  * Resolve project documents root.
  * @param {string} projectRoot
@@ -14,59 +17,36 @@ export function resolveDocumentsRoot(projectRoot) {
     return path.resolve(projectRoot, 'documents');
 }
 /**
- * Parse documents.config.json or a JSON-compatible export-default .ts/.js.
- * @param {string} documentsRoot
- * @returns {{ config: Record<string, any> | null, diagnostics: any[], configPath: string | null }}
+ * Load normalized DocumentRoutePlan from Rust (author JSON5/JSON/declaration).
+ * @param {string} projectRoot
  */
-export function loadDocumentsConfig(documentsRoot) {
-    /** @type {any[]} */
-    const diagnostics = [];
-    const candidates = ['documents.config.json', 'documents.config.ts', 'documents.config.js'];
-    for (const name of candidates) {
-        const p = path.join(documentsRoot, name);
-        if (!fs.existsSync(p))
-            continue;
-        try {
-            const raw = fs.readFileSync(p, 'utf8');
-            const config = parseConfigSource(raw, name);
-            return { config, diagnostics, configPath: p };
-        }
-        catch (e) {
-            diagnostics.push({
-                code: DIAG.CONFIG_INVALID,
-                severity: 'error',
-                message: `failed to parse ${name}: ${e instanceof Error ? e.message : String(e)}`,
-                path: p,
-            });
-            return { config: null, diagnostics, configPath: p };
-        }
-    }
-    return { config: null, diagnostics, configPath: null };
+export function loadDocumentsRoutePlan(projectRoot) {
+    return loadDocumentRoutePlan(projectRoot);
 }
 /**
- *: only declaration objects — no arbitrary hooks.
- * @param {string} raw
- * @param {string} filename
+ * @deprecated Prefer loadDocumentsRoutePlan(projectRoot). Kept for call sites that
+ * only need the plan-shaped config fields.
+ * @param {string} documentsRoot
  */
-function parseConfigSource(raw, filename) {
-    if (filename.endsWith('.json')) {
-        return JSON.parse(raw);
+export function loadDocumentsConfig(documentsRoot) {
+    const projectRoot = path.dirname(documentsRoot);
+    const plan = loadDocumentRoutePlan(projectRoot);
+    const diagnostics = mapPlanDiagnostics(plan.diagnostics);
+    const configPath = plan.sourcePath ? path.join(projectRoot, plan.sourcePath) : null;
+    const missing = diagnostics.some((d) => d.code === DIAG.CONFIG_MISSING);
+    if (missing) {
+        return { config: null, diagnostics, configPath, plan };
     }
-    // Strip line/block comments, then require `export default { ... }`
-    let s = raw.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
-    s = s.trim();
-    const m = s.match(/^export\s+default\s+([\s\S]*?);?\s*$/);
-    if (!m) {
-        throw new Error('expected `export default { ... }` (JSON-compatible declaration only)');
+    /** @type {Record<string, any>} */
+    const config = {
+        defaultLocale: plan.defaultLocale ?? undefined,
+        locales: Object.fromEntries(Object.entries(plan.localeLabels || {}).map(([id, label]) => [id, { label }])),
+        collections: Object.fromEntries((plan.collections || []).map((c) => [c.id, { source: c.sourceRoot, mount: c.routeBase }])),
+    };
+    if (plan.silentFallbackRequested) {
+        config.fallback = true;
     }
-    let body = m[1].trim();
-    // Quote bare keys: { defaultLocale: "x" } → { "defaultLocale": "x" }
-    body = body.replace(/([,{]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
-    // Single-quoted strings → JSON double-quoted
-    body = body.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_, inner) => JSON.stringify(inner.replace(/\\'/g, "'").replace(/\\"/g, '"').replace(/\\\\/g, '\\')));
-    // Trailing commas
-    body = body.replace(/,\s*([}\]])/g, '$1');
-    return JSON.parse(body);
+    return { config, diagnostics, configPath, plan };
 }
 /**
  * @param {object} opts
@@ -82,61 +62,53 @@ export function checkDocuments(opts) {
     const diagnostics = [];
     const scanned = scanDocumentsTree(documentsRoot);
     diagnostics.push(...scanned.diagnostics);
-    const { config, diagnostics: cfgDiags, configPath } = loadDocumentsConfig(documentsRoot);
-    diagnostics.push(...cfgDiags);
-    if (!config) {
-        diagnostics.push({
-            code: DIAG.CONFIG_MISSING,
-            severity: strict ? 'error' : 'warning',
-            message: 'documents.config.json|ts missing; strict mode requires defaultLocale + locales for strict coverage checks',
-            path: documentsRoot,
-        });
+    const plan = loadDocumentRoutePlan(projectRoot);
+    diagnostics.push(...mapPlanDiagnostics(plan.diagnostics));
+    const configMissing = (plan.diagnostics || []).some((d) => d.code === DIAG.CONFIG_MISSING);
+    const configPath = plan.sourcePath ? path.join(projectRoot, plan.sourcePath) : null;
+    if (configMissing && strict) {
+        // Plan already emitted warning; elevate message under --strict if needed.
+        if (!diagnostics.some((d) => d.code === DIAG.CONFIG_MISSING && d.severity === 'error')) {
+            diagnostics.push({
+                code: DIAG.CONFIG_MISSING,
+                severity: 'error',
+                message: 'documents.config.json|json5|ts|js missing; strict mode requires defaultLocale + locales for strict coverage checks',
+                path: documentsRoot,
+            });
+        }
     }
     /** @type {Record<string, string>} */
-    const localeLabels = {};
-    let defaultLocale = null;
+    const localeLabels = { ...(plan.localeLabels || {}) };
+    const defaultLocale = plan.defaultLocale || null;
     /** @type {import('./document-schema.js').DocumentCollection[]} */
     const collections = [];
     /** @type {import('./document-schema.js').DocumentMount[]} */
     const mounts = [];
-    if (config && typeof config === 'object') {
-        if (typeof config.defaultLocale === 'string') {
-            defaultLocale = config.defaultLocale;
-        }
-        if (config.locales && typeof config.locales === 'object') {
-            for (const [k, v] of Object.entries(config.locales)) {
-                localeLabels[k] = v && typeof v === 'object' && typeof v.label === 'string' ? v.label : k;
-            }
-        }
-        if (config.collections && typeof config.collections === 'object') {
-            for (const [id, c] of Object.entries(config.collections)) {
-                const sourceRoot = c && typeof c === 'object' && typeof c.source === 'string' ? c.source : '.';
-                const routeBase = c && typeof c === 'object' && typeof c.mount === 'string' ? c.mount : '/docs';
-                const pageKeys = [
-                    ...new Set(scanned.pages
-                        .filter((p) => {
-                        if (sourceRoot === '.' || sourceRoot === './')
-                            return true;
-                        const prefix = sourceRoot.replace(/^\.\//, '').replace(/\/$/, '');
-                        return p.identity.pageKey === prefix || p.identity.pageKey.startsWith(prefix + '/');
-                    })
-                        .map((p) => p.identity.pageKey)),
-                ].sort();
-                collections.push({ id, sourceRoot, pageKeys });
-                mounts.push({
-                    collectionId: id,
-                    routeBase,
-                    mode: routeBase === '/' ? 'standalone' : 'integrated',
-                });
-            }
-        }
+    for (const c of plan.collections || []) {
+        const sourceRoot = c.sourceRoot || '.';
+        const routeBase = c.routeBase || '/docs';
+        const pageKeys = [
+            ...new Set(scanned.pages
+                .filter((p) => {
+                if (sourceRoot === '.' || sourceRoot === './')
+                    return true;
+                const prefix = sourceRoot.replace(/^\.\//, '').replace(/\/$/, '');
+                return p.identity.pageKey === prefix || p.identity.pageKey.startsWith(`${prefix}/`);
+            })
+                .map((p) => p.identity.pageKey)),
+        ].sort();
+        collections.push({ id: c.id, sourceRoot, pageKeys });
+        mounts.push({
+            collectionId: c.id,
+            routeBase,
+            mode: routeBase === '/' ? 'standalone' : 'integrated',
+        });
     }
     if (collections.length === 0) {
         const pageKeys = [...new Set(scanned.pages.map((p) => p.identity.pageKey))].sort();
         collections.push({ id: 'default', sourceRoot: '.', pageKeys });
         mounts.push({ collectionId: 'default', routeBase: '/docs', mode: 'integrated' });
     }
-    // Config locales vs disk
     const diskLocales = new Set(scanned.locales);
     const configLocales = Object.keys(localeLabels);
     if (defaultLocale) {
@@ -175,15 +147,6 @@ export function checkDocuments(opts) {
             });
         }
     }
-    // no silent whole-page fallback by default
-    if (config && config.fallback === true) {
-        diagnostics.push({
-            code: DIAG.FALLBACK_SILENT,
-            severity: 'error',
-            message: 'silent whole-page fallback is forbidden; allow only explicit nav/metadata or per-page fallback',
-            path: configPath || documentsRoot,
-        });
-    }
     // Coverage: default locale PageKeys are baseline; other locales missing/orphan under --strict
     if (defaultLocale && diskLocales.has(defaultLocale)) {
         const byLocale = new Map();

package/dist/document-cmd.js

@@ -2,7 +2,6 @@
 /**
  * `vmz document` / `vmz docs` CLI .
  */
-import fs from 'node:fs';
 import path from 'node:path';
 import { buildDocuments } from './document-build.js';
 import { checkDocuments, manifestHasErrors } from './document-check.js';
@@ -12,6 +11,7 @@ import { resolveMarkdownEngine } from './document-markdown.js';
 import { createWorkspace } from './index.js';
 import { log } from './log.js';
 import { parseArgs } from './cli.js';
+import { emitPrettyJson } from './pretty-json.js';
 function printDocumentHelp() {
     console.log(`vmz document — project /documents domain
 
@@ -95,14 +95,7 @@ async function cmdDocumentCheck(args) {
     }
     const jsonOut = args.json;
     if (jsonOut) {
-        const text = JSON.stringify(manifest, null, 2);
-        if (typeof jsonOut === 'string') {
-            fs.writeFileSync(jsonOut, text + '\n', 'utf8');
-            log.info(`wrote ${jsonOut}`);
-        }
-        else {
-            console.log(text);
-        }
+        emitPrettyJson(jsonOut, manifest, { logWrote: (p) => log.info(`wrote ${p}`) });
     }
     else {
         for (const d of manifest.diagnostics) {

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,7 +7,10 @@ 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';
 /**
  * @param {string} projectRoot
  */
@@ -30,6 +33,7 @@ export async function buildIntegratedDocuments(opts) {
         const result = await buildDocuments({
             projectRoot,
             outDir,
+            appDistDir: outDir,
             strict: Boolean(opts.strict),
         });
         if (!result.ok) {
@@ -39,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 };
     }
@@ -50,39 +54,43 @@ 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 });
-        const html = `<!DOCTYPE html>
-<html lang="${escapeAttr(defaultLocale)}">
-<head>
-  <meta charset="utf-8" />
-  <meta http-equiv="refresh" content="0;url=${escapeAttr(target)}" />
-  <link rel="canonical" href="${escapeAttr(target)}" />
-  <title>Documents</title>
-</head>
-<body>
-  <p><a href="${escapeAttr(target)}">Continue to ${escapeAttr(defaultLocale)} docs</a></p>
-</body>
-</html>
-`;
+        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`');
+        }
+        const html = native.generateRedirectHtml({
+            lang: defaultLocale,
+            target,
+            title: 'Documents',
+        });
         fs.writeFileSync(abs, html, 'utf8');
     }
 }
-/** @param {string} s */
-function escapeAttr(s) {
-    return String(s).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
-}

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,17 @@
+/**
+ * Project locale routing — consume Rust LocalePlan (no author JSON5 in TS).
+ */
+/**
+ * @param {string} projectRoot
+ * @returns {{ strategy?: string, defaultPrefix?: string, defaultLocale?: string } | null}
+ */
+export declare function loadLocalesRouting(projectRoot: any): {
+    strategy: any;
+    defaultPrefix: any;
+    defaultLocale: 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,31 @@
+// @ts-nocheck
+/**
+ * Project locale routing — consume Rust LocalePlan (no author JSON5 in TS).
+ */
+import { loadLocalePlan } from './author-input.js';
+/**
+ * @param {string} projectRoot
+ * @returns {{ strategy?: string, defaultPrefix?: string, defaultLocale?: string } | null}
+ */
+export function loadLocalesRouting(projectRoot) {
+    const plan = loadLocalePlan(projectRoot);
+    if (!plan || plan.diagnostics?.some((d) => d.code === 'vmz::locale::manifest_missing')) {
+        return null;
+    }
+    const routing = plan.routing || {};
+    return {
+        strategy: routing.strategy || 'prefix',
+        defaultPrefix: routing.defaultPrefix || 'include',
+        defaultLocale: plan.defaultLocale || undefined,
+    };
+}
+/**
+ * @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/document-schema.js

@@ -48,7 +48,14 @@ export const DOCUMENT_SEARCH_SCHEMA = 'vmz.document.search.v0';
 /** Island-only resume plan for search/playground — not a Doc IR. */
 export const DOCUMENT_ISLANDS_SCHEMA = 'vmz.document.islands.v0';
 /** Top-level non-locale reserved names under /documents */
-export const DOCUMENT_RESERVED_TOP = new Set(['package.json', 'documents.config.ts', 'documents.config.json', 'documents.config.js', 'public']);
+export const DOCUMENT_RESERVED_TOP = new Set([
+    'package.json',
+    'documents.config.ts',
+    'documents.config.json',
+    'documents.config.json5',
+    'documents.config.js',
+    'public',
+]);
 /** Known locale aliases → canonical key (lowercase, hyphen). */
 export const LOCALE_ALIASES = {
     'zh-cn': 'zh-hans',

package/dist/embedded-packaging.js

@@ -6,6 +6,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const EMBEDDED_RESOURCE_INDEX_SCHEMA = 'vmz.embedded.resource_index.v0';
 /** Paths that must never enter the embedded baseline closure. */
 const SKIP_NAMES = new Set(['vmz-serve-host.mjs', 'vmz-serve-host.js', 'node_modules', '.git']);
@@ -55,7 +56,7 @@ export function emitEmbeddedPackaging(outDir, opts = {}) {
     };
     index.indexDigest = sha256Hex(canonicalJson({ ...index, indexDigest: undefined }));
     const indexPath = path.join(vmzDir, 'embedded-resource-index.json');
-    fs.writeFileSync(indexPath, `${JSON.stringify(index, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(indexPath, index);
     // Optional include_bytes entry point for Rust packaging adapters
     const rsPath = path.join(vmzDir, 'embedded_site.rs');
     fs.writeFileSync(rsPath, `// @generated by vmz — rust-embedded packaging adapter (do not edit)