worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,25 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type ScenarioResult, type ScenarioRunner } from "./scenarios.js";
+import { type PropertyOptions } from "./property-generator.js";
+export interface PropertyFailure {
+    readonly seed: number;
+    readonly index: number;
+    readonly binding: string;
+    readonly actual: "false" | "Unknown";
+    readonly at: IR.Span;
+    readonly scenario: IR.Scenario;
+}
+export interface PropertyResult {
+    readonly name: string;
+    readonly passed: boolean;
+    readonly seed: number;
+    readonly cases: number;
+    readonly checks: number;
+    readonly antecedents: readonly {
+        readonly at: IR.Span;
+        readonly cases: number;
+    }[];
+    readonly failure?: PropertyFailure;
+}
+export declare const checkProperty: (ir: IR.WorldIR, property: IR.Property, options: PropertyOptions, observe?: (result: ScenarioResult, index: number) => void, run?: ScenarioRunner) => PropertyResult;
+export declare const checkProperties: (ir: IR.WorldIR, options: PropertyOptions) => readonly PropertyResult[];

package/dist/_internal/reconciler/properties.js

@@ -0,0 +1,67 @@
+import { Unknown } from "./reconcile.js";
+import { createScenarioRunner } from "./scenarios.js";
+import { evaluateProperty } from "./property-eval.js";
+import { createPropertyCaseGenerator, validatePropertyOptions, } from "./property-generator.js";
+export const checkProperty = (ir, property, options, observe, run = createScenarioRunner(ir)) => {
+    validatePropertyOptions(options);
+    const generate = createPropertyCaseGenerator(ir, property, run);
+    const antecedents = new Map();
+    const visit = (e) => {
+        if (e.k !== "call")
+            return;
+        if (e.op === "implies")
+            antecedents.set(e, { at: e.at, cases: 0 });
+        e.args.forEach(visit);
+    };
+    visit(property.predicate);
+    let checks = 0;
+    for (let index = 0; index < options.cases; index++) {
+        const matched = new Set();
+        const scenario = generate(options.seed, index), observed = run(scenario);
+        if (!observed.passed)
+            throw new Error(`Invalid generated history: ${JSON.stringify(observed.failures)}`);
+        observe?.(observed, index);
+        const subjects = scenario.given.filter((e) => e.entity === property.binding.entity);
+        if (!subjects.length)
+            throw new Error("A generated case must bind at least one quantified entity.");
+        for (const subject of subjects) {
+            checks++;
+            const actual = evaluateProperty(property, observed.world, observed.steps[0].reconciliation, subject.name, (expr, truth) => {
+                if (truth && !matched.has(expr)) {
+                    antecedents.get(expr).cases++;
+                    matched.add(expr);
+                }
+            });
+            if (actual !== true)
+                return {
+                    name: property.name,
+                    passed: false,
+                    seed: options.seed,
+                    cases: index + 1,
+                    checks,
+                    antecedents: [...antecedents.values()],
+                    failure: {
+                        seed: options.seed,
+                        index,
+                        binding: subject.name,
+                        actual: actual instanceof Unknown ? "Unknown" : "false",
+                        at: property.predicate.at,
+                        scenario,
+                    },
+                };
+        }
+    }
+    return {
+        name: property.name,
+        passed: true,
+        seed: options.seed,
+        cases: options.cases,
+        checks,
+        antecedents: [...antecedents.values()],
+    };
+};
+export const checkProperties = (ir, options) => {
+    validatePropertyOptions(options);
+    const run = createScenarioRunner(ir);
+    return (ir.properties ?? []).map((property) => checkProperty(ir, property, options, undefined, run));
+};

package/dist/_internal/reconciler/property-eval.d.ts

@@ -0,0 +1,5 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type World } from "./memory.js";
+import { type Value, type WorldReconciliation } from "./reconcile.js";
+/** Kleene predicates share the kernel's distinction between missing values and status enums. */
+export declare const evaluateProperty: (property: IR.Property, world: World, recon: WorldReconciliation, subject: string, antecedent?: (expression: IR.PropertyExpr, trueAntecedent: boolean) => void) => Value;

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

@@ -0,0 +1,101 @@
+import { basis } from "./memory.js";
+import { findOccurrence } from "./occurrences.js";
+import { Unknown } from "./reconcile.js";
+/** Kleene predicates share the kernel's distinction between missing values and status enums. */
+export const evaluateProperty = (property, world, recon, subject, antecedent) => {
+    if (recon.now !== property.date)
+        throw new Error("Property date and reconciliation basis differ.");
+    const b = basis(world, property.date);
+    const unknown = () => new Unknown("Property operand is unknown");
+    const truth = (v) => (typeof v === "boolean" ? v : unknown());
+    const all = (args) => args.includes(false) ? false : args.every((v) => v === true) ? true : unknown();
+    const any = (args) => args.includes(true) ? true : args.every((v) => v === false) ? false : unknown();
+    const target = (t) => {
+        const key = t.key.map(ev), focus = t.attachedTo ? ev(t.attachedTo) : undefined;
+        return (t.attachedTo && typeof focus !== "string") ||
+            key.some((v) => v instanceof Unknown || v === null)
+            ? undefined
+            : findOccurrence(recon, property.world, t.component, key, t.cycle, typeof focus === "string" ? focus : undefined);
+    };
+    const ev = (e) => {
+        switch (e.k) {
+            case "literal":
+                return e.value;
+            case "read": {
+                let value = e.root === property.binding.name ? subject : unknown();
+                for (const attr of e.attrs)
+                    value = typeof value === "string" ? (b.fact(value, attr)?.v ?? unknown()) : unknown();
+                return value;
+            }
+            case "instance": {
+                const inst = target(e.target);
+                return inst ? { inst: inst.id } : unknown();
+            }
+            case "observation": {
+                const inst = target(e.of.target), result = inst && recon.results.get(inst.id);
+                if (!result)
+                    return unknown();
+                if (e.query === "work")
+                    return result.actions.find((a) => a.action === e.action)?.state ?? "absent";
+                const requirements = result.requirements.filter((r) => r.name === e.of.name);
+                if (e.query === "occurrence-count") {
+                    const cycle = e.cycle ? ev(e.cycle) : undefined;
+                    if (cycle instanceof Unknown || cycle === null)
+                        return unknown();
+                    return requirements.filter((r) => r.status !== "NotApplicable" &&
+                        (cycle === undefined || r.occurrence === `${inst.id}/${e.of.name}@${String(cycle)}`)).length;
+                }
+                return requirements[0]?.due ?? unknown();
+            }
+            case "status": {
+                const inst = target(e.target), result = inst && recon.results.get(inst.id);
+                return (result?.requirements.find((r) => r.name === e.name)?.status ??
+                    result?.outputs.find((o) => o.name === e.name)?.status ??
+                    unknown());
+            }
+            case "attested": {
+                const inst = target(e.target);
+                return inst
+                    ? b.evidenceOf(inst.id).some((r) => r.type === e.evidence && r.status === "attested")
+                    : unknown();
+            }
+            case "call": {
+                const args = e.args.map(ev), a = args[0], c = args[1];
+                switch (e.op) {
+                    case "known?":
+                        return !(a instanceof Unknown) && a !== null;
+                    case "unknown?":
+                        return a instanceof Unknown;
+                    case "and":
+                        return all(args.map(truth));
+                    case "or":
+                        return any(args.map(truth));
+                    case "not":
+                        return typeof a === "boolean" ? !a : unknown();
+                    case "implies":
+                        antecedent?.(e, a === true);
+                        return any([typeof a === "boolean" ? !a : unknown(), truth(c)]);
+                    case "satisfied?":
+                        return a instanceof Unknown || a === "Unknown"
+                            ? unknown()
+                            : a === "Satisfied" || a === "Waived";
+                    case "not-applicable?":
+                        return a instanceof Unknown || a === "Unknown" ? unknown() : a === "NotApplicable";
+                    default: {
+                        if (a instanceof Unknown || c instanceof Unknown)
+                            return unknown();
+                        if (e.op === "=")
+                            return a === c;
+                        if (e.op === "!=")
+                            return a !== c;
+                        if ((typeof a !== "string" && typeof a !== "number") ||
+                            (typeof c !== "string" && typeof c !== "number"))
+                            return unknown();
+                        return e.op === "<" ? a < c : e.op === "<=" ? a <= c : e.op === ">" ? a > c : a >= c;
+                    }
+                }
+            }
+        }
+    };
+    return ev(property.predicate);
+};

package/dist/_internal/reconciler/property-generator.d.ts

@@ -0,0 +1,9 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type ScenarioRunner } from "./scenarios.js";
+export interface PropertyOptions {
+    readonly seed: number;
+    readonly cases: number;
+}
+export declare const validatePropertyOptions: ({ seed, cases }: PropertyOptions) => void;
+export declare const createPropertyCaseGenerator: (ir: IR.WorldIR, property: IR.Property, run?: ScenarioRunner) => (seed: number, index: number) => IR.Scenario;
+export declare const generatePropertyCase: (ir: IR.WorldIR, property: IR.Property, seed: number, index: number, run?: ScenarioRunner) => IR.Scenario;

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

@@ -0,0 +1,288 @@
+import { sensitivePayload } from "../ir-checks/index.js";
+import { localDateAt } from "./instants.js";
+import { addDays } from "./dates.js";
+import { createScenarioRunner } from "./scenarios.js";
+import { validEvidence } from "./commands.js";
+export const validatePropertyOptions = ({ seed, cases }) => {
+    if (!Number.isInteger(seed) ||
+        seed < 0 ||
+        seed > 0xffffffff ||
+        !Number.isInteger(cases) ||
+        cases < 1 ||
+        cases > 10000)
+        throw new RangeError("Properties require a uint32 seed and 1–10000 cases.");
+};
+// Static authored views live only for one property run, like its prepared scenario runner.
+const prepareGeneration = (ir, property) => {
+    const world = ir.accounts.find((a) => a.name === property.world);
+    const types = ir.entities.filter((e) => e.ns.split(".")[0] === world.package.name);
+    const aliases = new Map(ir.types.map((t) => [t.name, t.type]));
+    const keywords = new Set(["sample", "other"]);
+    const inspect = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        if (Array.isArray(value)) {
+            value.forEach(inspect);
+            return;
+        }
+        const object = value;
+        if (object.k === "kw" && typeof object.v === "string")
+            keywords.add(object.v);
+        Object.values(object).forEach(inspect);
+    };
+    inspect(ir.components);
+    inspect(ir.derives);
+    const words = [...keywords].sort();
+    const references = new WeakMap();
+    const evidenceNames = (value) => {
+        if (!value || typeof value !== "object")
+            return [];
+        const old = references.get(value);
+        if (old)
+            return old;
+        const found = new Set();
+        const visit = (node) => {
+            if (!node || typeof node !== "object")
+                return;
+            if (Array.isArray(node)) {
+                node.forEach(visit);
+                return;
+            }
+            const e = node;
+            if (e.k === "ref" && e.kind === "evidence" && typeof e.name === "string")
+                found.add(e.name);
+            Object.values(e).forEach(visit);
+        };
+        visit(value);
+        const names = [...found];
+        references.set(value, names);
+        return names;
+    };
+    return { types, aliases, words, evidenceNames };
+};
+/** Six entities and two history records bound generation and the eventual replay artifact. */
+const generateCase = (property, seed, index, run, view) => {
+    validatePropertyOptions({ seed, cases: index + 1 });
+    let state = (seed + Math.imul(index + 1, 0x9e3779b9)) >>> 0;
+    const pick = (n) => {
+        state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+        return Math.floor((state / 4294967296) * n);
+    };
+    const { types, aliases, words, evidenceNames } = view;
+    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 given = [];
+    const at = property.at;
+    const literal = (value) => ({ k: "literal", value, at });
+    const fieldValue = (original, createReferences) => {
+        const type = resolve(original);
+        if (Array.isArray(type)) {
+            if (type[0] === "Id" && typeof type[1] === "string") {
+                const target = types.find((e) => e.name === type[1]) ??
+                    types.find((e) => e.implements.some((b) => b.role === type[1]));
+                if (!target)
+                    return undefined;
+                const existing = given.filter((e) => e.entity === target.name);
+                const node = existing.length && (!createReferences || pick(4) !== 0)
+                    ? existing[pick(existing.length)]
+                    : createReferences
+                        ? create(target)
+                        : undefined;
+                return node ? { k: "entity", name: node.name, at } : undefined;
+            }
+            if (type[0] === "Union") {
+                const options = type
+                    .slice(1)
+                    .filter((v) => typeof v === "string" && v.startsWith(":"));
+                return options.length ? literal(options[pick(options.length)].slice(1)) : undefined;
+            }
+            return undefined;
+        }
+        switch (type) {
+            case "String":
+            case "Group":
+                return literal(["Synthetic value", "Unknown", ""][pick(3)]);
+            case "Keyword":
+                return literal(words[pick(words.length)]);
+            case "Bool":
+                return literal(pick(2) === 1);
+            case "Int":
+                return literal([-1, 0, 1, 2, 3, 30, 90][pick(7)]);
+            case "Float":
+                return literal([-0.5, 0, 1.5, 42.25][pick(4)]);
+            case "Instant":
+                return literal(`${property.date.slice(0, 10)}T${String(pick(24)).padStart(2, "0")}:00:00.000Z`);
+            case "Date": {
+                const candidate = addDays(localDateAt(property.date), pick(721) - 360);
+                return literal(/^\d{4}-\d{2}-\d{2}$/.test(candidate) ? candidate : localDateAt(property.date));
+            }
+            default:
+                return undefined;
+        }
+    };
+    const create = (entity) => {
+        if (given.length >= 6)
+            return undefined;
+        const node = { name: `g${given.length}`, entity: entity.name, fields: [], at };
+        given.push(node);
+        for (const field of entity.fields) {
+            if (pick(5) === 0)
+                continue;
+            const value = fieldValue(field.type, true);
+            if (value)
+                node.fields.push({ name: field.name, value, at });
+        }
+        return node;
+    };
+    const primary = types.find((e) => e.name === property.binding.entity);
+    if (!primary)
+        throw new Error("Property binding is not in its account package.");
+    if (property.given) {
+        // Authored seed fields win; vary the remaining fields without changing seed identities.
+        for (const node of property.given)
+            given.push({ ...node, fields: [...node.fields] });
+        for (const node of given) {
+            const entity = types.find((e) => e.name === node.entity);
+            for (const field of entity.fields) {
+                if (node.fields.some((f) => f.name === field.name) || pick(5) === 0)
+                    continue;
+                const value = fieldValue(field.type, false);
+                if (value)
+                    node.fields.push({ name: field.name, value, at });
+            }
+        }
+    }
+    else {
+        const roots = 1 + pick(2);
+        for (let i = 0; i < roots; i++)
+            create(primary);
+    }
+    const scenario = {
+        name: `generated-${property.name}-${seed}-${index}`,
+        doc: "Synthetic seeded property data.",
+        world: property.world,
+        given,
+        steps: [{ kind: "at", date: property.date, expects: [], at }],
+        at,
+    };
+    const observed = run(scenario);
+    if (!observed.passed)
+        throw new Error("Generated entity basis failed reconciliation.");
+    const recon = observed.steps[0].reconciliation, program = recon.programs[0];
+    const target = (inst) => ({
+        k: "instance",
+        component: inst.component,
+        cycle: inst.cycle,
+        key: inst.key.map((v) => {
+            if (v && typeof v === "object" && "inst" in v)
+                return target(recon.instances.get(v.inst));
+            if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+                return literal(v);
+            throw new Error("Unknown generated occurrence key");
+        }),
+        at,
+    });
+    const candidates = [];
+    const evidence = [];
+    for (const inst of recon.instances.values()) {
+        let occurrence;
+        try {
+            occurrence = target(inst);
+        }
+        catch {
+            continue;
+        }
+        const component = program.components.get(inst.component);
+        for (const use of component.machines)
+            for (const status of program.machines.get(use.protocol).states)
+                candidates.push({
+                    kind: "signal",
+                    target: occurrence,
+                    machine: use.name,
+                    state: status.name,
+                    by: literal("Synthetic service"),
+                    at,
+                });
+        for (const requirement of component.requirements)
+            for (const name of evidenceNames(requirement.satisfiedBy)) {
+                const type = program.evidence.get(name);
+                if (type?.of === component.name)
+                    evidence.push({ target: occurrence, type, requirement: requirement.name });
+            }
+    }
+    const records = [];
+    const count = pick(3);
+    for (let i = 0; i < count; i++) {
+        if (candidates.length && (!evidence.length || pick(2) === 0)) {
+            records.push(candidates[pick(candidates.length)]);
+            continue;
+        }
+        if (!evidence.length)
+            continue;
+        const candidate = evidence[pick(evidence.length)];
+        const fields = candidate.type.fields.flatMap((f) => {
+            if (pick(5) === 0)
+                return [];
+            const value = fieldValue(f.type, false);
+            return value ? [{ name: f.name, value, at }] : [];
+        });
+        const values = Object.fromEntries(fields.flatMap((f) => f.value.k === "entity"
+            ? [[f.name, f.value.name]]
+            : f.value.k === "literal" && f.value.value !== null
+                ? [[f.name, f.value.value]]
+                : []));
+        records.push({
+            kind: "evidence",
+            target: candidate.target,
+            evidence: candidate.type.name,
+            requirement: candidate.requirement,
+            status: pick(2) === 0 && validEvidence(program, candidate.type.name, values, property.date)
+                ? "attested"
+                : "submitted",
+            by: literal("Synthetic human"),
+            values: fields,
+            at,
+        });
+    }
+    const pinned = property.records ?? [];
+    // Generated keys use scalar IDs; authored keys retain entity aliases and may omit a cycle.
+    const sameValue = (seed, generated) => seed.k === "instance" || generated.k === "instance"
+        ? seed.k === "instance" && generated.k === "instance" && sameTarget(seed, generated)
+        : (seed.k === "entity" ? seed.name : seed.value) ===
+            (generated.k === "entity" ? generated.name : generated.value);
+    const sameTarget = (seed, generated) => seed.component === generated.component &&
+        (seed.cycle === undefined || seed.cycle === generated.cycle) &&
+        seed.key.length === generated.key.length &&
+        seed.key.every((v, i) => sameValue(v, generated.key[i]));
+    const history = [
+        ...records.filter((record) => !pinned.some((seed) => seed.kind === record.kind &&
+            sameTarget(seed.target, record.target) &&
+            (seed.kind === "evidence" && record.kind === "evidence"
+                ? seed.evidence === record.evidence
+                : seed.kind === "signal" &&
+                    record.kind === "signal" &&
+                    seed.machine === record.machine))),
+        ...pinned,
+    ];
+    return { ...scenario, ...(history.length ? { records: history } : {}) };
+};
+export const createPropertyCaseGenerator = (ir, property, run = createScenarioRunner(ir)) => {
+    const view = prepareGeneration(ir, property);
+    return (seed, index) => generateCase(property, seed, index, run, view);
+};
+export const generatePropertyCase = (ir, property, seed, index, run = createScenarioRunner(ir)) => {
+    validatePropertyOptions({ seed, cases: index + 1 });
+    return createPropertyCaseGenerator(ir, property, run)(seed, index);
+};

package/dist/_internal/reconciler/property-shrink.d.ts

@@ -0,0 +1,14 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { PropertyFailure } from "./properties.js";
+export interface ShrunkPropertyFailure {
+    readonly scenario: IR.Scenario;
+    readonly source: string;
+    readonly attempts: number;
+    readonly complete: boolean;
+    readonly originalSize: number;
+    readonly shrunkSize: number;
+}
+/** Greedy deletion preserves the selected failure class; retained evidence payloads stay intact. */
+export declare const shrinkPropertyFailure: (ir: IR.WorldIR, property: IR.Property, failure: PropertyFailure, options?: {
+    readonly maxAttempts?: number;
+}) => ShrunkPropertyFailure;