@vmz/vmz 0.0.4 → 0.1.1

package/dist/production-test-pack.d.ts

@@ -19,8 +19,6 @@ export declare function browserProductionScenarioPack(): {
         runner: string;
         required: boolean;
         detail?: undefined;
-        quarantine?: undefined;
-        reason?: undefined;
     } | {
         scenarioId: string;
         category: string;
@@ -29,18 +27,6 @@ export declare function browserProductionScenarioPack(): {
         runner: string;
         required: boolean;
         detail: string;
-        quarantine?: undefined;
-        reason?: undefined;
-    } | {
-        scenarioId: string;
-        category: string;
-        fixture: any;
-        modes: string[];
-        runner: string;
-        required: boolean;
-        quarantine: boolean;
-        reason: string;
-        detail?: undefined;
     })[];
 };
 /** Deterministic CI profile for production-test (no flaky disguise). */

package/dist/production-test-pack.js

@@ -8,6 +8,7 @@ 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';
@@ -126,56 +127,51 @@ export function browserProductionScenarioPack() {
                 required: true,
                 detail: 'pack digest + CURRENT/PREVIOUS rollback',
             },
-            // Explicit quarantine — must never be reported as passed.
+            // Previously quarantined — now required with real serve-host/browser runners.
             {
                 scenarioId: 'production.ui.field.submit',
                 category: 'field',
-                fixture: null,
+                fixture: 'packages/examples/production-inspector',
                 modes: ['browser'],
-                runner: 'quarantine',
-                required: false,
-                quarantine: true,
-                reason: 'A4: Field input/submit/dup-submit/cancel not assembled (@vmz/ui UI1)',
+                runner: 'serve-host-browser',
+                required: true,
+                detail: 'Field input + validation error on inspector',
             },
             {
                 scenarioId: 'production.ui.dialog.focus',
                 category: 'dialog',
-                fixture: null,
+                fixture: 'packages/examples/production-inspector',
                 modes: ['browser'],
-                runner: 'quarantine',
-                required: false,
-                quarantine: true,
-                reason: 'A4: Dialog focus enter/loop/restore + outside dismiss not assembled',
+                runner: 'serve-host-browser',
+                required: true,
+                detail: 'Dialog open/focus/Escape dismiss on inspector',
             },
             {
                 scenarioId: 'production.locale.switch-rtl',
                 category: 'locale',
-                fixture: null,
+                fixture: 'packages/examples/production-router',
                 modes: ['browser'],
-                runner: 'quarantine',
-                required: false,
-                quarantine: true,
-                reason: 'A4: locale switch / fallback forbidden / RTL not in this pack',
+                runner: 'serve-host-browser',
+                required: true,
+                detail: 'LocaleTransition commit + inspector RTL dir toggle',
             },
             {
                 scenarioId: 'production.theme.missing-token',
                 category: 'theme',
-                fixture: null,
-                modes: ['browser'],
-                runner: 'quarantine',
-                required: false,
-                quarantine: true,
-                reason: 'A4: theme switch + missing semantic token not in this pack',
+                fixture: 'temp:missing-token',
+                modes: ['compile'],
+                runner: 'vmz-build',
+                required: true,
+                detail: 'missing semantic token → build fails unknown_design_token',
             },
             {
                 scenarioId: 'production.mount.child-failure',
                 category: 'mount',
-                fixture: null,
-                modes: ['browser'],
-                runner: 'quarantine',
-                required: false,
-                quarantine: true,
-                reason: 'A4: ApplicationMount child failure isolation not in this pack',
+                fixture: 'temp:application-isolation',
+                modes: ['deployment'],
+                runner: 'application-isolation',
+                required: true,
+                detail: 'ApplicationMount child failure → 503 application_unavailable; siblings survive',
             },
         ],
     };
@@ -436,9 +432,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');
-    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');
+    writePrettyJsonFile(reportPath, stamped);
+    writePrettyJsonFile(packPath, pack);
+    writePrettyJsonFile(profilePath, profile);
     return { reportPath, packPath, profilePath, report: stamped };
 }
 /** Assert CI profile forbids JS test-runner disguise. */

package/dist/release-pack.js

@@ -9,6 +9,8 @@
 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';
@@ -88,21 +90,6 @@ 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
@@ -124,13 +111,13 @@ export function packRelease(distDir, opts = {}) {
     for (const rel of files) {
         fileDigests[rel] = sha256File(path.join(abs, ...rel.split('/')));
     }
-    const pages = (deployment.units || []).filter((u) => u.kind === 'page');
+    const pages = listPublicPageUnits(deployment);
     const routeRealization = {
         schema: ROUTE_REALIZATION_TABLE_SCHEMA,
         routes: pages.map((u) => ({
             routeId: String(u.chunkId),
             chunkId: String(u.chunkId),
-            pathPattern: pathPatternFromChunk(String(u.chunkId)),
+            pathPattern: unitBrowserPathPattern(u),
             clientEntry: u.clientEntry || null,
             programIr: u.programIr || null,
         })),
@@ -200,7 +187,7 @@ export function packRelease(distDir, opts = {}) {
  * @param {unknown} value
  */
 function writeJson(file, value) {
-    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(file, value);
 }
 /**
  * @param {string} pointerPath
@@ -241,16 +228,25 @@ export function publishRelease(releasesRoot, distDir, envelope) {
     if (!digest)
         throw new Error('publishRelease: envelope missing artifactDigest');
     const root = path.resolve(releasesRoot);
+    const srcDist = path.resolve(distDir);
+    // Node fs.cpSync refuses copying a directory into any subdirectory of itself.
+    // Releases root must sit beside dist (e.g. .vmz-releases), never under dist/.
     const dest = path.join(root, digest);
+    const destDist = path.join(dest, 'dist');
+    if (root === srcDist || root.startsWith(srcDist + path.sep) || destDist.startsWith(srcDist + path.sep)) {
+        throw new Error(`publishRelease: releasesRoot must not be under distDir (got releasesRoot=${root}, distDir=${srcDist})`);
+    }
     fs.mkdirSync(dest, { recursive: true });
     // Immutable snapshot of packed dist (exclude prior releases nesting).
-    const destDist = path.join(dest, 'dist');
     fs.rmSync(destDist, { recursive: true, force: true });
-    fs.cpSync(path.resolve(distDir), destDist, {
+    fs.cpSync(srcDist, destDist, {
         recursive: true,
         filter: (src) => {
             const n = src.replace(/\\/g, '/');
-            return !n.includes('/.vmz-releases/') && !n.includes('/dist/releases');
+            return (!n.includes('/.vmz-releases/') &&
+                !n.includes('/.vmz-cdn-releases/') &&
+                !n.includes('/releases-cdn/') &&
+                !/\/dist\/releases(\/|$)/.test(n));
         },
     });
     writeJson(path.join(dest, 'envelope.json'), envelope);

package/dist/route-path.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
+ * Mini pack ignores this and lowers RouteId → chunk id → page stem.
+ */
+export declare function isRouteBoundaryStem(stem: string): boolean;
+export declare function isRouteGroupDir(seg: string): boolean;
+/**
+ * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
+ * Used only when a deployment unit has no `pathPattern`.
+ */
+export declare function filePathPatternFromChunk(chunkId: string): string;
+export type DeploymentPageUnit = {
+    kind?: string;
+    chunkId?: string;
+    clientEntry?: string;
+    programIr?: string;
+    pathPattern?: string;
+    routeId?: string;
+};
+/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
+export declare function unitBrowserPathPattern(unit: DeploymentPageUnit | null | undefined): string;
+export type PathSeg = {
+    kind: 'static';
+    value: string;
+} | {
+    kind: 'param';
+    name: string;
+} | {
+    kind: 'catch';
+    name: string;
+};
+export declare function parsePathPattern(pattern: string): PathSeg[];
+export declare function listPublicPageUnits(deployment: {
+    units?: DeploymentPageUnit[];
+} | null | undefined): DeploymentPageUnit[];

package/dist/route-path.js

@@ -0,0 +1,77 @@
+/**
+ * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
+ * Mini pack ignores this and lowers RouteId → chunk id → page stem.
+ */
+export function isRouteBoundaryStem(stem) {
+    return stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound';
+}
+export function isRouteGroupDir(seg) {
+    return typeof seg === 'string' && seg.startsWith('(') && seg.endsWith(')') && seg.length > 2;
+}
+/**
+ * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
+ * Used only when a deployment unit has no `pathPattern`.
+ */
+export function filePathPatternFromChunk(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 (isRouteGroupDir(p))
+            continue;
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        if (isRouteBoundaryStem(p))
+            continue;
+        segs.push(p);
+    }
+    return segs.length ? `/${segs.join('/')}` : '/';
+}
+/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
+export function unitBrowserPathPattern(unit) {
+    const explicit = String(unit?.pathPattern || '').trim();
+    if (explicit)
+        return explicit.startsWith('/') ? explicit : `/${explicit}`;
+    return filePathPatternFromChunk(String(unit?.chunkId || ''));
+}
+export function parsePathPattern(pattern) {
+    const raw = String(pattern || '').trim();
+    if (!raw || raw === '/')
+        return [];
+    const parts = raw.replace(/^\/+/, '').replace(/\/+$/, '').split('/').filter(Boolean);
+    const segs = [];
+    for (const p of parts) {
+        if (isRouteGroupDir(p))
+            continue;
+        segs.push(parsePathSegment(p));
+    }
+    return segs;
+}
+function parsePathSegment(p) {
+    const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
+    const star = /^\*([A-Za-z_][\w]*)$/.exec(p);
+    const param = /^\[([^\]]+)\]$/.exec(p);
+    const colon = /^:([A-Za-z_][\w]*)$/.exec(p);
+    if (catchAll)
+        return { kind: 'catch', name: catchAll[1] };
+    if (star)
+        return { kind: 'catch', name: star[1] };
+    if (param)
+        return { kind: 'param', name: param[1] };
+    if (colon)
+        return { kind: 'param', name: colon[1] };
+    return { kind: 'static', value: p.toLowerCase() };
+}
+export function listPublicPageUnits(deployment) {
+    const units = Array.isArray(deployment?.units) ? deployment.units : [];
+    return units.filter((u) => {
+        if (u?.kind !== 'page')
+            return false;
+        const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
+        if (!chunkId.startsWith('pages/'))
+            return false;
+        const stem = chunkId.split('/').pop() || '';
+        return !isRouteBoundaryStem(stem);
+    });
+}

package/dist/server-artifact.d.ts

@@ -0,0 +1,140 @@
+/**
+ * P4 ServerArtifact — compiled route decision tree + public ServerRoute contracts
+ * + internal capability units + selected runtime adapter. Web Standards Fetch entry.
+ */
+export declare const SERVER_ARTIFACT_SCHEMA = "vmz.server.artifact.v0";
+export declare const HTTP_CONTRACT_SCHEMA = "vmz.http.contract.v0";
+export declare const SERVER_RUNTIME_ADAPTER_SCHEMA = "vmz.server.runtime_adapter.v0";
+/**
+ * @param {string} outDir
+ * @param {{
+ *   profileId?: string | null,
+ *   assembly?: string | null,
+ *   serverRuntime?: string | null,
+ *   packDigest?: string | null,
+ * }} [opts]
+ */
+export declare function emitServerArtifact(outDir: any, opts?: {}): {
+    artifact: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        selectedRuntime: string;
+        entry: {
+            kind: string;
+            standards: string[];
+            rpcPath: string;
+        };
+        httpContract: {
+            schema: string;
+            digest: string;
+        };
+        publicRoutes: {
+            verb: string;
+            path: string;
+            moduleId: string;
+            method: string;
+            className: string;
+            visibility: string;
+            kind: string;
+        }[];
+        internalCapabilities: any[];
+        middlewareUnits: any[];
+        routeDecisionTree: ({
+            id: string;
+            match: {
+                method: string;
+                path: string;
+            };
+            action: string;
+            target: {
+                moduleId: string;
+                method: string;
+            };
+            visibility: string;
+        } | {
+            id: string;
+            match: {
+                method: string;
+                path: string;
+            };
+            action: string;
+            visibility: string;
+        })[];
+        deploymentSchema: any;
+        packDigest: any;
+        adapters: {
+            node: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            worker: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            deno: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            bun: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            'rust-host': {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+        };
+    };
+    path: string;
+    httpContractDigest: string;
+};
+/**
+ * @param {Record<string, any>} artifact
+ * @param {string} adapterId
+ */
+export declare function projectServerRuntimeAdapter(artifact: any, adapterId: any): {
+    host: string;
+    invoke: string;
+    status: string;
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+} | {
+    host: string;
+    invoke: string;
+    status: string;
+    note: string;
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+} | {
+    host: string;
+    invoke: string;
+    status: string;
+    note: string;
+    consumes: string[];
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+};

package/dist/server-artifact.js

@@ -0,0 +1,204 @@
+/**
+ * P4 ServerArtifact — compiled route decision tree + public ServerRoute contracts
+ * + internal capability units + selected runtime adapter. Web Standards Fetch entry.
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } 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';
+const DEFAULT_RPC_PATH = '/__vmz/rpc';
+/**
+ * @param {string} outDir
+ * @param {{
+ *   profileId?: string | null,
+ *   assembly?: string | null,
+ *   serverRuntime?: string | null,
+ *   packDigest?: string | null,
+ * }} [opts]
+ */
+export function emitServerArtifact(outDir, opts = {}) {
+    const deployment = readJson(path.join(outDir, 'vmz-deployment.json')) || { schema: null, units: [] };
+    const routes = readJson(path.join(outDir, 'vmz-routes.json'));
+    const routeRows = Array.isArray(routes) ? routes : [];
+    const selectedRuntime = normalizeRuntime(opts.serverRuntime);
+    const units = Array.isArray(deployment.units) ? deployment.units : [];
+    const publicRoutes = routeRows.map((r) => ({
+        verb: String(r.verb || 'GET').toUpperCase(),
+        path: String(r.path || ''),
+        moduleId: String(r.moduleId || ''),
+        method: String(r.method || ''),
+        className: r.className != null ? String(r.className) : null,
+        visibility: 'public',
+        kind: 'server-route',
+    }));
+    const publicKeys = new Set(publicRoutes.map((r) => `${r.moduleId}::${r.method}`));
+    /** @type {Array<Record<string, unknown>>} */
+    const internalCapabilities = [];
+    for (const u of units) {
+        const moduleId = u.serverModuleId != null ? String(u.serverModuleId) : '';
+        if (!moduleId)
+            continue;
+        const caps = Array.isArray(u.capabilities) ? u.capabilities.map(String) : [];
+        for (const method of caps) {
+            const key = `${moduleId}::${method}`;
+            if (publicKeys.has(key))
+                continue;
+            internalCapabilities.push({
+                chunkId: String(u.chunkId || ''),
+                moduleId,
+                method,
+                visibility: 'internal',
+                kind: 'capability',
+            });
+        }
+    }
+    const routeDecisionTree = [
+        {
+            id: 'rpc',
+            match: { method: 'POST', path: DEFAULT_RPC_PATH },
+            action: 'invoke-rpc',
+            visibility: 'internal-transport',
+        },
+        ...publicRoutes.map((r, i) => ({
+            id: `public-route-${i}`,
+            match: { method: r.verb, path: r.path },
+            action: 'invoke-server-route',
+            target: { moduleId: r.moduleId, method: r.method },
+            visibility: 'public',
+        })),
+    ];
+    const httpContractBody = {
+        schema: HTTP_CONTRACT_SCHEMA,
+        rpcPath: DEFAULT_RPC_PATH,
+        publicRoutes: publicRoutes.map((r) => ({
+            verb: r.verb,
+            path: r.path,
+            moduleId: r.moduleId,
+            method: r.method,
+        })),
+        internalCapabilityCount: internalCapabilities.length,
+        entry: 'fetch',
+    };
+    const httpContractDigest = sha256Hex(canonicalJson(httpContractBody));
+    const artifact = {
+        schema: SERVER_ARTIFACT_SCHEMA,
+        profileId: opts.profileId || null,
+        assembly: opts.assembly || null,
+        selectedRuntime,
+        entry: {
+            kind: 'fetch',
+            standards: ['Request', 'Response', 'Streams', 'AbortSignal'],
+            rpcPath: DEFAULT_RPC_PATH,
+        },
+        httpContract: {
+            schema: HTTP_CONTRACT_SCHEMA,
+            digest: httpContractDigest,
+        },
+        publicRoutes,
+        internalCapabilities,
+        middlewareUnits: [],
+        routeDecisionTree,
+        deploymentSchema: deployment.schema || null,
+        packDigest: opts.packDigest || null,
+        adapters: {
+            node: { kind: 'node-http', status: 'runtime', entry: 'handleNodeRequest' },
+            worker: { kind: 'fetch', status: 'runtime', entry: 'handleFetchRequest' },
+            deno: { kind: 'fetch', status: 'projected', entry: 'handleFetchRequest' },
+            bun: { kind: 'fetch', status: 'projected', entry: 'handleFetchRequest' },
+            'rust-host': { kind: 'contract-projection', status: 'projected', entry: 'fetch' },
+        },
+    };
+    artifact.artifactDigest = sha256Hex(canonicalJson({ ...artifact, artifactDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'server-artifact.json');
+    writePrettyJsonFile(file, artifact);
+    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);
+    }
+    return { artifact, path: file, httpContractDigest };
+}
+/**
+ * @param {Record<string, any>} artifact
+ * @param {string} adapterId
+ */
+export function projectServerRuntimeAdapter(artifact, adapterId) {
+    const id = String(adapterId || '').trim();
+    if (!SERVER_RUNTIMES.includes(id) && id !== 'worker') {
+        throw new Error(`projectServerRuntimeAdapter: unknown adapter ${id}`);
+    }
+    const base = {
+        schema: SERVER_RUNTIME_ADAPTER_SCHEMA,
+        adapterId: id,
+        artifactDigest: artifact.artifactDigest,
+        httpContractDigest: artifact.httpContract?.digest || null,
+        spaFallback: false,
+        entry: artifact.entry,
+        publicRouteCount: Array.isArray(artifact.publicRoutes) ? artifact.publicRoutes.length : 0,
+        internalCapabilityCount: Array.isArray(artifact.internalCapabilities) ? artifact.internalCapabilities.length : 0,
+    };
+    if (id === 'node') {
+        return { ...base, host: 'node:http', invoke: 'handleNodeRequest', status: 'runtime' };
+    }
+    if (id === 'worker' || id === 'deno' || id === 'bun') {
+        return {
+            ...base,
+            host: 'fetch',
+            invoke: 'handleFetchRequest',
+            status: id === 'worker' ? 'runtime' : 'projected',
+            note: id === 'worker'
+                ? 'Fetch entry; live thin gated via worker-shaped subprocess host'
+                : 'Fetch contract projection; live runtime not gated',
+        };
+    }
+    // rust-host
+    return {
+        ...base,
+        host: 'rust-fetch-consumer',
+        invoke: 'fetch',
+        status: 'projected',
+        note: 'contract projection only — live Rust host binary parity not gated',
+        consumes: ['server-artifact.json', 'vmz-routes.json', 'vmz-deployment.json'],
+    };
+}
+function normalizeRuntime(raw) {
+    const v = String(raw || 'node').trim();
+    return SERVER_RUNTIMES.includes(v) ? v : 'node';
+}
+function readJson(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+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;
+}
+function sha256Hex(text) {
+    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}