@vmz/vmz 0.0.4 → 0.1.1

package/dist/build-assemble.d.ts

@@ -0,0 +1,52 @@
+/**
+ * B5 Assemble dispatch + B6 build-proof (per-build semantic id slots).
+ */
+export declare const BUILD_PROOF_SCHEMA = "vmz.build.proof.v0";
+export declare const ASSEMBLE_MANIFEST_SCHEMA = "vmz.assemble.manifest.v0";
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export declare function assembleDelivery(outDir: any, ctx: any): Promise<{
+    manifest: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        serverRuntime: any;
+        steps: any[];
+    };
+    path: string;
+}>;
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export declare function emitBuildProof(outDir: any, ctx: any): {
+    proof: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        selectionDigest: any;
+        packDigest: any;
+        assembleDigest: any;
+        release: boolean;
+        semanticIds: string[];
+        slots: {
+            'server-host': {
+                status: string;
+            };
+            'static-delivery': {
+                status: string;
+            };
+            'site-fallback': {
+                status: string;
+            };
+            'asset-graph': {
+                status: string;
+            };
+        };
+        productionReadyClaim: boolean;
+        note: string;
+    };
+    path: string;
+};

package/dist/build-assemble.js

@@ -0,0 +1,192 @@
+/**
+ * B5 Assemble dispatch + B6 build-proof (per-build semantic id slots).
+ */
+// @ts-nocheck
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { semanticIdsForAssembly, sha256Hex, canonicalJson } from './delivery-profile.js';
+import { emitServerArtifact } from './server-artifact.js';
+import { emitEmbeddedPackaging } from './embedded-packaging.js';
+import { emitSiteDelivery } from './site-delivery.js';
+import { emitWebStatic } from './static-emit.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+export const BUILD_PROOF_SCHEMA = 'vmz.build.proof.v0';
+export const ASSEMBLE_MANIFEST_SCHEMA = 'vmz.assemble.manifest.v0';
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export async function assembleDelivery(outDir, ctx) {
+    const { selection, profile } = ctx;
+    const assembly = selection.assembly;
+    const result = {
+        schema: ASSEMBLE_MANIFEST_SCHEMA,
+        profileId: selection.profileId,
+        assembly,
+        serverRuntime: selection.serverRuntime || null,
+        steps: [],
+    };
+    if (assembly === 'static-cdn' || assembly === 'cdn+server') {
+        const staticResult = await emitWebStatic(outDir, { origin: ctx.origin });
+        result.steps.push({
+            kind: 'static-cdn',
+            digest: staticResult.digest,
+            htmlFiles: staticResult.htmlFiles?.length ?? 0,
+            skipped: staticResult.skipped?.length ?? 0,
+        });
+        result.staticDelivery = {
+            digest: staticResult.digest,
+            htmlFiles: staticResult.htmlFiles,
+            skipped: staticResult.skipped,
+        };
+    }
+    if (assembly === 'local-static') {
+        result.steps.push({
+            kind: 'local-static',
+            status: 'modules-ready',
+            note: 'client modules packed; no ServerArtifact',
+        });
+    }
+    if (assembly === 'server-host' || assembly === 'cdn+server') {
+        const server = emitServerArtifact(outDir, {
+            profileId: selection.profileId,
+            assembly,
+            serverRuntime: selection.serverRuntime || 'node',
+            packDigest: ctx.pack?.packDigest || null,
+        });
+        result.steps.push({
+            kind: 'server-host',
+            status: 'emitted',
+            digest: server.artifact.artifactDigest,
+            publicRoutes: server.artifact.publicRoutes?.length ?? 0,
+            internalCapabilities: server.artifact.internalCapabilities?.length ?? 0,
+            httpContractDigest: server.httpContractDigest,
+        });
+        result.serverArtifact = {
+            digest: server.artifact.artifactDigest,
+            httpContractDigest: server.httpContractDigest,
+            schema: server.artifact.schema,
+            selectedRuntime: server.artifact.selectedRuntime,
+        };
+    }
+    const siteAuthoring = profile.sources || null;
+    if (siteAuthoring || assembly === 'rust-embedded') {
+        if (!siteAuthoring) {
+            throw new Error('rust-embedded requires delivery sources (SiteDeliveryContract); cannot assemble without embedded|filesystem|remote baselines');
+        }
+        const site = emitSiteDelivery(outDir, siteAuthoring, {
+            siteId: ctx.siteId,
+        });
+        result.steps.push({
+            kind: 'site-delivery',
+            digest: site.contract.contractDigest,
+        });
+        result.siteDelivery = {
+            digest: site.contract.contractDigest,
+            schema: site.contract.schema,
+        };
+        if (assembly === 'rust-embedded') {
+            const pack = emitEmbeddedPackaging(outDir, {
+                siteId: ctx.siteId,
+                contractDigest: site.contract.contractDigest,
+            });
+            result.steps.push({
+                kind: 'embedded-packaging',
+                digest: pack.index.indexDigest,
+                objectCount: pack.index.objectCount,
+            });
+            result.embeddedPackaging = {
+                digest: pack.index.indexDigest,
+                objectCount: pack.index.objectCount,
+                schema: pack.index.schema,
+            };
+        }
+    }
+    result.packDigest = ctx.pack?.packDigest || null;
+    result.assembleDigest = sha256Hex(canonicalJson({ ...result, assembleDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'assemble-manifest.json');
+    writePrettyJsonFile(file, result);
+    return { manifest: result, path: file };
+}
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export function emitBuildProof(outDir, ctx) {
+    const semanticIds = semanticIdsForAssembly(ctx.selection.assembly);
+    const slots = {
+        'server-host': { status: 'not-applicable' },
+        'static-delivery': { status: 'not-applicable' },
+        'site-fallback': { status: 'not-applicable' },
+        'asset-graph': { status: 'not-applicable' },
+    };
+    for (const id of semanticIds) {
+        if (id === 'static-delivery') {
+            const step = (ctx.assemble?.steps || []).find((s) => s.kind === 'static-cdn');
+            slots[id] = step
+                ? { status: 'emitted', detail: `digest=${String(step.digest).slice(0, 12)}` }
+                : { status: 'pending', detail: 'assembly requires static emit' };
+        }
+        else if (id === 'site-fallback') {
+            const siteStep = (ctx.assemble?.steps || []).find((s) => s.kind === 'site-delivery');
+            const packStep = (ctx.assemble?.steps || []).find((s) => s.kind === 'embedded-packaging');
+            if (siteStep && packStep) {
+                slots[id] = {
+                    status: 'emitted',
+                    detail: `contract=${String(siteStep.digest).slice(0, 12)}; pack=${String(packStep.digest).slice(0, 12)}; objects=${packStep.objectCount ?? '?'}`,
+                };
+            }
+            else if (siteStep && siteStep.status !== 'skipped') {
+                slots[id] = {
+                    status: 'pending',
+                    detail: 'site contract emitted; embedded packaging missing',
+                };
+            }
+            else {
+                slots[id] = { status: 'pending', detail: siteStep?.reason || 'no site sources' };
+            }
+        }
+        else if (id === 'server-host') {
+            const step = (ctx.assemble?.steps || []).find((s) => s.kind === 'server-host');
+            slots[id] =
+                step && step.status === 'emitted'
+                    ? {
+                        status: 'emitted',
+                        detail: `digest=${String(step.digest).slice(0, 12)}; routes=${step.publicRoutes ?? 0}; internal=${step.internalCapabilities ?? 0}`,
+                    }
+                    : {
+                        status: 'pending',
+                        detail: step?.note || 'ServerArtifact not emitted',
+                    };
+        }
+        else if (id === 'asset-graph') {
+            slots[id] = {
+                status: ctx.pack?.packDigest ? 'pack-digest' : 'pending',
+                detail: ctx.pack?.packDigest
+                    ? `pack=${String(ctx.pack.packDigest).slice(0, 12)} units=${ctx.pack.unitCount ?? '?'}`
+                    : 'pack missing',
+            };
+        }
+    }
+    const body = {
+        schema: BUILD_PROOF_SCHEMA,
+        profileId: ctx.selection.profileId,
+        assembly: ctx.selection.assembly,
+        selectionDigest: ctx.selection.digest || null,
+        packDigest: ctx.pack?.packDigest || null,
+        assembleDigest: ctx.assemble?.assembleDigest || null,
+        release: Boolean(ctx.release),
+        semanticIds,
+        slots,
+        productionReadyClaim: false,
+        note: 'Aggregate production-ready requires browser-production + cleared production-proof gaps (08)',
+    };
+    body.proofDigest = sha256Hex(canonicalJson({ ...body, proofDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'build-proof.json');
+    writePrettyJsonFile(file, body);
+    return { proof: body, path: file };
+}

package/dist/cdn-policy.d.ts

@@ -9,9 +9,13 @@ export declare const CACHE_HTML = "public, max-age=0, must-revalidate";
 export declare const CACHE_ASSET_IMMUTABLE = "public, max-age=31536000, immutable";
 export declare const CACHE_META = "public, max-age=3600";
 /**
- * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects).
+ * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects / locale artifact).
+ * Locale-prefixed HTML gets LocaleId-encoded cache keys; Accept-Language must not steal body.
  * @param {Record<string, any>} staticManifest
- * @param {{ redirects?: Array<{ from: string, to: string, status?: number, reason?: string }> }} [opts]
+ * @param {{
+ *   redirects?: Array<{ from: string, to: string, status?: number, reason?: string }>,
+ *   localeArtifact?: Record<string, any> | null,
+ * }} [opts]
  */
 export declare function buildCdnPolicyManifest(staticManifest: any, opts?: {}): {
     schema: string;
@@ -35,7 +39,14 @@ export declare function buildCdnPolicyManifest(staticManifest: any, opts?: {}):
         };
     })[];
     errorDocuments: any;
-    routes: any;
+    routes: any[];
+    localeCache: {
+        strategy: string;
+        varyAcceptLanguage: boolean;
+        defaultLocale: any;
+        routeCount: number;
+        locales: any[];
+    };
 };
 /**
  * Write CDN policy + adapter projections under dist/_vmz.
@@ -66,7 +77,14 @@ export declare function emitCdnPolicy(distDir: any, staticManifest: any, opts?:
             };
         })[];
         errorDocuments: any;
-        routes: any;
+        routes: any[];
+        localeCache: {
+            strategy: string;
+            varyAcceptLanguage: boolean;
+            defaultLocale: any;
+            routeCount: number;
+            locales: any[];
+        };
     };
     adapters: {
         'local-static': {

package/dist/cdn-policy.js

@@ -7,6 +7,8 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
+import { assertLocaleCacheKey, localeAwareCacheKey } from './locale-router.js';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const CDN_POLICY_MANIFEST_SCHEMA = 'vmz.cdn.policy_manifest.v0';
 export const CDN_ADAPTER_PROJECTION_SCHEMA = 'vmz.cdn.adapter_projection.v0';
 /** HTML: revalidate. Hashed/static assets: long immutable. */
@@ -14,13 +16,19 @@ export const CACHE_HTML = 'public, max-age=0, must-revalidate';
 export const CACHE_ASSET_IMMUTABLE = 'public, max-age=31536000, immutable';
 export const CACHE_META = 'public, max-age=3600';
 /**
- * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects).
+ * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects / locale artifact).
+ * Locale-prefixed HTML gets LocaleId-encoded cache keys; Accept-Language must not steal body.
  * @param {Record<string, any>} staticManifest
- * @param {{ redirects?: Array<{ from: string, to: string, status?: number, reason?: string }> }} [opts]
+ * @param {{
+ *   redirects?: Array<{ from: string, to: string, status?: number, reason?: string }>,
+ *   localeArtifact?: Record<string, any> | null,
+ * }} [opts]
  */
 export function buildCdnPolicyManifest(staticManifest, opts = {}) {
     const origin = String(staticManifest.origin || '');
-    const redirects = [{ from: '/home', to: '/', status: 301, reason: 'canonical-alias' }, ...(opts.redirects || [])];
+    const localeArt = opts.localeArtifact || null;
+    const localeRedirects = buildOmitPrefixRedirects(staticManifest, localeArt);
+    const redirects = [{ from: '/home', to: '/', status: 301, reason: 'canonical-alias' }, ...localeRedirects, ...(opts.redirects || [])];
     const headers = [
         { match: '**/*.html', headers: { 'cache-control': CACHE_HTML } },
         {
@@ -34,6 +42,47 @@ export function buildCdnPolicyManifest(staticManifest, opts = {}) {
         { match: '**/robots.txt', headers: { 'cache-control': CACHE_META } },
     ];
     const errorDocuments = Array.isArray(staticManifest.errorDocuments) ? staticManifest.errorDocuments : [{ status: 404, path: '404.html' }];
+    /** @type {any[]} */
+    const routes = [];
+    /** @type {any[]} */
+    const cacheKeyDiagnostics = [];
+    for (const r of staticManifest.routes || []) {
+        const localeId = r.localeId || null;
+        const alternates = Array.isArray(r.seo?.alternates) ? r.seo.alternates : [];
+        const cacheKey = localeId
+            ? localeAwareCacheKey({ routeId: String(r.routeId), localeId: String(localeId), path: String(r.path) })
+            : `route=${r.routeId}|path=${r.path}`;
+        // When LocaleId is bound, prove the key would still be safe even if Vary: Accept-Language were set.
+        if (localeId) {
+            const assert = assertLocaleCacheKey({
+                cacheKey,
+                varyAcceptLanguage: true,
+                localeId: String(localeId),
+            });
+            if (!assert.ok) {
+                cacheKeyDiagnostics.push(...(assert.diagnostics || []));
+            }
+        }
+        routes.push({
+            routeId: r.routeId,
+            path: r.path,
+            htmlPath: r.htmlPath,
+            canonical: r.seo?.canonical || null,
+            localeId,
+            cacheKey,
+            varyAcceptLanguage: false,
+            hreflang: alternates.map((a) => ({
+                hreflang: a.hreflang,
+                href: a.href,
+                localeId: a.localeId || null,
+            })),
+        });
+    }
+    if (cacheKeyDiagnostics.length) {
+        const msg = cacheKeyDiagnostics.map((d) => d.message || d.code).join('; ');
+        throw new Error(`buildCdnPolicyManifest: locale cache key contract failed: ${msg}`);
+    }
+    const localeRoutes = routes.filter((r) => r.localeId);
     const body = {
         schema: CDN_POLICY_MANIFEST_SCHEMA,
         applicationId: staticManifest.applicationId || null,
@@ -44,16 +93,48 @@ export function buildCdnPolicyManifest(staticManifest, opts = {}) {
         redirects,
         headers,
         errorDocuments,
-        routes: (staticManifest.routes || []).map((r) => ({
-            routeId: r.routeId,
-            path: r.path,
-            htmlPath: r.htmlPath,
-            canonical: r.seo?.canonical || null,
-        })),
+        routes,
+        localeCache: {
+            strategy: 'path-locale',
+            varyAcceptLanguage: false,
+            defaultLocale: localeArt?.defaultLocale || null,
+            routeCount: localeRoutes.length,
+            locales: [...new Set(localeRoutes.map((r) => r.localeId))],
+        },
     };
     body.policyDigest = sha256Hex(canonicalJson(body));
     return body;
 }
+/**
+ * Omit-prefix: /{defaultLocale}/… → canonical unprefixed path (CDN redirect, not Accept-Language).
+ * @param {Record<string, any>} staticManifest
+ * @param {Record<string, any> | null} localeArt
+ */
+function buildOmitPrefixRedirects(staticManifest, localeArt) {
+    const routing = localeArt?.routing || {};
+    const defaultLocale = localeArt?.defaultLocale || routing.defaultLocale;
+    if (!defaultLocale || routing.defaultPrefix !== 'omit')
+        return [];
+    /** @type {Array<{ from: string, to: string, status: number, reason: string }>} */
+    const out = [];
+    const seen = new Set();
+    for (const r of staticManifest.routes || []) {
+        if (r.localeId !== defaultLocale)
+            continue;
+        const canonical = String(r.path || '/');
+        const from = canonical === '/' ? `/${defaultLocale}` : `/${defaultLocale}${canonical.startsWith('/') ? canonical : `/${canonical}`}`;
+        if (seen.has(from))
+            continue;
+        seen.add(from);
+        out.push({
+            from,
+            to: canonical,
+            status: 301,
+            reason: 'locale-omit-prefix-default',
+        });
+    }
+    return out;
+}
 /**
  * Write CDN policy + adapter projections under dist/_vmz.
  * @param {string} distDir
@@ -61,21 +142,36 @@ export function buildCdnPolicyManifest(staticManifest, opts = {}) {
  * @param {{ redirects?: Array<{ from: string, to: string, status?: number, reason?: string }> }} [opts]
  */
 export function emitCdnPolicy(distDir, staticManifest, opts = {}) {
-    const policy = buildCdnPolicyManifest(staticManifest, opts);
+    const localeArtifact = loadLocaleArtifact(distDir);
+    const policy = buildCdnPolicyManifest(staticManifest, { ...opts, localeArtifact });
     const vmzDir = path.join(distDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
-    fs.writeFileSync(path.join(vmzDir, 'cdn-policy-manifest.json'), `${JSON.stringify(policy, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'cdn-policy-manifest.json'), policy);
     const local = projectCdnAdapter(policy, 'local-static');
     const netlify = projectCdnAdapter(policy, 'netlify');
     const adaptersDir = path.join(vmzDir, 'adapters');
     fs.mkdirSync(path.join(adaptersDir, 'local-static'), { recursive: true });
     fs.mkdirSync(path.join(adaptersDir, 'netlify'), { recursive: true });
-    fs.writeFileSync(path.join(adaptersDir, 'local-static', 'projection.json'), `${JSON.stringify(local, null, 2)}\n`, 'utf8');
-    fs.writeFileSync(path.join(adaptersDir, 'netlify', 'projection.json'), `${JSON.stringify(netlify, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(adaptersDir, 'local-static', 'projection.json'), local);
+    writePrettyJsonFile(path.join(adaptersDir, 'netlify', 'projection.json'), netlify);
     fs.writeFileSync(path.join(adaptersDir, 'netlify', '_headers'), String(netlify.files['_headers'] || ''), 'utf8');
     fs.writeFileSync(path.join(adaptersDir, 'netlify', '_redirects'), String(netlify.files['_redirects'] || ''), 'utf8');
     return { policy, adapters: { 'local-static': local, netlify } };
 }
+/**
+ * @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;
+    }
+}
 /**
  * Project vendor-neutral policy to an adapter. Must preserve redirect targets and forbid SPA fallback.
  * @param {Record<string, any>} policy