@vmz/vmz 0.1.11 → 0.1.13

package/dist/locale-route-emit.js

@@ -7,9 +7,34 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { checkLocales, localeHasErrors } from './locale-check.js';
 import { buildLocalePageMeta, buildLocaleRouteRealizationTable } from './locale-router.js';
-import { writePrettyJsonFile } from './pretty-json.js';
-import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
 export const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = 'vmz.locale.route_realization.v0';
+/**
+ * @param {string} chunkId
+ */
+function pathPatternFromChunk(chunkId) {
+    const rel = String(chunkId || '').replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    const segs = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        segs.push(p);
+    }
+    return segs.length ? `/${segs.join('/')}` : '/';
+}
+/**
+ * Layouts are not public RouteNodes for locale realization / SEO.
+ * @param {string} chunkId
+ */
+function isPublicPageChunk(chunkId) {
+    const id = String(chunkId || '');
+    if (!id.startsWith('pages/'))
+        return false;
+    if (/(^|\/)Layout$/.test(id))
+        return false;
+    return true;
+}
 /**
  * @param {string} projectRoot
  * @param {string} distDir
@@ -34,10 +59,10 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
         };
     }
     const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
-    const pages = listPublicPageUnits(deployment);
+    const pages = (deployment.units || []).filter((u) => u.kind === 'page' && isPublicPageChunk(String(u.chunkId)));
     const routes = pages.map((u) => ({
         routeId: String(u.chunkId),
-        path: unitBrowserPathPattern(u),
+        path: pathPatternFromChunk(String(u.chunkId)),
     }));
     const localeEntries = report.manifest?.locales || [];
     const locales = localeEntries.map((l) => l.id);
@@ -92,14 +117,14 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
     const vmzDir = path.join(distDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
     const outPath = path.join(vmzDir, 'locale-route-realization.json');
-    writePrettyJsonFile(outPath, artifact);
+    fs.writeFileSync(outPath, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
     const manifestOut = path.join(vmzDir, 'locale-manifest.json');
-    writePrettyJsonFile(manifestOut, {
+    fs.writeFileSync(manifestOut, `${JSON.stringify({
         schema: 'vmz.locale.manifest.v0',
         defaultLocale,
         locales: artifact.locales,
         routing: artifact.routing,
-    });
+    }, null, 2)}\n`, 'utf8');
     return {
         ok: true,
         written: ['_vmz/locale-route-realization.json', '_vmz/locale-manifest.json'],

package/dist/locale-router.js

@@ -90,34 +90,16 @@ export function buildLocaleRouteRealizationTable(input) {
                 pathPattern: normalizePath(route.path),
             };
             realizations.push(entry);
-            // `none` / `domain`: LocaleId is Host preference — many locales share one URL path.
-            // Collision only when *different RouteIds* claim the same path.
-            if (routing.strategy === 'none' || routing.strategy === 'domain') {
-                const prevRoute = pathOwners.get(entry.path);
-                if (prevRoute && prevRoute !== route.routeId) {
-                    diagnostics.push({
-                        code: DIAG_LOCALE_ROUTE_COLLISION,
-                        severity: 'error',
-                        message: `path ${entry.path} claimed by ${prevRoute} and ${route.routeId}`,
-                    });
-                }
-                else {
-                    pathOwners.set(entry.path, route.routeId);
-                }
+            const prev = pathOwners.get(entry.path);
+            if (prev && prev !== `${route.routeId}@${localeId}`) {
+                diagnostics.push({
+                    code: DIAG_LOCALE_ROUTE_COLLISION,
+                    severity: 'error',
+                    message: `path ${entry.path} claimed by ${prev} and ${route.routeId}@${localeId}`,
+                });
             }
             else {
-                const owner = `${route.routeId}@${localeId}`;
-                const prev = pathOwners.get(entry.path);
-                if (prev && prev !== owner) {
-                    diagnostics.push({
-                        code: DIAG_LOCALE_ROUTE_COLLISION,
-                        severity: 'error',
-                        message: `path ${entry.path} claimed by ${prev} and ${owner}`,
-                    });
-                }
-                else {
-                    pathOwners.set(entry.path, owner);
-                }
+                pathOwners.set(entry.path, `${route.routeId}@${localeId}`);
             }
         }
     }

package/dist/pack.js

@@ -5,11 +5,10 @@
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { loadDeploymentIr, planBundleInputs } from './bundler-adapter.js';
 import { packClientBareImports } from './pack-client-packages.js';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const PACK_MANIFEST_SCHEMA = 'vmz.pack.manifest.v0';
 /**
  * Ensure dom split companions sit next to vmz-dom.js (barrel imports ./dom-core.js).
@@ -101,7 +100,7 @@ export function packFromDeploymentIr(outDir, opts = {}) {
     const vmzDir = path.join(outDir, '_vmz');
     mkdirSync(vmzDir, { recursive: true });
     const file = path.join(vmzDir, 'pack-manifest.json');
-    writePrettyJsonFile(file, body);
+    writeFileSync(file, `${JSON.stringify(body, null, 2)}\n`, 'utf8');
     return { manifest: body, path: file, clientPackages };
 }
 function stableStringify(value) {

package/dist/production-observability.js

@@ -7,7 +7,6 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { canonicalJson, sha256Hex } from './release-pack.js';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const PRODUCTION_OBSERVABILITY_SCHEMA = 'vmz.production.observability.v0';
 export const PRODUCTION_TRACE_SCHEMA = 'vmz.production.trace.v0';
 /** Facets that production traces must be able to carry (08 A5). */
@@ -458,8 +457,8 @@ export function emitProductionObservability(distDir, overrides = {}, meta = {})
     fs.mkdirSync(vmzDir, { recursive: true });
     const contractPath = path.join(vmzDir, 'production-observability.json');
     const tracePath = path.join(vmzDir, 'production-trace.sample.json');
-    writePrettyJsonFile(contractPath, contract);
-    writePrettyJsonFile(tracePath, trace);
+    fs.writeFileSync(contractPath, `${JSON.stringify(contract, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(tracePath, `${JSON.stringify(trace, null, 2)}\n`, 'utf8');
     return { contract, trace, contractPath, tracePath };
 }
 export function observabilityDigest(contract) {

package/dist/production-test-pack.js

@@ -8,7 +8,6 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { canonicalJson, sha256Hex } from './release-pack.js';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const PRODUCTION_SCENARIO_PACK_SCHEMA = 'vmz.production.scenario_pack.v0';
 export const PRODUCTION_CI_PROFILE_SCHEMA = 'vmz.production.ci_profile.v0';
 export const PRODUCTION_TEST_REPORT_SCHEMA = 'vmz.production.test_report.v0';
@@ -432,9 +431,9 @@ export function emitProductionTestArtifacts(root, report, pack, profile) {
     const reportPath = path.join(dir, 'report.json');
     const packPath = path.join(dir, 'scenario-pack.json');
     const profilePath = path.join(dir, 'ci-profile.json');
-    writePrettyJsonFile(reportPath, stamped);
-    writePrettyJsonFile(packPath, pack);
-    writePrettyJsonFile(profilePath, profile);
+    fs.writeFileSync(reportPath, `${JSON.stringify(stamped, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(packPath, `${JSON.stringify(pack, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(profilePath, `${JSON.stringify(profile, null, 2)}\n`, 'utf8');
     return { reportPath, packPath, profilePath, report: stamped };
 }
 /** Assert CI profile forbids JS test-runner disguise. */

package/dist/release-pack.js

@@ -9,8 +9,6 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { writePrettyJsonFile } from './pretty-json.js';
-import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
 export const RELEASE_ENVELOPE_SCHEMA = 'vmz.release.envelope.v0';
 export const APPLICATION_ARTIFACT_SCHEMA = 'vmz.application.artifact.v0';
 export const DELIVERY_ARTIFACT_MANIFEST_SCHEMA = 'vmz.profile.delivery_artifact_manifest.v0';
@@ -90,6 +88,21 @@ function listContentFiles(distDir) {
     out.sort();
     return out;
 }
+/**
+ * @param {string} chunkId
+ */
+function pathPatternFromChunk(chunkId) {
+    const rel = chunkId.replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    const segs = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        segs.push(p);
+    }
+    return segs.length ? `/${segs.join('/')}` : '/';
+}
 /**
  * Pack `dist/` into `_vmz` manifests + release envelope (filesystem Delivery Profile).
  * @param {string} distDir
@@ -111,13 +124,13 @@ export function packRelease(distDir, opts = {}) {
     for (const rel of files) {
         fileDigests[rel] = sha256File(path.join(abs, ...rel.split('/')));
     }
-    const pages = listPublicPageUnits(deployment);
+    const pages = (deployment.units || []).filter((u) => u.kind === 'page');
     const routeRealization = {
         schema: ROUTE_REALIZATION_TABLE_SCHEMA,
         routes: pages.map((u) => ({
             routeId: String(u.chunkId),
             chunkId: String(u.chunkId),
-            pathPattern: unitBrowserPathPattern(u),
+            pathPattern: pathPatternFromChunk(String(u.chunkId)),
             clientEntry: u.clientEntry || null,
             programIr: u.programIr || null,
         })),
@@ -187,7 +200,7 @@ export function packRelease(distDir, opts = {}) {
  * @param {unknown} value
  */
 function writeJson(file, value) {
-    writePrettyJsonFile(file, value);
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
 }
 /**
  * @param {string} pointerPath

package/dist/server-artifact.js

@@ -4,10 +4,9 @@
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { SERVER_RUNTIMES } from './delivery-profile.js';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const SERVER_ARTIFACT_SCHEMA = 'vmz.server.artifact.v0';
 export const HTTP_CONTRACT_SCHEMA = 'vmz.http.contract.v0';
 export const SERVER_RUNTIME_ADAPTER_SCHEMA = 'vmz.server.runtime_adapter.v0';
@@ -117,14 +116,14 @@ export function emitServerArtifact(outDir, opts = {}) {
     const vmzDir = path.join(outDir, '_vmz');
     mkdirSync(vmzDir, { recursive: true });
     const file = path.join(vmzDir, 'server-artifact.json');
-    writePrettyJsonFile(file, artifact);
+    writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
     const adapterDir = path.join(vmzDir, 'adapters');
     mkdirSync(adapterDir, { recursive: true });
     for (const adapterId of ['worker', 'rust-host']) {
         const projection = projectServerRuntimeAdapter(artifact, adapterId);
         const dir = path.join(adapterDir, adapterId);
         mkdirSync(dir, { recursive: true });
-        writePrettyJsonFile(path.join(dir, 'adapter.json'), projection);
+        writeFileSync(path.join(dir, 'adapter.json'), `${JSON.stringify(projection, null, 2)}\n`, 'utf8');
     }
     return { artifact, path: file, httpContractDigest };
 }

package/dist/site-delivery.js

@@ -6,7 +6,6 @@
 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';
 /**
@@ -136,7 +135,7 @@ export function normalizeSiteDelivery(raw, opts = {}) {
         artifact: String(d.artifact),
         expectedCompatibility: d.expectedCompatibility || {
             runtime: 'vmz',
-            deliveryProfiles: ['static', 'filesystem'],
+            deliveryProfiles: ['web-static', 'filesystem'],
         },
         sources,
         resolutionPolicy: {
@@ -319,11 +318,11 @@ export function emitSiteDelivery(outDir, deliveryRaw, opts = {}) {
     }
     const vmzDir = path.join(outDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
-    writePrettyJsonFile(path.join(vmzDir, 'site-delivery-contract.json'), norm.contract);
+    fs.writeFileSync(path.join(vmzDir, 'site-delivery-contract.json'), `${JSON.stringify(norm.contract, null, 2)}\n`, 'utf8');
     let resolution = null;
     if (opts.probes) {
         resolution = resolveSiteRelease(norm.contract, opts.probes);
-        writePrettyJsonFile(path.join(vmzDir, 'site-delivery-resolution.json'), resolution);
+        fs.writeFileSync(path.join(vmzDir, 'site-delivery-resolution.json'), `${JSON.stringify(resolution, null, 2)}\n`, 'utf8');
     }
     return { contract: norm.contract, resolution };
 }

package/dist/static-emit.js

@@ -7,14 +7,9 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { createRenderHost } from '@vmz/core/render-host';
-import { listClientComponentsSync } from '@vmz/core/component-registry';
 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
@@ -31,8 +26,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     if (!fs.existsSync(domPath)) {
         throw new Error(`emitWebStatic: missing ${domPath} — run vmz build first`);
     }
-    const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
-    const { renderToString, renderToStream } = host;
+    const { renderToString, renderToStream } = await import(pathToFileURL(domPath).href);
     const pageCatalog = listPageClientFiles(distDir);
     /** @type {Array<{
      *   routeId: string,
@@ -49,7 +43,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 = page.pathPattern || patternFromSegs(page.segs);
+        const pattern = patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
         if (page.segs.some((s) => s.kind === 'param' || s.kind === 'catch')) {
             skipped.push({
@@ -101,7 +95,6 @@ export async function emitWebStatic(distDir, opts = {}) {
         }
         const meta = await resolvePageMeta(Page, { params, props, pathname: pattern, origin });
         const layoutChain = resolveLayoutChain(distDir, page.chunkId);
-        await host.ensureComponents([page.chunkId, ...layoutChain]);
         let bodyHtml = '';
         for await (const chunk of renderToStream(Page, props, {})) {
             bodyHtml += chunk;
@@ -169,11 +162,7 @@ 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 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`);
+    const robots = `User-agent: *\nAllow: /\nDisallow: /404\nSitemap: ${origin}/sitemap.xml\n`;
     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']) {
@@ -190,7 +179,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const manifest = {
         schema: STATIC_DELIVERY_MANIFEST_SCHEMA,
         applicationId,
-        deliveryProfile: 'static',
+        deliveryProfile: 'web-static',
         origin,
         generatedAt: new Date().toISOString(),
         spaFallback: false,
@@ -218,8 +207,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     };
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
-    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
-    emitStaticClientEntries(distDir, pageCatalog);
+    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -230,7 +218,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));
-    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
+    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     const cdn = emitCdnPolicy(distDir, manifest);
     return {
         manifest,
@@ -270,11 +258,8 @@ 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 parsePathPattern>, pathPattern: string }>} */
+    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parseChunkSegments> }>} */
     const out = [];
     function walk(abs, relParts) {
         let ents;
@@ -289,11 +274,10 @@ 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 (isRouteBoundaryStem(stem))
+                if (stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound')
                     continue;
                 const chunkId = ['pages', ...relParts, stem].join('/');
-                const pathPattern = filePathPatternFromChunk(chunkId);
-                out.push({ chunkId, pathPattern, segs: parsePathPattern(pathPattern) });
+                out.push({ chunkId, segs: parseChunkSegments(chunkId) });
             }
         }
     }
@@ -301,26 +285,32 @@ function listPageClientFiles(distDir) {
     return out;
 }
 /**
- * @param {string} distDir
+ * @param {string} chunkId
  */
-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 [];
+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() });
     }
+    return segs;
 }
 /**
- * @param {ReturnType<typeof parsePathPattern>} segs
+ * @param {ReturnType<typeof parseChunkSegments>} segs
  */
 function patternFromSegs(segs) {
     if (!segs.length)
@@ -399,8 +389,8 @@ async function resolvePageMeta(Page, ctx) {
     else if (Page.meta && typeof Page.meta === 'object') {
         raw = Page.meta;
     }
-    const title = String(raw.title || guessTitle(ctx.pathname) || 'App');
-    const description = String(raw.description || '');
+    const title = String(raw.title || `${guessTitle(ctx.pathname)} · VMZ`);
+    const description = String(raw.description || `VMZ page ${ctx.pathname}`);
     const canonical = String(raw.canonical || `${ctx.origin}${ctx.pathname === '/' ? '/' : ctx.pathname}`);
     const robots = String(raw.robots || 'index,follow');
     const lang = String(raw.lang || 'en');
@@ -524,87 +514,59 @@ function readCssEntry(distDir) {
  */
 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 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,
-    });
+    const localeAttr = ` data-vmz-locale="${escapeAttr(localeId)}" data-vmz-dir="${escapeAttr(dir)}"`;
+    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`;
+    const hreflang = (input.meta.alternates || [])
+        .map((a) => `  <link rel="alternate" hreflang="${escapeAttr(a.hreflang)}" href="${escapeAttr(a.href)}" />`)
+        .join('\n');
+    const hreflangBlock = hreflang ? `${hreflang}\n` : '';
+    return `<!DOCTYPE html>
+<html lang="${escapeAttr(localeId)}" data-locale="${escapeAttr(localeId)}" dir="${escapeAttr(dir)}">
+<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)}" />
+${hreflangBlock}  <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}${localeAttr} data-vmz-props="${escapeAttr(propsJson)}">${input.bodyHtml}</div>
+${entry}</body>
+</html>
+`;
 }
 /**
  * @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) => ({ 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);
+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>
+`;
 }
-/**
- * Static CDN must ship entry-client/event like serve-host (content-addressed + HTML rewrite).
- * @param {string} distDir
- * @param {Array<{ chunkId: string }>} pageCatalog
- */
-function emitStaticClientEntries(distDir, pageCatalog) {
-    const componentEntries = listClientComponentsSync(distDir, { strict: true });
-    const indexChunk = pageCatalog.find((p) => p.chunkId === 'pages/index')?.chunkId || pageCatalog[0]?.chunkId || 'pages/index';
-    const resumeEntries = loadPageResumeEntriesSync(distDir, indexChunk);
-    const lazySet = new Set(resumeEntries
-        .filter((e) => isEventResumeStrategy(e.strategy))
-        .map((e) => e.component)
-        .filter(Boolean));
-    const eager = componentEntries.filter((e) => !lazySet.has(e.name));
-    const lazy = componentEntries.filter((e) => lazySet.has(e.name));
-    const native = requireNativeAddon();
-    if (typeof native.generateServeEntryClient !== 'function') {
-        throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
-    }
-    fs.writeFileSync(path.join(distDir, 'entry-client.js'), native.generateServeEntryClient(eager, lazy, ''), 'utf8');
-    if (typeof native.generateServeEntryEvent === 'function') {
-        fs.writeFileSync(path.join(distDir, 'entry-event.js'), native.generateServeEntryEvent(''), 'utf8');
-    }
+function escapeHtml(s) {
+    return String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 }
-/**
- * @param {string} distDir
- * @param {string} chunkId
- */
-function loadPageResumeEntriesSync(distDir, chunkId) {
-    try {
-        const dep = JSON.parse(fs.readFileSync(path.join(distDir, 'vmz-deployment.json'), 'utf8'));
-        const units = Array.isArray(dep.units) ? dep.units : [];
-        const page = units.find((u) => u.chunkId === chunkId) || units.find((u) => u.chunkId === 'pages/index') || units.find((u) => u.kind === 'page');
-        const entries = Array.isArray(page?.resumeEntries) ? page.resumeEntries : [];
-        return entries.map((e) => ({
-            component: String(e.component || ''),
-            strategy: String(e.strategy || ''),
-        }));
-    }
-    catch {
-        return [];
-    }
+function escapeAttr(s) {
+    return escapeHtml(s).replaceAll('"', '&quot;');
 }
-/** @param {string} strategy */
-function isEventResumeStrategy(strategy) {
-    return strategy === 'event' || strategy === 'click' || String(strategy).startsWith('event:');
+function escapeXml(s) {
+    return escapeAttr(s).replaceAll("'", '&apos;');
 }

package/dist/test-cmd.js

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