worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/result-digest.d.ts

@@ -0,0 +1,13 @@
+import type { Instance, Reconciliation } from "./reconcile.js";
+type Content = Omit<Reconciliation, "digest"> & {
+    readonly digest?: string;
+};
+export { canonicalJson, semanticJson } from "../ir-checks/index.js";
+/** Invocation-local caches never outlive the immutable evaluation snapshot. */
+export declare const makeResultDigester: () => {
+    canonical: (instance: Instance, result: Content) => string;
+    digest: (instance: Instance, result: Content) => string;
+};
+/** Source spans are annotations; data dates and all observations remain committed. */
+export declare const canonicalResult: (instance: Instance, result: Content) => string;
+export declare const resultDigest: (instance: Instance, result: Content) => string;

package/dist/_internal/reconciler/result-digest.js

@@ -0,0 +1,66 @@
+import { DependencyMap, isLocalDependency } from "./dependencies.js";
+import { sha256 } from "./sha256.js";
+import { semanticJson } from "../ir-checks/index.js";
+export { canonicalJson, semanticJson } from "../ir-checks/index.js";
+const staticDigests = new WeakMap();
+const observation = (dependency) => {
+    if (dependency.kind !== "program")
+        return dependency;
+    let value = staticDigests.get(dependency.value);
+    if (!value) {
+        value = `sha256:${sha256(semanticJson(dependency.value))}`;
+        staticDigests.set(dependency.value, value);
+    }
+    return { kind: dependency.kind, account: dependency.account, value };
+};
+const entries = (map) => [...map].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+/** Invocation-local caches never outlive the immutable evaluation snapshot. */
+export const makeResultDigester = () => {
+    const observations = new WeakMap();
+    const sets = new WeakMap();
+    const commitment = (map) => {
+        const cached = sets.get(map);
+        if (cached)
+            return cached;
+        const hashes = entries(map).map(([key, value]) => {
+            const cached = observations.get(value);
+            if (cached?.key === key)
+                return cached.hash;
+            const hash = sha256(semanticJson([key, observation(value)]));
+            observations.set(value, { key, hash });
+            return hash;
+        });
+        const hash = `sha256:${sha256(JSON.stringify(hashes))}`;
+        sets.set(map, hash);
+        return hash;
+    };
+    const canonical = (instance, result) => {
+        const { digest: _digest, dependsOn, ...evaluation } = result;
+        const basis = dependsOn instanceof DependencyMap
+            ? dependsOn.shared
+            : new Map([...dependsOn].filter(([, d]) => !isLocalDependency(d)));
+        const local = dependsOn instanceof DependencyMap
+            ? dependsOn.local
+            : new Map([...dependsOn].filter(([, d]) => isLocalDependency(d)));
+        return semanticJson({
+            format: "worldvm/reconciliation@2",
+            instance: {
+                ...instance,
+                inputs: entries(instance.inputs),
+                ...(instance.params ? { params: entries(instance.params) } : {}),
+                parents: [...instance.parents].sort(),
+            },
+            result: {
+                ...evaluation,
+                dependsOn: { basis: commitment(basis), local: commitment(local) },
+            },
+        });
+    };
+    return {
+        canonical,
+        digest: (instance, result) => `sha256:${sha256(canonical(instance, result))}`,
+    };
+};
+/** Source spans are annotations; data dates and all observations remain committed. */
+export const canonicalResult = (instance, result) => makeResultDigester().canonical(instance, result);
+export const resultDigest = (instance, result) => makeResultDigester().digest(instance, result);

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

@@ -0,0 +1,16 @@
+import { reuseDecisionName } from "../ir-checks/index.js";
+import type * as IR from "../world-ir/types.generated.js";
+import type { EvidenceRecord } from "./basis.js";
+import { Unknown, type Cx, type Value } from "./model.js";
+export { reuseDecisionName };
+export declare const withReuseDecisions: (ir: IR.WorldIR) => IR.WorldIR;
+/** Scope values are captured at signature time, not reconstructed from mutable profile facts. */
+export declare const reuseKey: (cx: Cx, r: IR.Requirement) => string | null;
+export interface ReusableProof {
+    readonly record: EvidenceRecord;
+    readonly from: string;
+    readonly until: string;
+}
+/** Host-side indexed query only. A pinned confirmation cannot silently switch to newer proof. */
+export declare const reusableProof: (cx: Cx, r: IR.Requirement, pinned?: string) => ReusableProof | Unknown | null;
+export declare const readReuse: (cx: Cx, r: IR.Requirement) => Value;

package/dist/_internal/reconciler/reuse.js

@@ -0,0 +1,119 @@
+import { evidenceSuperseded } from "./evidence-history.js";
+import { signatureValid } from "./signatures.js";
+import { signedFilesAllowed } from "./files.js";
+import { reuseDecisionName, reuseDecisions } from "../ir-checks/index.js";
+import { evaluateIn, isUnknown, selectedDecision } from "./evaluation.js";
+import { recordValidity } from "./evidence-validity.js";
+import { shiftTime, isPastDeadline, nextTime, timeOrder } from "./instants.js";
+import { Unknown } from "./model.js";
+export { reuseDecisionName };
+export const withReuseDecisions = (ir) => {
+    const added = ir.components
+        .flatMap((c) => c.requirements.flatMap((r) => reuseDecisions(c, r)))
+        .filter((d) => !ir.decisions?.some((old) => old.name === d.name && old.of === d.of));
+    return added.length ? { ...ir, decisions: [...(ir.decisions ?? []), ...added] } : ir;
+};
+/** Scope values are captured at signature time, not reconstructed from mutable profile facts. */
+export const reuseKey = (cx, r) => {
+    if (!r.reuse || !cx.inst || r.satisfiedBy.k !== "call" || r.satisfiedBy.args[0]?.k !== "ref")
+        return null;
+    const values = r.reuse.scope.map((e) => evaluateIn(cx, e));
+    if (values.some((v) => isUnknown(v) || v === null || typeof v === "object"))
+        return null;
+    return JSON.stringify([
+        "worldvm/reuse@1",
+        cx.p.account.name,
+        cx.p.library.digest,
+        cx.inst.component,
+        r.name,
+        r.satisfiedBy.args[0].name,
+        r.reuse.scope.map((e, i) => [e.k === "var" ? e.name : "", values[i]]),
+    ], (key, v) => (key === "at" ? undefined : v));
+};
+/** Host-side indexed query only. A pinned confirmation cannot silently switch to newer proof. */
+export const reusableProof = (cx, r, pinned) => {
+    const key = reuseKey(cx, r);
+    if (!key)
+        return new Unknown("Evidence reuse scope is Unknown");
+    const proof = r.satisfiedBy;
+    if (proof.k !== "call" || proof.args[0]?.k !== "ref")
+        return null;
+    const type = proof.args[0].name, candidates = cx.b.evidenceIn?.(key) ?? [];
+    const seen = new Set();
+    // Append order selects each source's standing signature, matching direct attestation.
+    for (const record of [...candidates].reverse()) {
+        if (record.type !== type ||
+            !record.reuseScopes?.includes(key) ||
+            timeOrder(record.at, cx.b.now) > 0 ||
+            record.occurrence === cx.occurrence ||
+            record.status === "submitted")
+            continue;
+        if (seen.has(record.occurrence))
+            continue;
+        seen.add(record.occurrence);
+        if (record.status !== "attested" || (pinned && record.id !== pinned))
+            continue;
+        if (evidenceSuperseded(cx.b, record) ||
+            !signatureValid(record) ||
+            !signedFilesAllowed(cx, type, record.values))
+            continue;
+        let until;
+        try {
+            const window = r.reuse.within;
+            until = shiftTime(record.at.length === 10 && ["minutes", "hours"].includes(window.unit)
+                ? `${record.at}T00:00:00.000Z`
+                : record.at, window.n, window.unit);
+        }
+        catch {
+            return new Unknown("Evidence reuse window exceeds the supported calendar");
+        }
+        const boundary = nextTime(until);
+        if (boundary)
+            cx.temporal?.add(boundary);
+        if (isPastDeadline(cx.b.now, until))
+            continue;
+        if (proof.fn === "valid") {
+            const validity = recordValidity({ ...cx, trace: { steps: [] } }, type, record);
+            if (isUnknown(validity.value))
+                return validity.value;
+            if (validity.value !== true)
+                continue;
+        }
+        return { record, from: record.occurrence.slice(0, record.occurrence.lastIndexOf("/")), until };
+    }
+    return null;
+};
+export const readReuse = (cx, r) => {
+    const selected = r.reuse?.confirm
+        ? selectedDecision(cx, r.name, (date) => cx.temporal?.add(date))
+        : null;
+    const accepted = selected?.definition.name === reuseDecisionName(cx.inst.component, r.name, "accepted") &&
+        selected.record.effect === "accept";
+    const candidate = reusableProof(cx, r, accepted ? selected.record.evidence : undefined);
+    if (candidate instanceof Unknown) {
+        if (cx.trace)
+            cx.trace.witness = {
+                evidence: null,
+                via: "",
+                type: r.satisfiedBy.k === "call" && r.satisfiedBy.args[0]?.k === "ref"
+                    ? r.satisfiedBy.args[0].name
+                    : "",
+                detail: candidate.why,
+            };
+        return candidate;
+    }
+    if (!candidate ||
+        (r.reuse.confirm &&
+            (!accepted ||
+                selected.record.from !== candidate.from ||
+                selected.record.evidence !== candidate.record.id)))
+        return false;
+    if (cx.trace)
+        cx.trace.witness = {
+            evidence: candidate.record,
+            via: "reuse",
+            type: candidate.record.type,
+            detail: `Reused ${candidate.record.id} from ${candidate.from}, signed by ${candidate.record.by} on ${candidate.record.at}${accepted ? `; confirmed by ${selected.record.by} (${selected.record.id})` : ""}; within ${candidate.until}`,
+        };
+    return true;
+};

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

@@ -0,0 +1,32 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type World } from "./memory.js";
+import { type WorldReconciliation } from "./reconcile.js";
+export interface ScenarioFailure {
+    readonly code: "E_SCENARIO_ASSERT" | "E_SCENARIO_RUN";
+    readonly message: string;
+    readonly at: IR.Span;
+    readonly expected?: unknown;
+    readonly actual?: unknown;
+}
+export interface ScenarioCommandOutcome {
+    readonly accepted: boolean;
+    readonly codes: readonly string[];
+}
+export interface ScenarioResult {
+    readonly name: string;
+    readonly passed: boolean;
+    readonly assertions: number;
+    readonly failures: readonly ScenarioFailure[];
+    readonly steps: readonly {
+        readonly date: string;
+        readonly reconciliation: WorldReconciliation;
+        readonly commands: readonly ScenarioCommandOutcome[];
+    }[];
+    readonly world: World;
+}
+export type ScenarioRunner = (scenario: IR.Scenario) => ScenarioResult;
+/** A session reuses immutable linked programs, never scenario facts or evaluation state. */
+export declare const createScenarioRunner: (ir: IR.WorldIR) => ScenarioRunner;
+/** Runs authored finite test data through pure reconciliation. */
+export declare const runScenario: (ir: IR.WorldIR, scenario: IR.Scenario) => ScenarioResult;
+export declare const runScenarios: (ir: IR.WorldIR) => readonly ScenarioResult[];