@vmz/vmz 0.0.3 → 0.0.4

package/dist/invocation.js

@@ -2,9 +2,11 @@
 /**
  * `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)
  *
  */
@@ -13,8 +15,9 @@ import { existsSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 /** @typedef {'developer' | 'project' | 'global'} InvocationMode */
+const PROJECT_PKG_SEGMENTS = [['@vmz', 'vmz'], ['vmz']];
 /**
- * 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 function resolveThisPackageRoot(fromUrl = import.meta.url) {
@@ -32,15 +35,15 @@ function tryRealpath(p) {
     }
 }
 /**
- * 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 function findNearestProjectVmz(startDir) {
     let dir = path.resolve(startDir);
     for (;;) {
-        const candidates = [path.join(dir, 'node_modules', 'vmz'), path.join(dir, 'node_modules', '@vmz', 'vmz')];
-        for (const candidate of candidates) {
+        for (const segments of PROJECT_PKG_SEGMENTS) {
+            const candidate = path.join(dir, 'node_modules', ...segments);
             const pkgJson = path.join(candidate, 'package.json');
             if (existsSync(pkgJson)) {
                 return tryRealpath(candidate);
@@ -53,7 +56,7 @@ export function findNearestProjectVmz(startDir) {
     }
 }
 /**
- * Resolve CLI entry for a `vmz` package root (`bin/vmz.js`).
+ * Resolve CLI entry (`bin/vmz.js`).
  * @param {string} packageRoot
  * @returns {string | null}
  */
@@ -64,8 +67,6 @@ export function resolveVmzBin(packageRoot) {
     return null;
 }
 /**
- * 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 function isUnderNodeModules(packageRoot) {
@@ -74,27 +75,10 @@ export function isUnderNodeModules(packageRoot) {
     return parts.includes('node_modules');
 }
 /**
- * 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 function getInvocationContext(opts = {}) {
     const cwd = path.resolve(opts.cwd ?? process.cwd());
@@ -124,8 +108,6 @@ export function getInvocationContext(opts = {}) {
     };
 }
 /**
- * Commands allowed in **global** mode without re-exec / refusal.
- * Developer + project modes allow the full CLI.
  * @param {string | undefined} cmd
  */
 export function isGlobalAllowedCommand(cmd) {
@@ -142,7 +124,7 @@ export function isGlobalAllowedCommand(cmd) {
 }
 /**
  * @param {string} bin
- * @param {string[]} argv full argv including command (e.g. `['check', '.']`)
+ * @param {string[]} argv
  * @returns {Promise<number>}
  */
 export function reexecProjectVmz(bin, argv) {
@@ -161,9 +143,6 @@ export function reexecProjectVmz(bin, argv) {
     });
 }
 /**
- * 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 async function gateGlobalProjectCommand(opts) {
@@ -175,7 +154,7 @@ export async function gateGlobalProjectCommand(opts) {
     if (ctx.nearestProjectVmz && ctx.nearestProjectVmz !== ctx.thisPackageRoot) {
         const bin = resolveVmzBin(ctx.nearestProjectVmz);
         if (!bin) {
-            logError('found project `@vmz/vmz` / `vmz` but bin/vmz.js is missing.');
+            logError('found project `vmz` / `@vmz/vmz` but bin/vmz.js is missing.');
             return { action: 'exit', code: 1 };
         }
         const code = await reexec(bin, argv);

package/dist/locale-check.d.ts

@@ -80,6 +80,22 @@ export declare function scanLocaleUsages(projectRoot: any): {
  * @param {string} outDir
  */
 export declare function emitLocaleTypedModules(report: any, outDir: any): any[];
+/**
+ * Emit runtime `#locales/<catalog>.js` into application `dist/` and rewrite
+ * client imports from `#locales/...` to relative ESM paths.
+ *
+ * Variant pick reads `html[data-locale]` (else defaultLocale). Thin bridge until
+ * host LocaleTransition reloads locale-scoped chunks (I2/I4).
+ *
+ * @param {string} projectRoot
+ * @param {string} distDir
+ * @returns {{ ok: boolean, written: string[], diagnostics: any[] }}
+ */
+export declare function emitLocaleRuntimeModules(projectRoot: any, distDir: any): {
+    ok: boolean;
+    written: any[];
+    diagnostics: any;
+};
 /**
  * MessageId rename plan — WorkspaceEdit-shaped, no parallel rename IR.
  * @param {ReturnType<typeof checkLocales>} report

package/dist/locale-check.js

@@ -694,6 +694,131 @@ export function emitLocaleTypedModules(report, outDir) {
     fs.writeFileSync(path.join(outDir, 'index.json'), `${JSON.stringify(index, null, 2)}\n`, 'utf8');
     return written;
 }
+/**
+ * Emit runtime `#locales/<catalog>.js` into application `dist/` and rewrite
+ * client imports from `#locales/...` to relative ESM paths.
+ *
+ * Variant pick reads `html[data-locale]` (else defaultLocale). Thin bridge until
+ * host LocaleTransition reloads locale-scoped chunks (I2/I4).
+ *
+ * @param {string} projectRoot
+ * @param {string} distDir
+ * @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';
+    const byId = new Map((report.messageCatalog?.messages || []).map((m) => [m.messageId, m]));
+    /** @type {string[]} */
+    const written = [];
+    const localesOut = path.join(distDir, 'locales');
+    fs.mkdirSync(localesOut, { recursive: true });
+    for (const mod of report.typedModules || []) {
+        const lines = [
+            `/** Generated ${mod.module} — runtime LocalizedText (defaultLocale=${defaultLocale}) */`,
+            `const __vmzDefaultLocale = ${JSON.stringify(defaultLocale)};`,
+            `function __vmzLocaleId() {`,
+            `  try {`,
+            `    const stored = localStorage.getItem("vmz.locale");`,
+            `    if (stored) return stored;`,
+            `  } catch {}`,
+            `  if (typeof document !== "undefined") {`,
+            `    const d = document.documentElement?.getAttribute("data-locale");`,
+            `    if (d) return d;`,
+            `    const lang = document.documentElement?.lang;`,
+            `    if (lang === "en" || lang === "en-US" || lang === "en-us") return "en-us";`,
+            `    if (lang === "zh" || lang === "zh-CN" || lang === "zh-Hans" || lang === "zh-hans") return "zh-hans";`,
+            `  }`,
+            `  return __vmzDefaultLocale;`,
+            `}`,
+            `function __vmzFormat(template, args) {`,
+            `  if (!args) return String(template ?? "");`,
+            `  return String(template ?? "").replace(/\\{(\\w+)(?:,\\s*\\w+)?\\}/g, (m, name) =>`,
+            `    Object.prototype.hasOwnProperty.call(args, name) ? String(args[name]) : m`,
+            `  );`,
+            `}`,
+            `function __vmzPick(variants, args) {`,
+            `  const id = __vmzLocaleId();`,
+            `  const template = variants[id] ?? variants[__vmzDefaultLocale] ?? "";`,
+            `  return __vmzFormat(template, args);`,
+            `}`,
+            '',
+        ];
+        for (const exp of mod.exports || []) {
+            const node = byId.get(exp.messageId);
+            const variants = {};
+            if (node?.variants) {
+                for (const [loc, v] of Object.entries(node.variants)) {
+                    variants[loc] = v.template;
+                }
+            }
+            const lit = JSON.stringify(variants);
+            if ((exp.params || []).length) {
+                lines.push(`export function ${exp.exportName}(args) { return __vmzPick(${lit}, args); }`);
+            }
+            else {
+                lines.push(`export function ${exp.exportName}() { return __vmzPick(${lit}); }`);
+            }
+        }
+        lines.push('');
+        const file = path.join(localesOut, `${mod.catalogId}.js`);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, lines.join('\n'), 'utf8');
+        written.push(file);
+    }
+    rewriteLocaleImportsInDist(distDir);
+    return { ok: true, written, diagnostics: report.diagnostics || [] };
+}
+/**
+ * @param {string} distDir
+ */
+function rewriteLocaleImportsInDist(distDir) {
+    /** @type {string[]} */
+    const files = [];
+    walkDistJs(distDir, (file) => files.push(file));
+    for (const file of files) {
+        let text = fs.readFileSync(file, 'utf8');
+        if (!text.includes('#locales/'))
+            continue;
+        const fromDir = path.dirname(file);
+        // Emit path is dist/locales/*.js — `#` cannot appear in ESM file URLs (fragment).
+        const next = text.replace(/from\s*(["'])#locales\/([^"']+)\1/g, (_m, quote, id) => {
+            const target = path.join(distDir, 'locales', `${id}.js`);
+            let rel = path.relative(fromDir, target).replace(/\\/g, '/');
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            return `from ${quote}${rel}${quote}`;
+        });
+        if (next !== text)
+            fs.writeFileSync(file, next, 'utf8');
+    }
+}
+/**
+ * @param {string} dir
+ * @param {(file: string) => void} fn
+ */
+function walkDistJs(dir, fn) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            if (ent.name === 'node_modules')
+                continue;
+            walkDistJs(full, fn);
+        }
+        else if (ent.name.endsWith('.js') || ent.name.endsWith('.mjs')) {
+            fn(full);
+        }
+    }
+}
 /**
  * MessageId rename plan — WorkspaceEdit-shaped, no parallel rename IR.
  * @param {ReturnType<typeof checkLocales>} report

package/dist/plugin-host.d.ts

@@ -12,11 +12,20 @@ export declare function importMaybeTs(full: any): Promise<any>;
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project
- * @returns {Promise<{ plugins: import('@vmz/plugin').VmzPlugin[], engines: import('@vmz/plugin').VmzEngines, path: string | null, pluginPath: string | null }>}
+ * @returns {Promise<{
+ *   plugins: import('@vmz/plugin').VmzPlugin[],
+ *   engines: import('@vmz/plugin').VmzEngines,
+ *   delivery: import('@vmz/plugin').SiteDeliveryAuthoring | null,
+ *   application: { id?: string } | null,
+ *   path: string | null,
+ *   pluginPath: string | null,
+ * }>}
  */
 export declare function loadVmzConfig(project: any): Promise<{
     plugins: any[];
     engines: {};
+    delivery: any;
+    application: any;
     path: any;
     pluginPath: any;
 }>;

package/dist/plugin-host.js

@@ -32,13 +32,24 @@ export async function importMaybeTs(full) {
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project
- * @returns {Promise<{ plugins: import('@vmz/plugin').VmzPlugin[], engines: import('@vmz/plugin').VmzEngines, path: string | null, pluginPath: string | null }>}
+ * @returns {Promise<{
+ *   plugins: import('@vmz/plugin').VmzPlugin[],
+ *   engines: import('@vmz/plugin').VmzEngines,
+ *   delivery: import('@vmz/plugin').SiteDeliveryAuthoring | null,
+ *   application: { id?: string } | null,
+ *   path: string | null,
+ *   pluginPath: string | null,
+ * }>}
  */
 export async function loadVmzConfig(project) {
     /** @type {import('@vmz/plugin').VmzPlugin[]} */
     const plugins = [];
     /** @type {import('@vmz/plugin').VmzEngines} */
     let engines = {};
+    /** @type {import('@vmz/plugin').SiteDeliveryAuthoring | null} */
+    let delivery = null;
+    /** @type {{ id?: string } | null} */
+    let application = null;
     /** @type {string | null} */
     let configPath = null;
     /** @type {string | null} */
@@ -51,6 +62,12 @@ export async function loadVmzConfig(project) {
         const cfg = await importMaybeTs(full);
         const raw = cfg?.plugins ?? [];
         engines = cfg?.engines && typeof cfg.engines === 'object' ? { ...cfg.engines } : {};
+        if (cfg?.delivery && typeof cfg.delivery === 'object') {
+            delivery = cfg.delivery;
+        }
+        if (cfg?.application && typeof cfg.application === 'object') {
+            application = cfg.application;
+        }
         for (const entry of raw) {
             plugins.push(await resolvePluginEntry(project, entry));
         }
@@ -64,7 +81,7 @@ export async function loadVmzConfig(project) {
         plugins.push(await resolvePluginEntry(project, full));
         break;
     }
-    return { plugins, engines, path: configPath, pluginPath };
+    return { plugins, engines, delivery, application, path: configPath, pluginPath };
 }
 /**
  * @param {string} project

package/dist/port.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Probe for a free TCP port starting at `start` (inclusive).
+ * Used by `vmz dev` when `--port` is omitted.
+ *
+ * @param {string} host
+ * @param {number} [start=5173]
+ * @param {number} [maxTries=50]
+ * @returns {Promise<number>}
+ */
+export declare function findAvailablePort(host: any, start?: number, maxTries?: number): Promise<unknown>;

package/dist/port.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import net from 'node:net';
+/**
+ * Probe for a free TCP port starting at `start` (inclusive).
+ * Used by `vmz dev` when `--port` is omitted.
+ *
+ * @param {string} host
+ * @param {number} [start=5173]
+ * @param {number} [maxTries=50]
+ * @returns {Promise<number>}
+ */
+export function findAvailablePort(host, start = 5173, maxTries = 50) {
+    const first = Number(start);
+    if (!Number.isFinite(first) || first <= 0) {
+        return Promise.reject(new Error(`invalid start port: ${start}`));
+    }
+    return new Promise((resolve, reject) => {
+        let port = first;
+        const attempt = () => {
+            if (port > first + maxTries) {
+                reject(new Error(`no free port in ${first}..${first + maxTries} on ${host}`));
+                return;
+            }
+            const server = net.createServer();
+            server.unref();
+            server.once('error', (err) => {
+                if (err && err.code === 'EADDRINUSE') {
+                    port += 1;
+                    attempt();
+                    return;
+                }
+                reject(err);
+            });
+            server.once('listening', () => {
+                server.close((closeErr) => {
+                    if (closeErr)
+                        reject(closeErr);
+                    else
+                        resolve(port);
+                });
+            });
+            server.listen(port, host);
+        };
+        attempt();
+    });
+}

package/dist/production-observability.d.ts

@@ -0,0 +1,286 @@
+/**
+ * A5: Production observability — trace facets, redaction, CSP/security,
+ * performance budgets, health/readiness, capability closure.
+ */
+export declare const PRODUCTION_OBSERVABILITY_SCHEMA = "vmz.production.observability.v0";
+export declare const PRODUCTION_TRACE_SCHEMA = "vmz.production.trace.v0";
+/** Facets that production traces must be able to carry (08 A5). */
+export declare const REQUIRED_TRACE_FACETS: readonly string[];
+/**
+ * Default Browser Production Profile observability contract.
+ * @param {Record<string, unknown>} [overrides]
+ */
+export declare function browserProductionObservability(overrides?: {}): {
+    schema: string;
+    id: any;
+    trace: {
+        schema: string;
+        requiredFacets: any;
+        retainOnFailure: any;
+    };
+    redaction: {
+        mode: string;
+        replaceWith: any;
+        allowPublicProvenance: boolean;
+        sensitiveKeyPattern: string;
+    };
+    security: {
+        csp: any;
+        requireIntegrityForRemote: boolean;
+        originIsolation: boolean;
+        requireNonceForInline: boolean;
+        cookieNamespace: any;
+        sessionNamespace: any;
+    };
+    capability: {
+        allowlistRequired: boolean;
+        inputOutputSchemaRequired: boolean;
+        timeoutMsDefault: number;
+        cancelSupported: boolean;
+        serverSecretClosure: boolean;
+    };
+    budgets: {
+        irrelevantBindingWork: number;
+        irrelevantRouteRegionRebuild: number;
+        wholeTreeRerender: number;
+        maxArtifactBytes: number;
+        maxHtmlBytes: number;
+        maxClientJsBytes: number;
+        maxPatchCountPerTransition: number;
+    };
+    health: {
+        livePath: any;
+        readyPath: any;
+        gracefulShutdown: {
+            stopAccepting: boolean;
+            drainInFlight: boolean;
+            timeoutMs: number;
+        };
+    };
+    sampling: {
+        diagnosticSampleRate: number;
+        rollbackOnErrorRate: number;
+        latencyBudgetMs: {
+            p95: number;
+            p99: number;
+        };
+    };
+};
+/**
+ * @param {unknown} raw
+ */
+export declare function normalizeObservability(raw: any): {
+    schema: string;
+    id: any;
+    trace: {
+        schema: string;
+        requiredFacets: any;
+        retainOnFailure: any;
+    };
+    redaction: {
+        mode: string;
+        replaceWith: any;
+        allowPublicProvenance: boolean;
+        sensitiveKeyPattern: string;
+    };
+    security: {
+        csp: any;
+        requireIntegrityForRemote: boolean;
+        originIsolation: boolean;
+        requireNonceForInline: boolean;
+        cookieNamespace: any;
+        sessionNamespace: any;
+    };
+    capability: {
+        allowlistRequired: boolean;
+        inputOutputSchemaRequired: boolean;
+        timeoutMsDefault: number;
+        cancelSupported: boolean;
+        serverSecretClosure: boolean;
+    };
+    budgets: {
+        irrelevantBindingWork: number;
+        irrelevantRouteRegionRebuild: number;
+        wholeTreeRerender: number;
+        maxArtifactBytes: number;
+        maxHtmlBytes: number;
+        maxClientJsBytes: number;
+        maxPatchCountPerTransition: number;
+    };
+    health: {
+        livePath: any;
+        readyPath: any;
+        gracefulShutdown: {
+            stopAccepting: boolean;
+            drainInFlight: boolean;
+            timeoutMs: number;
+        };
+    };
+    sampling: {
+        diagnosticSampleRate: number;
+        rollbackOnErrorRate: number;
+        latencyBudgetMs: {
+            p95: number;
+            p99: number;
+        };
+    };
+};
+/**
+ * Redact sensitive keys recursively. Never returns secrets for public provenance.
+ * @param {unknown} value
+ * @param {Record<string, any>} [policy]
+ * @param {{ privilege?: 'public' | 'operator' }} [opts]
+ */
+export declare function redactSensitive(value: any, policy?: {}, opts?: {}): any;
+/**
+ * Validate a production trace carries required facets (as event.facet or mapped kind).
+ * @param {unknown} raw
+ * @param {string[]} [requiredFacets]
+ */
+export declare function validateProductionTrace(raw: any, requiredFacets?: readonly string[]): {
+    ok: boolean;
+    covered: unknown[];
+    errors: any[];
+};
+/**
+ * Build a minimal valid production trace covering all required facets (for CI assembly).
+ * @param {Record<string, unknown>} [meta]
+ */
+export declare function buildCoveringProductionTrace(meta?: {}): {
+    schema: string;
+    status: string;
+    applicationId: any;
+    artifactDigest: any;
+    events: {
+        facet: string;
+        kind: string;
+        stableId: {
+            kind: string;
+            id: string;
+        };
+        generation: number;
+        redacted: boolean;
+        payload: any;
+    }[];
+};
+/**
+ * @param {Record<string, any>} measured
+ * @param {Record<string, any>} budgets
+ */
+export declare function checkProductionBudgets(measured: any, budgets: any): {
+    ok: boolean;
+    violations: any[];
+};
+/**
+ * Validate capability production closure (allowlist + schema + timeout + secret).
+ * @param {Record<string, any>} cap
+ * @param {Record<string, any>} policy
+ */
+export declare function checkCapabilityClosure(cap: any, policy: any): {
+    ok: boolean;
+    errors: any[];
+};
+/**
+ * Merge CSP / security headers into a CDN policy headers list (HTML matches).
+ * @param {Record<string, any>} cdnPolicy
+ * @param {Record<string, any>} security
+ */
+export declare function applySecurityHeadersToCdnPolicy(cdnPolicy: any, security: any): any;
+/**
+ * Measure dist sizes for budget gates.
+ * @param {string} distDir
+ */
+export declare function measureDistBudgets(distDir: any): {
+    artifactBytes: number;
+    htmlBytes: number;
+    clientJsBytes: number;
+    irrelevantBindingWork: number;
+    irrelevantRouteRegionRebuild: number;
+    wholeTreeRerender: number;
+    patchCount: number;
+};
+/**
+ * Write observability contract (+ covering trace sample) under dist/_vmz.
+ * @param {string} distDir
+ * @param {Record<string, unknown>} [overrides]
+ * @param {{ applicationId?: string, artifactDigest?: string }} [meta]
+ */
+export declare function emitProductionObservability(distDir: any, overrides?: {}, meta?: {}): {
+    contract: {
+        schema: string;
+        id: any;
+        trace: {
+            schema: string;
+            requiredFacets: any;
+            retainOnFailure: any;
+        };
+        redaction: {
+            mode: string;
+            replaceWith: any;
+            allowPublicProvenance: boolean;
+            sensitiveKeyPattern: string;
+        };
+        security: {
+            csp: any;
+            requireIntegrityForRemote: boolean;
+            originIsolation: boolean;
+            requireNonceForInline: boolean;
+            cookieNamespace: any;
+            sessionNamespace: any;
+        };
+        capability: {
+            allowlistRequired: boolean;
+            inputOutputSchemaRequired: boolean;
+            timeoutMsDefault: number;
+            cancelSupported: boolean;
+            serverSecretClosure: boolean;
+        };
+        budgets: {
+            irrelevantBindingWork: number;
+            irrelevantRouteRegionRebuild: number;
+            wholeTreeRerender: number;
+            maxArtifactBytes: number;
+            maxHtmlBytes: number;
+            maxClientJsBytes: number;
+            maxPatchCountPerTransition: number;
+        };
+        health: {
+            livePath: any;
+            readyPath: any;
+            gracefulShutdown: {
+                stopAccepting: boolean;
+                drainInFlight: boolean;
+                timeoutMs: number;
+            };
+        };
+        sampling: {
+            diagnosticSampleRate: number;
+            rollbackOnErrorRate: number;
+            latencyBudgetMs: {
+                p95: number;
+                p99: number;
+            };
+        };
+    };
+    trace: {
+        schema: string;
+        status: string;
+        applicationId: any;
+        artifactDigest: any;
+        events: {
+            facet: string;
+            kind: string;
+            stableId: {
+                kind: string;
+                id: string;
+            };
+            generation: number;
+            redacted: boolean;
+            payload: any;
+        }[];
+    };
+    contractPath: string;
+    tracePath: string;
+};
+export declare function observabilityDigest(contract: any): any;
+export declare function sha256Text(text: any): string;