worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/scenarios.js

@@ -0,0 +1,442 @@
+import { scenarioResources, observeScenarioLifecycles, scenarioResourceObservation, } from "./resource-scenarios.js";
+import { instanceId, instanceContext } from "./evaluation.js";
+import { canAttestEvidence } from "./evidence-authority.js";
+import { invokeOperation } from "./component-operations.js";
+import { evidenceFilesAllowed } from "./files.js";
+import { occurrenceHome } from "./homes.js";
+import { canPerformWork, actionTargets } from "./work.js";
+import { recordMilestones } from "./milestones.js";
+import { decide } from "./decide.js";
+import { priorCycleOperationName } from "../ir-checks/index.js";
+import { evaluateProperty } from "./property-eval.js";
+import { command, perform, signal, validEvidence } from "./commands.js";
+import { basis, emptyWorld } from "./memory.js";
+import { findOccurrence } from "./occurrences.js";
+import { link, canTransition, programFor, reconcile, } from "./reconcile.js";
+class ScenarioError extends Error {
+    at;
+    constructor(message, at) {
+        super(message);
+        this.at = at;
+    }
+}
+const scalar = (value) => {
+    if (value.k === "entity")
+        return value.name;
+    if (value.k === "literal")
+        return value.value;
+    throw new ScenarioError("A stored field must be a scalar or an entity alias.", value.at);
+};
+const select = (recon, account, target) => {
+    const key = target.key.map((v) => v.k === "instance" ? { inst: select(recon, account, v).id } : scalar(v));
+    const found = findOccurrence(recon, account, target.component, key, target.cycle);
+    if (!found)
+        throw new ScenarioError(`No matching occurrence of ${target.component}${target.cycle ? ` cycle ${target.cycle}` : ""}.`, target.at);
+    return found;
+};
+const resourceTarget = (recon, account, target) => {
+    try {
+        return select(recon, account, target).id;
+    }
+    catch (error) {
+        if (!(error instanceof ScenarioError))
+            throw error;
+        return instanceId(target.component, target.key.map((v) => v.k === "instance" ? { inst: resourceTarget(recon, account, v) } : scalar(v)), target.cycle ?? 1);
+    }
+};
+const values = (fields) => Object.fromEntries(fields.flatMap((f) => {
+    const v = scalar(f.value);
+    return v === null ? [] : [[f.name, String(v)]];
+}));
+const inputs = (fields) => Object.fromEntries(fields.flatMap((f) => {
+    const v = scalar(f.value);
+    return v === null ? [] : [[f.name, v]];
+}));
+const execute = (ir, scenario, world, recon, date, request, commandId) => {
+    const accepted = (next) => ({ world: next, outcome: { accepted: true, codes: [] } });
+    const rejected = (code, next = world, extra = []) => ({
+        world: next,
+        outcome: { accepted: false, codes: [code, ...extra] },
+    });
+    if (request.kind === "resource")
+        return scenarioResourceObservation(recon, world, date, scenario.world, resourceTarget(recon, scenario.world, request.target), request, commandId);
+    const by = String(scalar(request.by));
+    const profile = scenario.actors?.find((a) => a.name === by);
+    const authority = {
+        id: by,
+        kind: profile?.kind ?? "human",
+        groups: profile?.groups ?? [],
+    };
+    if (request.kind === "set") {
+        const given = scenario.given.find((e) => e.name === request.entity), entity = ir.entities.find((e) => e.name === given.entity);
+        const next = command(recon, world, date, {
+            kind: request.commandKind ?? "set",
+            subject: request.subject ?? request.entity,
+            by,
+            title: `Set ${request.entity}.${request.field}`,
+            facts: [{ e: request.entity, a: `${entity.ns}/${request.field}`, v: scalar(request.value) }],
+        });
+        return next.violations.length
+            ? rejected("invariant", next.world, next.violations.map((v) => v.invariant))
+            : accepted(next.world);
+    }
+    if ((request.kind === "evidence" || request.kind === "signal") &&
+        request.date &&
+        request.date !== date)
+        return rejected("command-date");
+    let inst;
+    try {
+        inst = select(recon, scenario.world, request.target);
+    }
+    catch (error) {
+        if (!(error instanceof ScenarioError))
+            throw error;
+        return rejected("no-occurrence");
+    }
+    const program = programFor(recon, inst.id);
+    if (request.kind === "perform" && request.amend) {
+        const result = invokeOperation(recon, world, date, {
+            id: commandId,
+            account: scenario.world,
+            target: { instance: inst.id },
+            operation: request.action,
+            actor: authority,
+            values: inputs(request.values),
+            unsigned: request.unsigned,
+            amend: request.amend,
+            ...(request.signature ? { signature: request.signature } : {}),
+        });
+        return { world: result.world, outcome: { accepted: result.accepted, codes: result.codes } };
+    }
+    if (request.kind === "decide") {
+        const result = decide(recon, world, date, {
+            id: request.id ?? commandId,
+            instance: inst.id,
+            decision: request.decision,
+            actor: authority,
+            ...(request.reason === undefined ? {} : { reason: request.reason }),
+            ...(request.revoke ? { revoke: request.revoke } : {}),
+        });
+        return { world: result.world, outcome: { accepted: result.accepted, codes: result.codes } };
+    }
+    if (request.kind === "signal") {
+        const next = signal(recon, world, date, {
+            instance: inst.id,
+            machine: request.machine,
+            state: request.state,
+            by,
+        });
+        return canTransition(program, basis(world, date), inst, request.machine, request.state)
+            ? accepted(next)
+            : rejected("transition", next);
+    }
+    if (request.kind === "evidence") {
+        if (request.status === "attested" && authority.kind === "agent")
+            return rejected("human-required");
+        const result = recon.results.get(inst.id);
+        const occurrence = `${inst.id}/${request.requirement}${request.requirementCycle === undefined ? "" : `@${request.requirementCycle}`}`;
+        const authorized = result.actions.some((action) => action.kind === "interaction" &&
+            (action.state === "eligible" || action.state === "dispatched") &&
+            actionTargets(action).includes(request.requirement) &&
+            result.requirements.some((r) => r.name === request.requirement && r.occurrence === occurrence) &&
+            program.interactions.get(action.interaction ?? "")?.produces === request.evidence &&
+            canPerformWork(action, authority, by));
+        if (!authorized ||
+            (request.status === "attested" &&
+                !canAttestEvidence(instanceContext(recon, basis(world, date), inst), request.evidence, authority)))
+            return rejected("not-assignee");
+        if (request.status === "attested" && program.evidence.get(request.evidence)?.attest?.audit)
+            return rejected("signature-required");
+        if (request.status === "attested" &&
+            (!validEvidence(program, request.evidence, inputs(request.values), date) ||
+                !evidenceFilesAllowed(program, basis(world, date), occurrenceHome(program, inst, recon.instances)?.id, request.evidence, inputs(request.values))))
+            return rejected("evidence-invalid");
+        return accepted({
+            ...world,
+            evidence: [
+                ...world.evidence,
+                {
+                    id: `ev-${world.evidence.length + 1}`,
+                    type: request.evidence,
+                    occurrence,
+                    status: request.status,
+                    at: date,
+                    by,
+                    values: values(request.values),
+                },
+            ],
+        });
+    }
+    const name = request.kind === "accept" ? `accept-prior:${request.requirement}` : request.action;
+    if (request.kind === "accept" && request.revoke) {
+        const result = decide(recon, world, date, {
+            id: request.id ?? commandId,
+            instance: inst.id,
+            decision: priorCycleOperationName(programFor(recon, inst.id).ir.decisions ?? [], inst.component, request.requirement, request.decision),
+            actor: authority,
+            revoke: request.revoke,
+            ...(request.reason === undefined ? {} : { reason: request.reason }),
+        });
+        return { world: result.world, outcome: { accepted: result.accepted, codes: result.codes } };
+    }
+    const action = recon.results.get(inst.id).actions.find((a) => a.action === name);
+    if (!action || (action.state !== "eligible" && action.state !== "dispatched"))
+        return rejected("not-eligible");
+    if (request.kind === "accept") {
+        const result = decide(recon, world, date, {
+            id: request.id ?? commandId,
+            instance: inst.id,
+            decision: priorCycleOperationName(programFor(recon, inst.id).ir.decisions ?? [], inst.component, request.requirement, request.decision),
+            actor: authority,
+            ...(request.reason === undefined ? {} : { reason: request.reason }),
+        });
+        if (!result.accepted)
+            return { world: result.world, outcome: { accepted: false, codes: result.codes } };
+        return accepted({
+            ...result.world,
+            acceptances: result.world === world
+                ? world.acceptances
+                : [
+                    ...result.world.acceptances,
+                    {
+                        instance: inst.id,
+                        requirement: request.requirement,
+                        from: inst.prior ?? "",
+                        decision: request.decision,
+                        by,
+                        at: date,
+                    },
+                ],
+        });
+    }
+    if (authority.kind === "agent" && !request.unsigned)
+        return rejected("human-required");
+    if (!canPerformWork(action, authority, by) ||
+        (action.kind === "interaction" &&
+            !request.unsigned &&
+            !canAttestEvidence(instanceContext(recon, basis(world, date), inst), program.interactions.get(action.interaction).produces, authority)))
+        return rejected("not-assignee");
+    const next = perform(recon, world, date, {
+        instance: inst.id,
+        action: name,
+        by,
+        unsigned: request.unsigned,
+        ...(request.signature ? { signature: request.signature } : {}),
+        actor: authority,
+        values: inputs(request.values),
+    });
+    // The shared command snapshots bound facts before validating the signed record.
+    return action.interaction && next === world ? rejected("evidence-invalid") : accepted(next);
+};
+const observed = (recon, account, expectation, commands, world) => {
+    if (expectation.kind === "property") {
+        const property = recon.programs
+            .find((p) => p.account.name === account)
+            ?.ir.properties?.find((p) => p.name === expectation.name && p.world === account);
+        if (!property)
+            throw new ScenarioError("Unknown property in this observation.", expectation.at);
+        return evaluateProperty(property, world, recon, expectation.binding);
+    }
+    if (expectation.kind === "rejected") {
+        const outcome = commands[expectation.command - 1];
+        if (!outcome)
+            throw new ScenarioError("No command outcome in this observation.", expectation.at);
+        if (typeof expectation.expected === "boolean")
+            return !outcome.accepted;
+        return outcome.codes.includes(expectation.expected)
+            ? expectation.expected
+            : outcome.accepted
+                ? "accepted"
+                : outcome.codes.join(", ");
+    }
+    if (expectation.kind === "resource") {
+        const id = resourceTarget(recon, account, expectation.target), projections = scenarioResources(recon, world, recon.now)
+            .filter((s) => s.program.account.name === account)
+            .map((s) => s.projection), intent = projections
+            .flatMap((p) => p.intents)
+            .find((i) => i.instance === id && i.resource === expectation.name), view = projections
+            .flatMap((p) => p.views)
+            .filter((v) => v.instance === id && v.resource === expectation.name)
+            .sort((a, b) => b.generation - a.generation)[0];
+        return intent?.phase ?? view?.state ?? "absent";
+    }
+    const inst = select(recon, account, expectation.target), result = recon.results.get(inst.id);
+    const requirement = result.requirements.find((r) => r.name === expectation.name);
+    switch (expectation.kind) {
+        case "retention":
+            return result.retention?.[expectation.field];
+        case "status":
+            return requirement?.status ?? result.outputs.find((o) => o.name === expectation.name)?.status;
+        case "due":
+            return requirement?.due;
+        case "work":
+            return result.actions.find((a) => a.action === expectation.name)?.state ?? "absent";
+        case "blocked":
+            return result.blocked.some((r) => r.requirement === expectation.name);
+        case "why":
+            return requirement?.reasons.map((r) => `${r.label}: ${r.detail}`).join("\n");
+    }
+};
+const runWithProgram = (ir, scenario, resolveProgram) => {
+    let world = emptyWorld, assertions = 0;
+    const failures = [], steps = [];
+    const report = () => ({
+        name: scenario.name,
+        passed: failures.length === 0,
+        assertions,
+        failures,
+        steps,
+        world,
+    });
+    try {
+        const first = scenario.steps[0];
+        if (!first)
+            throw new ScenarioError("A scenario needs a dated observation.", scenario.at);
+        const program = resolveProgram(scenario.world), programs = [program];
+        world = {
+            ...emptyWorld,
+            ...(scenario.files?.length
+                ? {
+                    files: scenario.files.map((f) => ({
+                        account: scenario.world,
+                        home: f.home,
+                        digest: f.digest,
+                        mediaType: f.mediaType,
+                        size: f.size,
+                        scan: f.scan,
+                        redacted: f.redacted,
+                        at: f.date ?? first.date,
+                        by: "scenario:scanner",
+                    })),
+                }
+                : {}),
+            facts: scenario.given.flatMap((e) => {
+                const entity = ir.entities.find((t) => t.name === e.entity);
+                if (!entity)
+                    throw new ScenarioError(`Unknown entity ${e.entity}.`, e.at);
+                const fields = e.fields.length
+                    ? e.fields.map((f) => ({ name: f.name, value: scalar(f.value) }))
+                    : // A null attribute establishes namespace membership without asserting a missing fact.
+                        [{ name: entity.fields[0]?.name ?? "__exists", value: null }];
+                return fields.map((f) => ({
+                    e: e.name,
+                    a: `${entity.ns}/${f.name}`,
+                    v: f.value,
+                    at: first.date,
+                    by: "scenario",
+                }));
+            }),
+        };
+        let recon = reconcile(programs, basis(world, first.date), first.date);
+        for (const [i, record] of (scenario.records ?? []).entries()) {
+            if (record.kind === "evidence" &&
+                record.status === "attested" &&
+                scenario.actors?.some((a) => a.name === String(scalar(record.by)) && a.kind === "agent"))
+                throw new ScenarioError("Agents cannot attest evidence.", record.at);
+            const inst = select(recon, scenario.world, record.target), at = record.date ?? first.date, by = String(scalar(record.by));
+            world =
+                record.kind === "signal"
+                    ? {
+                        ...world,
+                        signals: [
+                            ...world.signals,
+                            { instance: inst.id, machine: record.machine, state: record.state, at, by },
+                        ],
+                    }
+                    : {
+                        ...world,
+                        evidence: [
+                            ...world.evidence,
+                            {
+                                id: `scenario:${scenario.name}:${i + 1}`,
+                                type: record.evidence,
+                                occurrence: `${inst.id}/${record.requirement}${record.requirementCycle === undefined ? "" : `@${record.requirementCycle}`}`,
+                                status: record.status,
+                                values: values(record.values),
+                                at,
+                                by,
+                            },
+                        ],
+                    };
+            recon = reconcile(programs, basis(world, first.date), first.date);
+        }
+        // Given records are one setup snapshot; observe each dated step and admitted command.
+        const observe = (date) => {
+            let current = reconcile(programs, basis(world, date), date);
+            const resources = observeScenarioLifecycles(current, world, date);
+            if (resources !== world) {
+                world = resources;
+                current = reconcile(programs, basis(world, date), date);
+            }
+            const recorded = recordMilestones(current, world);
+            if (recorded === world)
+                return current;
+            world = recorded;
+            return reconcile(programs, basis(world, date), date);
+        };
+        for (const [stepIndex, step] of scenario.steps.entries()) {
+            let current = observe(step.date);
+            const commands = [];
+            for (const [i, request] of (step.commands ?? []).entries()) {
+                const next = execute(ir, scenario, world, current, step.date, request, `scenario:${scenario.name}:${stepIndex}:${i + 1}`);
+                world = next.world;
+                commands.push(next.outcome);
+                if (!next.outcome.accepted &&
+                    !step.expects.some((e) => e.kind === "rejected" && e.command === i + 1))
+                    failures.push({
+                        code: "E_SCENARIO_RUN",
+                        message: `Unasserted command rejection: ${next.outcome.codes.join(", ")}.`,
+                        at: request.at,
+                    });
+                current = observe(step.date);
+            }
+            steps.push({ date: step.date, reconciliation: current, commands });
+            for (const expectation of step.expects) {
+                assertions++;
+                try {
+                    const actual = observed(current, scenario.world, expectation, commands, world), expected = expectation.expected;
+                    const passed = expectation.kind === "why"
+                        ? typeof actual === "string" && actual.includes(expected)
+                        : actual === expected;
+                    if (!passed)
+                        failures.push({
+                            code: "E_SCENARIO_ASSERT",
+                            message: `${expectation.kind} expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}.`,
+                            at: expectation.at,
+                            expected,
+                            actual,
+                        });
+                }
+                catch (error) {
+                    if (!(error instanceof ScenarioError))
+                        throw error;
+                    failures.push({
+                        code: "E_SCENARIO_ASSERT",
+                        message: error.message,
+                        at: expectation.at,
+                        expected: expectation.expected,
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (!(error instanceof ScenarioError))
+            throw error;
+        failures.push({ code: "E_SCENARIO_RUN", message: error.message, at: error.at });
+    }
+    return report();
+};
+/** A session reuses immutable linked programs, never scenario facts or evaluation state. */
+export const createScenarioRunner = (ir) => {
+    const programs = new Map();
+    return (scenario) => runWithProgram(ir, scenario, (account) => {
+        let program = programs.get(account);
+        if (!program)
+            programs.set(account, (program = link(ir, account)));
+        return program;
+    });
+};
+/** Runs authored finite test data through pure reconciliation. */
+export const runScenario = (ir, scenario) => createScenarioRunner(ir)(scenario);
+export const runScenarios = (ir) => (ir.scenarios ?? []).map(createScenarioRunner(ir));

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

@@ -0,0 +1,9 @@
+import { type EvaluationContext, type PredictedStatus } from "./context.js";
+import { type LocalDate } from "./dates.js";
+import { type Cx, type Instance } from "./model.js";
+export declare const timed: <T>(ctx: EvaluationContext, cx: Cx, path: readonly string[], why: string, read: (active: Cx) => T, signature?: (value: T) => string, options?: {
+    readonly enabled?: () => boolean;
+    readonly discovery?: boolean;
+    readonly instance?: string;
+}) => T;
+export declare function predictStatus(ctx: EvaluationContext, inst: Instance, name: string, at: LocalDate): PredictedStatus;

package/dist/_internal/reconciler/scheduling.js

@@ -0,0 +1,203 @@
+import { policyRequirements } from "./policies.js";
+import { timeOrder, isPastDeadline, nextTime, deadlineOrder } from "./instants.js";
+import {} from "./context.js";
+import {} from "./dates.js";
+import { forecastBasis, observeBasis, ReadSet } from "./dependencies.js";
+import { evaluateIn, timeOf, instanceEnv, isUnknown, legacyAcceptance, selectedDecision, selectedAddition, truth, } from "./evaluation.js";
+import {} from "./model.js";
+import { allOf, anyOf } from "./outputs.js";
+import { semanticJson } from "./result-digest.js";
+import { readEffective } from "./effective.js";
+import { readRecurrence } from "./recurrence.js";
+import { and } from "./evaluation.js";
+import { firstChange } from "./temporal.js";
+const recurringPrograms = new WeakMap();
+const hasRecurrence = (program) => {
+    let value = recurringPrograms.get(program);
+    if (value === undefined) {
+        value = [...program.components.values()].some((c) => c.requirements.some((r) => r.recur));
+        recurringPrograms.set(program, value);
+    }
+    return value;
+};
+export const timed = (ctx, cx, path, why, read, signature = semanticJson, options = {}) => {
+    const cutoffs = new Set();
+    const statuses = new Map();
+    const currentStatus = (inst, name) => {
+        const value = ctx.state.status(inst, name);
+        cx.reads.add({ kind: "status", instance: inst.id, name, value });
+        return value;
+    };
+    const value = read({
+        ...cx,
+        temporal: cutoffs,
+        statusRead: (inst, name) => {
+            statuses.set(JSON.stringify([inst.id, name]), { inst, name });
+            return currentStatus(inst, name);
+        },
+    });
+    if (cutoffs.size || statuses.size)
+        (options.discovery ? ctx.discoveryJobs : ctx.temporalJobs).push(() => {
+            if (options.enabled && !options.enabled())
+                return;
+            const consume = (inst, name, at, found) => {
+                currentStatus(inst, name);
+                const projected = predictStatus(ctx, inst, name, at);
+                for (const date of projected.cutoffs)
+                    found.add(date);
+                cx.reads.merge(projected.reads);
+                return projected.value;
+            };
+            for (const { inst, name } of statuses.values())
+                consume(inst, name, ctx.now, cutoffs);
+            const { trace: _trace, ...base } = cx;
+            // Repeated calendar boundaries are unbounded; the earliest cutoff is conservative.
+            const at = hasRecurrence(cx.p)
+                ? ([...cutoffs].filter((at) => timeOrder(at, ctx.now) > 0).sort()[0] ?? null)
+                : firstChange(ctx.now, value, cutoffs, (at, found) => read({
+                    ...base,
+                    b: forecastBasis(cx.b, at),
+                    temporal: found,
+                    statusRead: (inst, name) => consume(inst, name, at, found),
+                }), signature);
+            cx.reads.add({
+                kind: "time",
+                instance: options.instance ?? cx.inst.id,
+                path,
+                value: at ? { at, why } : null,
+            });
+        });
+    return value;
+};
+export function predictStatus(ctx, inst, name, at) {
+    const key = JSON.stringify([inst.id, name, at]);
+    const cached = ctx.predictions.get(key);
+    if (cached)
+        return cached;
+    if (ctx.predicting.has(key))
+        return { value: "Unknown", cutoffs: new Set(), reads: new Map(), cyclic: true };
+    ctx.predicting.add(key);
+    const p = ctx.programOf.get(inst.id);
+    const component = p.components.get(inst.component);
+    const cutoffs = new Set();
+    const reads = new ReadSet();
+    let cyclic = false;
+    const statusRead = (target, field) => {
+        const next = predictStatus(ctx, target, field, at);
+        if (next.cyclic)
+            cyclic = true;
+        next.cutoffs.forEach((date) => cutoffs.add(date));
+        reads.merge(next.reads);
+        return next.value;
+    };
+    let cx = {
+        p,
+        inst,
+        b: forecastBasis(observeBasis(ctx.b, reads), at),
+        env: instanceEnv(p, inst, (field) => statusRead(inst, field)),
+        k: ctx.state,
+        statusRead,
+        temporal: cutoffs,
+    };
+    const pathStatus = (owner, segments, focus) => {
+        const [head, ...rest] = segments;
+        const c = ctx.programOf.get(owner.id).components.get(owner.component);
+        if (!rest.length && [...c.requirements, ...c.outputs].some((item) => item.name === head))
+            return statusRead(owner, head);
+        const slot = owner.children.find((slot) => slot.name === head);
+        if (!slot || slot.applies === "unknown")
+            return "Unknown";
+        if (!slot.applies)
+            return "NotApplicable";
+        const candidates = slot.instances.map((id) => ctx.instances.get(id));
+        const target = candidates.find((child) => focus !== undefined && child.attached.includes(focus)) ??
+            candidates.at(-1);
+        if (!target)
+            return "Unknown";
+        return rest.length
+            ? pathStatus(target, rest, focus)
+            : allOf(ctx.programOf
+                .get(target.id)
+                .components.get(target.component)
+                .outputs.map((output) => statusRead(target, output.name)));
+    };
+    const requirement = component.requirements.find((item) => item.name === name);
+    let value = "Unknown";
+    if (requirement) {
+        const recurrence = requirement.recur ? readRecurrence(cx, requirement.recur) : null;
+        if (recurrence?.period)
+            cx = {
+                ...cx,
+                proofPeriod: recurrence.period,
+                occurrence: `${inst.id}/${name}@${recurrence.period.start}`,
+            };
+        const ordinaryApplies = requirement.discretionary && !selectedAddition(cx, name, (date) => cutoffs.add(date))
+            ? false
+            : requirement.appliesWhen
+                ? truth(evaluateIn(cx, requirement.appliesWhen))
+                : true;
+        const applies = and([
+            ordinaryApplies,
+            recurrence?.truth ?? true,
+            requirement.effective ? readEffective(cx, requirement.effective).truth : true,
+        ]);
+        if (applies === false)
+            value = "NotApplicable";
+        else if (applies === true) {
+            const cycle = requirement.recur
+                ? (recurrence?.period?.start ?? null)
+                : requirement.cycle
+                    ? evaluateIn(cx, requirement.cycle)
+                    : null;
+            const occurrence = `${inst.id}/${name}${cycle !== null && !isUnknown(cycle) ? `@${String(cycle)}` : ""}`;
+            const accepted = legacyAcceptance(cx, requirement);
+            const decision = selectedDecision(cx, name, (date) => cutoffs.add(date));
+            const lawSat = decision?.definition.effect === "reject"
+                ? false
+                : decision?.definition.effect === "accept"
+                    ? true
+                    : accepted?.decision === "accepted"
+                        ? true
+                        : truth(evaluateIn({ ...cx, occurrence }, requirement.satisfiedBy));
+            const sat = and([lawSat, ...policyRequirements(cx).map((p) => p.truth)]);
+            if (decision?.definition.effect === "waive")
+                value = "Waived";
+            else if (sat === true)
+                value = "Satisfied";
+            else if (sat === false) {
+                const due = requirement.due ? evaluateIn(cx, requirement.due) : null;
+                const point = due !== null ? timeOf(due) : null;
+                let date = point !== null && !isUnknown(point) ? point : null;
+                if (date &&
+                    decision?.definition.effect === "defer" &&
+                    decision.record.deferredUntil &&
+                    deadlineOrder(decision.record.deferredUntil, date) > 0)
+                    date = decision.record.deferredUntil;
+                if (date) {
+                    const next = nextTime(date);
+                    if (next)
+                        cutoffs.add(next);
+                }
+                value = date !== null && isPastDeadline(at, date) ? "Overdue" : "Open";
+            }
+        }
+    }
+    else {
+        const output = component.outputs.find((item) => item.name === name);
+        if (output) {
+            const statuses = output.paths.map((path) => pathStatus(inst, path.segments, ctx.rootFocus.get(inst.id)));
+            value =
+                output.op === "all-of"
+                    ? allOf(statuses)
+                    : output.op === "any-of"
+                        ? anyOf(statuses)
+                        : statuses[0];
+        }
+    }
+    const result = { value, cutoffs, reads: reads.snapshot(), cyclic };
+    ctx.predicting.delete(key);
+    // A back edge's Unknown depends on the active call stack, so it cannot be reused elsewhere.
+    if (!cyclic)
+        ctx.predictions.set(key, result);
+    return result;
+}

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

@@ -0,0 +1 @@
+export { sha256 } from "../ir-checks/index.js";

package/dist/_internal/reconciler/sha256.js

@@ -0,0 +1 @@
+export { sha256 } from "../ir-checks/index.js";

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

@@ -0,0 +1,13 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { EvidenceRecord } from "./basis.js";
+export interface SignatureTrail extends IR.SignaturePolicy {
+    readonly method: string;
+    readonly device: string;
+    readonly by: string;
+    readonly at: string;
+    readonly digest: string;
+}
+export declare const signatureInputValid: (input: IR.SignatureInput | undefined, method: string) => boolean;
+export declare const signEvidence: (record: EvidenceRecord, policy: IR.SignaturePolicy, input: IR.SignatureInput) => EvidenceRecord;
+/** Historical basic records carry no inferred consent. A present trail must bind its source. */
+export declare const signatureValid: (record: EvidenceRecord) => boolean;