@vmz/vmz 0.0.3 → 0.0.4

package/dist/content-addressed-assets.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A3: content-addressed assets/<hash> layout for immutable CDN objects.
+ * Logical paths stay available for serve/dev; web-static HTML rewrites to hashed URLs.
+ * Identical bytes → identical asset path (cross-release / cross-source reuse by digest).
+ */
+export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
+/**
+ * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * @param {string} distDir
+ * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ */
+export declare function emitContentAddressedAssets(distDir: any, opts?: {}): {
+    manifest: {
+        schema: string;
+        layout: string;
+        immutable: boolean;
+        objectCount: number;
+        objects: any[];
+        rewrittenHtml: number;
+    };
+    assetsDir: string;
+    rewrites: {};
+    manifestPath: string;
+};
+/**
+ * Resolve an immutable object by digest under dist/assets (cross-source reuse).
+ * @param {string} distDir
+ * @param {string} digest
+ * @param {string} [ext]
+ */
+export declare function resolveAssetByDigest(distDir: any, digest: any, ext?: string): {
+    assetPath: string;
+    digest: string;
+    bytes: number;
+};
+/**
+ * Prove two buffers share one asset path (content-address stability).
+ * @param {string} distDir
+ * @param {Buffer|string} a
+ * @param {Buffer|string} b
+ * @param {string} [ext]
+ */
+export declare function assertSharedAssetPath(distDir: any, a: any, b: any, ext?: string): {
+    ok: boolean;
+    reason: string;
+    digestA: string;
+    digestB: string;
+    rel?: undefined;
+    assetPath?: undefined;
+    digest?: undefined;
+} | {
+    ok: boolean;
+    reason: string;
+    rel: string;
+    digestA?: undefined;
+    digestB?: undefined;
+    assetPath?: undefined;
+    digest?: undefined;
+} | {
+    ok: boolean;
+    assetPath: string;
+    digest: string;
+    reason?: undefined;
+    digestA?: undefined;
+    digestB?: undefined;
+    rel?: undefined;
+};
+export declare function contentAddressedAssetsDigest(manifest: any): any;
+export declare function sha256Buffer(buf: any): string;

package/dist/content-addressed-assets.js

@@ -0,0 +1,206 @@
+/**
+ * A3: content-addressed assets/<hash> layout for immutable CDN objects.
+ * Logical paths stay available for serve/dev; web-static HTML rewrites to hashed URLs.
+ * Identical bytes → identical asset path (cross-release / cross-source reuse by digest).
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { canonicalJson, sha256Hex } from './release-pack.js';
+export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
+/** Immutable delivery candidates (client-facing bytes). */
+const DEFAULT_CANDIDATES = [
+    'entry-client.js',
+    'entry-event.js',
+    'vmz.css',
+    'vmz-designs.css',
+    'vmz-dom.js',
+    'vmz-runtime.js',
+    'vmz-http.js',
+    'vmz-client-nav.js',
+];
+/**
+ * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * @param {string} distDir
+ * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ */
+export function emitContentAddressedAssets(distDir, opts = {}) {
+    const abs = path.resolve(distDir);
+    if (!fs.existsSync(abs)) {
+        throw new Error(`emitContentAddressedAssets: missing dist ${abs}`);
+    }
+    const assetsDir = path.join(abs, 'assets');
+    fs.mkdirSync(assetsDir, { recursive: true });
+    const candidates = Array.isArray(opts.candidates) ? opts.candidates : collectCandidates(abs);
+    /** @type {Array<Record<string, any>>} */
+    const objects = [];
+    /** @type {Record<string, string>} */
+    const rewrites = {};
+    for (const rel of candidates) {
+        const logical = String(rel).replace(/\\/g, '/').replace(/^\//, '');
+        const src = path.join(abs, ...logical.split('/'));
+        if (!fs.existsSync(src) || !fs.statSync(src).isFile())
+            continue;
+        const buf = fs.readFileSync(src);
+        const digest = sha256Hex(buf);
+        const ext = path.extname(logical) || '';
+        const assetRel = `assets/${digest}${ext}`;
+        const dest = path.join(abs, ...assetRel.split('/'));
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.writeFileSync(dest, buf);
+        }
+        else {
+            // Cross-release reuse: identical digest must not be rewritten.
+            const existing = sha256Hex(fs.readFileSync(dest));
+            if (existing !== digest) {
+                throw new Error(`content-address collision at ${assetRel}`);
+            }
+        }
+        objects.push({
+            logicalPath: logical,
+            assetPath: assetRel,
+            digest,
+            bytes: buf.length,
+            immutable: true,
+        });
+        rewrites[`/${logical}`] = `/${assetRel}`;
+        rewrites[logical] = assetRel;
+    }
+    objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
+    let rewrittenHtml = 0;
+    if (opts.rewriteHtml !== false) {
+        rewrittenHtml = rewriteHtmlReferences(abs, rewrites);
+    }
+    const manifest = {
+        schema: CONTENT_ADDRESSED_ASSETS_SCHEMA,
+        layout: 'assets/<sha256>.<ext>',
+        immutable: true,
+        objectCount: objects.length,
+        objects,
+        rewrittenHtml,
+    };
+    manifest.manifestDigest = sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));
+    const vmzDir = path.join(abs, '_vmz');
+    fs.mkdirSync(vmzDir, { recursive: true });
+    const outPath = path.join(vmzDir, 'content-addressed-assets.json');
+    fs.writeFileSync(outPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return { manifest, assetsDir, rewrites, manifestPath: outPath };
+}
+/**
+ * Resolve an immutable object by digest under dist/assets (cross-source reuse).
+ * @param {string} distDir
+ * @param {string} digest
+ * @param {string} [ext]
+ */
+export function resolveAssetByDigest(distDir, digest, ext = '') {
+    const d = String(digest || '').trim();
+    if (!/^[a-f0-9]{64}$/i.test(d))
+        return null;
+    const suffix = ext && !ext.startsWith('.') ? `.${ext}` : ext;
+    const rel = `assets/${d}${suffix}`;
+    const abs = path.join(distDir, ...rel.split('/'));
+    if (!fs.existsSync(abs))
+        return null;
+    return { assetPath: rel, digest: d.toLowerCase(), bytes: fs.statSync(abs).size };
+}
+/**
+ * Prove two buffers share one asset path (content-address stability).
+ * @param {string} distDir
+ * @param {Buffer|string} a
+ * @param {Buffer|string} b
+ * @param {string} [ext]
+ */
+export function assertSharedAssetPath(distDir, a, b, ext = '.js') {
+    const da = sha256Hex(a);
+    const db = sha256Hex(b);
+    if (da !== db) {
+        return { ok: false, reason: 'digests differ', digestA: da, digestB: db };
+    }
+    const assetsDir = path.join(distDir, 'assets');
+    fs.mkdirSync(assetsDir, { recursive: true });
+    const rel = `assets/${da}${ext}`;
+    const dest = path.join(distDir, ...rel.split('/'));
+    fs.writeFileSync(dest, typeof a === 'string' ? Buffer.from(a) : a);
+    // Second write of identical bytes must be reuse, not fork.
+    fs.writeFileSync(dest, typeof b === 'string' ? Buffer.from(b) : b);
+    const again = resolveAssetByDigest(distDir, da, ext);
+    if (!again || again.assetPath !== rel) {
+        return { ok: false, reason: 'resolve missed shared path', rel };
+    }
+    return { ok: true, assetPath: rel, digest: da };
+}
+function collectCandidates(distDir) {
+    /** @type {string[]} */
+    const out = [];
+    for (const name of DEFAULT_CANDIDATES) {
+        if (fs.existsSync(path.join(distDir, name)))
+            out.push(name);
+    }
+    // Include top-level *.client.js and pages/**/*.client.js referenced by resume.
+    walk(distDir, distDir, (rel) => {
+        if (/\.client\.js$/i.test(rel))
+            out.push(rel);
+    });
+    return [...new Set(out)].sort();
+}
+function walk(root, dir, onFile) {
+    for (const name of fs.readdirSync(dir)) {
+        if (name === 'assets' || name === '_vmz' || name === 'node_modules')
+            continue;
+        const full = path.join(dir, name);
+        const st = fs.statSync(full);
+        if (st.isDirectory())
+            walk(root, full, onFile);
+        else
+            onFile(path.relative(root, full).replace(/\\/g, '/'));
+    }
+}
+/**
+ * @param {string} distDir
+ * @param {Record<string, string>} rewrites map `/logical` → `/assets/hash.ext`
+ */
+function rewriteHtmlReferences(distDir, rewrites) {
+    const pairs = Object.entries(rewrites)
+        .filter(([from]) => from.startsWith('/'))
+        .sort((a, b) => b[0].length - a[0].length);
+    if (!pairs.length)
+        return 0;
+    let count = 0;
+    walkHtml(distDir, (file) => {
+        let text = fs.readFileSync(file, 'utf8');
+        let next = text;
+        for (const [from, to] of pairs) {
+            // href="/x" src="/x" and unquoted variants in attributes
+            next = next.split(from).join(to);
+        }
+        if (next !== text) {
+            fs.writeFileSync(file, next, 'utf8');
+            count += 1;
+        }
+    });
+    return count;
+}
+function walkHtml(dir, onFile) {
+    const stack = [dir];
+    while (stack.length) {
+        const cur = stack.pop();
+        for (const name of fs.readdirSync(cur)) {
+            if (name === 'assets' || name === '_vmz' || name === 'node_modules')
+                continue;
+            const full = path.join(cur, name);
+            const st = fs.statSync(full);
+            if (st.isDirectory())
+                stack.push(full);
+            else if (name.endsWith('.html'))
+                onFile(full);
+        }
+    }
+}
+export function contentAddressedAssetsDigest(manifest) {
+    return manifest.manifestDigest || sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));
+}
+export function sha256Buffer(buf) {
+    return crypto.createHash('sha256').update(buf).digest('hex');
+}

package/dist/dev-session.js

@@ -10,6 +10,7 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
 import { createWorkspace } from './index.js';
+import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { log } from './log.js';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
 /**
@@ -48,12 +49,23 @@ export function createDevSession(options) {
             ws.updateFiles(changes);
         return ws.build();
     }
+    function emitLocales() {
+        const localeEmit = emitLocaleRuntimeModules(project, outDir);
+        if (!localeEmit.ok || localeHasErrors({ diagnostics: localeEmit.diagnostics })) {
+            log.diagnostics(localeEmit.diagnostics ?? []);
+            log.error('locale runtime emit failed');
+            return false;
+        }
+        return true;
+    }
     function printReport(report, label) {
         const errors = log.diagnostics(report.diagnostics ?? []);
         if (errors) {
             log.error(`${label} failed (${errors} error(s))`);
             return false;
         }
+        if (!emitLocales())
+            return false;
         const mode = report.full ? 'full' : 'affected';
         const chunks = (report.affectedChunks || []).join(', ') || '(none)';
         log.info(`${label} ok (${mode}; chunks=[${chunks}]; ${(report.emitted ?? []).length} emitted)`);
@@ -82,7 +94,8 @@ export function createDevSession(options) {
         }
         child = spawnHost({ project, outDir, host, port });
         const docsRoot = path.join(project, 'documents');
-        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []);
+        const localesRoot = path.join(project, 'locales');
+        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []).concat(existsSync(localesRoot) ? [localesRoot] : []);
         log.info(`dev → http://${host}:${port} (watching ${watchRoots.join(', ')})`);
         /** @type {Map<string, Map<string, string>>} */
         let fingerprints = new Map();
@@ -100,10 +113,12 @@ export function createDevSession(options) {
                 if (stopped || signal?.aborted)
                     break;
                 if (child && child.exitCode != null) {
-                    throw new Error(`vmz serve-host exited: ${child.exitCode}`);
+                    log.warn(`serve-host exited (${child.exitCode}) — respawning…`);
+                    child = spawnHost({ project, outDir, host, port });
+                    continue;
                 }
-                /** @type {{ srcChanged: string[], srcDeleted: string[], docsDirty: boolean }} */
-                let batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                /** @type {{ srcChanged: string[], srcDeleted: string[], docsDirty: boolean, localesDirty: boolean }} */
+                let batch = { srcChanged: [], srcDeleted: [], docsDirty: false, localesDirty: false };
                 try {
                     // Probe only — keep prior fingerprints until debounce resample
                     // (same contract as pre-docs watcher: empty second pass would miss soft reload).
@@ -115,6 +130,10 @@ export function createDevSession(options) {
                             batch.srcChanged = diff.changed;
                             batch.srcDeleted = diff.deleted;
                         }
+                        else if (root === localesRoot) {
+                            if (diff.changed.length || diff.deleted.length)
+                                batch.localesDirty = true;
+                        }
                         else if (diff.changed.length || diff.deleted.length) {
                             batch.docsDirty = true;
                         }
@@ -124,11 +143,11 @@ export function createDevSession(options) {
                     log.warn('watch error:', err);
                     continue;
                 }
-                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty && !batch.localesDirty)
                     continue;
                 await sleep(200);
                 // Resample against the same prior fingerprints, then commit.
-                batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                batch = { srcChanged: [], srcDeleted: [], docsDirty: false, localesDirty: false };
                 for (const root of watchRoots) {
                     const prev = fingerprints.get(root) || new Map();
                     const next = fileFingerprintMap(root);
@@ -138,11 +157,15 @@ export function createDevSession(options) {
                         batch.srcChanged = diff.changed;
                         batch.srcDeleted = diff.deleted;
                     }
+                    else if (root === localesRoot) {
+                        if (diff.changed.length || diff.deleted.length)
+                            batch.localesDirty = true;
+                    }
                     else if (diff.changed.length || diff.deleted.length) {
                         batch.docsDirty = true;
                     }
                 }
-                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty && !batch.localesDirty)
                     continue;
                 let needFullReload = batch.docsDirty;
                 if (batch.srcChanged.length || batch.srcDeleted.length) {
@@ -180,12 +203,26 @@ export function createDevSession(options) {
                                 : 'soft reload ok (full page)');
                     }
                     catch (err) {
-                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
-                        killChild(child);
-                        child = spawnHost({ project, outDir, host, port });
+                        log.warn(`soft reload failed (${err}) — keeping previous serve-host (fix and save)`);
                     }
                     continue;
                 }
+                if (batch.localesDirty) {
+                    log.info('locales change detected — re-emitting #locales runtime…');
+                    if (!emitLocales()) {
+                        log.warn('locale runtime emit failed — keeping previous modules');
+                        continue;
+                    }
+                    try {
+                        await softReload(host, port, { full: true, islandHmr: false });
+                        log.info('soft reload ok (full page; locales)');
+                    }
+                    catch (err) {
+                        log.warn(`soft reload failed (${err}) — keeping previous serve-host (fix and save)`);
+                    }
+                    if (!batch.docsDirty)
+                        continue;
+                }
                 if (batch.docsDirty) {
                     log.info('documents change detected — rebuilding document mount…');
                     const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
@@ -198,9 +235,7 @@ export function createDevSession(options) {
                         log.info('soft reload ok (full page; docs)');
                     }
                     catch (err) {
-                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
-                        killChild(child);
-                        child = spawnHost({ project, outDir, host, port });
+                        log.warn(`soft reload failed (${err}) — keeping previous serve-host (fix and save)`);
                     }
                 }
             }

package/dist/document-designs.js

@@ -64,12 +64,17 @@ function emitMinimalDesignsCss(designsDir) {
     const vars = {};
     const tokenDir = path.join(designsDir, 'tokens');
     if (fs.existsSync(tokenDir)) {
-        walkJson(tokenDir, (obj, prefix) => flattenTokens(obj, prefix, vars));
+        walkJson(tokenDir, (obj, prefix) => {
+            collectStyleThemeEntries(obj, vars);
+            flattenTokens(obj, prefix, vars);
+        });
     }
     const themeJson = path.join(designsDir, 'theme.json');
     if (fs.existsSync(themeJson)) {
         try {
-            flattenTokens(JSON.parse(fs.readFileSync(themeJson, 'utf8')), '', vars);
+            const theme = JSON.parse(fs.readFileSync(themeJson, 'utf8'));
+            collectStyleThemeEntries(theme, vars);
+            flattenTokens(theme, '', vars);
         }
         catch {
             /* ignore */
@@ -89,10 +94,33 @@ function cssVar(key) {
         .replace(/^-|-$/g, '');
     return `--${name}`;
 }
+/**
+ * Style Theme entries (`key.path` + `value`) → `vmz-*` CSS vars (same naming as application compile).
+ * @param {unknown} obj
+ * @param {Record<string, string>} out
+ */
+function collectStyleThemeEntries(obj, out) {
+    if (obj == null || typeof obj !== 'object' || Array.isArray(obj))
+        return;
+    const entries = /** @type {{ key?: { path?: unknown }, value?: unknown }[]} */ ( /** @type {{ entries?: unknown }} */(obj).entries);
+    if (!Array.isArray(entries))
+        return;
+    for (const e of entries) {
+        const pathParts = e?.key?.path;
+        if (!Array.isArray(pathParts) || pathParts.length === 0)
+            continue;
+        if (typeof e.value !== 'string' && typeof e.value !== 'number')
+            continue;
+        const dotted = pathParts.map(String).join('-');
+        out[`vmz-${dotted}`] = String(e.value);
+    }
+}
 function flattenTokens(obj, prefix, out) {
     if (obj == null || typeof obj !== 'object' || Array.isArray(obj))
         return;
     for (const [k, v] of Object.entries(obj)) {
+        if (k === 'entries')
+            continue;
         const key = prefix ? `${prefix}-${k}` : k;
         if (v != null && typeof v === 'object' && !Array.isArray(v)) {
             if ('value' in v && (typeof v.value === 'string' || typeof v.value === 'number')) {

package/dist/index.d.ts

@@ -14,8 +14,8 @@ export declare function expectedProtocol(): {
     pluginProtocol: string;
 };
 /**
- * Resolve native `.node` via the platform optionalDependency only
- * (`@vmz/vmz-<short>` from pnpm workspace or published npm).
+ * Resolve native `.node` via the platform optionalDependency
+ * (`@vmz/vmz-<short>`; transitional fallback `@vmz/vmz-<short>`).
  * @returns {string}
  */
 export declare function resolveNativePath(): any;
@@ -138,12 +138,21 @@ export declare function checkApplicationHostCompositionJson(hostRoot: any, packa
  */
 export declare function checkApplicationDevTestDeployJson(hostRoot: any, packageRoots: any, dirtyPaths?: any[]): any;
 export { createDevSession, listWatchedFiles, srcFingerprint } from './dev-session.js';
+export { findAvailablePort } from './port.js';
 export { runCli, parseArgs, printHelp, printGlobalHelp, printProjectHelp } from './cli.js';
 export { findNearestProjectVmz, getInvocationContext, isGlobalAllowedCommand, isUnderNodeModules, resolveThisPackageRoot, resolveVmzBin, gateGlobalProjectCommand, } from './invocation.js';
 export { resolveWorkspaceDirs, findPackageJson, readPackageMeta } from './resolve.js';
 export { resolvePackageRoot, resolveWorkspacePackages } from './packages.js';
 export { log } from './log.js';
 export { cmdApplication, runCheck as runApplicationCheck } from './application-cmd.js';
+export { cmdArtifact } from './release-cmd.js';
+export { ARTIFACT_DIFF_SCHEMA, DELIVERY_ARTIFACT_MANIFEST_SCHEMA, RELEASE_ENVELOPE_SCHEMA, ROUTE_REALIZATION_TABLE_SCHEMA, atomicWritePointer, canonicalJson, diffArtifacts, loadReleaseEnvelope, packRelease, publishRelease, readPointer, rollbackRelease, sha256File, sha256Hex, } from './release-pack.js';
+export { STATIC_DELIVERY_MANIFEST_SCHEMA, emitWebStatic, } from './static-emit.js';
+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 { 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 { assertHostMessageInvariant, assertServerErrorEnvelope, assertServerFormatContext, buildLocaleDeliveryResolution, checkLocaleDelivery, fallbackDigest, messageCatalogHash, proveMiniPackageMessages, validateNativeLocalePack, } from './locale-delivery.js';

package/dist/index.js

@@ -52,32 +52,34 @@ function platformShort(triple = platformTriple()) {
     return triple;
 }
 /**
- * Resolve native `.node` via the platform optionalDependency only
- * (`@vmz/vmz-<short>` from pnpm workspace or published npm).
+ * Resolve native `.node` via the platform optionalDependency
+ * (`@vmz/vmz-<short>`; transitional fallback `@vmz/vmz-<short>`).
  * @returns {string}
  */
 export function resolveNativePath() {
     const triple = platformTriple();
     const short = platformShort(triple);
-    const name = `@vmz/vmz-${short}`;
+    const names = [`@vmz/vmz-${short}`, `@vmz/vmz-${short}`];
     /** @type {string[]} */
     const candidates = [];
-    try {
-        const resolved = require.resolve(`${name}/package.json`);
-        const dir = path.dirname(resolved);
-        // Prefer platform-named binary; plain `vmz.node` is legacy-only.
-        candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
-    }
-    catch {
-        /* optional dep not installed */
+    for (const name of names) {
+        try {
+            const resolved = require.resolve(`${name}/package.json`);
+            const dir = path.dirname(resolved);
+            // Prefer platform-named binary; plain `vmz.node` is legacy-only.
+            candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
+        }
+        catch {
+            /* optional dep not installed */
+        }
+        // pnpm may nest under the @vmz/vmz package's node_modules
+        candidates.push(path.join(pkgRoot, 'node_modules', name, `vmz.${triple}.node`), path.join(pkgRoot, 'node_modules', name, 'vmz.node'));
     }
-    // pnpm may nest under the vmz package's node_modules
-    candidates.push(path.join(pkgRoot, 'node_modules', name, `vmz.${triple}.node`), path.join(pkgRoot, 'node_modules', name, 'vmz.node'));
     for (const p of candidates) {
         if (existsSync(p))
             return p;
     }
-    throw new Error(`vmz native addon not found for ${name}. Run: pnpm napi:build (writes packages/runtimes/vmz-${short}/)\n` +
+    throw new Error(`vmz native addon not found for @vmz/vmz-${short}. Run: pnpm napi:build (writes packages/runtimes/vmz-${short}/)\n` +
         `Looked in:\n${candidates.map((c) => `  - ${c}`).join('\n')}`);
 }
 let _native;
@@ -316,12 +318,23 @@ export function checkApplicationDevTestDeployJson(hostRoot, packageRoots, dirtyP
     return native.checkApplicationDevTestDeployJson(hostRoot, packageRoots, dirtyPaths);
 }
 export { createDevSession, listWatchedFiles, srcFingerprint } from './dev-session.js';
+export { findAvailablePort } from './port.js';
 export { runCli, parseArgs, printHelp, printGlobalHelp, printProjectHelp } from './cli.js';
 export { findNearestProjectVmz, getInvocationContext, isGlobalAllowedCommand, isUnderNodeModules, resolveThisPackageRoot, resolveVmzBin, gateGlobalProjectCommand, } from './invocation.js';
 export { resolveWorkspaceDirs, findPackageJson, readPackageMeta } from './resolve.js';
 export { resolvePackageRoot, resolveWorkspacePackages } from './packages.js';
 export { log } from './log.js';
 export { cmdApplication, runCheck as runApplicationCheck } from './application-cmd.js';
+export { cmdArtifact } from './release-cmd.js';
+export { ARTIFACT_DIFF_SCHEMA, DELIVERY_ARTIFACT_MANIFEST_SCHEMA, RELEASE_ENVELOPE_SCHEMA, ROUTE_REALIZATION_TABLE_SCHEMA, atomicWritePointer, canonicalJson, diffArtifacts, loadReleaseEnvelope, packRelease, publishRelease, readPointer, rollbackRelease, sha256File, sha256Hex, } from './release-pack.js';
+// APPLICATION_ARTIFACT_SCHEMA lives in @vmz/protocol (already re-exported above);
+// release-pack keeps a local constant for envelope writes — do not dual-export the name.
+export { STATIC_DELIVERY_MANIFEST_SCHEMA, emitWebStatic, } from './static-emit.js';
+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 { 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 { assertHostMessageInvariant, assertServerErrorEnvelope, assertServerFormatContext, buildLocaleDeliveryResolution, checkLocaleDelivery, fallbackDigest, messageCatalogHash, proveMiniPackageMessages, validateNativeLocalePack, } from './locale-delivery.js';

package/dist/invocation.d.ts

@@ -1,58 +1,40 @@
 /**
  * `vmz` CLI invocation modes (JS gate only; Rust binary stays full).
  *
+ * Product install face: workspace `vmz` / publish `@vmz/vmz` (bin still `vmz`).
+ *
  * Three modes — do not collapse them:
  * - **developer**: monorepo source checkout (`packages/runtimes/vmz`, not under node_modules)
- * - **project**: app's `node_modules/vmz` or `node_modules/@vmz/vmz` (pnpm/npm/yarn)
+ * - **project**: app's nearest `node_modules/vmz` or `node_modules/@vmz/vmz`
  * - **global**: npm/pnpm global (or any install under node_modules that is not the nearest project one)
  *
  */
-/** @typedef {'developer' | 'project' | 'global'} InvocationMode */
 /**
- * Package root of the running `vmz` / `@vmz/vmz` install (`…/vmz`, not `…/vmz/dist`).
+ * Package root of the running `vmz` / `@vmz/vmz` install.
  * @param {string} [fromUrl]
  */
 export declare function resolveThisPackageRoot(fromUrl?: string): string;
 /**
- * Walk from `startDir` for nearest project `vmz` / `@vmz/vmz` package root.
+ * Walk from `startDir` for nearest project CLI package root.
  * @param {string} startDir
- * @returns {string | null} realpath of package root
+ * @returns {string | null}
  */
 export declare function findNearestProjectVmz(startDir: any): string;
 /**
- * Resolve CLI entry for a `vmz` package root (`bin/vmz.js`).
+ * Resolve CLI entry (`bin/vmz.js`).
  * @param {string} packageRoot
  * @returns {string | null}
  */
 export declare function resolveVmzBin(packageRoot: any): string;
 /**
- * Install lives under a `node_modules` tree (npm -g, pnpm store link, etc.).
- * Workspace source checkout (`packages/runtimes/vmz`) does not → developer mode.
  * @param {string} packageRoot
  */
 export declare function isUnderNodeModules(packageRoot: any): boolean;
 /**
- * Classify how this process was launched.
- *
- * | mode | thisPackageRoot | rule |
- * |-------------|-----------------------------------------|-------------------------------------------|
- * | developer | monorepo `packages/runtimes/vmz` | not under `node_modules` |
- * | project | app `node_modules/(@vmz/)vmz` | under node_modules ∧ equals nearest |
- * | global | global / unrelated node_modules install | under node_modules ∧ not nearest project |
- *
  * @param {{
  * cwd?: string,
  * thisPackageRoot?: string,
  * }} [opts]
- * @returns {{
- * mode: InvocationMode,
- * cwd: string,
- * thisPackageRoot: string,
- * nearestProjectVmz: string | null,
- * isDeveloper: boolean,
- * isProjectLocal: boolean,
- * isGlobalLike: boolean,
- * }}
  */
 export declare function getInvocationContext(opts?: {}): {
     mode: any;
@@ -65,21 +47,16 @@ export declare function getInvocationContext(opts?: {}): {
     isGlobalLike: boolean;
 };
 /**
- * Commands allowed in **global** mode without re-exec / refusal.
- * Developer + project modes allow the full CLI.
  * @param {string | undefined} cmd
  */
 export declare function isGlobalAllowedCommand(cmd: any): boolean;
 /**
  * @param {string} bin
- * @param {string[]} argv full argv including command (e.g. `['check', '.']`)
+ * @param {string[]} argv
  * @returns {Promise<number>}
  */
 export declare function reexecProjectVmz(bin: any, argv: any): Promise<unknown>;
 /**
- * Guard for project-only commands when the current install is **global** mode.
- * Developer / project → proceed. Global + local present → re-exec. Global alone → refuse.
- *
  * @returns {Promise<{ action: 'proceed' } | { action: 'exit', code: number }>}
  */
 export declare function gateGlobalProjectCommand(opts: any): Promise<{