@vmz/vmz 0.0.4 → 0.1.1

package/dist/server-language-backend.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Server Language DSL backends (lang on `<script server>`).
+ * Author surface is a VMZ DSL flavor — not full target-language source.
+ */
+/** @typedef {'ts' | 'rust' | 'python' | 'java'} ServerLangId */
+export declare const SERVER_LANG_IDS: readonly string[];
+/** @type {Record<string, ServerLangId>} */
+export declare const SERVER_LANG_ALIASES: Readonly<{
+    ts: "ts";
+    typescript: "ts";
+    rust: "rust";
+    python: "python";
+    java: "java";
+}>;
+/**
+ * @typedef {{
+ *   langId: ServerLangId,
+ *   aliases: string[],
+ *   compatibleRuntimes: string[],
+ *   implemented: boolean,
+ *   artifactRoot: string,
+ * }} ServerLanguageBackendMeta
+ */
+/** @type {Record<ServerLangId, ServerLanguageBackendMeta>} */
+export declare const SERVER_LANGUAGE_BACKENDS: Readonly<{
+    ts: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    rust: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    python: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    java: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+}>;
+/**
+ * Resolve author `lang` attr (or null/undefined for default TS).
+ * @param {string | null | undefined} raw
+ * @returns {{
+ *   ok: true, langId: ServerLangId, backend: ServerLanguageBackendMeta
+ * } | {
+ *   ok: false, code: string, message: string
+ * }}
+ */
+export declare function resolveServerLanguage(raw: any): {
+    ok: boolean;
+    code: string;
+    message: string;
+    langId?: undefined;
+    backend?: undefined;
+} | {
+    ok: boolean;
+    langId: any;
+    backend: any;
+    code?: undefined;
+    message?: undefined;
+};
+/**
+ * @param {ServerLangId} langId
+ * @param {string | null | undefined} serverRuntime
+ */
+export declare function assertLangRuntimePair(langId: any, serverRuntime: any): {
+    ok: boolean;
+    code: string;
+    message: string;
+} | {
+    ok: boolean;
+    code?: undefined;
+    message?: undefined;
+};

package/dist/server-language-backend.js

@@ -0,0 +1,121 @@
+/**
+ * Server Language DSL backends (lang on `<script server>`).
+ * Author surface is a VMZ DSL flavor — not full target-language source.
+ */
+// @ts-nocheck
+/** @typedef {'ts' | 'rust' | 'python' | 'java'} ServerLangId */
+export const SERVER_LANG_IDS = Object.freeze(['ts', 'rust', 'python', 'java']);
+/** @type {Record<string, ServerLangId>} */
+export const SERVER_LANG_ALIASES = Object.freeze({
+    ts: 'ts',
+    typescript: 'ts',
+    rust: 'rust',
+    python: 'python',
+    java: 'java',
+});
+/**
+ * @typedef {{
+ *   langId: ServerLangId,
+ *   aliases: string[],
+ *   compatibleRuntimes: string[],
+ *   implemented: boolean,
+ *   artifactRoot: string,
+ * }} ServerLanguageBackendMeta
+ */
+/** @type {Record<ServerLangId, ServerLanguageBackendMeta>} */
+export const SERVER_LANGUAGE_BACKENDS = Object.freeze({
+    ts: {
+        langId: 'ts',
+        aliases: ['ts', 'typescript'],
+        compatibleRuntimes: ['node', 'worker', 'deno', 'bun'],
+        implemented: true,
+        artifactRoot: 'dist/#server',
+    },
+    rust: {
+        langId: 'rust',
+        aliases: ['rust'],
+        compatibleRuntimes: ['rust-host'],
+        implemented: true,
+        artifactRoot: 'target/vmz/server-rust',
+    },
+    python: {
+        langId: 'python',
+        aliases: ['python'],
+        compatibleRuntimes: ['python-host'],
+        implemented: false,
+        artifactRoot: 'target/vmz/server-python',
+    },
+    java: {
+        langId: 'java',
+        aliases: ['java'],
+        compatibleRuntimes: ['jvm-host'],
+        implemented: false,
+        artifactRoot: 'target/vmz/server-java',
+    },
+});
+/**
+ * Resolve author `lang` attr (or null/undefined for default TS).
+ * @param {string | null | undefined} raw
+ * @returns {{
+ *   ok: true, langId: ServerLangId, backend: ServerLanguageBackendMeta
+ * } | {
+ *   ok: false, code: string, message: string
+ * }}
+ */
+export function resolveServerLanguage(raw) {
+    const trimmed = raw == null ? '' : String(raw).trim();
+    if (!trimmed) {
+        return { ok: true, langId: 'ts', backend: SERVER_LANGUAGE_BACKENDS.ts };
+    }
+    const langId = SERVER_LANG_ALIASES[trimmed];
+    if (!langId) {
+        return {
+            ok: false,
+            code: 'vmz::server::unknown_language',
+            message: `unknown script language \`${trimmed}\`; use ts|typescript|rust|python|java`,
+        };
+    }
+    const backend = SERVER_LANGUAGE_BACKENDS[langId];
+    if (!backend.implemented) {
+        return {
+            ok: false,
+            code: 'vmz::server::language_backend_unimplemented',
+            message: `\`<script server lang="${langId}">\` is registered but not implemented yet`,
+        };
+    }
+    return { ok: true, langId, backend };
+}
+/**
+ * @param {ServerLangId} langId
+ * @param {string | null | undefined} serverRuntime
+ */
+export function assertLangRuntimePair(langId, serverRuntime) {
+    const backend = SERVER_LANGUAGE_BACKENDS[langId];
+    if (!backend) {
+        return {
+            ok: false,
+            code: 'vmz::server::unknown_language',
+            message: `unknown langId ${langId}`,
+        };
+    }
+    if (langId === 'ts') {
+        // TS stays compatible with existing node/worker defaults; rust-host rejects ts.
+        if (serverRuntime === 'rust-host' || serverRuntime === 'python-host' || serverRuntime === 'jvm-host') {
+            return {
+                ok: false,
+                code: 'vmz::server::lang_runtime_mismatch',
+                message: `lang=ts is incompatible with serverRuntime=${serverRuntime}`,
+            };
+        }
+        return { ok: true };
+    }
+    const rt = String(serverRuntime || '').trim();
+    if (!backend.compatibleRuntimes.includes(rt)) {
+        return {
+            ok: false,
+            code: 'vmz::server::lang_runtime_mismatch',
+            message: `lang=${langId} requires serverRuntime in [${backend.compatibleRuntimes.join('|')}] (got ${rt || '(none)'})`,
+        };
+    }
+    return { ok: true };
+}

package/dist/site-delivery.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 SITE_DELIVERY_CONTRACT_SCHEMA = 'vmz.site.delivery_contract.v0';
 export const SITE_DELIVERY_RESOLUTION_SCHEMA = 'vmz.site.delivery_resolution.v0';
 /**
@@ -318,11 +319,11 @@ export function emitSiteDelivery(outDir, deliveryRaw, opts = {}) {
     }
     const vmzDir = path.join(outDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
-    fs.writeFileSync(path.join(vmzDir, 'site-delivery-contract.json'), `${JSON.stringify(norm.contract, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'site-delivery-contract.json'), norm.contract);
     let resolution = null;
     if (opts.probes) {
         resolution = resolveSiteRelease(norm.contract, opts.probes);
-        fs.writeFileSync(path.join(vmzDir, 'site-delivery-resolution.json'), `${JSON.stringify(resolution, null, 2)}\n`, 'utf8');
+        writePrettyJsonFile(path.join(vmzDir, 'site-delivery-resolution.json'), resolution);
     }
     return { contract: norm.contract, resolution };
 }

package/dist/static-emit.d.ts

@@ -29,11 +29,13 @@ export declare function emitWebStatic(distDir: any, opts?: {}): Promise<{
             chunkId: any;
             htmlPath: any;
             classification: any;
+            localeId: any;
             seo: {
                 title: any;
                 description: any;
                 canonical: any;
                 robots: any;
+                alternates: any;
             };
         }[];
         skipped: any[];
@@ -75,7 +77,14 @@ export declare function emitWebStatic(distDir: any, opts?: {}): Promise<{
             };
         })[];
         errorDocuments: any;
-        routes: any;
+        routes: any[];
+        localeCache: {
+            strategy: string;
+            varyAcceptLanguage: boolean;
+            defaultLocale: any;
+            routeCount: number;
+            locales: any[];
+        };
     };
     cdnAdapters: {
         'local-static': {

package/dist/static-emit.js

@@ -9,6 +9,10 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { emitCdnPolicy } from './cdn-policy.js';
 import { emitContentAddressedAssets } 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';
+import { filePathPatternFromChunk, isRouteBoundaryStem, listPublicPageUnits, parsePathPattern, unitBrowserPathPattern, } from './route-path.js';
 export const STATIC_DELIVERY_MANIFEST_SCHEMA = 'vmz.static.delivery_manifest.v0';
 /**
  * @param {string} distDir
@@ -42,7 +46,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     /** @type {Array<{ routeId: string, path: string, chunkId: string, classification: string, reason: string }>} */
     const skipped = [];
     for (const page of pageCatalog) {
-        const pattern = patternFromSegs(page.segs);
+        const pattern = page.pathPattern || patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
         if (page.segs.some((s) => s.kind === 'param' || s.kind === 'catch')) {
             skipped.push({
@@ -104,29 +108,44 @@ export async function emitWebStatic(distDir, opts = {}) {
                 continue;
             bodyHtml = await renderToString(Layout, {}, { slotHtml: bodyHtml });
         }
-        const htmlPath = htmlPathForRoute(pattern);
-        const absHtml = path.join(distDir, htmlPath);
-        fs.mkdirSync(path.dirname(absHtml), { recursive: true });
-        const html = wrapDocument({
-            bodyHtml,
+        const localeArt = loadLocaleArtifact(distDir);
+        // Locale artifact routeId is chunkId (`pages/about`), not the page class name.
+        const localeWrites = expandLocaleStaticGenerations({
+            localeArt,
+            routeId: page.chunkId,
             chunkId: page.chunkId,
-            layoutChain,
-            props,
-            meta,
-            cssEntry: readCssEntry(distDir),
-        });
-        fs.writeFileSync(absHtml, html, 'utf8');
-        generations.push({
-            routeId,
-            path: pattern,
-            chunkId: page.chunkId,
-            htmlPath: htmlPath.replaceAll('\\', '/'),
-            classification: 'Static',
-            title: meta.title,
-            description: meta.description,
-            canonical: meta.canonical,
-            robots: meta.robots,
+            pattern,
+            origin,
+            baseMeta: meta,
         });
+        for (const gen of localeWrites) {
+            const absHtml = path.join(distDir, gen.htmlPath);
+            fs.mkdirSync(path.dirname(absHtml), { recursive: true });
+            // Each LocaleId HTML must retain locale on same-app Links (realization authority).
+            const localizedBody = gen.localeId && localeArt ? localizeBodyLinks(bodyHtml, gen.localeId, localeArt) : bodyHtml;
+            const html = wrapDocument({
+                bodyHtml: localizedBody,
+                chunkId: page.chunkId,
+                layoutChain,
+                props,
+                meta: gen.meta,
+                cssEntry: readCssEntry(distDir),
+            });
+            fs.writeFileSync(absHtml, html, 'utf8');
+            generations.push({
+                routeId,
+                path: gen.path,
+                chunkId: page.chunkId,
+                htmlPath: gen.htmlPath.replaceAll('\\', '/'),
+                classification: 'Static',
+                title: gen.meta.title,
+                description: meta.description,
+                canonical: gen.meta.canonical,
+                robots: gen.meta.robots,
+                localeId: gen.localeId || null,
+                alternates: Array.isArray(gen.meta.alternates) ? gen.meta.alternates : [],
+            });
+        }
     }
     const notFoundHtml = wrapDocument({
         bodyHtml: '<main><h1>Not Found</h1><p>route-static-404</p></main>',
@@ -146,7 +165,11 @@ export async function emitWebStatic(distDir, opts = {}) {
     fs.writeFileSync(path.join(distDir, '404.html'), notFoundHtml, 'utf8');
     const sitemap = buildSitemap(origin, generations);
     fs.writeFileSync(path.join(distDir, 'sitemap.xml'), sitemap, 'utf8');
-    const robots = `User-agent: *\nAllow: /\nDisallow: /404\nSitemap: ${origin}/sitemap.xml\n`;
+    const nativeRobots = requireNativeAddon();
+    if (typeof nativeRobots.generateRobotsTxt !== 'function') {
+        throw new Error('vmz native addon missing generateRobotsTxt — rebuild with `pnpm napi:build`');
+    }
+    const robots = nativeRobots.generateRobotsTxt(`${origin}/sitemap.xml`);
     fs.writeFileSync(path.join(distDir, 'robots.txt'), robots, 'utf8');
     // Hard rule: no SPA fallback shim in artifact.
     for (const bad of ['_redirects', 'vercel.json', 'netlify.toml']) {
@@ -174,11 +197,13 @@ export async function emitWebStatic(distDir, opts = {}) {
             chunkId: g.chunkId,
             htmlPath: g.htmlPath,
             classification: g.classification,
+            localeId: g.localeId || null,
             seo: {
                 title: g.title,
                 description: g.description,
                 canonical: g.canonical,
                 robots: g.robots,
+                alternates: g.alternates || [],
             },
         })),
         skipped,
@@ -189,7 +214,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     };
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
-    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -200,7 +225,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     // Re-stamp static manifest after linking asset digest (HTML already rewritten on disk).
     delete manifest.manifestDigest;
     manifest.manifestDigest = sha256Hex(canonicalJson(manifest));
-    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
     const cdn = emitCdnPolicy(distDir, manifest);
     return {
         manifest,
@@ -240,8 +265,11 @@ function sortKeys(value) {
  * @param {string} distDir
  */
 function listPageClientFiles(distDir) {
+    const fromDep = listPagesFromDeployment(distDir);
+    if (fromDep.length)
+        return fromDep;
     const root = path.join(distDir, 'pages');
-    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parseChunkSegments> }>} */
+    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parsePathPattern>, pathPattern: string }>} */
     const out = [];
     function walk(abs, relParts) {
         let ents;
@@ -256,10 +284,11 @@ function listPageClientFiles(distDir) {
                 walk(path.join(abs, e.name), [...relParts, e.name]);
             else if (e.isFile() && e.name.endsWith('.client.js')) {
                 const stem = e.name.replace(/\.client\.js$/, '');
-                if (stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound')
+                if (isRouteBoundaryStem(stem))
                     continue;
                 const chunkId = ['pages', ...relParts, stem].join('/');
-                out.push({ chunkId, segs: parseChunkSegments(chunkId) });
+                const pathPattern = filePathPatternFromChunk(chunkId);
+                out.push({ chunkId, pathPattern, segs: parsePathPattern(pathPattern) });
             }
         }
     }
@@ -267,32 +296,26 @@ function listPageClientFiles(distDir) {
     return out;
 }
 /**
- * @param {string} chunkId
+ * @param {string} distDir
  */
-function parseChunkSegments(chunkId) {
-    const rel = chunkId.replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    /** @type {Array<{ kind: 'static' | 'param' | 'catch', value?: string, name?: string }>} */
-    const segs = [];
-    for (let i = 0; i < parts.length; i++) {
-        const p = parts[i];
-        if (p.startsWith('(') && p.endsWith(')') && p.length > 2)
-            continue;
-        if (p === 'index' && i === parts.length - 1)
-            continue;
-        const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
-        const param = /^\[([^\]]+)\]$/.exec(p);
-        if (catchAll)
-            segs.push({ kind: 'catch', name: catchAll[1] });
-        else if (param)
-            segs.push({ kind: 'param', name: param[1] });
-        else
-            segs.push({ kind: 'static', value: p.toLowerCase() });
+function listPagesFromDeployment(distDir) {
+    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
+    if (!fs.existsSync(deploymentPath))
+        return [];
+    try {
+        const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+        return listPublicPageUnits(deployment).map((u) => {
+            const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
+            const pathPattern = unitBrowserPathPattern(u);
+            return { chunkId, pathPattern, segs: parsePathPattern(pathPattern) };
+        });
+    }
+    catch {
+        return [];
     }
-    return segs;
 }
 /**
- * @param {ReturnType<typeof parseChunkSegments>} segs
+ * @param {ReturnType<typeof parsePathPattern>} segs
  */
 function patternFromSegs(segs) {
     if (!segs.length)
@@ -371,12 +394,96 @@ async function resolvePageMeta(Page, ctx) {
     else if (Page.meta && typeof Page.meta === 'object') {
         raw = Page.meta;
     }
-    const title = String(raw.title || `${guessTitle(ctx.pathname)} · VMZ`);
-    const description = String(raw.description || `VMZ page ${ctx.pathname}`);
+    const title = String(raw.title || guessTitle(ctx.pathname) || 'App');
+    const description = String(raw.description || '');
     const canonical = String(raw.canonical || `${ctx.origin}${ctx.pathname === '/' ? '/' : ctx.pathname}`);
     const robots = String(raw.robots || 'index,follow');
     const lang = String(raw.lang || 'en');
-    return { title, description, canonical, robots, lang };
+    return { title, description, canonical, robots, lang, alternates: [] };
+}
+/**
+ * @param {string} distDir
+ */
+function loadLocaleArtifact(distDir) {
+    const p = path.join(distDir, '_vmz', 'locale-route-realization.json');
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Expand one Static route across LocaleId realizations (hreflang seed + prefixed HTML).
+ * @param {{
+ *   localeArt: any,
+ *   routeId: string,
+ *   chunkId: string,
+ *   pattern: string,
+ *   origin: string,
+ *   baseMeta: { title: string, description: string, canonical: string, robots: string, lang: string, alternates?: any[] },
+ * }} input
+ */
+function expandLocaleStaticGenerations(input) {
+    const { localeArt, routeId, pattern, origin, baseMeta } = input;
+    if (!localeArt?.realizations?.length) {
+        return [
+            {
+                path: pattern,
+                htmlPath: htmlPathForRoute(pattern),
+                localeId: null,
+                meta: baseMeta,
+            },
+        ];
+    }
+    const locales = (localeArt.locales || []).map((l) => l.id);
+    const directions = Object.fromEntries((localeArt.locales || []).map((l) => [l.id, l.direction || 'ltr']));
+    const defaultLocale = localeArt.defaultLocale || locales[0];
+    const forRoute = (localeArt.realizations || []).filter((r) => r.routeId === routeId || r.routeId === input.chunkId || r.pathPattern === pattern || (r.path === pattern && !r.prefixed));
+    /** @type {any[]} */
+    const out = [];
+    for (const loc of locales) {
+        const hit = forRoute.find((r) => r.localeId === loc);
+        if (!hit)
+            continue;
+        const built = buildLocalePageMeta({
+            routeId,
+            localeId: loc,
+            direction: directions[loc],
+            title: baseMeta.title,
+            description: baseMeta.description,
+            origin,
+            realizations: localeArt.realizations,
+            locales,
+            defaultLocale,
+        });
+        out.push({
+            path: hit.path,
+            htmlPath: htmlPathForRoute(hit.path),
+            localeId: loc,
+            meta: {
+                title: baseMeta.title,
+                description: baseMeta.description,
+                canonical: built.canonical || absoluteUrl(origin, hit.path),
+                robots: baseMeta.robots,
+                lang: loc,
+                dir: directions[loc] || 'ltr',
+                alternates: built.alternates || [],
+            },
+        });
+    }
+    return out.length
+        ? out
+        : [
+            {
+                path: pattern,
+                htmlPath: htmlPathForRoute(pattern),
+                localeId: null,
+                meta: baseMeta,
+            },
+        ];
 }
 function guessTitle(pathname) {
     if (pathname === '/')
@@ -405,59 +512,47 @@ function readCssEntry(distDir) {
  *   chunkId: string,
  *   layoutChain: string[],
  *   props: Record<string, unknown>,
- *   meta: { title: string, description: string, canonical: string, robots: string, lang: string },
+ *   meta: { title: string, description: string, canonical: string, robots: string, lang: string, dir?: string, alternates?: Array<{ hreflang: string, href: string }> },
  *   cssEntry: string | null,
  *   isErrorDocument?: boolean,
  * }} input
  */
 function wrapDocument(input) {
     const propsJson = JSON.stringify(input.props ?? {});
-    const layoutAttr = input.layoutChain.length ? ` data-vmz-layout="${escapeAttr(input.layoutChain.join(','))}"` : '';
-    const pageAttr = input.chunkId ? ` data-vmz-page="${escapeAttr(input.chunkId)}"` : '';
-    const cssLink = input.cssEntry ? `  <link rel="stylesheet" href="/${String(input.cssEntry).replace(/^\/+/, '')}" />\n` : '';
-    const entry = input.isErrorDocument ? '' : `  <script type="module" src="/entry-client.js"></script>\n`;
-    return `<!DOCTYPE html>
-<html lang="${escapeAttr(input.meta.lang)}">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>${escapeHtml(input.meta.title)}</title>
-  <meta name="description" content="${escapeAttr(input.meta.description)}" />
-  <meta name="robots" content="${escapeAttr(input.meta.robots)}" />
-  <link rel="canonical" href="${escapeAttr(input.meta.canonical)}" />
-  <meta property="og:title" content="${escapeAttr(input.meta.title)}" />
-  <meta property="og:description" content="${escapeAttr(input.meta.description)}" />
-  <meta property="og:url" content="${escapeAttr(input.meta.canonical)}" />
-${cssLink}</head>
-<body>
-  <div id="app"${pageAttr}${layoutAttr} data-vmz-props="${escapeAttr(propsJson)}">${input.bodyHtml}</div>
-${entry}</body>
-</html>
-`;
+    const localeId = input.meta.lang || 'en';
+    const dir = input.meta.dir || 'ltr';
+    const native = requireNativeAddon();
+    if (typeof native.generatePageShell !== 'function') {
+        throw new Error('vmz native addon missing generatePageShell — rebuild with `pnpm napi:build`');
+    }
+    return native.generatePageShell({
+        bodyHtml: input.bodyHtml,
+        chunkId: input.chunkId || '',
+        layoutChain: input.layoutChain || [],
+        propsJson,
+        meta: {
+            title: input.meta.title,
+            description: input.meta.description,
+            canonical: input.meta.canonical,
+            robots: input.meta.robots,
+            lang: localeId,
+            dir,
+            alternates: input.meta.alternates || [],
+        },
+        // napi Option<String>: omit/undefined = None; null is rejected as String
+        ...(input.cssEntry ? { cssEntry: String(input.cssEntry) } : {}),
+        isErrorDocument: !!input.isErrorDocument,
+    });
 }
 /**
  * @param {string} origin
  * @param {Array<{ canonical: string, robots: string }>} generations
  */
-function buildSitemap(origin, generations) {
-    const urls = generations
-        .filter((g) => !String(g.robots).includes('noindex'))
-        .map((g) => `  <url>
-    <loc>${escapeXml(g.canonical)}</loc>
-  </url>`)
-        .join('\n');
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>
-`;
-}
-function escapeHtml(s) {
-    return String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-}
-function escapeAttr(s) {
-    return escapeHtml(s).replaceAll('"', '&quot;');
-}
-function escapeXml(s) {
-    return escapeAttr(s).replaceAll("'", '&apos;');
+function buildSitemap(_origin, generations) {
+    const urls = generations.filter((g) => !String(g.robots).includes('noindex')).map((g) => ({ loc: g.canonical }));
+    const native = requireNativeAddon();
+    if (typeof native.generateSitemapXml !== 'function') {
+        throw new Error('vmz native addon missing generateSitemapXml — rebuild with `pnpm napi:build`');
+    }
+    return native.generateSitemapXml(urls);
 }

package/dist/test-cmd.js

@@ -6,6 +6,7 @@
 import path from 'node:path';
 import { createWorkspace } from './index.js';
 import { log } from './log.js';
+import { generatePrettyJson } from './pretty-json.js';
 /**
  * @returns {Promise<typeof import('@vmz/test')>}
  */
@@ -317,7 +318,7 @@ export async function cmdTest(args) {
         return errors.length ? 2 : 0;
     }
     if (wantJson) {
-        const text = `${JSON.stringify(report, null, 2)}\n`;
+        const text = `${generatePrettyJson(report)}\n`;
         if (typeof args.json === 'string' && args.json !== 'true') {
             const { writeFileSync } = await import('node:fs');
             writeFileSync(path.resolve(String(args.json)), text);