@fundamental-engine/core 0.9.4 → 0.10.0

package/dist/world/conformance/predictions.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Prediction registry and accuracy metric (EXPERIMENTAL, internal).
+ *
+ * Contract stability and predictive power are different things, and only one of them is evidence of
+ * maturity. A contract nobody ever changes might be stable because it is right, or because nobody is
+ * testing it hard. What distinguishes a maturing theory is that it **predicts where it will fail**, and
+ * is surprised only in specific, explainable ways.
+ *
+ * So every substrate adaptation registers its expectations BEFORE adapting, and they are graded
+ * afterwards whether or not they held.
+ *
+ * ## Two hazards this file is designed against
+ *
+ * **1. The slush bucket.** `partially-confirmed` is the grade that lets a wrong prediction feel
+ * half-right. It is therefore only available to predictions that declared **two or more independent
+ * components in advance**, each graded separately. A single-component prediction can only be confirmed
+ * or falsified. `gradingProblems()` enforces this.
+ *
+ * **2. Self-grading.** These predictions are written and graded by the same author who writes the
+ * contract, so the accuracy number is not independent evidence. The real guarantee is commit order:
+ * `registeredIn` names the commit that recorded the prediction, and it must predate the adaptation.
+ * The metric is a discipline, not a proof — stated here rather than in a footnote.
+ */
+export type PredictionId = `P-${string}`;
+export type PredictionGrade = 'confirmed' | 'partially-confirmed' | 'falsified' | 'pending';
+export interface PredictionComponent {
+    readonly claim: string;
+    readonly held: boolean;
+}
+export interface Prediction {
+    readonly id: PredictionId;
+    readonly subject: string;
+    readonly statement: string;
+    /** The commit that registered this prediction. Must predate the adaptation that grades it. */
+    readonly registeredIn: string;
+    readonly grade: PredictionGrade;
+    /** Required for `partially-confirmed`; at least two, each independently graded. */
+    readonly components?: readonly PredictionComponent[];
+    /** What actually happened. Required for every graded prediction. */
+    readonly outcome?: string;
+    /** For falsified predictions: why the miss was informative. Falsifications are kept, never rewritten. */
+    readonly lesson?: string;
+}
+export declare function predictions(): Prediction[];
+export interface PredictionProblem {
+    readonly id: PredictionId;
+    readonly rule: string;
+    readonly detail: string;
+}
+/** Enforces the grading discipline. A registry that cannot be audited is not evidence. */
+export declare function gradingProblems(): PredictionProblem[];
+export interface PredictionAccuracy {
+    readonly total: number;
+    readonly graded: number;
+    readonly confirmed: number;
+    readonly partiallyConfirmed: number;
+    readonly falsified: number;
+    readonly pending: number;
+    /** Confirmed / graded. Partial credit is NOT awarded — a partial is not most of a hit. */
+    readonly accuracy: number;
+    /** Falsified / graded. Tracked deliberately: a program with zero surprises is not being tested. */
+    readonly surpriseRate: number;
+    readonly auditable: boolean;
+}
+export declare function predictionAccuracy(): PredictionAccuracy;
+//# sourceMappingURL=predictions.d.ts.map

package/dist/world/conformance/predictions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictions.d.ts","sourceRoot":"","sources":["../../../src/world/conformance/predictions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,YAAY,GAAG,KAAK,MAAM,EAAE,CAAC;AAEzC,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,qBAAqB,GAAG,WAAW,GAAG,SAAS,CAAC;AAE5F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8FAA8F;IAC9F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,mFAAmF;IACnF,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,yGAAyG;IACzG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,WAAW,IAAI,UAAU,EAAE,CA8E1C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,IAAI,iBAAiB,EAAE,CAwBrD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mGAAmG;IACnG,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAgB,kBAAkB,IAAI,kBAAkB,CAiBvD"}

package/dist/world/conformance/predictions.js

@@ -0,0 +1,141 @@
+/**
+ * Prediction registry and accuracy metric (EXPERIMENTAL, internal).
+ *
+ * Contract stability and predictive power are different things, and only one of them is evidence of
+ * maturity. A contract nobody ever changes might be stable because it is right, or because nobody is
+ * testing it hard. What distinguishes a maturing theory is that it **predicts where it will fail**, and
+ * is surprised only in specific, explainable ways.
+ *
+ * So every substrate adaptation registers its expectations BEFORE adapting, and they are graded
+ * afterwards whether or not they held.
+ *
+ * ## Two hazards this file is designed against
+ *
+ * **1. The slush bucket.** `partially-confirmed` is the grade that lets a wrong prediction feel
+ * half-right. It is therefore only available to predictions that declared **two or more independent
+ * components in advance**, each graded separately. A single-component prediction can only be confirmed
+ * or falsified. `gradingProblems()` enforces this.
+ *
+ * **2. Self-grading.** These predictions are written and graded by the same author who writes the
+ * contract, so the accuracy number is not independent evidence. The real guarantee is commit order:
+ * `registeredIn` names the commit that recorded the prediction, and it must predate the adaptation.
+ * The metric is a discipline, not a proof — stated here rather than in a footnote.
+ */
+export function predictions() {
+    return [
+        {
+            id: 'P-001',
+            subject: 'FiniteStateMachine',
+            statement: 'The FSM control will require zero contract change — it is the most contract-shaped substrate imaginable.',
+            registeredIn: 'd90b3bd2',
+            grade: 'falsified',
+            outcome: 'Churn 1. Accepting states finish, and the contract could not express termination without leaking substrate semantics.',
+            lesson: 'The miss was not about state machines. The contract lacked a concept that no prior substrate could exhibit, because neither the field nor the governor ever terminates. A control failing is the strongest available signal that a theory is incomplete rather than merely untested.',
+        },
+        {
+            id: 'P-002',
+            subject: 'SearchPlanner',
+            statement: 'The planner will expose a missing termination concept, classified structural rather than convenience.',
+            registeredIn: 'd90b3bd2',
+            grade: 'partially-confirmed',
+            components: [
+                { claim: 'a termination concept is missing from the contract', held: true },
+                { claim: 'the planner is the substrate that reveals it', held: false },
+                { claim: 'the change is structural, not a convenience', held: true },
+            ],
+            outcome: 'The gap was real and structural, but the FSM control reached it first, so the planner cost 0. Termination is general, not search-specific.',
+        },
+        {
+            id: 'P-003',
+            subject: 'SearchPlanner',
+            statement: "The planner's partially-declarable law will force executionKind 'hybrid', a variant declared in F1.3 but never exercised.",
+            registeredIn: 'd90b3bd2',
+            grade: 'confirmed',
+            outcome: "Confirmed. First substrate to use 'hybrid'. Weakened by author bias: the variant was known to exist while a planner with a computed heuristic was being chosen.",
+        },
+        {
+            id: 'P-004',
+            subject: 'EventSourcedAggregate',
+            statement: 'Churn 0: the existing replay / deterministicReplay split already separates log-replay from deterministic re-execution. If it does not, the distinction was cosmetic.',
+            registeredIn: 'd90b3bd2',
+            grade: 'pending',
+        },
+        // --- projection phase, registered before that phase begins
+        {
+            id: 'P-005',
+            subject: 'Projection / authority presentation',
+            statement: 'Authority presentation requires no new concept: presented-vs-effective already covers it, including delegated authority, which reduces to a grant with a different authoritySource.',
+            registeredIn: 'pending-registration',
+            grade: 'pending',
+        },
+        {
+            id: 'P-006',
+            subject: 'Projection / composition',
+            statement: 'Projecting a projection will expose a structural gap. The subtractive-power guarantee is proven only for one projection over a source; composition is untested, and evidence access in particular is expected not to compose.',
+            registeredIn: 'pending-registration',
+            grade: 'pending',
+        },
+        {
+            id: 'P-007',
+            subject: 'Projection / participant-relative state',
+            statement: 'Participant-relative state requires no participant model: it reduces to observation access plus scope, with belief remaining an unresolved obligation.',
+            registeredIn: 'pending-registration',
+            grade: 'pending',
+        },
+        {
+            id: 'P-008',
+            subject: 'Projection / invariant scope',
+            statement: 'Invariant scope needs one further distinction the current foundation lacks: an invariant that is unevaluable on a surface is not the same as one that is vacuously satisfied there.',
+            registeredIn: 'pending-registration',
+            grade: 'pending',
+        },
+    ];
+}
+/** Enforces the grading discipline. A registry that cannot be audited is not evidence. */
+export function gradingProblems() {
+    const problems = [];
+    for (const p of predictions()) {
+        if (p.grade === 'partially-confirmed') {
+            const n = p.components?.length ?? 0;
+            if (n < 2) {
+                problems.push({ id: p.id, rule: 'partial-requires-components', detail: 'partially-confirmed requires >= 2 pre-declared components' });
+            }
+            else {
+                const held = p.components.filter((c) => c.held).length;
+                if (held === 0)
+                    problems.push({ id: p.id, rule: 'partial-requires-a-hit', detail: 'no component held — this is falsified' });
+                if (held === n)
+                    problems.push({ id: p.id, rule: 'partial-requires-a-miss', detail: 'every component held — this is confirmed' });
+            }
+        }
+        if (p.grade !== 'pending' && !p.outcome) {
+            problems.push({ id: p.id, rule: 'graded-requires-outcome', detail: 'a graded prediction must record what actually happened' });
+        }
+        if (p.grade === 'falsified' && !p.lesson) {
+            problems.push({ id: p.id, rule: 'falsified-requires-lesson', detail: 'falsifications are preserved with what they taught, never merely recorded' });
+        }
+        if (p.grade !== 'pending' && (p.registeredIn === 'pending-registration' || p.registeredIn.length === 0)) {
+            problems.push({ id: p.id, rule: 'graded-requires-registration', detail: 'a graded prediction must name the commit that registered it' });
+        }
+    }
+    return problems;
+}
+export function predictionAccuracy() {
+    const all = predictions();
+    const graded = all.filter((p) => p.grade !== 'pending');
+    const count = (g) => all.filter((p) => p.grade === g).length;
+    const confirmed = count('confirmed');
+    const falsified = count('falsified');
+    return {
+        total: all.length,
+        graded: graded.length,
+        confirmed,
+        partiallyConfirmed: count('partially-confirmed'),
+        falsified,
+        pending: count('pending'),
+        accuracy: graded.length === 0 ? 0 : confirmed / graded.length,
+        surpriseRate: graded.length === 0 ? 0 : falsified / graded.length,
+        auditable: gradingProblems().length === 0,
+    };
+}
+//# sourceMappingURL=predictions.js.map

package/dist/world/conformance/predictions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictions.js","sourceRoot":"","sources":["../../../src/world/conformance/predictions.ts"],"names":[],"mappings":"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"}

package/dist/world/cross-substrate.d.ts

@@ -0,0 +1,19 @@
+export type ElementClassification = 'supported-by-both' | 'substrate-specific-value' | 'field-biased' | 'second-substrate-biased' | 'missing-general-concept' | 'unnecessary-generalization' | 'unresolved';
+export interface CrossSubstrateRow {
+    readonly dimension: string;
+    readonly field: string;
+    readonly governor: string;
+    readonly classification: ElementClassification;
+    readonly evidence: string;
+}
+export type GeneralizationOutcome = 'generalized' | 'generalized-with-refinement' | 'field-fitted' | 'inconclusive';
+export interface CrossSubstrateResult {
+    readonly rows: readonly CrossSubstrateRow[];
+    readonly outcome: GeneralizationOutcome;
+    readonly refinements: readonly string[];
+    readonly rationale: string;
+}
+/** Builds the matrix by INSPECTING both live contracts, not from stored prose. */
+export declare function crossSubstrateMatrix(): CrossSubstrateRow[];
+export declare function crossSubstrateResult(): CrossSubstrateResult;
+//# sourceMappingURL=cross-substrate.d.ts.map

package/dist/world/cross-substrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-substrate.d.ts","sourceRoot":"","sources":["../../src/world/cross-substrate.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,qBAAqB,GAC7B,mBAAmB,GACnB,0BAA0B,GAC1B,cAAc,GACd,yBAAyB,GACzB,yBAAyB,GACzB,4BAA4B,GAC5B,YAAY,CAAC;AAEjB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,6BAA6B,GAC7B,cAAc,GACd,cAAc,CAAC;AAEnB,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAMD,kFAAkF;AAClF,wBAAgB,oBAAoB,IAAI,iBAAiB,EAAE,CA4F1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAmB3D"}

package/dist/world/cross-substrate.js

@@ -0,0 +1,123 @@
+/**
+ * G3.3 — cross-substrate contract comparison (EXPERIMENTAL, internal).
+ *
+ * Compares the FieldRuntime substrate and the quality-governor substrate against the SAME
+ * `DynamicsContract`, dimension by dimension, and classifies each element. The question is whether the
+ * contract is substrate-neutral or quietly field-fitted.
+ *
+ * Every row is grounded in an executed fixture (G3.2 / F1.4), not in intent.
+ */
+import { governorDynamics } from "./adapters/governor-runtime.js";
+import { fieldRuntimeDynamics } from "./adapters/field-runtime.js";
+import { createWorldEnvelope } from "./envelope.js";
+function emptyWorld(id) {
+    return { envelope: createWorldEnvelope(id), entities: [], relations: [], invariants: [], projections: [] };
+}
+/** Builds the matrix by INSPECTING both live contracts, not from stored prose. */
+export function crossSubstrateMatrix() {
+    const f = fieldRuntimeDynamics(emptyWorld('field-world'));
+    const g = governorDynamics(emptyWorld('governor-world'));
+    const caps = (c) => `snapshot=${c.capabilities.snapshot} restore=${c.capabilities.restore} replay=${c.capabilities.replay} inspect=${c.capabilities.inspectInternalState} law=${c.capabilities.declareTransitionLaw}`;
+    return [
+        {
+            dimension: 'state model', field: 'opaque handle + closure-scattered runtime state', governor: 'plain data record (tier, streaks, budget)',
+            classification: 'substrate-specific-value',
+            evidence: 'both threaded as opaque `State` by the kernel; neither leaked into World',
+        },
+        {
+            dimension: 'input model', field: '{ steps? }', governor: '{ durationMs }',
+            classification: 'substrate-specific-value', evidence: 'generic `Input` type parameter carried both',
+        },
+        {
+            dimension: 'output model', field: '{ steps }', governor: '{ tier, changed }',
+            classification: 'substrate-specific-value', evidence: 'generic `Output` type parameter carried both',
+        },
+        {
+            dimension: 'executionKind', field: f.executionKind, governor: g.executionKind,
+            classification: 'supported-by-both', evidence: 'the closed union expressed both extremes without extension',
+        },
+        {
+            dimension: 'determinism', field: `${f.determinism.classification} (uncontrolled: ${f.determinism.uncontrolledInputs.length})`,
+            governor: `${g.determinism.classification} (uncontrolled: ${g.determinism.uncontrolledInputs.length})`,
+            classification: 'supported-by-both',
+            evidence: 'the declaration form expressed conditional and exact determinism honestly; the validator rejects `deterministic` with uncontrolled inputs',
+        },
+        {
+            dimension: 'capabilities', field: caps(f), governor: caps(g),
+            classification: 'supported-by-both',
+            evidence: 'conservative flags distinguished a lossy snapshot-only substrate from a fully restorable one',
+        },
+        {
+            dimension: 'evidence shape', field: 'declaredInputs / substrateResponses / executionTrace / unresolvedInterpretations',
+            governor: 'same five channels; unresolvedInterpretations records "tier as perceived quality"',
+            classification: 'supported-by-both', evidence: 'neither substrate needed a channel the other lacked',
+        },
+        {
+            dimension: 'failure semantics', field: 'no in-run failure exercised; typed codes available',
+            governor: 'invalid-state on non-finite input; restore rejection',
+            classification: 'supported-by-both',
+            evidence: 'the 10-code taxonomy covered the governor without extension; native cause retained internally',
+        },
+        {
+            dimension: 'snapshot fidelity', field: 'partial-observable (lossy, non-restorable)', governor: 'complete-restorable',
+            classification: 'supported-by-both', evidence: 'the closed fidelity union covered both extremes',
+        },
+        {
+            dimension: 'replay', field: String(f.capabilities.replay), governor: String(g.capabilities.replay),
+            classification: 'supported-by-both', evidence: 'capability flag + deterministicReplay consistency rule',
+        },
+        {
+            dimension: 'restore', field: `${f.capabilities.restore} (method absent)`, governor: `${g.capabilities.restore} (method present)`,
+            classification: 'supported-by-both', evidence: 'optional method + capability flag; restore reconstructed governor state exactly',
+        },
+        {
+            dimension: 'lifecycle', field: 'initialize → advance* → snapshot', governor: 'initialize → advance* → snapshot → restore',
+            classification: 'supported-by-both', evidence: 'the optional-method design absorbed the longer lifecycle',
+        },
+        {
+            dimension: 'ordering', field: 'frame ordering; measurement cadence every 6th frame',
+            governor: 'strict input-sequence ordering (streak state is order-dependent)',
+            classification: 'supported-by-both', evidence: 'order-change negative fixture diverges in both harnesses',
+        },
+        {
+            dimension: 'environment dependence', field: 'host geometry, viewport, scroll', governor: 'none',
+            classification: 'substrate-specific-value',
+            evidence: 'governor conditions record clock/environment/host-geometry as NOT-APPLICABLE rather than claimed',
+        },
+        {
+            dimension: 'opaque vs declarative region', field: 'wholly opaque (force code)', governor: 'wholly declared (threshold table)',
+            classification: 'supported-by-both', evidence: 'executionKind captured the distinction; F1.5 established the field boundary',
+        },
+        {
+            dimension: 'host dependence', field: 'requires a FieldHost', governor: 'none',
+            classification: 'substrate-specific-value', evidence: 'the contract never mentions a host; both adapters own their own',
+        },
+        {
+            dimension: 'execution context (`now`)', field: 'unused — the field injects its own clock', governor: 'unused — no clock exists',
+            classification: 'unnecessary-generalization',
+            evidence: 'neither substrate read `DynamicsExecutionContext.now` in any fixture; only `step` was used',
+        },
+        {
+            dimension: 'transition-law access', field: 'declareTransitionLaw=false (opaque)', governor: 'declareTransitionLaw=true, but the contract offered NO accessor',
+            classification: 'missing-general-concept',
+            evidence: 'the governor can truthfully declare its law (a data table) yet no contract method could return it — a gap invisible while only the field existed',
+        },
+    ];
+}
+export function crossSubstrateResult() {
+    const rows = crossSubstrateMatrix();
+    const missing = rows.filter((r) => r.classification === 'missing-general-concept');
+    const fieldBiased = rows.filter((r) => r.classification === 'field-biased');
+    const outcome = fieldBiased.length > 0 ? 'field-fitted' : missing.length > 0 ? 'generalized-with-refinement' : 'generalized';
+    return {
+        rows,
+        outcome,
+        refinements: missing.map((r) => `${r.dimension}: ${r.evidence}`),
+        rationale: 'No dimension was classified field-biased: the second substrate adopted the contract unchanged in ' +
+            'executionKind, determinism, capabilities, evidence, failures, fidelity, replay, restore, lifecycle and ' +
+            'ordering. One genuine gap surfaced (transition-law access) and one over-generalization (`context.now`, ' +
+            'unused by both). The gap is a missing general concept, not a substrate convenience: the contract already ' +
+            'carries a `declareTransitionLaw` capability with no way to exercise it.',
+    };
+}
+//# sourceMappingURL=cross-substrate.js.map

package/dist/world/cross-substrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-substrate.js","sourceRoot":"","sources":["../../src/world/cross-substrate.ts"],"names":[],"mappings":"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"}

package/dist/world/dynamics.d.ts

@@ -0,0 +1,166 @@
+/**
+ * DynamicsContract (F1.3) — the abstraction for lawful evolution: the plane-neutral execution boundary
+ * between a declared world and an execution substrate. The kernel executes a contract; it never
+ * understands the dynamics behind it, and asserts nothing about unobserved internal laws.
+ *
+ *     World  →  DynamicsContract  →  ExecutionSubstrate (FieldRuntime is one, executionKind 'opaque-native')
+ *
+ * There is deliberately NO `declarative: boolean` — that would collapse independent properties into one
+ * flag. `executionKind`, `capabilities`, and `determinism` carry those claims separately. EXPERIMENTAL,
+ * field-free (enforced by `world/architecture.test.ts`).
+ */
+import type { WorldStateSnapshot } from './world.ts';
+export interface DynamicsIdentity {
+    readonly id: string;
+    readonly version: string;
+}
+/** Closed for the current stage. `FieldRuntime` declares `opaque-native`. */
+export type DynamicsExecutionKind = 'declarative' | 'interpreted' | 'compiled' | 'opaque-native' | 'external' | 'nondeterministic' | 'hybrid';
+/** Explicit, conservative. A lossy snapshot must NOT imply restore or replay. */
+export interface DynamicsCapabilities {
+    readonly initialize: boolean;
+    readonly advance: true;
+    readonly snapshot: boolean;
+    readonly restore: boolean;
+    readonly replay: boolean;
+    readonly inspectInternalState: boolean;
+    readonly declareTransitionLaw: boolean;
+    readonly deterministicReplay: boolean;
+}
+export type DeterminismClassification = 'deterministic' | 'conditionally-deterministic' | 'nondeterministic' | 'unknown';
+export interface DeterminismDeclaration {
+    readonly classification: DeterminismClassification;
+    readonly controlledInputs: readonly string[];
+    readonly uncontrolledInputs: readonly string[];
+    readonly requirements: readonly string[];
+}
+export interface EvidenceSource {
+    readonly kind: string;
+    readonly id: string;
+}
+/** No evidence entry may exist without source identity. */
+export interface EvidenceRecord {
+    readonly id: string;
+    readonly kind: string;
+    readonly source: EvidenceSource;
+    readonly observedAt: string | number;
+    readonly payload: unknown;
+}
+export interface InvariantEvidence {
+    readonly id: string;
+    readonly held: boolean;
+    readonly detail: string;
+    readonly source: EvidenceSource;
+}
+export interface TransitionEvidence {
+    readonly id: string;
+    readonly step: number;
+    readonly source: EvidenceSource;
+    readonly summary: string;
+}
+/**
+ * An interpretation the runtime does NOT assert. It records that the claim is unresolved and which
+ * authority may discharge it — never that it is established.
+ */
+export interface InterpretationObligation {
+    readonly id: string;
+    readonly claim: string;
+    readonly authority: string;
+    readonly status: 'unresolved';
+}
+export interface DynamicsEvidence {
+    readonly declaredInputs: readonly EvidenceRecord[];
+    readonly substrateResponses: readonly EvidenceRecord[];
+    readonly checkedInvariants: readonly InvariantEvidence[];
+    readonly executionTrace: readonly TransitionEvidence[];
+    readonly unresolvedInterpretations: readonly InterpretationObligation[];
+}
+export type DynamicsFailureCode = 'invalid-declaration' | 'invalid-state' | 'unsupported-operation' | 'capability-unavailable' | 'substrate-failure' | 'invariant-violation' | 'version-incompatible' | 'nondeterministic-result' | 'snapshot-unsupported' | 'restore-unsupported';
+export interface DynamicsFailure {
+    readonly code: DynamicsFailureCode;
+    readonly message: string;
+    /** The original cause is retained internally; it is NOT a substrate-specific type on the generic surface. */
+    readonly cause?: unknown;
+}
+/** Typed results, not routine exceptions. Exceptions stay reserved for programmer errors. */
+export type DynamicsResult<T, Evidence> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly evidence: Evidence;
+} | {
+    readonly ok: false;
+    readonly error: DynamicsFailure;
+    readonly evidence: Evidence;
+};
+/**
+ * Whether further transitions are defined from the resulting state (corpus finding C1).
+ *
+ * Added because the corpus introduced the first substrates that FINISH. The field and the governor run
+ * indefinitely, so no earlier substrate could reveal that a kernel driving a contract has no generic way
+ * to learn it should stop calling `advance`. Without this, a kernel must read substrate-specific output
+ * to decide whether to continue — which is exactly the abstraction leak the contract exists to prevent.
+ *
+ * Deliberately minimal: `terminal` does NOT distinguish "finished with a result" from "finished without
+ * one" (goal-reached vs exhausted). Both corpus substrates exhibit that distinction, but the evidence
+ * only forces "must the kernel keep going?", so the richer split stays in substrate-specific output
+ * until a third substrate needs it generically.
+ */
+export type TransitionLifecycle = 'continuing' | 'terminal';
+export interface Transition<State, Output> {
+    readonly state: State;
+    readonly output: Output;
+    /** Absent is read as `continuing` — the behaviour of every substrate that predates this concept. */
+    readonly lifecycle?: TransitionLifecycle;
+}
+export interface TransitionLawRule {
+    readonly [key: string]: number | string | boolean;
+}
+/**
+ * A substrate's declared transition law, expressed as DATA (G3.3 refinement).
+ *
+ * Added because the second substrate exposed a gap: `capabilities.declareTransitionLaw` could be set
+ * truthfully, yet the contract offered no way to obtain the law. An `opaque-native` substrate cannot
+ * provide one (and must leave the capability false); a substrate whose law IS a declared table can.
+ */
+export interface TransitionLawDescription {
+    readonly kind: string;
+    readonly rules: readonly TransitionLawRule[];
+    readonly notes?: string;
+}
+export interface DynamicsSnapshot {
+    /** The generic readable projection the kernel may inspect (e.g. to check invariants). */
+    readonly reading: WorldStateSnapshot;
+    /** Whether this snapshot can reconstruct `State`. A lossy substrate sets false. */
+    readonly restorable: boolean;
+    /** Substrate-specific serialization — present ONLY when `restorable`. */
+    readonly payload?: unknown;
+}
+export interface InitializeRequest {
+    readonly declaration: unknown;
+}
+export interface DynamicsExecutionContext {
+    readonly step: number;
+    readonly now?: number;
+}
+export interface DynamicsContract<State, Input, Output, Evidence = DynamicsEvidence> {
+    readonly identity: DynamicsIdentity;
+    readonly executionKind: DynamicsExecutionKind;
+    readonly capabilities: DynamicsCapabilities;
+    readonly determinism: DeterminismDeclaration;
+    initialize(request: InitializeRequest): DynamicsResult<State, Evidence>;
+    advance(state: State, input: Input, context: DynamicsExecutionContext): DynamicsResult<Transition<State, Output>, Evidence>;
+    snapshot?(state: State, context: DynamicsExecutionContext): DynamicsResult<DynamicsSnapshot, Evidence>;
+    restore?(snapshot: DynamicsSnapshot, context: DynamicsExecutionContext): DynamicsResult<State, Evidence>;
+    /** Present iff `capabilities.declareTransitionLaw` is true. Returns the law as data. */
+    describeTransitionLaw?(): DynamicsResult<TransitionLawDescription, Evidence>;
+}
+export interface DynamicsContractProblem {
+    readonly rule: string;
+    readonly detail: string;
+}
+/**
+ * Static consistency check over a contract's declarations. Rejects contradictory capability /
+ * execution-kind / determinism combinations (F1.3 negative tests).
+ */
+export declare function validateDynamicsContract(c: Pick<DynamicsContract<unknown, unknown, unknown, unknown>, 'executionKind' | 'capabilities' | 'determinism' | 'describeTransitionLaw'>): DynamicsContractProblem[];
+//# sourceMappingURL=dynamics.d.ts.map

package/dist/world/dynamics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamics.d.ts","sourceRoot":"","sources":["../../src/world/dynamics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,6EAA6E;AAC7E,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,aAAa,GACb,UAAU,GACV,eAAe,GACf,UAAU,GACV,kBAAkB,GAClB,QAAQ,CAAC;AAEb,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,MAAM,MAAM,yBAAyB,GACjC,eAAe,GACf,6BAA6B,GAC7B,kBAAkB,GAClB,SAAS,CAAC;AAEd,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAAC;IACnD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,cAAc,EAAE,SAAS,cAAc,EAAE,CAAC;IACnD,QAAQ,CAAC,kBAAkB,EAAE,SAAS,cAAc,EAAE,CAAC;IACvD,QAAQ,CAAC,iBAAiB,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzD,QAAQ,CAAC,cAAc,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvD,QAAQ,CAAC,yBAAyB,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACzE;AAED,MAAM,MAAM,mBAAmB,GAC3B,qBAAqB,GACrB,eAAe,GACf,uBAAuB,GACvB,wBAAwB,GACxB,mBAAmB,GACnB,qBAAqB,GACrB,sBAAsB,GACtB,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6GAA6G;IAC7G,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,6FAA6F;AAC7F,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,QAAQ,IAClC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GACrE;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEzF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,UAAU,CAAC;AAE5D,MAAM,WAAW,UAAU,CAAC,KAAK,EAAE,MAAM;IACvC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oGAAoG;IACpG,QAAQ,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CACnD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAG,gBAAgB;IACjF,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC;IAC9C,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAE7C,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACxE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,wBAAwB,GAAG,cAAc,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC5H,QAAQ,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,wBAAwB,GAAG,cAAc,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;IACvG,OAAO,CAAC,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,wBAAwB,GAAG,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACzG,wFAAwF;IACxF,qBAAqB,CAAC,IAAI,cAAc,CAAC,wBAAwB,EAAE,QAAQ,CAAC,CAAC;CAC9E;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,GAAG,aAAa,GAAG,uBAAuB,CAAC,GACxI,uBAAuB,EAAE,CAwB3B"}

package/dist/world/dynamics.js

@@ -0,0 +1,30 @@
+/**
+ * Static consistency check over a contract's declarations. Rejects contradictory capability /
+ * execution-kind / determinism combinations (F1.3 negative tests).
+ */
+export function validateDynamicsContract(c) {
+    const problems = [];
+    const caps = c.capabilities;
+    if (caps.deterministicReplay && !caps.replay) {
+        problems.push({ rule: 'deterministicReplay⇒replay', detail: 'deterministicReplay:true requires replay:true' });
+    }
+    if (caps.restore && !caps.snapshot) {
+        problems.push({ rule: 'restore⇒snapshot', detail: 'restore:true requires snapshot:true' });
+    }
+    if (caps.declareTransitionLaw && c.executionKind === 'opaque-native') {
+        problems.push({ rule: 'law∦opaque-native', detail: 'declareTransitionLaw:true is incompatible with executionKind opaque-native' });
+    }
+    if (c.determinism.classification === 'deterministic' && c.determinism.uncontrolledInputs.length > 0) {
+        problems.push({ rule: 'deterministic∦uncontrolled', detail: 'classification deterministic must not list uncontrolled inputs' });
+    }
+    // G3.3 refinement: the capability must be exercisable, and must not be claimed silently.
+    const hasLaw = typeof c.describeTransitionLaw === 'function';
+    if (caps.declareTransitionLaw && !hasLaw) {
+        problems.push({ rule: 'declareTransitionLaw⇒describeTransitionLaw', detail: 'declareTransitionLaw:true requires a describeTransitionLaw() method' });
+    }
+    if (!caps.declareTransitionLaw && hasLaw) {
+        problems.push({ rule: 'describeTransitionLaw⇒declareTransitionLaw', detail: 'describeTransitionLaw() present but declareTransitionLaw is false' });
+    }
+    return problems;
+}
+//# sourceMappingURL=dynamics.js.map

package/dist/world/dynamics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamics.js","sourceRoot":"","sources":["../../src/world/dynamics.ts"],"names":[],"mappings":"AAwMA;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CACtC,CAAyI;IAEzI,MAAM,QAAQ,GAA8B,EAAE,CAAC;IAC/C,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,CAAC;IAC5B,IAAI,IAAI,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4BAA4B,EAAE,MAAM,EAAE,+CAA+C,EAAE,CAAC,CAAC;IACjH,CAAC;IACD,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC,CAAC;IAC7F,CAAC;IACD,IAAI,IAAI,CAAC,oBAAoB,IAAI,CAAC,CAAC,aAAa,KAAK,eAAe,EAAE,CAAC;QACrE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,4EAA4E,EAAE,CAAC,CAAC;IACrI,CAAC;IACD,IAAI,CAAC,CAAC,WAAW,CAAC,cAAc,KAAK,eAAe,IAAI,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpG,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4BAA4B,EAAE,MAAM,EAAE,gEAAgE,EAAE,CAAC,CAAC;IAClI,CAAC;IACD,yFAAyF;IACzF,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,qBAAqB,KAAK,UAAU,CAAC;IAC7D,IAAI,IAAI,CAAC,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC;QACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4CAA4C,EAAE,MAAM,EAAE,qEAAqE,EAAE,CAAC,CAAC;IACvJ,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,oBAAoB,IAAI,MAAM,EAAE,CAAC;QACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4CAA4C,EAAE,MAAM,EAAE,mEAAmE,EAAE,CAAC,CAAC;IACrJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/world/envelope.d.ts

@@ -0,0 +1,44 @@
+export interface WorldVersionEnvelope {
+    /** Which running world this is. */
+    readonly worldInstance: string;
+    /** Shape of this world's declared state / ontology. */
+    readonly worldSchema: string;
+    /** The K semantics that evolve it. */
+    readonly kernelSemantics: string;
+    /** Shape of the contracts in force. */
+    readonly contractSchema: string;
+    /** The projection(s) that produced any accompanying representation. */
+    readonly projectionContract: string;
+    /** Engine build + plane, e.g. `js@0.9.4`. */
+    readonly implementation: string;
+    /** Version of the golden vectors this was checked against. */
+    readonly conformanceVector: string;
+    /** Ordered history of schema migrations applied (identity only in F1; tooling in F4.4). */
+    readonly migrationChain: readonly string[];
+}
+export declare const WORLD_SCHEMA_VERSION = "0.1.0";
+export declare const KERNEL_SEMANTICS_VERSION = "0.1.0";
+export declare const CONTRACT_SCHEMA_VERSION = "0.1.0";
+export declare const PROJECTION_CONTRACT_VERSION = "0.1.0";
+export declare const CONFORMANCE_VECTOR_VERSION = "0.1.0";
+/** The seven single-identity fields. `migrationChain` is compared as an ordered list, not a scalar. */
+export declare const WORLD_ENVELOPE_IDENTITY_FIELDS: readonly ["worldInstance", "worldSchema", "kernelSemantics", "contractSchema", "projectionContract", "implementation", "conformanceVector"];
+export type WorldEnvelopeIdentityField = (typeof WORLD_ENVELOPE_IDENTITY_FIELDS)[number];
+export interface EnvelopeMismatch {
+    readonly field: WorldEnvelopeIdentityField | 'migrationChain';
+    readonly expected: string;
+    readonly actual: string;
+}
+/** Thrown when a loaded world/trace envelope is not identical to the current runtime's. */
+export declare class IncompatibleWorldVersion extends Error {
+    readonly mismatches: readonly EnvelopeMismatch[];
+    constructor(mismatches: readonly EnvelopeMismatch[]);
+}
+/** Build an envelope for `worldInstance`, defaulting each layer to its current version. */
+export declare function createWorldEnvelope(worldInstance: string, overrides?: Partial<Omit<WorldVersionEnvelope, 'worldInstance'>>): WorldVersionEnvelope;
+/** Every field on which `loaded` differs from `current`. Empty ⇒ compatible. */
+export declare function envelopeMismatches(loaded: WorldVersionEnvelope, current: WorldVersionEnvelope): EnvelopeMismatch[];
+export declare function isCompatibleEnvelope(loaded: WorldVersionEnvelope, current: WorldVersionEnvelope): boolean;
+/** Throw {@link IncompatibleWorldVersion} unless `loaded` is identical to `current`. No silent migration. */
+export declare function assertCompatibleEnvelope(loaded: WorldVersionEnvelope, current: WorldVersionEnvelope): void;
+//# sourceMappingURL=envelope.d.ts.map