worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/property-shrink.js

@@ -0,0 +1,183 @@
+import { sensitivePayload, semanticJson } from "../ir-checks/index.js";
+import { runScenario } from "./scenarios.js";
+import { evaluateProperty } from "./property-eval.js";
+import { Unknown } from "./reconcile.js";
+const size = (s) => s.given.reduce((n, e) => n + 1 + e.fields.length, 0) + (s.records?.length ?? 0);
+const uses = (v, name) => v.k === "entity"
+    ? v.name === name
+    : v.k === "literal"
+        ? v.value === name
+        : v.key.some((k) => uses(k, name));
+const withoutEntity = (s, name) => ({
+    ...s,
+    given: s.given
+        .filter((e) => e.name !== name)
+        .map((e) => ({ ...e, fields: e.fields.filter((f) => !uses(f.value, name)) })),
+    ...(s.records
+        ? {
+            records: s.records.filter((r) => !uses(r.by, name) &&
+                !r.target.key.some((v) => uses(v, name)) &&
+                !(r.kind === "evidence" && r.values.some((f) => uses(f.value, name)))),
+        }
+        : {}),
+});
+const render = (ir, property, scenario, binding) => {
+    const aliases = new Map(ir.types.map((t) => [t.name, t.type]));
+    const resolve = (t, seen = new Set()) => {
+        if (Array.isArray(t)) {
+            const payload = sensitivePayload(t);
+            return payload
+                ? resolve(payload, seen)
+                : t[0] === "Option" || t[0] === "Brand"
+                    ? resolve(t[1], seen)
+                    : t;
+        }
+        if (typeof t !== "string" || !aliases.has(t) || seen.has(t))
+            return t;
+        seen.add(t);
+        return resolve(aliases.get(t), seen);
+    };
+    const value = (v, expected) => {
+        if (v.k === "entity")
+            return v.name;
+        if (v.k === "instance")
+            return instance(v);
+        if (v.value === null)
+            return "nil";
+        const type = resolve(expected);
+        if (Array.isArray(type) && type[0] === "Id")
+            return String(v.value);
+        if (type === "Keyword" || (Array.isArray(type) && type[0] === "Union"))
+            return `:${v.value}`;
+        return JSON.stringify(v.value);
+    };
+    const instance = (target) => {
+        const c = ir.components.find((c) => c.name === target.component);
+        return `(${target.component} ${target.key.map((v, i) => value(v, c.inputs.find((f) => f.name === c.key[i]).type)).join(" ")}${target.cycle === undefined ? "" : ` :cycle ${target.cycle}`})`;
+    };
+    const fields = (data, declared) => `{${data.map((f) => `:${f.name} ${value(f.value, declared.find((d) => d.name === f.name).type)}`).join(" ")}}`;
+    const rows = scenario.given.map((e) => `(entity ${e.entity} ${e.name} ${fields(e.fields, ir.entities.find((t) => t.name === e.entity).fields)})`);
+    for (const r of scenario.records ?? []) {
+        const by = r.by.k === "entity"
+            ? r.by.name
+            : r.by.k === "literal"
+                ? JSON.stringify(r.by.value)
+                : (() => {
+                    throw new Error("Invalid generated actor");
+                })();
+        const on = r.date ? ` :on ${JSON.stringify(r.date)}` : "";
+        rows.push(r.kind === "signal"
+            ? `(signal ${instance(r.target)} ${r.machine} :state :${r.state} :by ${by}${on})`
+            : `(evidence ${r.evidence} :for ${instance(r.target)} :requirement ${r.requirement} :status :${r.status} :by ${by}${on} :values ${fields(r.values, ir.evidence.find((e) => e.name === r.evidence).fields)})`);
+    }
+    const lines = [
+        `(scenario ${scenario.name} ${JSON.stringify(scenario.doc ?? "Synthetic counterexample.")} :world ${scenario.world}`,
+        ...rows.map((row, i) => `${i === 0 ? "  (given " : "    "}${row}${i === rows.length - 1 ? ")" : ""}`),
+        `  (at ${JSON.stringify(property.date)} (expect (property ${property.name} :for ${binding}) true)))`,
+    ];
+    if (!property.given && lines.length > 10)
+        throw new Error("Counterexample exceeds the bounded eight-record input contract.");
+    return lines.join("\n") + "\n";
+};
+/** Greedy deletion preserves the selected failure class; retained evidence payloads stay intact. */
+export const shrinkPropertyFailure = (ir, property, failure, options = {}) => {
+    const max = options.maxAttempts ?? 10000;
+    if (!Number.isSafeInteger(max) || max < 1 || max > 100000)
+        throw new RangeError("Shrink attempts must be 1–100000.");
+    let current = failure.scenario, attempts = 0, limited = false;
+    const reproduces = (input) => {
+        if (property.given?.some((seed) => {
+            const entity = input.given.find((e) => e.name === seed.name && e.entity === seed.entity);
+            return (!entity ||
+                seed.fields.some((field) => !entity.fields.some((f) => semanticJson(f) === semanticJson(field))));
+        }) ||
+            property.records?.some((seed) => !input.records?.some((r) => semanticJson(r) === semanticJson(seed))))
+            return false;
+        if (!input.given.some((e) => e.name === failure.binding && e.entity === property.binding.entity))
+            return false;
+        const observed = runScenario(ir, input);
+        if (!observed.passed || !observed.steps[0])
+            return false;
+        const result = evaluateProperty(property, observed.world, observed.steps[0].reconciliation, failure.binding);
+        return result !== true && (result instanceof Unknown ? "Unknown" : "false") === failure.actual;
+    };
+    if (!reproduces(current))
+        throw new Error("Input does not reproduce the selected property failure.");
+    const keep = (candidate) => {
+        if (attempts >= max) {
+            limited = true;
+            return false;
+        }
+        attempts++;
+        if (!reproduces(candidate))
+            return false;
+        current = candidate;
+        return true;
+    };
+    while (!limited) {
+        let changed = false;
+        for (let i = 0; i < (current.records?.length ?? 0); i++) {
+            if (keep({ ...current, records: current.records.filter((_, j) => j !== i) })) {
+                changed = true;
+                break;
+            }
+        }
+        if (changed)
+            continue;
+        for (const e of current.given) {
+            if (e.name !== failure.binding && keep(withoutEntity(current, e.name))) {
+                changed = true;
+                break;
+            }
+        }
+        if (changed)
+            continue;
+        for (const e of current.given) {
+            for (let i = 0; i < e.fields.length; i++) {
+                if (keep({
+                    ...current,
+                    given: current.given.map((x) => x.name === e.name ? { ...x, fields: x.fields.filter((_, j) => j !== i) } : x),
+                })) {
+                    changed = true;
+                    break;
+                }
+            }
+            if (changed)
+                break;
+        }
+        if (!changed)
+            break;
+    }
+    let name = `counterexample-${property.name}-${failure.seed}-${failure.index}`;
+    while (ir.scenarios?.some((s) => s.name === name))
+        name += "-replay";
+    const scenario = {
+        ...current,
+        name,
+        doc: `Synthetic seed ${failure.seed}, case ${failure.index}, ${failure.actual}.`,
+        steps: [
+            {
+                kind: "at",
+                date: property.date,
+                expects: [
+                    {
+                        kind: "property",
+                        name: property.name,
+                        binding: failure.binding,
+                        expected: true,
+                        at: property.predicate.at,
+                    },
+                ],
+                at: property.at,
+            },
+        ],
+    };
+    return {
+        scenario,
+        source: render(ir, property, scenario, failure.binding),
+        attempts,
+        complete: !limited,
+        originalSize: size(failure.scenario),
+        shrunkSize: size(scenario),
+    };
+};

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

@@ -0,0 +1,8 @@
+import type { Basis } from "./basis.js";
+import { ReadSet, type Dependency } from "./dependencies.js";
+import type { Instance, Program, WorldReconciliation } from "./reconcile.js";
+/** Internal projections can be provisional during discovery. Retain their Basis reads instead. */
+export declare const structuralObservation: (d: Dependency) => boolean;
+/** Reconstruct the indexed discovery closure for each home, independently of whole-world root
+ * enumeration. Excluded candidate roots matter: changing their predicates may add a member. */
+export declare const discoveryProvenance: (b: Basis, instances: ReadonlyMap<string, Instance>, roots: WorldReconciliation["roots"], observations: ReadonlyMap<string, ReadSet>, homeOf: (p: Program, inst: Instance) => string | undefined) => ((p: Program, home: string) => ReadonlyMap<string, Dependency>);

package/dist/_internal/reconciler/provenance.js

@@ -0,0 +1,61 @@
+import { ReadSet, observeBasis, programDependency } from "./dependencies.js";
+import { rootCandidates } from "./discovery.js";
+/** Internal projections can be provisional during discovery. Retain their Basis reads instead. */
+export const structuralObservation = (d) => d.kind !== "input" && d.kind !== "members" && d.kind !== "status" && d.kind !== "slot";
+/** Reconstruct the indexed discovery closure for each home, independently of whole-world root
+ * enumeration. Excluded candidate roots matter: changing their predicates may add a member. */
+export const discoveryProvenance = (b, instances, roots, observations, homeOf) => {
+    const rootKey = (account, component, subject) => JSON.stringify([account, component, subject]);
+    const byRoot = new Map();
+    for (const root of roots) {
+        const inst = instances.get(root.instance);
+        const key = rootKey(root.account, inst.component, root.subject);
+        const ids = byRoot.get(key) ?? [];
+        ids.push(inst.id);
+        byRoot.set(key, ids);
+    }
+    const plans = new Map();
+    const homes = new Map();
+    return (p, home) => {
+        let cached = homes.get(p);
+        if (!cached)
+            homes.set(p, (cached = new Map()));
+        const found = cached.get(home);
+        if (found)
+            return found;
+        let seeds = plans.get(p);
+        if (!seeds)
+            plans.set(p, (seeds = new Map()));
+        const reads = new ReadSet();
+        reads.add(programDependency(p));
+        const pending = new Set([home]);
+        const visited = new Set();
+        for (const target of pending) {
+            let plan = seeds.get(target);
+            if (!plan) {
+                const observed = new ReadSet();
+                const candidates = rootCandidates(p, observeBasis(b, observed), target);
+                plan = { candidates, reads: observed.snapshot() };
+                seeds.set(target, plan);
+            }
+            reads.merge(plan.reads);
+            const queue = plan.candidates.flatMap((r) => byRoot.get(rootKey(p.account.name, r.component, r.subject)) ?? []);
+            for (let cursor = 0; cursor < queue.length; cursor++) {
+                const id = queue[cursor];
+                if (visited.has(id))
+                    continue;
+                visited.add(id);
+                const inst = instances.get(id);
+                reads.merge(observations.get(id).entries());
+                const owner = homeOf(p, inst);
+                if (owner !== undefined)
+                    pending.add(owner);
+                for (const slot of inst.children)
+                    queue.push(...slot.instances);
+            }
+        }
+        const result = reads.snapshot();
+        cached.set(home, result);
+        return result;
+    };
+};

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

@@ -0,0 +1,32 @@
+import { type Basis } from "./basis.js";
+import { type TimePoint } from "./instants.js";
+import { type Program, type SubjectHome, type SubjectReconciliation, type WorldReconciliation } from "./model.js";
+export declare const reconcile: (programs: readonly Program[], b: Basis, now?: TimePoint) => WorldReconciliation;
+/** Evaluate one home and its synchronous read closure. Only that home's occurrences escape. */
+export declare const reconcileSubject: (p: Program, b: Basis, subject: string | SubjectHome, now?: TimePoint) => SubjectReconciliation;
+/** The program an instance was reconciled under. */
+export declare const programFor: (recon: WorldReconciliation, instance: string) => Program | undefined;
+/** Every started machine, its state, and the transitions its protocol allows next. */
+export declare const machines: (recon: WorldReconciliation, b: Basis, now?: TimePoint) => {
+    readonly instance: string;
+    readonly machine: string;
+    readonly signal: string;
+    readonly state: {
+        readonly name: string;
+        readonly label: string;
+    };
+    readonly next: ReadonlyArray<{
+        readonly name: string;
+        readonly label: string;
+    }>;
+}[];
+/** How each entity presents itself: its declared :display field, else its id. */
+export declare const displayNames: (programs: readonly Program[], b: Basis, now?: TimePoint) => Map<string, string>;
+export { Unknown, type ActionResult, type InteractionField, type ChildSlot, type HoldResult, type MilestoneResult, type Duration, type EscalationIntent, type EscalationResult, type Instance, type InstRef, type OutputResult, type Program, type ReasonNode, type Reconciliation, type RequirementResult, type RenewalResult, type RecurrencePeriod, type Status, type Step, type SubjectHome, type SubjectReconciliation, type Truth, type UpgradeConsequence, type Value, type WorkIntent, type Violation, type WorldReconciliation, } from "./model.js";
+export { link, linkAll, LinkError } from "./linking.js";
+export { allOf, anyOf } from "./outputs.js";
+export { canonicalDecision, digest, proofOf, verifyProof } from "./proofs.js";
+export { canTransition, describeValue, evaluateFor, evaluateIn, evaluateValues, machineState, } from "./evaluation.js";
+export { occurrenceHome } from "./homes.js";
+export { admit } from "./invariants.js";
+export { planUpgrade } from "./upgrades.js";

package/dist/_internal/reconciler/reconcile.js

@@ -0,0 +1,164 @@
+import {} from "./basis.js";
+import { createEvaluationContext } from "./context.js";
+import {} from "./instants.js";
+import { ReadSet } from "./dependencies.js";
+import { rootCandidates } from "./discovery.js";
+import { assertSnapshot, machineState } from "./evaluation.js";
+import { buildInstanceGraph } from "./graph.js";
+import { entityHomes, occurrenceHome } from "./homes.js";
+import { assertFiniteClock } from "./linking.js";
+import {} from "./model.js";
+import { finishReconciliation } from "./projections.js";
+import { discoveryProvenance, structuralObservation } from "./provenance.js";
+import { evaluate } from "./requirements.js";
+import { nextWake } from "./temporal.js";
+export const reconcile = (programs, b, now = b.now) => reconcileKernel(programs, b, now);
+/** Evaluate one home and its synchronous read closure. Only that home's occurrences escape. */
+export const reconcileSubject = (p, b, subject, now = b.now) => {
+    assertSnapshot(b, now);
+    entityHomes(p);
+    assertFiniteClock(p.ir);
+    const home = typeof subject === "string" ? { kind: "entity", id: subject } : subject;
+    const members = new Map();
+    const visited = new Set();
+    const add = (root) => {
+        let ids = members.get(root.component);
+        if (!ids)
+            members.set(root.component, (ids = new Set()));
+        if (ids.has(root.subject))
+            return false;
+        ids.add(root.subject);
+        return true;
+    };
+    const include = (target) => {
+        const key = target.id;
+        if (visited.has(key))
+            return false;
+        visited.add(key);
+        const roots = rootCandidates(p, b, target.id);
+        let changed = false;
+        for (const root of roots)
+            changed = add(root) || changed;
+        return changed;
+    };
+    include(home);
+    let graph = new Map();
+    const scope = {
+        home,
+        reads: new ReadSet(),
+        subjects: (component, namespaces) => [...(members.get(component) ?? [])]
+            .filter((id) => namespaces.includes(b.nsOf(id) ?? ""))
+            .sort(),
+        complete: (instances) => {
+            graph = instances;
+            let changed = false;
+            for (const inst of instances.values()) {
+                const target = occurrenceHome(p, inst, instances);
+                if (target)
+                    changed = include(target) || changed;
+            }
+            return !changed;
+        },
+        select: (inst) => {
+            const target = occurrenceHome(p, inst, graph);
+            return target?.id === home.id;
+        },
+    };
+    while (true) {
+        const result = reconcileKernel([p], b, now, scope);
+        if (result) {
+            const dependsOn = scope.reads.snapshot();
+            return {
+                ...result,
+                home,
+                dependsOn,
+                ...nextWake(dependsOn.values(), now),
+                ...([...p.components.values()].some((c) => c.resources?.length) &&
+                    [...graph.values()].some((i) => i.children.some((s) => s.applies === "unknown"))
+                    ? { applicabilityUnknown: true }
+                    : {}),
+            };
+        }
+    }
+};
+/** The program an instance was reconciled under. */
+export const programFor = (recon, instance) => {
+    const inst = recon.instances.get(instance);
+    return inst ? recon.programs.find((p) => p.account.name === inst.account) : undefined;
+};
+/** Every started machine, its state, and the transitions its protocol allows next. */
+export const machines = (recon, b, now = b.now) => {
+    assertSnapshot(b, now);
+    const out = [];
+    for (const inst of recon.instances.values()) {
+        const p = programFor(recon, inst.id);
+        for (const use of p.components.get(inst.component).machines) {
+            const protocol = p.machines.get(use.protocol);
+            const state = machineState(b, inst.id, use.name);
+            if (!protocol || state === null)
+                continue;
+            const label = (name) => protocol.states.find((s) => s.name === name)?.label ?? name;
+            out.push({
+                instance: inst.id,
+                machine: use.name,
+                signal: protocol.signal,
+                state: { name: state, label: label(state) },
+                next: protocol.transitions
+                    .filter((t) => t.from === state)
+                    .map((t) => ({ name: t.to, label: label(t.to) })),
+            });
+        }
+    }
+    return out;
+};
+/** How each entity presents itself: its declared :display field, else its id. */
+export const displayNames = (programs, b, now = b.now) => {
+    assertSnapshot(b, now);
+    const names = new Map();
+    for (const id of b.entities()) {
+        const entity = programs.map((p) => p.entities.get(b.nsOf(id) ?? "")).find(Boolean);
+        const shown = entity?.display ? b.fact(id, `${entity.ns}/${entity.display}`)?.v : undefined;
+        names.set(id, shown === undefined ? id : String(shown));
+    }
+    return names;
+};
+const reconcileKernel = (programs, b, now = b.now, scope) => {
+    assertSnapshot(b, now);
+    for (const program of programs) {
+        entityHomes(program);
+        assertFiniteClock(program.ir);
+    }
+    const ctx = createEvaluationContext(programs, b, now, scope);
+    buildInstanceGraph(ctx);
+    if (ctx.scope && !ctx.scope.complete(ctx.instances))
+        return undefined;
+    const discoveryReads = discoveryProvenance(ctx.b, ctx.instances, ctx.roots, ctx.observations, (p, inst) => occurrenceHome(p, inst, ctx.instances)?.id);
+    for (const inst of ctx.instances.values())
+        if (!ctx.scope || ctx.scope.select(inst))
+            evaluate(ctx, inst);
+    // Finish current projections before probes can resolve a previously untaken reference.
+    let temporalCursor = 0, discoveryCursor = 0;
+    while (temporalCursor < ctx.temporalJobs.length || discoveryCursor < ctx.discoveryJobs.length) {
+        while (temporalCursor < ctx.temporalJobs.length)
+            ctx.temporalJobs[temporalCursor++]();
+        if (discoveryCursor < ctx.discoveryJobs.length)
+            ctx.discoveryJobs[discoveryCursor++]();
+    }
+    ctx.temporalJobs.length = 0;
+    ctx.discoveryJobs.length = 0;
+    for (const [id, reads] of ctx.discoveryReadSets)
+        ctx.observations.get(id).merge(reads.entries(), structuralObservation);
+    const result = finishReconciliation(ctx, discoveryReads);
+    return ctx.state.uncertainMembership &&
+        programs.some((p) => [...p.components.values()].some((c) => c.resources?.length))
+        ? { ...result, applicabilityUnknown: true }
+        : result;
+};
+export { Unknown, } from "./model.js";
+export { link, linkAll, LinkError } from "./linking.js";
+export { allOf, anyOf } from "./outputs.js";
+export { canonicalDecision, digest, proofOf, verifyProof } from "./proofs.js";
+export { canTransition, describeValue, evaluateFor, evaluateIn, evaluateValues, machineState, } from "./evaluation.js";
+export { occurrenceHome } from "./homes.js";
+export { admit } from "./invariants.js";
+export { planUpgrade } from "./upgrades.js";

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

@@ -0,0 +1,9 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Cx, RecurrencePeriod, Truth } from "./model.js";
+export interface RecurrenceRead {
+    readonly truth: Truth;
+    readonly period: RecurrencePeriod | null;
+    readonly reason: string;
+}
+/** Calculate from the original anchor: leap-day clamping must not accumulate drift. */
+export declare const readRecurrence: (cx: Cx, recurrence: IR.Recurrence) => RecurrenceRead;

package/dist/_internal/reconciler/recurrence.js

@@ -0,0 +1,44 @@
+import { localDateAt } from "./instants.js";
+import { isLocalDate as date } from "../ir-checks/index.js";
+import { addDays, addYears, daysBetween } from "./dates.js";
+import { evaluateIn, isUnknown } from "./evaluation.js";
+/** Calculate from the original anchor: leap-day clamping must not accumulate drift. */
+export const readRecurrence = (cx, recurrence) => {
+    const anchor = evaluateIn(cx, recurrence.from), now = localDateAt(cx.b.now);
+    if (isUnknown(anchor) || !date(anchor))
+        return {
+            truth: "unknown",
+            period: null,
+            reason: isUnknown(anchor) ? anchor.why : "Recurrence anchor is not a valid local date",
+        };
+    if (now < anchor) {
+        cx.temporal?.add(anchor);
+        return { truth: false, period: null, reason: `Starts on ${anchor}` };
+    }
+    const { n, unit } = recurrence.every;
+    if (!Number.isSafeInteger(n) || n <= 0 || (unit !== "days" && unit !== "years"))
+        return { truth: "unknown", period: null, reason: "Invalid recurrence interval" };
+    const shift = (index) => {
+        try {
+            const result = unit === "years" ? addYears(anchor, index * n) : addDays(anchor, index * n);
+            return date(result) ? result : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    let index = unit === "years"
+        ? Math.floor((Number(now.slice(0, 4)) - Number(anchor.slice(0, 4))) / n)
+        : Math.floor(daysBetween(anchor, now) / n);
+    let start = shift(index);
+    if (start > now)
+        start = shift(--index);
+    const next = shift(index + 1);
+    if (next)
+        cx.temporal?.add(next);
+    return {
+        truth: true,
+        period: { index, start, next },
+        reason: `Period ${index + 1} starts on ${start}`,
+    };
+};

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

@@ -0,0 +1,5 @@
+import { type EvaluationContext } from "./context.js";
+import type * as IR from "../world-ir/types.generated.js";
+import { type Cx, type EvaluationResult, type Instance, type RequirementResult } from "./model.js";
+export declare function evaluate(ctx: EvaluationContext, inst: Instance): EvaluationResult;
+export declare const evaluateRequirements: (ctx: EvaluationContext, inst: Instance, baseCx: Cx, component: IR.Component, partial: Map<string, RequirementResult>) => RequirementResult[];