worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,25 @@
+import { type LocalDate } from "./dates.js";
+import type { DecisionRecord, Scalar } from "./basis.js";
+import { type World } from "./memory.js";
+import { type WorldReconciliation } from "./reconcile.js";
+export interface DecisionRequest {
+    readonly id: string;
+    readonly instance: string;
+    readonly decision: string;
+    /** Trusted host identity and memberships, never an unverified form field. */
+    readonly actor: {
+        readonly id: string;
+        readonly kind: "human" | "agent";
+        readonly groups: readonly string[];
+    };
+    readonly reason?: Scalar | null;
+    readonly revoke?: string;
+}
+export interface DecisionResult {
+    readonly world: World;
+    readonly accepted: boolean;
+    readonly codes: readonly string[];
+    readonly record?: DecisionRecord;
+}
+/** Pure admission against the supplied current reconciliation; no durable runtime or I/O. */
+export declare const decide: (recon: WorldReconciliation, world: World, now: LocalDate, request: DecisionRequest) => DecisionResult;

package/dist/_internal/reconciler/decide.js

@@ -0,0 +1,263 @@
+import { instanceContext } from "./evaluation.js";
+import { reusableProof } from "./reuse.js";
+import { isInstant, isLocalDate } from "../ir-checks/index.js";
+import { shiftTime, timeOrder, isPastDeadline } from "./instants.js";
+import { decisionRelease } from "./decision-release.js";
+import {} from "./dates.js";
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+import { decisionHeads, validApprovalCount } from "./decision-records.js";
+import { log } from "./journal.js";
+import { basis } from "./memory.js";
+import { admit, evaluateFor, programFor, Unknown, } from "./reconcile.js";
+const isDate = (value) => isLocalDate(value) || isInstant(value);
+const shifted = (date, duration) => {
+    if (!Number.isSafeInteger(duration.n) || duration.n < 0)
+        return undefined;
+    try {
+        const value = shiftTime(date.length === 10 && ["minutes", "hours"].includes(duration.unit)
+            ? `${date}T00:00:00.000Z`
+            : date, duration.n, duration.unit);
+        return isDate(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const validReason = (type, value, aliases, seen = new Set()) => {
+    if (Array.isArray(type)) {
+        if (type[0] === "Option")
+            return value == null || validReason(type[1], value, aliases, seen);
+        if (type[0] === "Brand")
+            return validReason(type[1], value, aliases, seen);
+        if (type[0] === "Union")
+            return typeof value === "string" && type.slice(1).includes(`:${value}`);
+        return false;
+    }
+    if (typeof type !== "string" || seen.has(type))
+        return false;
+    const alias = aliases.find((a) => a.name === type);
+    if (alias)
+        return validReason(alias.type, value, aliases, new Set([...seen, type]));
+    if (type === "Bool")
+        return typeof value === "boolean";
+    if (type === "Int")
+        return typeof value === "number" && Number.isSafeInteger(value);
+    if (type === "Float")
+        return typeof value === "number" && Number.isFinite(value);
+    if (type === "Date")
+        return (typeof value === "string" &&
+            /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+            !Number.isNaN(Date.parse(value)) &&
+            new Date(value).toISOString().slice(0, 10) === value);
+    return (["String", "Keyword", "Group"].includes(type) &&
+        typeof value === "string" &&
+        value.trim().length > 0);
+};
+/** Pure admission against the supplied current reconciliation; no durable runtime or I/O. */
+export const decide = (recon, world, now, request) => {
+    const rejected = (...codes) => ({
+        accepted: false,
+        codes,
+        world: log(world, {
+            at: now,
+            actor: request.actor.id,
+            title: `Rejected decision ${request.decision}`,
+            context: request.instance,
+            changes: [{ label: "admission", before: "requested", after: codes.join(", ") }],
+        }),
+    });
+    const commandDigest = sha256(canonicalJson({
+        instance: request.instance,
+        decision: request.decision,
+        actor: request.actor.id,
+        kind: request.actor.kind,
+        reason: request.reason ?? null,
+        revoke: request.revoke ?? null,
+    }));
+    const previous = world.decisions?.find((d) => d.id === request.id);
+    if (previous)
+        return previous.commandDigest === commandDigest
+            ? { accepted: true, codes: [], world, record: previous }
+            : rejected("decision-duplicate");
+    if (recon.now !== now)
+        return rejected("decision-snapshot");
+    if (request.actor.kind !== "human")
+        return rejected("decision-authority");
+    const instance = recon.instances.get(request.instance), program = programFor(recon, request.instance);
+    const definition = program?.ir.decisions?.find((d) => d.name === request.decision && d.of === instance?.component);
+    if (!instance || !program || !definition || !request.id.trim())
+        return rejected("decision-target");
+    const target = recon.results
+        .get(instance.id)
+        ?.requirements.find((r) => r.name === definition.applies);
+    const component = program.components.get(instance.component);
+    const addedItem = definition.effect === "add"
+        ? [...component.requirements, ...component.slots.filter((s) => s.mode === "child")].find((item) => item.name === definition.applies && item.discretionary === definition.name)
+        : undefined;
+    if (definition.effect === "add" ? !addedItem : !target)
+        return rejected("decision-target");
+    const snapshot = basis(world, now), evaluate = (e) => {
+        try {
+            return evaluateFor(recon, snapshot, now, instance.id, e, target?.occurrence ?? `${instance.id}/${definition.applies}`);
+        }
+        catch {
+            return new Unknown("Decision expression failed");
+        }
+    };
+    const who = evaluate(definition.by);
+    const group = definition.byKind === "group" ||
+        (definition.byKind === undefined &&
+            ((definition.by.k === "call" && definition.by.fn === "members") ||
+                (typeof who === "string" && snapshot.nsOf(who) === undefined)));
+    if (typeof who !== "string" ||
+        !(group ? request.actor.groups.includes(who) : who === request.actor.id))
+        return rejected("decision-authority");
+    let home;
+    const homePath = component.home?.kind === "input"
+        ? component.home.path
+        : component.home
+            ? []
+            : [component.key[0]];
+    for (const [index, part] of homePath.entries()) {
+        home =
+            index === 0
+                ? instance.inputs.get(part)
+                : home && typeof home === "object" && "inst" in home
+                    ? recon.instances.get(home.inst)?.inputs.get(part)
+                    : undefined;
+    }
+    if (typeof home !== "string")
+        return rejected("decision-home");
+    if (admit(recon, snapshot, now, { kind: request.revoke ? "revoke" : "decide", subject: home })
+        .length)
+        return rejected("decision-invariant");
+    const heads = decisionHeads(snapshot.decisions?.(instance.id) ?? [], definition.name, definition.approvals !== undefined);
+    const head = request.revoke
+        ? heads.find((r) => r.id === request.revoke)
+        : definition.approvals
+            ? heads.find((r) => r.by === request.actor.id)
+            : heads[0];
+    if (request.revoke &&
+        (!head || head.kind !== "grant" || head.release !== decisionRelease(program)))
+        return rejected("decision-stale");
+    let approvals;
+    const distinctFrom = [];
+    if (!request.revoke) {
+        const count = definition.approvals ? evaluate(definition.approvals) : undefined;
+        if (definition.approvals && !validApprovalCount(count))
+            return rejected("decision-approvals");
+        if (validApprovalCount(count))
+            approvals = count;
+        for (const exclusion of definition.distinctFrom ?? []) {
+            const principal = evaluate(exclusion);
+            if (typeof principal !== "string" || principal === request.actor.id)
+                return rejected("decision-distinct");
+            distinctFrom.push(principal);
+        }
+    }
+    if (!request.revoke && definition.when && evaluate(definition.when) !== true)
+        return rejected("decision-condition");
+    if (!validReason(definition.reason, request.reason, program.ir.types))
+        return rejected("decision-reason");
+    let expiresAt, deferredUntil, from, evidence;
+    if (!request.revoke && definition.expires) {
+        const duration = evaluate(definition.expires);
+        if (!duration ||
+            typeof duration !== "object" ||
+            !("n" in duration) ||
+            !Number.isSafeInteger(duration.n) ||
+            duration.n <= 0)
+            return rejected("decision-expiry");
+        expiresAt = shifted(now, duration);
+        if (!expiresAt)
+            return rejected("decision-expiry");
+    }
+    if (!request.revoke && definition.until && definition.effect !== "defer") {
+        const until = evaluate(definition.until);
+        if (!isDate(until) || timeOrder(until, now) <= 0)
+            return rejected("decision-expiry");
+        if (!expiresAt || timeOrder(until, expiresAt) < 0)
+            expiresAt = until;
+    }
+    if (!request.revoke && definition.effect === "defer") {
+        const target = recon.results
+            .get(instance.id)
+            .requirements.find((r) => r.name === definition.applies);
+        if (["Satisfied", "Waived", "NotApplicable"].includes(target.status))
+            return rejected("decision-state");
+        const until = definition.until ? evaluate(definition.until) : new Unknown("missing until");
+        const due = recon.results
+            .get(instance.id)
+            .requirements.find((r) => r.name === definition.applies).due;
+        if (!isDate(until) || isPastDeadline(now, until) || !due)
+            return rejected("decision-until");
+        deferredUntil = until;
+    }
+    if (!request.revoke && definition.effect === "accept") {
+        const requirement = program.components
+            .get(instance.component)
+            .requirements.find((r) => r.name === definition.applies);
+        if (requirement.reuse) {
+            const candidate = reusableProof({ ...instanceContext(recon, snapshot, instance), occurrence: target.occurrence }, requirement);
+            if (!candidate || candidate instanceof Unknown)
+                return rejected("decision-prior");
+            from = candidate.from;
+            evidence = candidate.record.id;
+        }
+        else {
+            const accepts = requirement.accepts;
+            if (!accepts || !instance.prior)
+                return rejected("decision-prior");
+            const priorRequirement = recon.results
+                .get(instance.prior)
+                ?.requirements.find((r) => r.name === (accepts.from ?? requirement.name));
+            const prior = priorRequirement?.status === "Satisfied" ? priorRequirement.evidence : null;
+            if (!prior || prior.status !== "attested")
+                return rejected("decision-prior");
+            if (accepts.within) {
+                const duration = evaluate(accepts.within);
+                if (!duration || typeof duration !== "object" || !("n" in duration))
+                    return rejected("decision-prior");
+                const last = shifted(prior.at, duration);
+                if (!last || isPastDeadline(now, last))
+                    return rejected("decision-prior");
+            }
+            from = instance.prior;
+            evidence = prior.id;
+        }
+    }
+    const record = {
+        id: request.id,
+        instance: instance.id,
+        decision: definition.name,
+        requirement: definition.applies,
+        effect: definition.effect,
+        kind: request.revoke ? "revoke" : "grant",
+        at: now,
+        by: request.actor.id,
+        reason: request.reason ?? null,
+        release: decisionRelease(program),
+        commandDigest,
+        authority: { kind: group ? "group" : "individual", principal: who },
+        ...(approvals !== undefined ? { approvals } : {}),
+        ...(!request.revoke && definition.distinctFrom ? { distinctFrom } : {}),
+        ...(request.revoke ? { revokes: request.revoke } : {}),
+        ...(expiresAt ? { expiresAt } : {}),
+        ...(deferredUntil ? { deferredUntil } : {}),
+        ...(from ? { from } : {}),
+        ...(evidence ? { evidence } : {}),
+    };
+    return {
+        accepted: true,
+        codes: [],
+        record,
+        world: log({ ...world, decisions: [...(world.decisions ?? []), record] }, {
+            at: now,
+            actor: request.actor.id,
+            title: `${request.revoke ? "Revoked" : "Granted"} ${definition.name}`,
+            context: instance.id,
+            changes: [{ label: "decision", before: head?.id ?? "none", after: record.id }],
+        }),
+    };
+};

package/dist/_internal/reconciler/decision-evaluation.d.ts

@@ -0,0 +1,9 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { LocalDate } from "./dates.js";
+import { type SelectedDecision } from "./decision-records.js";
+import { type Cx, type Value } from "./model.js";
+export declare const withinProofPeriod: (cx: Cx, at: LocalDate) => boolean;
+export declare const decisionApprovalCount: (cx: Cx, definition: IR.Decision) => Value;
+export declare const selectedDecision: (cx: Cx, requirement: string, boundary?: (date: LocalDate) => void) => SelectedDecision | null;
+export declare const selectedAddition: (cx: Cx, target: string, boundary?: (date: LocalDate) => void) => SelectedDecision | null;
+export declare const legacyAcceptance: (cx: Cx, requirement: IR.Component["requirements"][number]) => import("./basis.js").AcceptanceRecord | undefined;

package/dist/_internal/reconciler/decision-evaluation.js

@@ -0,0 +1,67 @@
+import { evidenceSuperseded, supersededEvidence } from "./evidence-history.js";
+import { timeOrder } from "./instants.js";
+import { selectDecision } from "./decision-records.js";
+import { decisionRelease } from "./decision-release.js";
+import { evaluateIn, isUnknown } from "./evaluation.js";
+import { Unknown } from "./model.js";
+export const withinProofPeriod = (cx, at) => !cx.proofPeriod ||
+    (timeOrder(at, cx.proofPeriod.start) >= 0 &&
+        (!cx.proofPeriod.next || timeOrder(at, cx.proofPeriod.next) < 0));
+export const decisionApprovalCount = (cx, definition) => {
+    if (!definition.approvals)
+        return 1;
+    if (!cx.inst)
+        return new Unknown("Decision has no owning occurrence");
+    const requirement = cx.p.components
+        .get(cx.inst.component)
+        ?.requirements.find((r) => r.name === definition.applies);
+    const cycle = requirement?.cycle ? evaluateIn(cx, requirement.cycle) : null;
+    const occurrence = cx.occurrence ??
+        `${cx.inst.id}/${definition.applies}${cycle !== null && !isUnknown(cycle) ? `@${String(cycle)}` : ""}`;
+    return evaluateIn({ ...cx, occurrence }, definition.approvals);
+};
+export const selectedDecision = (cx, requirement, boundary) => {
+    const definitions = cx.p.ir.decisions ?? [];
+    const alias = cx.inst
+        ? cx.p.components.get(cx.inst.component)?.requirements.find((r) => r.name === requirement)
+            ?.accepts?.with
+        : undefined;
+    const target = alias ?? requirement;
+    if (!cx.inst ||
+        !definitions.some((d) => d.of === cx.inst.component && d.applies === target && d.effect !== "add"))
+        return null;
+    const selected = selectDecision(definitions, cx.proofPeriod
+        ? (cx.b.decisions?.(cx.inst.id) ?? []).filter((record) => withinProofPeriod(cx, record.at))
+        : (cx.b.decisions?.(cx.inst.id) ?? []), cx.inst.component, target, cx.b.now, decisionRelease(cx.p), boundary, (definition) => decisionApprovalCount(cx, definition));
+    if (selected?.record.effect === "accept" && selected.record.evidence && selected.record.from) {
+        const source = cx.b
+            .evidenceOf(selected.record.from)
+            .find((e) => e.id === selected.record.evidence);
+        if (source && evidenceSuperseded(cx.b, source))
+            return null;
+    }
+    return alias && selected?.record.effect !== "accept" ? null : selected;
+};
+export const selectedAddition = (cx, target, boundary) => {
+    if (!cx.inst)
+        return null;
+    const component = cx.p.components.get(cx.inst.component);
+    const item = [...component.requirements, ...component.slots].find((item) => item.name === target);
+    if (!item?.discretionary)
+        return null;
+    return selectDecision((cx.p.ir.decisions ?? []).filter((d) => d.name === item.discretionary), cx.b.decisions?.(cx.inst.id) ?? [], cx.inst.component, target, cx.b.now, decisionRelease(cx.p), boundary, (definition) => decisionApprovalCount(cx, definition), "addition");
+};
+export const legacyAcceptance = (cx, requirement) => {
+    if (!cx.inst || !requirement.accepts)
+        return undefined;
+    const hasHistory = (cx.b.decisions?.(cx.inst.id) ?? []).some((record) => withinProofPeriod(cx, record.at) &&
+        record.requirement === (requirement.accepts?.with ?? requirement.name) &&
+        record.effect !== "add");
+    const accepted = hasHistory
+        ? undefined
+        : cx.b.acceptance(cx.inst.id, requirement.accepts.with ?? requirement.name);
+    if (accepted &&
+        supersededEvidence(cx.b.evidence(`${accepted.from}/${requirement.accepts.from ?? requirement.name}`)).size)
+        return undefined;
+    return accepted && withinProofPeriod(cx, accepted.at) ? accepted : undefined;
+};

package/dist/_internal/reconciler/decision-records.d.ts

@@ -0,0 +1,14 @@
+import type { DecisionRecord } from "./basis.js";
+import type * as IR from "../world-ir/types.generated.js";
+import { type LocalDate } from "./dates.js";
+export interface SelectedDecision {
+    readonly definition: IR.Decision;
+    readonly record: DecisionRecord;
+    readonly votes?: readonly DecisionRecord[];
+}
+export declare const validApprovalCount: (value: unknown) => value is number;
+export declare const latestDecision: (records: readonly DecisionRecord[], name: string) => DecisionRecord | undefined;
+/** A revocation replaces the target signer's head, even when another reviewer rescinds it. */
+export declare const decisionHeads: (records: readonly DecisionRecord[], name: string, perSigner: boolean) => readonly DecisionRecord[];
+/** Current heads only: an expired or revoked vote never exposes an older grant. */
+export declare const selectDecision: (definitions: readonly IR.Decision[], records: readonly DecisionRecord[], component: string, requirement: string, now: LocalDate, release: string, boundary?: (date: LocalDate) => void, approvalCount?: (definition: IR.Decision) => unknown, mode?: "normal" | "addition") => SelectedDecision | null;

package/dist/_internal/reconciler/decision-records.js

@@ -0,0 +1,77 @@
+import { timeOrder, nextTime } from "./instants.js";
+import {} from "./dates.js";
+export const validApprovalCount = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+export const latestDecision = (records, name) => {
+    let latest;
+    for (const record of records)
+        if (record.decision === name && (!latest || timeOrder(latest.at, record.at) <= 0))
+            latest = record;
+    return latest;
+};
+/** A revocation replaces the target signer's head, even when another reviewer rescinds it. */
+export const decisionHeads = (records, name, perSigner) => {
+    if (!perSigner) {
+        const head = latestDecision(records, name);
+        return head ? [head] : [];
+    }
+    const owned = records.filter((r) => r.decision === name);
+    const byId = new Map(owned.map((r) => [r.id, r]));
+    const heads = new Map();
+    for (const record of owned) {
+        const signer = record.kind === "grant" ? record.by : byId.get(record.revokes ?? "")?.by;
+        if (!signer)
+            continue;
+        const previous = heads.get(signer);
+        if (!previous || timeOrder(previous.at, record.at) <= 0)
+            heads.set(signer, record);
+    }
+    const current = new Set(heads.values());
+    return owned.filter((r) => current.has(r));
+};
+/** Current heads only: an expired or revoked vote never exposes an older grant. */
+export const selectDecision = (definitions, records, component, requirement, now, release, boundary, approvalCount, mode = "normal") => {
+    const candidates = new Map();
+    for (const definition of definitions)
+        if (definition.of === component &&
+            definition.applies === requirement &&
+            (mode === "addition" ? definition.effect === "add" : definition.effect !== "add"))
+            candidates.set(definition.name, definition);
+    const visible = records.filter((r) => timeOrder(r.at, now) <= 0);
+    const qualified = new Map();
+    for (const definition of candidates.values()) {
+        const votes = decisionHeads(visible, definition.name, definition.approvals !== undefined).filter((record) => {
+            if (record.kind !== "grant" ||
+                record.release !== release ||
+                record.effect !== definition.effect ||
+                (record.authority !== undefined &&
+                    definition.byKind !== undefined &&
+                    record.authority.kind !== definition.byKind))
+                return false;
+            if (record.expiresAt)
+                boundary?.(record.expiresAt);
+            if (record.deferredUntil) {
+                const next = nextTime(record.deferredUntil);
+                if (next)
+                    boundary?.(next);
+            }
+            return !record.expiresAt || timeOrder(now, record.expiresAt) < 0;
+        });
+        const count = definition.approvals ? approvalCount?.(definition) : 1;
+        if (!validApprovalCount(count) || votes.length < count)
+            continue;
+        const record = votes.reduce((latest, next) => timeOrder(latest.at, next.at) <= 0 ? next : latest);
+        qualified.set(definition.name, {
+            definition,
+            record,
+            ...(definition.approvals ? { votes } : {}),
+        });
+    }
+    let selected = null;
+    for (const record of records) {
+        const candidate = qualified.get(record.decision);
+        if (candidate?.record === record &&
+            (!selected || timeOrder(selected.record.at, record.at) <= 0))
+            selected = candidate;
+    }
+    return selected;
+};

package/dist/_internal/reconciler/decision-release.d.ts

@@ -0,0 +1,3 @@
+import type { Program } from "./reconcile.js";
+/** Grants bind to the immutable library and account release, excluding source spans. */
+export declare const decisionRelease: (program: Program) => string;

package/dist/_internal/reconciler/decision-release.js

@@ -0,0 +1,12 @@
+import { semanticJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+const releases = new WeakMap();
+/** Grants bind to the immutable library and account release, excluding source spans. */
+export const decisionRelease = (program) => {
+    let digest = releases.get(program);
+    if (!digest) {
+        digest = `sha256:${sha256(semanticJson([program.library.digest, program.account.name, program.account.package.digest, program.account.params, ...(program.account.policies?.length ? [program.account.policies] : [])]))}`;
+        releases.set(program, digest);
+    }
+    return digest;
+};

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

@@ -0,0 +1,179 @@
+import type { AcceptanceRecord, ConfirmationRecord, Basis, DispatchRecord, DecisionRecord, EvidenceRecord, Fact, FileRecord, DocumentRecord, NoticeDeliveryRecord, NoticeAcknowledgmentRecord, Scalar, SignalRecord, MilestoneRecord, LifecycleRecord, ResourceRecord } from "./basis.js";
+import type { TimePoint } from "./instants.js";
+import type { Program, Status, Truth, Value } from "./reconcile.js";
+/** A query's identity and its observed value, including missing records. */
+export type Dependency = {
+    readonly kind: "lifecycles";
+    readonly account: string;
+    readonly home: string;
+    readonly value: readonly LifecycleRecord[];
+} | {
+    readonly kind: "lifecycle";
+    readonly account: string;
+    readonly instance: string;
+    readonly value: LifecycleRecord | null;
+} | {
+    readonly kind: "resources";
+    readonly account: string;
+    readonly home: string;
+    readonly value: readonly ResourceRecord[];
+} | {
+    readonly kind: "document";
+    readonly account: string;
+    readonly home: string;
+    readonly key: string;
+    readonly value: DocumentRecord | null;
+} | {
+    readonly kind: "notice-delivery";
+    readonly account: string;
+    readonly home: string;
+    readonly key: string;
+    readonly value: NoticeDeliveryRecord | null;
+} | {
+    readonly kind: "notice-acknowledgment";
+    readonly account: string;
+    readonly home: string;
+    readonly key: string;
+    readonly value: NoticeAcknowledgmentRecord | null;
+} | {
+    readonly kind: "file";
+    readonly account: string;
+    readonly home: string;
+    readonly digest: string;
+    readonly value: FileRecord | null;
+} | {
+    readonly kind: "scoped-evidence";
+    readonly scope: string;
+    readonly value: readonly EvidenceRecord[];
+} | {
+    readonly kind: "confirmation";
+    readonly entity: string;
+    readonly attribute: string;
+    readonly value: ConfirmationRecord | null;
+} | {
+    readonly kind: "milestone";
+    readonly instance: string;
+    readonly name: string;
+    readonly value: MilestoneRecord | null;
+} | {
+    readonly kind: "decisions";
+    readonly instance: string;
+    readonly value: readonly DecisionRecord[];
+} | {
+    readonly kind: "fact";
+    readonly entity: string;
+    readonly attribute: string;
+    readonly value: Fact | null;
+} | {
+    readonly kind: "entities";
+    readonly namespace: string | null;
+    readonly value: readonly string[];
+} | {
+    readonly kind: "matching";
+    readonly attribute: string;
+    readonly where: Scalar;
+    readonly value: readonly string[];
+} | {
+    readonly kind: "namespace";
+    readonly entity: string;
+    readonly value: string | null;
+} | {
+    readonly kind: "evidence";
+    readonly occurrence: string;
+    readonly value: readonly EvidenceRecord[];
+} | {
+    readonly kind: "instance-evidence";
+    readonly instance: string;
+    readonly value: readonly EvidenceRecord[];
+} | {
+    readonly kind: "acceptance";
+    readonly instance: string;
+    readonly requirement: string;
+    readonly value: AcceptanceRecord | null;
+} | {
+    readonly kind: "signals";
+    readonly instance: string;
+    readonly machine: string;
+    readonly value: readonly SignalRecord[];
+} | {
+    readonly kind: "dispatch";
+    readonly key: string;
+    readonly value: DispatchRecord | null;
+} | {
+    readonly kind: "clock";
+    readonly value: TimePoint;
+} | {
+    readonly kind: "time";
+    readonly instance: string;
+    readonly path: readonly string[];
+    readonly value: {
+        readonly at: TimePoint;
+        readonly why: string;
+    } | null;
+} | {
+    readonly kind: "program";
+    readonly account: string;
+    readonly value: {
+        readonly library: Program["library"];
+        readonly package: Program["account"]["package"];
+        readonly params: Program["account"]["params"];
+        readonly roots: Program["account"]["forEach"];
+        readonly policies?: Program["account"]["policies"];
+        readonly entities: Program["ir"]["entities"];
+    };
+} | {
+    readonly kind: "input";
+    readonly instance: string;
+    readonly name: string;
+    readonly value: Value;
+} | {
+    readonly kind: "members";
+    readonly instance: string;
+    readonly value: readonly string[];
+} | {
+    readonly kind: "status";
+    readonly instance: string;
+    readonly name: string;
+    readonly value: Status;
+} | {
+    readonly kind: "slot";
+    readonly instance: string;
+    readonly name: string;
+    readonly value: {
+        readonly applies: Truth;
+        readonly instances: readonly string[];
+    };
+};
+/** Tuple keys distinguish opaque ids and scalar types without delimiter collisions. */
+export declare const dependencyKey: (d: Dependency) => string;
+export declare const programDependency: (p: Program) => Dependency;
+export declare class ReadSet {
+    private entriesByKey;
+    private cached;
+    add(d: Dependency, key?: string): void;
+    merge(entries: Iterable<readonly [string, Dependency]>, keep?: (d: Dependency) => boolean): void;
+    entries(): MapIterator<[string, Dependency]>;
+    values(): Iterable<Dependency>;
+    snapshot(): ReadonlyMap<string, Dependency>;
+}
+/** Internal projections can differ by consumer in cycles; keep them occurrence-local. */
+export declare const isLocalDependency: (d: Dependency) => boolean;
+/** Immutable union of sorted maps without copying shared observations into every result. */
+export declare class DependencyMap implements ReadonlyMap<string, Dependency> {
+    readonly shared: ReadonlyMap<string, Dependency>;
+    readonly local: ReadonlyMap<string, Dependency>;
+    constructor(shared: ReadonlyMap<string, Dependency>, local: ReadonlyMap<string, Dependency>);
+    get size(): number;
+    get(key: string): Dependency | undefined;
+    has(key: string): boolean;
+    entries(): MapIterator<[string, Dependency]>;
+    [Symbol.iterator](): MapIterator<[string, Dependency]>;
+    keys(): MapIterator<string>;
+    values(): MapIterator<Dependency>;
+    forEach(callback: (value: Dependency, key: string, map: ReadonlyMap<string, Dependency>) => void, thisArg?: unknown): void;
+    toJSON(): [string, Dependency][];
+}
+/** Observe every query, interning identical observations without caching query results. */
+export declare const observeBasis: (b: Basis, reads: ReadSet) => Basis;
+/** Forecast time over the current snapshot, retaining its actual clock observation. */
+export declare const forecastBasis: (b: Basis, now: TimePoint) => Basis;