@vmz/vmz 0.0.4 → 0.1.0

package/dist/delivery-profile.d.ts

@@ -0,0 +1,74 @@
+/**
+ * B0 — Delivery profile authoring normalize + CLI --profile resolve.
+ * Pure data only; expands legacy site-delivery sugar into profiles[default].
+ */
+export declare const DELIVERY_PROFILE_AUTHORING_SCHEMA = "vmz.delivery.authoring.v0";
+export declare const BUILD_PROFILE_SELECTION_SCHEMA = "vmz.build.profile_selection.v0";
+/** Browser-era assembly kinds (04 B5). */
+export declare const ASSEMBLIES: readonly string[];
+export declare const SERVER_RUNTIMES: readonly string[];
+/** Official built-in aliases when not overridden in config. */
+export declare const BUILTIN_PROFILES: Readonly<{
+    'web-client': {
+        host: string;
+        assembly: string;
+    };
+    'web-static': {
+        host: string;
+        assembly: string;
+    };
+    'web-ssr': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+    'web-hybrid': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+}>;
+export declare function pickSiteAuthoring(raw: any): {
+    artifact: string;
+    sources: any;
+};
+export declare function normalizeDeliveryAuthoring(raw: any): {
+    ok: boolean;
+    table: {
+        schema: string;
+        default: string;
+        profiles: {};
+        sugar: boolean;
+    };
+    diagnostics?: undefined;
+} | {
+    ok: boolean;
+    diagnostics: any[];
+    table?: undefined;
+};
+export declare function selectBuildProfile(table: any, cliProfile?: string): {
+    ok: boolean;
+    diagnostics: {
+        code: string;
+        message: string;
+    }[];
+    selection?: undefined;
+    profile?: undefined;
+} | {
+    ok: boolean;
+    selection: {
+        schema: string;
+        profileId: any;
+        host: any;
+        assembly: any;
+        serverRuntime: any;
+        hasSiteSources: boolean;
+        authoringDigest: any;
+        fromCli: boolean;
+    };
+    profile: any;
+    diagnostics?: undefined;
+};
+export declare function semanticIdsForAssembly(assembly: any): string[];
+export declare function canonicalJson(value: any): string;
+export declare function sha256Hex(text: any): string;

package/dist/delivery-profile.js

@@ -0,0 +1,279 @@
+/**
+ * B0 — Delivery profile authoring normalize + CLI --profile resolve.
+ * Pure data only; expands legacy site-delivery sugar into profiles[default].
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+export const DELIVERY_PROFILE_AUTHORING_SCHEMA = 'vmz.delivery.authoring.v0';
+export const BUILD_PROFILE_SELECTION_SCHEMA = 'vmz.build.profile_selection.v0';
+/** Browser-era assembly kinds (04 B5). */
+export const ASSEMBLIES = Object.freeze(['local-static', 'static-cdn', 'server-host', 'cdn+server', 'rust-embedded']);
+export const SERVER_RUNTIMES = Object.freeze(['node', 'worker', 'deno', 'bun', 'rust-host']);
+/** Official built-in aliases when not overridden in config. */
+export const BUILTIN_PROFILES = Object.freeze({
+    'web-client': { host: 'browser', assembly: 'local-static' },
+    'web-static': { host: 'browser', assembly: 'static-cdn' },
+    'web-ssr': { host: 'browser', assembly: 'server-host', serverRuntime: 'node' },
+    'web-hybrid': { host: 'browser', assembly: 'cdn+server', serverRuntime: 'node' },
+});
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+export function pickSiteAuthoring(raw) {
+    if (!isPlainObject(raw))
+        return null;
+    if (!Array.isArray(raw.sources) || raw.sources.length < 1)
+        return null;
+    if (typeof raw.artifact !== 'string' || !String(raw.artifact).trim())
+        return null;
+    const site = {
+        artifact: String(raw.artifact),
+        sources: raw.sources,
+    };
+    for (const k of [
+        'siteId',
+        'resolution',
+        'activation',
+        'expectedCompatibility',
+        'failure',
+        'failurePolicy',
+        'update',
+        'updatePolicy',
+        'rollback',
+        'rollbackPolicy',
+        'security',
+        'securityPolicy',
+    ]) {
+        if (raw[k] !== undefined)
+            site[k] = raw[k];
+    }
+    return site;
+}
+function normalizeProfileEntry(entry, id, diagnostics) {
+    if (!isPlainObject(entry)) {
+        diagnostics.push({ code: 'delivery.profile.invalid', message: `profiles.${id} must be an object` });
+        return null;
+    }
+    const host = String(entry.host || 'browser');
+    if (host !== 'browser') {
+        diagnostics.push({
+            code: 'delivery.profile.host',
+            message: `profiles.${id}.host: only 'browser' is supported before Browser Production (got ${host})`,
+        });
+    }
+    const assembly = String(entry.assembly || '').trim();
+    if (!ASSEMBLIES.includes(assembly)) {
+        diagnostics.push({
+            code: 'delivery.profile.assembly',
+            message: `profiles.${id}.assembly must be one of ${ASSEMBLIES.join('|')} (got ${assembly || '(empty)'})`,
+        });
+        return null;
+    }
+    let serverRuntime = null;
+    if (assembly === 'server-host' || assembly === 'cdn+server') {
+        serverRuntime = String(entry.serverRuntime || 'node');
+        if (!SERVER_RUNTIMES.includes(serverRuntime)) {
+            diagnostics.push({
+                code: 'delivery.profile.serverRuntime',
+                message: `profiles.${id}.serverRuntime must be one of ${SERVER_RUNTIMES.join('|')}`,
+            });
+        }
+    }
+    let sources = null;
+    if (entry.sources != null) {
+        if (isPlainObject(entry.sources) && Array.isArray(entry.sources.sources)) {
+            sources = pickSiteAuthoring(entry.sources);
+        }
+        else if (Array.isArray(entry.sources)) {
+            sources = pickSiteAuthoring({
+                artifact: entry.artifact || entry.sourcesArtifact || id,
+                sources: entry.sources,
+                resolution: entry.resolution,
+                activation: entry.activation,
+            });
+        }
+        else {
+            diagnostics.push({
+                code: 'delivery.profile.sources',
+                message: `profiles.${id}.sources must be defineSite({...}) or a sources array with artifact`,
+            });
+        }
+        if (entry.sources != null && sources == null) {
+            const already = diagnostics.some((d) => String(d.message || '').includes(`profiles.${id}`));
+            if (!already) {
+                diagnostics.push({
+                    code: 'delivery.profile.sources.artifact',
+                    message: `profiles.${id} site sources require artifact string`,
+                });
+            }
+        }
+    }
+    return {
+        id,
+        host: 'browser',
+        assembly,
+        serverRuntime,
+        sources,
+    };
+}
+export function normalizeDeliveryAuthoring(raw) {
+    const diagnostics = [];
+    if (raw == null) {
+        const profiles = { ...BUILTIN_PROFILES };
+        const normalized = {};
+        for (const [id, entry] of Object.entries(profiles)) {
+            const n = normalizeProfileEntry(entry, id, diagnostics);
+            if (n)
+                normalized[id] = n;
+        }
+        const table = {
+            schema: DELIVERY_PROFILE_AUTHORING_SCHEMA,
+            default: 'web-ssr',
+            profiles: normalized,
+            sugar: false,
+        };
+        table.digest = sha256Hex(canonicalJson(table));
+        return { ok: true, table };
+    }
+    if (!isPlainObject(raw)) {
+        return {
+            ok: false,
+            diagnostics: [{ code: 'delivery.invalid', message: 'delivery must be a plain object' }],
+        };
+    }
+    let profileInputs = {};
+    let defaultId = '';
+    let sugar = false;
+    if (isPlainObject(raw.profiles)) {
+        defaultId = String(raw.default || '').trim();
+        profileInputs = { ...BUILTIN_PROFILES, ...raw.profiles };
+        if (!defaultId) {
+            const keys = Object.keys(raw.profiles);
+            defaultId = keys[0] || 'web-ssr';
+        }
+    }
+    else if (Array.isArray(raw.sources) || raw.artifact != null || raw.assembly != null) {
+        sugar = true;
+        const site = pickSiteAuthoring(raw);
+        defaultId = String(raw.default || raw.artifact || 'web-ssr').trim() || 'web-ssr';
+        const assembly = typeof raw.assembly === 'string' && ASSEMBLIES.includes(raw.assembly) ? raw.assembly : site ? 'rust-embedded' : 'server-host';
+        profileInputs = {
+            ...BUILTIN_PROFILES,
+            [defaultId]: {
+                host: raw.host || 'browser',
+                assembly,
+                serverRuntime: raw.serverRuntime || 'node',
+                ...(site
+                    ? {
+                        artifact: site.artifact,
+                        sources: site.sources,
+                        resolution: site.resolution,
+                        activation: site.activation,
+                        expectedCompatibility: site.expectedCompatibility,
+                        failure: site.failure,
+                        failurePolicy: site.failurePolicy,
+                        update: site.update,
+                        updatePolicy: site.updatePolicy,
+                        rollback: site.rollback,
+                        rollbackPolicy: site.rollbackPolicy,
+                        security: site.security,
+                        securityPolicy: site.securityPolicy,
+                    }
+                    : {}),
+            },
+        };
+    }
+    else {
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    code: 'delivery.shape',
+                    message: 'delivery must declare profiles{} or legacy { artifact, sources }',
+                },
+            ],
+        };
+    }
+    const profiles = {};
+    for (const [id, entry] of Object.entries(profileInputs)) {
+        const n = normalizeProfileEntry(entry, id, diagnostics);
+        if (n)
+            profiles[id] = n;
+    }
+    if (!profiles[defaultId]) {
+        diagnostics.push({
+            code: 'delivery.default',
+            message: `delivery.default '${defaultId}' is not a known profile`,
+        });
+    }
+    if (diagnostics.length)
+        return { ok: false, diagnostics };
+    const table = {
+        schema: DELIVERY_PROFILE_AUTHORING_SCHEMA,
+        default: defaultId,
+        profiles,
+        sugar,
+    };
+    table.digest = sha256Hex(canonicalJson(table));
+    return { ok: true, table };
+}
+export function selectBuildProfile(table, cliProfile = '') {
+    const id = String(cliProfile || '').trim() || table.default;
+    const profile = table.profiles[id];
+    if (!profile) {
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    code: 'delivery.profile.unknown',
+                    message: `unknown build --profile ${id} (known: ${Object.keys(table.profiles).join(', ')})`,
+                },
+            ],
+        };
+    }
+    const selection = {
+        schema: BUILD_PROFILE_SELECTION_SCHEMA,
+        profileId: id,
+        host: profile.host,
+        assembly: profile.assembly,
+        serverRuntime: profile.serverRuntime,
+        hasSiteSources: Boolean(profile.sources),
+        authoringDigest: table.digest,
+        fromCli: Boolean(String(cliProfile || '').trim()),
+    };
+    selection.digest = sha256Hex(canonicalJson(selection));
+    return { ok: true, selection, profile };
+}
+export function semanticIdsForAssembly(assembly) {
+    switch (assembly) {
+        case 'static-cdn':
+            return ['static-delivery', 'asset-graph'];
+        case 'server-host':
+            return ['server-host', 'asset-graph'];
+        case 'cdn+server':
+            return ['server-host', 'static-delivery', 'asset-graph'];
+        case 'rust-embedded':
+            return ['site-fallback', 'asset-graph'];
+        case 'local-static':
+            return ['asset-graph'];
+        default:
+            return [];
+    }
+}
+export function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const k of Object.keys(value).sort())
+            out[k] = sortKeys(value[k]);
+        return out;
+    }
+    return value;
+}
+export function sha256Hex(text) {
+    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}

package/dist/dev-session.js

@@ -51,8 +51,9 @@ export function createDevSession(options) {
     }
     function emitLocales() {
         const localeEmit = emitLocaleRuntimeModules(project, outDir);
+        // Always surface locale diagnostics (warnings included) — missing /locales must not be silent.
+        log.diagnostics(localeEmit.diagnostics ?? []);
         if (!localeEmit.ok || localeHasErrors({ diagnostics: localeEmit.diagnostics })) {
-            log.diagnostics(localeEmit.diagnostics ?? []);
             log.error('locale runtime emit failed');
             return false;
         }

package/dist/document-build.js

@@ -164,11 +164,12 @@ function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, desig
     /** @type {string[]} */
     const cssHrefs = [];
     if (hostChrome) {
-        // Same application stylesheet as landing pages (header/footer chrome).
-        cssHrefs.push(`${prefix}vmz.css`);
+        // Integrated documents are served with pretty directory URLs. Root
+        // absolute assets remain correct for both emitted files and rewrites.
+        cssHrefs.push('/vmz.css');
     }
     if (designsHref)
-        cssHrefs.push(prefix + designsHref);
+        cssHrefs.push(hostChrome ? `/${designsHref}` : prefix + designsHref);
     const cssLink = cssHrefs.map((href) => `  <link rel="stylesheet" href="${esc(href)}" />`).join('\n') + (cssHrefs.length ? '\n' : '');
     const navItems = nav
         .map((n) => {
@@ -200,13 +201,17 @@ ${cssLink}</head>
   <div class="site site--docs">
   <a class="skip-link" href="#main">Skip to content</a>
 ${header}
+  <div class="doc-body">
+    <aside class="doc-sidebar">
 ${docsNav}
 ${searchShellHtml}
-  <div class="doc-body">
+    </aside>
+    <div class="doc-content">
   ${toc}<main id="main">
 ${bodyHtml}
 ${playgroundShellHtml}
   </main>
+    </div>
   </div>
 ${hostChrome.footer}
   </div>

package/dist/document-enrich.js

@@ -199,6 +199,14 @@ function resolveDocHref(href, fromPageKey, locale, routeBase, pageKeySet) {
     pk = normalizePageKey(pk);
     const keys = pageKeySet.get(locale) || new Set();
     if (!keys.has(pk)) {
+        // A directory index and a leaf page share the same normalized PageKey shape.
+        // Prefer the regular sibling resolution above, then retry relative to the
+        // PageKey itself so `guide/optimizations/index.md` keeps its directory.
+        const indexJoined = path.posix.normalize(path.posix.join(fromPageKey || '.', pathPart));
+        const indexPk = normalizePageKey(indexJoined.replace(/^\.\//, ''));
+        if (keys.has(indexPk)) {
+            return { ok: true, locale, pageKey: indexPk, anchor, anchors: [] };
+        }
         return { ok: false, reason: `no PageKey ${pk} in ${locale}` };
     }
     return { ok: true, locale, pageKey: pk, anchor, anchors: [] };

package/dist/embedded-packaging.d.ts

@@ -0,0 +1,22 @@
+/**
+ * rust-embedded packaging adapter: resource index + baseline closure.
+ * Packaging only — does not invent route / MIME / fallback semantics.
+ */
+export declare const EMBEDDED_RESOURCE_INDEX_SCHEMA = "vmz.embedded.resource_index.v0";
+/**
+ * Walk outDir and build path → digest → relative blob path map.
+ * Copies files into `dist/_vmz/embedded-baseline/` (whole release, no file-level mix).
+ * @param {string} outDir
+ * @param {{ siteId?: string, contractDigest?: string | null }} [opts]
+ */
+export declare function emitEmbeddedPackaging(outDir: any, opts?: {}): {
+    index: {
+        schema: string;
+        siteId: any;
+        contractDigest: any;
+        objectCount: number;
+        objects: any[];
+    };
+    indexPath: string;
+    baselineDir: string;
+};

package/dist/embedded-packaging.js

@@ -0,0 +1,113 @@
+/**
+ * rust-embedded packaging adapter: resource index + baseline closure.
+ * Packaging only — does not invent route / MIME / fallback semantics.
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+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',
+]);
+/**
+ * Walk outDir and build path → digest → relative blob path map.
+ * Copies files into `dist/_vmz/embedded-baseline/` (whole release, no file-level mix).
+ * @param {string} outDir
+ * @param {{ siteId?: string, contractDigest?: string | null }} [opts]
+ */
+export function emitEmbeddedPackaging(outDir, opts = {}) {
+    const vmzDir = path.join(outDir, '_vmz');
+    const baselineDir = path.join(vmzDir, 'embedded-baseline');
+    fs.mkdirSync(baselineDir, { recursive: true });
+    /** @type {Array<{ path: string, digest: string, blob: string, bytes: number }>} */
+    const objects = [];
+    const root = path.resolve(outDir);
+    walkFiles(root, (abs) => {
+        const rel = toPosix(path.relative(root, abs));
+        if (!rel || rel.startsWith('_vmz/embedded-baseline'))
+            return;
+        if (rel.startsWith('_vmz/embedded-resource-index'))
+            return;
+        const base = path.basename(abs);
+        if (SKIP_NAMES.has(base))
+            return;
+        // Keep other _vmz manifests inside baseline (contract, capability table, etc.)
+        const buf = fs.readFileSync(abs);
+        const digest = sha256Hex(buf);
+        const blobRel = `objects/${digest.slice(0, 2)}/${digest}`;
+        const blobAbs = path.join(baselineDir, blobRel);
+        fs.mkdirSync(path.dirname(blobAbs), { recursive: true });
+        if (!fs.existsSync(blobAbs))
+            fs.writeFileSync(blobAbs, buf);
+        // Also mirror tree under baseline/tree for host convenience
+        const treeAbs = path.join(baselineDir, 'tree', rel);
+        fs.mkdirSync(path.dirname(treeAbs), { recursive: true });
+        fs.copyFileSync(abs, treeAbs);
+        objects.push({ path: rel, digest, blob: blobRel, bytes: buf.length });
+    });
+    objects.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const index = {
+        schema: EMBEDDED_RESOURCE_INDEX_SCHEMA,
+        siteId: opts.siteId || null,
+        contractDigest: opts.contractDigest || null,
+        objectCount: objects.length,
+        objects,
+    };
+    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');
+    // 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)
+// Index digest: ${index.indexDigest}
+pub const EMBEDDED_RESOURCE_INDEX: &str = include_str!("embedded-resource-index.json");
+`, 'utf8');
+    return { index, indexPath, baselineDir };
+}
+/**
+ * @param {string} dir
+ * @param {(abs: string) => void} onFile
+ */
+function walkFiles(dir, onFile) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const name of fs.readdirSync(dir)) {
+        if (SKIP_NAMES.has(name))
+            continue;
+        const abs = path.join(dir, name);
+        const st = fs.statSync(abs);
+        if (st.isDirectory()) {
+            if (name === 'embedded-baseline' && path.basename(path.dirname(abs)) === '_vmz')
+                continue;
+            walkFiles(abs, onFile);
+        }
+        else if (st.isFile()) {
+            onFile(abs);
+        }
+    }
+}
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+function sha256Hex(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const k of Object.keys(value).sort())
+            out[k] = sortKeys(value[k]);
+        return out;
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -151,10 +151,17 @@ export { STATIC_DELIVERY_MANIFEST_SCHEMA, emitWebStatic, } from './static-emit.j
 export { CONTENT_ADDRESSED_ASSETS_SCHEMA, emitContentAddressedAssets, resolveAssetByDigest, assertSharedAssetPath, contentAddressedAssetsDigest, } from './content-addressed-assets.js';
 export { CDN_POLICY_MANIFEST_SCHEMA, CDN_ADAPTER_PROJECTION_SCHEMA, CACHE_HTML, CACHE_ASSET_IMMUTABLE, CACHE_META, buildCdnPolicyManifest, emitCdnPolicy, projectCdnAdapter, createLocalStaticHandler, listenLocalStaticHost, matchGlob, } from './cdn-policy.js';
 export { SITE_DELIVERY_CONTRACT_SCHEMA, SITE_DELIVERY_RESOLUTION_SCHEMA, defineSite, normalizeSiteDelivery, normalizeSourceProbe, resolveSiteRelease, probeReleaseDirectory, emitSiteDelivery, } from './site-delivery.js';
+export { EMBEDDED_RESOURCE_INDEX_SCHEMA, emitEmbeddedPackaging, } from './embedded-packaging.js';
+export { SERVER_LANG_IDS, SERVER_LANG_ALIASES, SERVER_LANGUAGE_BACKENDS, resolveServerLanguage, assertLangRuntimePair, } from './server-language-backend.js';
+export { DELIVERY_PROFILE_AUTHORING_SCHEMA, BUILD_PROFILE_SELECTION_SCHEMA, ASSEMBLIES, SERVER_RUNTIMES, BUILTIN_PROFILES, pickSiteAuthoring, normalizeDeliveryAuthoring, selectBuildProfile, semanticIdsForAssembly, } from './delivery-profile.js';
+export { PACK_MANIFEST_SCHEMA, packFromDeploymentIr, ensureRuntimeCompanions } from './pack.js';
+export { SERVER_ARTIFACT_SCHEMA, HTTP_CONTRACT_SCHEMA, SERVER_RUNTIME_ADAPTER_SCHEMA, emitServerArtifact, projectServerRuntimeAdapter, } from './server-artifact.js';
+export { BUILD_PROOF_SCHEMA, ASSEMBLE_MANIFEST_SCHEMA, assembleDelivery, emitBuildProof, } from './build-assemble.js';
 export { PRODUCTION_SCENARIO_PACK_SCHEMA, PRODUCTION_CI_PROFILE_SCHEMA, PRODUCTION_TEST_REPORT_SCHEMA, browserProductionScenarioPack, browserProductionCiProfile, normalizeScenarioPack, normalizeCiProfile, scenarioPackDigest, ciProfileDigest, buildProductionTestReport, productionTestReportDigest, emitProductionTestArtifacts, assertNoForbiddenRunners, } from './production-test-pack.js';
 export { PRODUCTION_OBSERVABILITY_SCHEMA, PRODUCTION_TRACE_SCHEMA, REQUIRED_TRACE_FACETS, browserProductionObservability, normalizeObservability, redactSensitive, validateProductionTrace, buildCoveringProductionTrace, checkProductionBudgets, checkCapabilityClosure, applySecurityHeadersToCdnPolicy, measureDistBudgets, emitProductionObservability, observabilityDigest, } from './production-observability.js';
 export { buildApplicationContext, buildFormatterContext, checkLocaleRuntime, checkSsrClientParity, createLocaleSession, formatMessageTemplate, formatterContextDigest, negotiateLocale, resolveMessageVariant, validateFormatterContext, } from './locale-runtime.js';
-export { absoluteUrl, assertLocaleCacheKey, buildLocalePageMeta, buildLocaleRouteRealizationTable, checkLocaleRouter, commitLocaleRouteMetaTransition, localeAwareCacheKey, parseLocaleFromPath, planLocalePathNavigation, realizeRoutePath, resolveLinkHref, } from './locale-router.js';
+export { absoluteUrl, assertLocaleCacheKey, buildLocalePageMeta, buildLocaleRouteRealizationTable, checkLocaleRouter, commitLocaleRouteMetaTransition, localeAwareCacheKey, localizeBodyLinks, localizeSameAppHref, parseLocaleFromPath, planLocalePathNavigation, realizeRoutePath, resolveLinkHref, } from './locale-router.js';
+export { LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA, emitLocaleRouteRealization, } from './locale-route-emit.js';
 export { assertHostMessageInvariant, assertServerErrorEnvelope, assertServerFormatContext, buildLocaleDeliveryResolution, checkLocaleDelivery, fallbackDigest, messageCatalogHash, proveMiniPackageMessages, validateNativeLocalePack, } from './locale-delivery.js';
 export { checkLocaleConformance, diffLocaleCatalogs, explainLocaleMessage, extractHardcodedText, pseudoLocalizeCatalog, } from './locale-tooling.js';
 export { applyPlugins, contentHash, defineConfig, definePlugin, loadVmzConfig, } from './plugin-host.js';

package/dist/index.js

@@ -333,10 +333,17 @@ export { STATIC_DELIVERY_MANIFEST_SCHEMA, emitWebStatic, } from './static-emit.j
 export { CONTENT_ADDRESSED_ASSETS_SCHEMA, emitContentAddressedAssets, resolveAssetByDigest, assertSharedAssetPath, contentAddressedAssetsDigest, } from './content-addressed-assets.js';
 export { CDN_POLICY_MANIFEST_SCHEMA, CDN_ADAPTER_PROJECTION_SCHEMA, CACHE_HTML, CACHE_ASSET_IMMUTABLE, CACHE_META, buildCdnPolicyManifest, emitCdnPolicy, projectCdnAdapter, createLocalStaticHandler, listenLocalStaticHost, matchGlob, } from './cdn-policy.js';
 export { SITE_DELIVERY_CONTRACT_SCHEMA, SITE_DELIVERY_RESOLUTION_SCHEMA, defineSite, normalizeSiteDelivery, normalizeSourceProbe, resolveSiteRelease, probeReleaseDirectory, emitSiteDelivery, } from './site-delivery.js';
+export { EMBEDDED_RESOURCE_INDEX_SCHEMA, emitEmbeddedPackaging, } from './embedded-packaging.js';
+export { SERVER_LANG_IDS, SERVER_LANG_ALIASES, SERVER_LANGUAGE_BACKENDS, resolveServerLanguage, assertLangRuntimePair, } from './server-language-backend.js';
+export { DELIVERY_PROFILE_AUTHORING_SCHEMA, BUILD_PROFILE_SELECTION_SCHEMA, ASSEMBLIES, SERVER_RUNTIMES, BUILTIN_PROFILES, pickSiteAuthoring, normalizeDeliveryAuthoring, selectBuildProfile, semanticIdsForAssembly, } from './delivery-profile.js';
+export { PACK_MANIFEST_SCHEMA, packFromDeploymentIr, ensureRuntimeCompanions } from './pack.js';
+export { SERVER_ARTIFACT_SCHEMA, HTTP_CONTRACT_SCHEMA, SERVER_RUNTIME_ADAPTER_SCHEMA, emitServerArtifact, projectServerRuntimeAdapter, } from './server-artifact.js';
+export { BUILD_PROOF_SCHEMA, ASSEMBLE_MANIFEST_SCHEMA, assembleDelivery, emitBuildProof, } from './build-assemble.js';
 export { PRODUCTION_SCENARIO_PACK_SCHEMA, PRODUCTION_CI_PROFILE_SCHEMA, PRODUCTION_TEST_REPORT_SCHEMA, browserProductionScenarioPack, browserProductionCiProfile, normalizeScenarioPack, normalizeCiProfile, scenarioPackDigest, ciProfileDigest, buildProductionTestReport, productionTestReportDigest, emitProductionTestArtifacts, assertNoForbiddenRunners, } from './production-test-pack.js';
 export { PRODUCTION_OBSERVABILITY_SCHEMA, PRODUCTION_TRACE_SCHEMA, REQUIRED_TRACE_FACETS, browserProductionObservability, normalizeObservability, redactSensitive, validateProductionTrace, buildCoveringProductionTrace, checkProductionBudgets, checkCapabilityClosure, applySecurityHeadersToCdnPolicy, measureDistBudgets, emitProductionObservability, observabilityDigest, } from './production-observability.js';
 export { buildApplicationContext, buildFormatterContext, checkLocaleRuntime, checkSsrClientParity, createLocaleSession, formatMessageTemplate, formatterContextDigest, negotiateLocale, resolveMessageVariant, validateFormatterContext, } from './locale-runtime.js';
-export { absoluteUrl, assertLocaleCacheKey, buildLocalePageMeta, buildLocaleRouteRealizationTable, checkLocaleRouter, commitLocaleRouteMetaTransition, localeAwareCacheKey, parseLocaleFromPath, planLocalePathNavigation, realizeRoutePath, resolveLinkHref, } from './locale-router.js';
+export { absoluteUrl, assertLocaleCacheKey, buildLocalePageMeta, buildLocaleRouteRealizationTable, checkLocaleRouter, commitLocaleRouteMetaTransition, localeAwareCacheKey, localizeBodyLinks, localizeSameAppHref, parseLocaleFromPath, planLocalePathNavigation, realizeRoutePath, resolveLinkHref, } from './locale-router.js';
+export { LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA, emitLocaleRouteRealization, } from './locale-route-emit.js';
 export { assertHostMessageInvariant, assertServerErrorEnvelope, assertServerFormatContext, buildLocaleDeliveryResolution, checkLocaleDelivery, fallbackDigest, messageCatalogHash, proveMiniPackageMessages, validateNativeLocalePack, } from './locale-delivery.js';
 export { checkLocaleConformance, diffLocaleCatalogs, explainLocaleMessage, extractHardcodedText, pseudoLocalizeCatalog, } from './locale-tooling.js';
 export { applyPlugins, contentHash, defineConfig, definePlugin, loadVmzConfig, } from './plugin-host.js';

package/dist/locale-check.js

@@ -250,10 +250,12 @@ export function checkLocales(opts) {
     const manifestPathJson = path.join(localesRoot, 'locales.json');
     const manifestPath = fs.existsSync(manifestPathJson5) ? manifestPathJson5 : fs.existsSync(manifestPathJson) ? manifestPathJson : null;
     if (!fs.existsSync(localesRoot) || !manifestPath) {
+        // Discipline nudge: i18n is first-class — missing policy is never silent.
+        // Soft for now (warning); production profiles may elevate to error later.
         diagnostics.push({
             code: DIAG_MANIFEST_MISSING,
-            severity: 'error',
-            message: 'locales/locales.json5 missing (LocaleId policy truth source)',
+            severity: 'warning',
+            message: 'locales/locales.json5 missing — declare LocaleId policy under /locales (native i18n, not an afterthought)',
             path: 'locales/locales.json5',
         });
         return emptyReport(projectRoot, diagnostics);
@@ -586,9 +588,10 @@ function paramSignature(params) {
         .join(',');
 }
 function emptyReport(projectRoot, diagnostics) {
+    const hasErrors = (diagnostics || []).some((d) => d.severity === 'error');
     return {
         schema: LOCALE_CHECK_SCHEMA,
-        status: 'failed',
+        status: hasErrors ? 'failed' : 'ready',
         root: projectRoot,
         localesRoot: 'locales',
         manifest: null,
@@ -706,15 +709,15 @@ export function emitLocaleTypedModules(report, outDir) {
  * @returns {{ ok: boolean, written: string[], diagnostics: any[] }}
  */
 export function emitLocaleRuntimeModules(projectRoot, distDir) {
-    const localesRoot = path.join(projectRoot, 'locales');
-    if (!fs.existsSync(localesRoot)) {
-        return { ok: true, written: [], diagnostics: [] };
-    }
     const report = checkLocales({ projectRoot, checkUnused: false });
     if (localeHasErrors(report)) {
         return { ok: false, written: [], diagnostics: report.diagnostics || [] };
     }
-    const defaultLocale = report.manifest?.defaultLocale || 'zh-hans';
+    // Missing locales.json5 is warning-only for now — surface diagnostics, skip emit.
+    if (!report.manifest) {
+        return { ok: true, written: [], diagnostics: report.diagnostics || [] };
+    }
+    const defaultLocale = report.manifest.defaultLocale || 'zh-hans';
     const byId = new Map((report.messageCatalog?.messages || []).map((m) => [m.messageId, m]));
     /** @type {string[]} */
     const written = [];

package/dist/locale-cmd.js

@@ -117,8 +117,8 @@ function cmdLocaleList(args) {
     const projectRoot = resolveProject(args);
     const report = checkLocales({ projectRoot, checkUnused: false });
     if (!report.manifest) {
-        log.error('locales.json5 missing');
-        return 1;
+        console.warn('vmz warn vmz::locale::manifest_missing: locales/locales.json5 missing');
+        return localeHasErrors(report) ? 1 : 0;
     }
     for (const loc of report.manifest.locales) {
         const mark = loc.id === report.manifest.defaultLocale ? ' (default)' : '';