worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/invariants.js

@@ -0,0 +1,34 @@
+import {} from "./basis.js";
+import {} from "./dates.js";
+import { assertSnapshot, evaluateIn, instanceContext, machineState } from "./evaluation.js";
+import {} from "./model.js";
+/** Would a command of `kind` against `subject` violate a declared invariant at `now`? */
+export const admit = (recon, b, now, command) => {
+    assertSnapshot(b, now);
+    const violations = [];
+    for (const inst of recon.instances.values()) {
+        const p = recon.programs.find((x) => x.account.name === inst.account);
+        const component = p.components.get(inst.component);
+        if (!component.invariants.length)
+            continue;
+        const cx = instanceContext(recon, b, inst);
+        for (const invariant of component.invariants) {
+            if (invariant.forbids.action !== command.kind)
+                continue;
+            if (evaluateIn(cx, invariant.forbids.subject) !== command.subject)
+                continue;
+            if (evaluateIn(cx, invariant.while) !== true)
+                continue;
+            const states = component.machines
+                .map((m) => machineState(b, inst.id, m.name))
+                .filter(Boolean);
+            violations.push({
+                instance: inst.id,
+                invariant: invariant.name,
+                reason: `${invariant.name} holds while ${inst.id} is ${states.join(", ")}`,
+                at: invariant.at,
+            });
+        }
+    }
+    return violations;
+};

package/dist/_internal/reconciler/journal.d.ts

@@ -0,0 +1,3 @@
+import type { JournalEntry } from "./basis.js";
+import type { World } from "./memory.js";
+export declare const log: (world: World, entry: Omit<JournalEntry, "id">) => World;

package/dist/_internal/reconciler/journal.js

@@ -0,0 +1,4 @@
+export const log = (world, entry) => ({
+    ...world,
+    journal: [...world.journal, { ...entry, id: `tx-${world.journal.length + 1}` }],
+});

package/dist/_internal/reconciler/linking.d.ts

@@ -0,0 +1,10 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type Program } from "./model.js";
+export declare class LinkError extends Error {
+}
+export declare const finiteClocks: WeakSet<IR.WorldIR>;
+export declare const assertFiniteClock: (ir: IR.WorldIR) => void;
+export declare const rewrite: <T>(value: T, f: (expr: IR.Expr) => IR.Expr | undefined) => T;
+export declare const link: (ir: IR.WorldIR, accountName: string) => Program;
+/** Every account in a compiled IR, linked. */
+export declare const linkAll: (ir: IR.WorldIR) => Program[];

package/dist/_internal/reconciler/linking.js

@@ -0,0 +1,259 @@
+import { agentReadDiagnostics } from "../ir-checks/index.js";
+import { sensitivityDiagnostics } from "../ir-checks/index.js";
+import { vaultDiagnostics } from "../ir-checks/index.js";
+import { resourceProofDiagnostics } from "../ir-checks/index.js";
+import { amendmentDiagnostics } from "../ir-checks/index.js";
+import { resourceDiagnostics } from "../ir-checks/index.js";
+import { signatureDiagnostics } from "../ir-checks/index.js";
+import { noticeDiagnostics } from "../ir-checks/index.js";
+import { documentDiagnostics } from "../ir-checks/index.js";
+import { fileFieldDiagnostics } from "../ir-checks/index.js";
+import { childParameterDiagnostics } from "../ir-checks/index.js";
+import { componentContractDiagnostics } from "../ir-checks/index.js";
+import { advanceTargets, stableWorkIdentity, reuseProblem } from "../ir-checks/index.js";
+import { withReuseDecisions } from "./reuse.js";
+import { policyRelease, validatePolicies } from "./policy-linking.js";
+import { evidenceScopeDiagnostics, finiteTimeDiagnostics, instantLiteralDiagnostics, clockBindingDiagnostics, } from "../ir-checks/index.js";
+import { makeCalendar } from "./dates.js";
+import { constant } from "./evaluation.js";
+import {} from "./model.js";
+import { withPriorDecisions } from "./prior-decisions.js";
+import { withPrincipalKinds } from "./principal-types.js";
+import { sha256 } from "./sha256.js";
+export class LinkError extends Error {
+}
+export const finiteClocks = new WeakSet();
+// Only successful byte-identical authored content may reuse publish validation.
+// Bound fingerprints without retaining IRs; account binding/policy checks still run.
+const validatedSources = new Set();
+// Canonical source/account inputs determine the outgoing bytes. Retain only expected
+// digests, never shared runtime views; incoming objects are still fingerprinted each time.
+const resolvedDigests = new Map();
+const linkedSources = new WeakMap();
+const fingerprint = (ir) => {
+    let reusable = true;
+    const bytes = JSON.stringify(ir, function (key, value) {
+        const prototype = value && typeof value === "object" ? Object.getPrototypeOf(value) : null;
+        if (this[key] !== value ||
+            (prototype !== null && prototype !== Object.prototype && !Array.isArray(value)) ||
+            value === undefined ||
+            typeof value === "function" ||
+            typeof value === "symbol" ||
+            (typeof value === "number" && !Number.isFinite(value)))
+            reusable = false;
+        return value;
+    });
+    return { digest: sha256(bytes), reusable };
+};
+export const assertFiniteClock = (ir) => {
+    if (finiteClocks.has(ir))
+        return;
+    const [diagnostic] = [
+        ...finiteTimeDiagnostics(ir),
+        ...evidenceScopeDiagnostics(ir),
+        ...instantLiteralDiagnostics(ir),
+        ...clockBindingDiagnostics(ir),
+    ];
+    if (diagnostic) {
+        const at = diagnostic.at;
+        throw new LinkError(`${diagnostic.code}: ${diagnostic.message}${at ? ` (${at.src}:${at.line}:${at.col})` : ""} ${diagnostic.help} Republish this model.`);
+    }
+    finiteClocks.add(ir);
+};
+export const rewrite = (value, f) => {
+    if (Array.isArray(value))
+        return value.map((v) => rewrite(v, f));
+    if (value && typeof value === "object") {
+        const replaced = "k" in value ? f(value) : undefined;
+        if (replaced)
+            return replaced;
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, k === "at" ? v : rewrite(v, f)]));
+    }
+    return value;
+};
+export const link = (ir, accountName) => {
+    // Relinking an unchanged owned result needs authored reads, including contract policy
+    // expressions. Never recover through an edited source/result or a raw-IR clone.
+    const authored = linkedSources.get(ir);
+    let source = fingerprint(ir);
+    if (authored && source.digest === authored.resolvedDigest) {
+        const original = fingerprint(authored.ir);
+        if (original.digest === authored.sourceDigest) {
+            ir = authored.ir;
+            source = original;
+        }
+    }
+    const sourceDigest = source.digest;
+    const sourceIR = ir;
+    if (!source.reusable || !validatedSources.has(sourceDigest)) {
+        const vaultError = vaultDiagnostics(ir).find((d) => d.severity === "error");
+        if (vaultError)
+            throw new LinkError(`${vaultError.code}: ${vaultError.message} ${vaultError.help}`);
+        const agentError = agentReadDiagnostics(ir)[0];
+        if (agentError)
+            throw new LinkError(`${agentError.code}: ${agentError.message} ${agentError.help}`);
+        const sensitive = sensitivityDiagnostics(ir)[0];
+        if (sensitive)
+            throw new LinkError(`${sensitive.code}: ${sensitive.message} ${sensitive.help}`);
+        const proofError = resourceProofDiagnostics(ir)[0];
+        if (proofError)
+            throw new LinkError(`${proofError.code}: ${proofError.message} ${proofError.help}`);
+        const resourceError = resourceDiagnostics(ir)[0];
+        if (resourceError)
+            throw new LinkError(`${resourceError.code}: ${resourceError.message} ${resourceError.help}`);
+        const amendmentError = amendmentDiagnostics(ir)[0];
+        if (amendmentError)
+            throw new LinkError(`${amendmentError.code}: ${amendmentError.message} ${amendmentError.help}`);
+        const signatureError = signatureDiagnostics(ir)[0];
+        if (signatureError)
+            throw new LinkError(`${signatureError.code}: ${signatureError.message} ${signatureError.help}`);
+        const noticeError = noticeDiagnostics(ir)[0];
+        if (noticeError)
+            throw new LinkError(`${noticeError.code}: ${noticeError.message} ${noticeError.help}`);
+        const documentError = documentDiagnostics(ir)[0];
+        if (documentError)
+            throw new LinkError(`${documentError.code}: ${documentError.message} ${documentError.help}`);
+        const fileError = fileFieldDiagnostics(ir)[0];
+        if (fileError)
+            throw new LinkError(`${fileError.code}: ${fileError.message} ${fileError.help}`);
+        const parameterError = childParameterDiagnostics(ir)[0];
+        if (parameterError)
+            throw new LinkError(`${parameterError.code}: ${parameterError.message} (${parameterError.at?.src}:${parameterError.at?.line}:${parameterError.at?.col}) ${parameterError.help}`);
+        const contractError = componentContractDiagnostics(ir)[0];
+        if (contractError)
+            throw new LinkError(`${contractError.code}: ${contractError.message} (${contractError.at?.src}:${contractError.at?.line}:${contractError.at?.col}) ${contractError.help}`);
+        if (source.reusable)
+            validatedSources.add(sourceDigest);
+        if (validatedSources.size > 64)
+            validatedSources.delete(validatedSources.values().next().value);
+    }
+    try {
+        ir = withPrincipalKinds(withPriorDecisions(withReuseDecisions(ir)));
+    }
+    catch (error) {
+        throw new LinkError(error instanceof Error ? error.message : String(error));
+    }
+    const account = ir.accounts.find((a) => a.name === accountName);
+    if (!account)
+        throw new LinkError(`No account ${accountName}`);
+    const pin = account.requires[0];
+    const library = ir.libraries.find((l) => l.name === pin?.library && l.version === pin?.version);
+    if (!library)
+        throw new LinkError(`${accountName} requires an unpublished library`);
+    assertFiniteClock(ir);
+    for (const bundle of ir.bundles ?? []) {
+        if (!ir.roles.some((r) => r.name === bundle.role))
+            throw new LinkError(`E_BUNDLE_ROLE: ${bundle.name} must name a declared role (${bundle.at.src}:${bundle.at.line}:${bundle.at.col}). Republish :for with a declared role.`);
+        if (!bundle.label.trim())
+            throw new LinkError(`E_BUNDLE_LABEL: ${bundle.name} needs a nonempty label (${bundle.at.src}:${bundle.at.line}:${bundle.at.col}). Republish a readable session title.`);
+    }
+    const reuseError = reuseProblem(ir);
+    if (reuseError)
+        throw new LinkError(`${reuseError.code}: ${reuseError.message}. ${reuseError.help}`);
+    for (const component of ir.components)
+        for (const action of component.actions) {
+            const names = advanceTargets(action), requirements = names.map((name) => component.requirements.find((r) => r.name === name));
+            const code = !names.length || new Set(names).size !== names.length
+                ? "E_ADVANCES"
+                : requirements.some((r) => !r)
+                    ? "E_UNKNOWN_REQUIREMENT"
+                    : names.length > 1 &&
+                        (!stableWorkIdentity(component, action) ||
+                            requirements.some((r) => r.cycle || r.recur || r.renewWithin || r.accepts || r.reuse))
+                        ? "E_ADVANCES_SCOPE"
+                        : null;
+            if (code)
+                throw new LinkError(`${code}: ${component.name}/${action.name} has incompatible targets (${action.at.src}:${action.at.line}:${action.at.col}). Use unique ordinary local targets and stable key inputs including the first entity key or self; separate actions for distinct proof scopes.`);
+        }
+    const packaged = ir.entities.filter((e) => e.ns.split(".")[0] === account.package.name);
+    const bindings = new Map();
+    for (const role of ir.roles)
+        for (const field of role.fields) {
+            const found = packaged.flatMap((e) => e.implements
+                .filter((b) => b.role === role.name && b.field === field.name)
+                .map((b) => ({ attrs: b.attrs, entity: e.name })));
+            if (found.length > 1)
+                throw new LinkError(`${accountName}: more than one entity implements ${role.name}`);
+            if (found[0])
+                bindings.set(`${role.name}.${field.name}`, found[0]);
+        }
+    const resolveRead = (expr) => {
+        if (expr.k !== "read")
+            return undefined;
+        const binding = bindings.get(`${expr.role}.${expr.field}`);
+        if (!binding)
+            throw new LinkError(`${accountName} does not bind ${expr.role}.${expr.field}`);
+        let of = rewrite(expr.of, resolveRead);
+        for (const attr of binding.attrs)
+            of = {
+                k: "attr",
+                attr,
+                of,
+                meta: { path: expr.meta.path, via: `${expr.role}.${expr.field}` },
+                at: expr.at,
+            };
+        return of;
+    };
+    // Test predicates have their own typed read nodes and retain their authored environment.
+    const { scenarios, properties, ...runtime } = ir;
+    const resolved = {
+        ...rewrite(runtime, resolveRead),
+        ...(scenarios ? { scenarios } : {}),
+        ...(properties ? { properties } : {}),
+    };
+    const roots = account.forEach.map((f) => ({
+        component: f.component,
+        namespaces: packaged
+            .filter((e) => e.implements.some((b) => b.role === f.role))
+            .map((e) => e.ns),
+    }));
+    const program = {
+        sourceIR,
+        ir: resolved,
+        account: resolved.accounts.find((a) => a.name === accountName),
+        library,
+        release: policyRelease(account, library),
+        components: new Map(resolved.components.map((c) => [c.name, c])),
+        derives: new Map(resolved.derives.map((d) => [d.name, d])),
+        evidence: new Map(resolved.evidence.map((e) => [e.name, e])),
+        interactions: new Map(resolved.interactions.map((i) => [i.name, i])),
+        machines: new Map(resolved.machines.map((m) => [m.name, m])),
+        connectors: new Map(resolved.connectors.map((c) => [c.name, c])),
+        calendars: new Map(resolved.calendars.map((c) => [
+            c.name,
+            makeCalendar(c.name, c.version, c.weekend, c.holidays),
+        ])),
+        entities: new Map(resolved.entities.map((e) => [e.ns, e])),
+        bindings,
+        params: new Map(),
+        roots,
+    };
+    const params = new Map();
+    for (const p of program.account.params)
+        params.set(p.name, constant(program, p.value));
+    const linked = { ...program, params };
+    try {
+        validatePolicies(linked);
+    }
+    catch (error) {
+        throw new LinkError(error instanceof Error ? error.message : String(error));
+    }
+    const identity = source.reusable ? JSON.stringify([sourceDigest, accountName]) : undefined;
+    let resolvedDigest = identity ? resolvedDigests.get(identity) : undefined;
+    if (!resolvedDigest) {
+        resolvedDigest = sha256(JSON.stringify(resolved));
+        if (identity) {
+            resolvedDigests.set(identity, resolvedDigest);
+            if (resolvedDigests.size > 64)
+                resolvedDigests.delete(resolvedDigests.keys().next().value);
+        }
+    }
+    linkedSources.set(resolved, {
+        ir: sourceIR,
+        sourceDigest,
+        resolvedDigest,
+    });
+    return linked;
+};
+/** Every account in a compiled IR, linked. */
+export const linkAll = (ir) => ir.accounts.map((a) => link(ir, a.name));

package/dist/_internal/reconciler/memory.d.ts

@@ -0,0 +1,32 @@
+import type { TimePoint } from "./instants.js";
+import type { AcceptanceRecord, ConfirmationRecord, Basis, DispatchRecord, DecisionRecord, EvidenceRecord, Fact, FileRecord, DocumentRecord, NoticeDeliveryRecord, NoticeAcknowledgmentRecord, JournalEntry, MilestoneRecord, SignalRecord } from "./basis.js";
+export interface OperationReceipt {
+    readonly account: string;
+    readonly id: string;
+    readonly digest: string;
+    readonly instance: string;
+    readonly operation: string;
+    readonly kind: "action" | "decision";
+    readonly at: TimePoint;
+}
+export interface World {
+    readonly redactions?: readonly import("./basis.js").RedactionObservation[];
+    readonly lifecycles?: readonly import("./basis.js").LifecycleRecord[];
+    readonly resources?: readonly import("./basis.js").ResourceRecord[];
+    readonly noticeDeliveries?: readonly NoticeDeliveryRecord[];
+    readonly noticeAcknowledgments?: readonly NoticeAcknowledgmentRecord[];
+    readonly documents?: readonly DocumentRecord[];
+    readonly files?: readonly FileRecord[];
+    readonly operationReceipts?: readonly OperationReceipt[];
+    readonly confirmations?: readonly ConfirmationRecord[];
+    readonly milestones?: readonly MilestoneRecord[];
+    readonly facts: readonly Fact[];
+    readonly evidence: readonly EvidenceRecord[];
+    readonly decisions?: readonly DecisionRecord[];
+    readonly acceptances: readonly AcceptanceRecord[];
+    readonly signals: readonly SignalRecord[];
+    readonly dispatches: readonly DispatchRecord[];
+    readonly journal: readonly JournalEntry[];
+}
+export declare const emptyWorld: World;
+export declare const basis: (world: World, now: TimePoint) => Basis;

package/dist/_internal/reconciler/memory.js

@@ -0,0 +1,190 @@
+import { normalizeInstant } from "../ir-checks/index.js";
+import { timeOrder } from "./instants.js";
+export const emptyWorld = {
+    facts: [],
+    evidence: [],
+    acceptances: [],
+    signals: [],
+    dispatches: [],
+    journal: [],
+};
+export const basis = (world, now) => {
+    if (now.length !== 10) {
+        const normalized = normalizeInstant(now);
+        if (!normalized)
+            throw new RangeError("Invalid snapshot instant");
+        now = normalized;
+    }
+    const facts = new Map();
+    const byNs = new Map();
+    const nsOf = new Map();
+    for (const f of world.facts) {
+        if (timeOrder(f.at, now) > 0)
+            continue;
+        let attributes = facts.get(f.e);
+        if (!attributes) {
+            facts.set(f.e, (attributes = new Map()));
+            const ns = f.a.slice(0, f.a.indexOf("/"));
+            nsOf.set(f.e, ns);
+            let members = byNs.get(ns);
+            if (!members)
+                byNs.set(ns, (members = new Set()));
+            members.add(f.e);
+        }
+        const previous = attributes.get(f.a);
+        if (!previous || timeOrder(previous.at, f.at) <= 0)
+            attributes.set(f.a, f);
+    }
+    const redactions = world.redactions?.filter((r) => timeOrder(r.at, now) <= 0);
+    for (const r of redactions ?? []) {
+        if (!facts.has(r.entity))
+            facts.set(r.entity, new Map());
+        if (r.attribute) {
+            const ns = r.attribute.slice(0, r.attribute.indexOf("/"));
+            if (!nsOf.has(r.entity))
+                nsOf.set(r.entity, ns);
+            if (!byNs.has(ns))
+                byNs.set(ns, new Set());
+            byNs.get(ns).add(r.entity);
+        }
+    }
+    const evidence = new Map();
+    const matches = new Map();
+    for (const [entity, attributes] of facts)
+        for (const f of attributes.values()) {
+            if (f.v === null)
+                continue;
+            let values = matches.get(f.a);
+            if (!values)
+                matches.set(f.a, (values = new Map()));
+            let ids = values.get(f.v);
+            if (!ids)
+                values.set(f.v, (ids = []));
+            ids.push(entity);
+        }
+    for (const values of matches.values())
+        for (const ids of values.values())
+            ids.sort();
+    const byScope = new Map();
+    const byInstance = new Map();
+    const push = (map, key, e) => {
+        const list = map.get(key);
+        if (list)
+            list.push(e);
+        else
+            map.set(key, [e]);
+    };
+    for (const e of world.evidence)
+        if (timeOrder(e.at, now) <= 0) {
+            for (const scope of new Set(e.reuseScopes ?? []))
+                push(byScope, scope, e);
+            const instances = new Set();
+            for (const occurrence of new Set([e.occurrence, ...(e.occurrences ?? [])])) {
+                push(evidence, occurrence, e);
+                instances.add(occurrence.slice(0, occurrence.lastIndexOf("/")));
+            }
+            for (const instance of instances)
+                push(byInstance, instance, e);
+        }
+    const milestones = new Map();
+    for (const record of world.milestones ?? []) {
+        const key = JSON.stringify([record.instance, record.milestone]);
+        // Append order is authoritative: later attempts cannot overwrite the first record.
+        if (timeOrder(record.at, now) <= 0 && !milestones.has(key))
+            milestones.set(key, record);
+    }
+    const decisions = new Map();
+    for (const record of world.decisions ?? [])
+        if (timeOrder(record.at, now) <= 0) {
+            let list = decisions.get(record.instance);
+            if (!list)
+                decisions.set(record.instance, (list = []));
+            list.push(record);
+        }
+    const acceptances = new Map(world.acceptances
+        .filter((a) => timeOrder(a.at, now) <= 0)
+        .map((a) => [`${a.instance}\u0000${a.requirement}`, a]));
+    const histories = new Map();
+    for (const s of world.signals)
+        if (timeOrder(s.at, now) <= 0) {
+            const key = `${s.instance}\u0000${s.machine}`;
+            const list = histories.get(key);
+            if (list)
+                list.push(s);
+            else
+                histories.set(key, [s]);
+        }
+    const confirmations = new Map();
+    for (const record of world.confirmations ?? []) {
+        if (timeOrder(record.at, now) > 0)
+            continue;
+        const key = JSON.stringify([record.entity, record.attribute]);
+        const previous = confirmations.get(key);
+        if (!previous || timeOrder(previous.at, record.at) <= 0)
+            confirmations.set(key, record);
+    }
+    const dispatches = new Map(world.dispatches.filter((d) => timeOrder(d.at, now) <= 0).map((d) => [d.key, d]));
+    const immutableIndex = (records) => {
+        const index = new Map();
+        for (const record of records) {
+            const key = JSON.stringify([record.account, record.home, record.key]);
+            if (timeOrder(record.at, now) <= 0 && !index.has(key))
+                index.set(key, record);
+        }
+        return (account, home, key) => index.get(JSON.stringify([account, home, key]));
+    };
+    const document = immutableIndex(world.documents ?? []), noticeDelivery = immutableIndex(world.noticeDeliveries ?? []), noticeAcknowledgment = immutableIndex(world.noticeAcknowledgments ?? []);
+    const files = new Map();
+    for (const record of world.files ?? []) {
+        if (timeOrder(record.at, now) > 0)
+            continue;
+        const key = JSON.stringify([record.account, record.home, record.digest]), previous = files.get(key);
+        if (!previous || timeOrder(previous.at, record.at) <= 0)
+            files.set(key, record);
+    }
+    const lifecycles = new Map(), lifecycleHomes = new Map(), resources = new Map();
+    for (const record of world.lifecycles ?? [])
+        if (timeOrder(record.at, now) <= 0)
+            lifecycles.set(JSON.stringify([record.account, record.instance]), record);
+    for (const record of lifecycles.values()) {
+        const key = JSON.stringify([record.account, record.home]), records = lifecycleHomes.get(key) ?? [];
+        records.push(record);
+        lifecycleHomes.set(key, records);
+    }
+    for (const record of world.resources ?? []) {
+        if (timeOrder(record.at, now) > 0)
+            continue;
+        const key = JSON.stringify([record.account, record.home]), records = resources.get(key) ?? [];
+        records.push(record);
+        resources.set(key, records);
+    }
+    return {
+        ...(redactions?.length
+            ? { redactions: (entity) => redactions.filter((r) => r.entity === entity) }
+            : {}),
+        now,
+        lifecycleRecords: (account, home) => lifecycleHomes.get(JSON.stringify([account, home])) ?? [],
+        lifecycle: (account, instance) => lifecycles.get(JSON.stringify([account, instance])),
+        resourceRecords: (account, home) => resources.get(JSON.stringify([account, home])) ?? [],
+        document,
+        noticeDelivery,
+        noticeAcknowledgment,
+        file: (account, home, digest) => files.get(JSON.stringify([account, home, digest])),
+        fact: (e, a) => {
+            const f = facts.get(e)?.get(a);
+            return f && f.v !== null ? f : undefined;
+        },
+        confirmation: (e, a) => confirmations.get(JSON.stringify([e, a])),
+        entities: (ns) => (ns === undefined ? [...facts.keys()] : [...(byNs.get(ns) ?? [])]),
+        matching: (a, v) => matches.get(a)?.get(v) ?? [],
+        nsOf: (e) => nsOf.get(e),
+        evidence: (occurrence) => evidence.get(occurrence) ?? [],
+        evidenceIn: (scope) => byScope.get(scope) ?? [],
+        evidenceOf: (instance) => byInstance.get(instance) ?? [],
+        milestone: (instance, name) => milestones.get(JSON.stringify([instance, name])),
+        decisions: (instance) => decisions.get(instance) ?? [],
+        acceptance: (instance, requirement) => acceptances.get(`${instance}\u0000${requirement}`),
+        history: (instance, machine) => histories.get(`${instance}\u0000${machine}`) ?? [],
+        dispatched: (key) => dispatches.get(key),
+    };
+};

package/dist/_internal/reconciler/milestones.d.ts

@@ -0,0 +1,7 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { EvaluationContext } from "./context.js";
+import type { World } from "./memory.js";
+import type { Cx, MilestoneResult, WorldReconciliation } from "./model.js";
+export declare const evaluateMilestones: (ctx: EvaluationContext, cx: Cx, component: IR.Component) => MilestoneResult[];
+/** In-memory host admission; durable hosts enforce the same unique occurrence/name key. */
+export declare const recordMilestones: (result: WorldReconciliation, world: World) => World;

package/dist/_internal/reconciler/milestones.js

@@ -0,0 +1,58 @@
+import { observeBasis, programDependency, ReadSet } from "./dependencies.js";
+import { evaluateIn, instanceEnv, isUnknown, truth } from "./evaluation.js";
+import { semanticJson } from "./result-digest.js";
+import { timed } from "./scheduling.js";
+import { sha256 } from "./sha256.js";
+export const evaluateMilestones = (ctx, cx, component) => (component.milestones ?? []).map((milestone, index) => {
+    const instance = cx.inst.id;
+    const program = ctx.programOf.get(instance);
+    const existing = cx.b.milestone?.(instance, milestone.name);
+    // A separate read set makes the capture independent of other consumers and graph scope.
+    const reads = new ReadSet();
+    reads.add(programDependency(program));
+    const env = instanceEnv(program, cx.inst, (name) => ctx.state.status(cx.inst, name), reads);
+    const read = timed(ctx, { ...cx, b: observeBasis(ctx.b, reads), reads, env }, ["milestone", String(index), milestone.name], `${milestone.label ?? milestone.name}: condition changes`, (c) => {
+        const value = evaluateIn(c, milestone.when);
+        return { condition: truth(value), unknown: isUnknown(value) ? value.why : null };
+    });
+    cx.reads.merge(reads.entries());
+    // Temporal jobs can discover additional dependencies after this call.
+    ctx.temporalJobs.push(() => cx.reads.merge(reads.entries()));
+    const record = existing ??
+        (read.condition === true
+            ? {
+                instance,
+                milestone: milestone.name,
+                at: ctx.now,
+                release: program.release,
+                basis: { at: ctx.now, digest: `sha256:${sha256(semanticJson([...reads.snapshot()]))}` },
+            }
+            : null);
+    return {
+        name: milestone.name,
+        label: milestone.label ?? milestone.name,
+        ...read,
+        reached: record !== null,
+        pending: !existing && record !== null,
+        record,
+        finding: existing && read.condition === false ? "regressed" : null,
+        at: milestone.at,
+    };
+});
+/** In-memory host admission; durable hosts enforce the same unique occurrence/name key. */
+export const recordMilestones = (result, world) => {
+    const records = [...(world.milestones ?? [])];
+    const key = (r) => JSON.stringify([r.instance, r.milestone]);
+    const seen = new Set(records.map(key));
+    for (const reconciliation of result.results.values())
+        for (const milestone of reconciliation.milestones ?? []) {
+            const record = milestone.record;
+            if (!milestone.pending || !record || seen.has(key(record)))
+                continue;
+            seen.add(key(record));
+            records.push(record);
+        }
+    return records.length === (world.milestones?.length ?? 0)
+        ? world
+        : { ...world, milestones: records };
+};

package/dist/_internal/reconciler/missing.d.ts

@@ -0,0 +1,18 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Cx } from "./model.js";
+/** A display reason plus the IR address a host can act on. Compounds remain opaque. */
+export interface Missing {
+    readonly text: string;
+    readonly kind: "requirement" | "evidence" | "fact" | "machine" | "other";
+    readonly requirement?: string;
+    readonly instance?: string;
+    readonly evidence?: string;
+    readonly producedBy?: readonly {
+        readonly requirement: string;
+        readonly instance: string;
+    }[];
+    readonly fact?: string;
+    readonly machine?: string;
+    readonly states?: readonly string[];
+}
+export declare const missingCondition: (cx: Cx, text: string, expr: IR.Expr) => Missing;