worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/forma/world/scenarios.js

@@ -0,0 +1,757 @@
+import { sourceSyntax } from "./source-syntax.js";
+import { sensitivePayload } from "../../ir-checks/index.js";
+import { fileDigest, fileMediaType, isLocalDate, normalizeInstant, timePointKey, } from "../../ir-checks/index.js";
+import { priorCycleOperationName } from "../../ir-checks/index.js";
+import {} from "@forma-language/forma/reader";
+const name = (e) => (e?._tag === "Sym" ? e.name : undefined);
+const list = (e) => e?._tag === "List" || e?._tag === "Vector" ? e.items : [];
+const head = (e) => (e._tag === "List" ? name(e.items[0]) : undefined);
+const option = (e, key) => {
+    const xs = list(e), i = xs.findIndex((x) => name(x) === `:${key}`);
+    return i < 0 ? undefined : xs[i + 1];
+};
+class InvalidScenario extends Error {
+    code;
+    at;
+    help;
+    constructor(code, message, at, help) {
+        super(message);
+        this.code = code;
+        this.at = at;
+        this.help = help;
+    }
+}
+/** Finite authored data only; resolving aliases never discovers runtime entities. */
+export const compileScenarios = (ir, files, forms) => {
+    const scenarios = [], diagnostics = [];
+    const aliases = new Map(ir.types.map((t) => [t.name, t.type]));
+    const unalias = (t, seen = new Set()) => {
+        if (typeof t !== "string" || !aliases.has(t) || seen.has(t))
+            return t;
+        seen.add(t);
+        return unalias(aliases.get(t), seen);
+    };
+    for (const file of files)
+        for (const form of forms ?? sourceSyntax(file).forms) {
+            if (head(form) !== "scenario")
+                continue;
+            const at = (e = form) => ({
+                src: file.id,
+                from: e.loc.start,
+                to: e.loc.end,
+                line: e.loc.line,
+                col: e.loc.col,
+            });
+            const fail = (code, message, e, help) => {
+                throw new InvalidScenario(code, message, at(e), help);
+            };
+            const shape = (message, e) => fail("E_SCENARIO_SHAPE", message, e, "Use finite given entity/evidence/signal records, do commands, and dated at/expect blocks.");
+            const reference = (message, e) => fail("E_SCENARIO_REF", message, e, "Use an entity, account, component, property or clause declared in this world, and declare local aliases in given.");
+            const mismatch = (e) => fail("E_SCENARIO_TYPE", "Scenario value does not match its declared type.", e, "Use a literal of the declared field/key type, a compatible given entity alias, or a declared component reference.");
+            const readDate = (e) => {
+                if (e?._tag !== "Str" || (!isLocalDate(e.value) && !normalizeInstant(e.value)))
+                    return fail("E_SCENARIO_DATE", "Expected a real local date or explicitly zoned scenario instant.", e, "Use YYYY-MM-DD or an explicitly zoned RFC3339 instant; observation times must be nondecreasing.");
+                return isLocalDate(e.value) ? e.value : normalizeInstant(e.value);
+            };
+            try {
+                const world = option(form, "world"), account = ir.accounts.find((a) => a.name === name(world));
+                if (!account)
+                    reference("Unknown scenario world.", world);
+                const authored = list(form), start = authored[2]?._tag === "Str" ? 3 : 2;
+                const blocks = authored.slice(start + 2);
+                for (const block of blocks)
+                    if (block._tag !== "List")
+                        shape("Scenario blocks must be lists.", block);
+                const givenBlocks = blocks.filter((e) => head(e) === "given");
+                if (givenBlocks.length > 1)
+                    shape("A scenario has at most one given block.", givenBlocks[1]);
+                const declarations = givenBlocks.flatMap((e) => list(e).slice(1));
+                const actorAliases = new Set(declarations
+                    .filter((e) => head(e) === "actor")
+                    .map((e) => name(list(e)[1]))
+                    .filter((n) => !!n));
+                const local = new Map();
+                for (const e of declarations.filter((e) => head(e) === "entity")) {
+                    const xs = list(e), type = ir.entities.find((t) => t.name === name(xs[1])), alias = name(xs[2]);
+                    if (head(e) !== "entity" || xs.length !== 4 || !alias)
+                        shape("Given records are (entity Type alias {fields}).", e);
+                    if (!type || type.ns.split(".")[0] !== account.package.name)
+                        reference("Unknown entity type in this world.", xs[1]);
+                    if (local.has(alias))
+                        shape("Given aliases must be unique.", xs[2]);
+                    local.set(alias, type);
+                }
+                const compatible = (entity, target) => entity.name === target || entity.implements.some((b) => b.role === target);
+                const instance = (e) => {
+                    const xs = list(e), component = ir.components.find((c) => c.name === name(xs[0]));
+                    if (e?._tag !== "List")
+                        return shape("Use (Component key...) for an occurrence.", e);
+                    if (!component)
+                        return reference("Unknown scenario component.", xs[0]);
+                    const end = component.key.length + 1;
+                    let cycle;
+                    if (xs.length !== end) {
+                        if (xs.length !== end + 2 || name(xs[end]) !== ":cycle")
+                            return shape("Occurrence keys must match the component's key arity; optionally add :cycle N.", e);
+                        const n = xs[end + 1];
+                        if (n?._tag !== "Num" || !Number.isSafeInteger(Number(n.value)) || Number(n.value) < 1)
+                            return mismatch(n);
+                        cycle = Number(n.value);
+                    }
+                    return {
+                        k: "instance",
+                        component: component.name,
+                        ...(cycle === undefined ? {} : { cycle }),
+                        key: component.key.map((key, i) => {
+                            const result = value(xs[i + 1], component.inputs.find((f) => f.name === key).type);
+                            if (result.k === "literal" && result.value === null)
+                                return mismatch(xs[i + 1]);
+                            return result;
+                        }),
+                        at: at(e),
+                    };
+                };
+                const value = (e, original) => {
+                    const t = unalias(original);
+                    if (name(e) === "nil")
+                        return { k: "literal", value: null, at: at(e) };
+                    if (Array.isArray(t)) {
+                        const payload = sensitivePayload(t);
+                        if (payload)
+                            return value(e, payload);
+                        if (t[0] === "Option" || t[0] === "Brand")
+                            return value(e, t[1]);
+                        if (t[0] === "Id" && typeof t[1] === "string") {
+                            if (ir.components.some((c) => c.name === t[1])) {
+                                const ref = instance(e);
+                                if (ref.component !== t[1])
+                                    return mismatch(e);
+                                return ref;
+                            }
+                            const alias = name(e), entity = local.get(alias ?? "");
+                            if (!entity)
+                                return reference("Unknown given entity alias.", e);
+                            if (!compatible(entity, t[1]))
+                                return mismatch(e);
+                            return { k: "entity", name: alias, at: at(e) };
+                        }
+                        if (t[0] === "Union" && name(e)?.startsWith(":")) {
+                            if (!t.slice(1).includes(name(e)))
+                                return mismatch(e);
+                            return { k: "literal", value: name(e).slice(1), at: at(e) };
+                        }
+                        return mismatch(e);
+                    }
+                    let v;
+                    if (e._tag === "Str")
+                        v = e.value;
+                    else if (e._tag === "Bool")
+                        v = e.value;
+                    else if (e._tag === "Num")
+                        v = Number(e.value);
+                    else if (name(e)?.startsWith(":"))
+                        v = name(e).slice(1);
+                    else
+                        return mismatch(e);
+                    if ((t === "String" || t === "Group") && e._tag !== "Str")
+                        return mismatch(e);
+                    if (t === "Keyword" && !name(e)?.startsWith(":"))
+                        return mismatch(e);
+                    if (t === "Bool" && typeof v !== "boolean")
+                        return mismatch(e);
+                    if ((t === "Int" || t === "Float") &&
+                        (typeof v !== "number" ||
+                            !Number.isFinite(v) ||
+                            (t === "Int" && !Number.isSafeInteger(v))))
+                        return mismatch(e);
+                    if (t === "File" && (e._tag !== "Str" || !fileDigest(e.value)))
+                        return mismatch(e);
+                    if (t === "Date" && (e._tag !== "Str" || !isLocalDate(e.value)))
+                        return mismatch(e);
+                    if (t === "Instant") {
+                        if (e._tag !== "Str" || !normalizeInstant(e.value))
+                            return mismatch(e);
+                        v = normalizeInstant(e.value);
+                    }
+                    if (![
+                        "String",
+                        "Group",
+                        "Keyword",
+                        "Bool",
+                        "Int",
+                        "Float",
+                        "Date",
+                        "Instant",
+                        "File",
+                    ].includes(String(t)))
+                        return mismatch(e);
+                    return { k: "literal", value: v, at: at(e) };
+                };
+                const given = declarations
+                    .filter((e) => head(e) === "entity")
+                    .map((e) => {
+                    const xs = list(e), alias = name(xs[2]), entity = local.get(alias), fields = xs[3];
+                    if (fields?._tag !== "Map")
+                        return shape("Given fields must be a keyword-keyed record.", fields);
+                    const seen = new Set();
+                    return {
+                        name: alias,
+                        entity: entity.name,
+                        fields: fields.pairs.map(([key, v]) => {
+                            const field = entity.fields.find((f) => `:${f.name}` === name(key));
+                            if (!field)
+                                return reference("Unknown scenario entity field.", key);
+                            if (seen.has(field.name))
+                                return shape("Given fields must be unique.", key);
+                            seen.add(field.name);
+                            const result = value(v, field.type);
+                            if (result.k === "instance")
+                                return mismatch(v);
+                            return { name: field.name, value: result, at: at(key) };
+                        }),
+                        at: at(e),
+                    };
+                });
+                const options = (e, start, allowed) => {
+                    const xs = list(e), out = new Map();
+                    for (let i = start; i < xs.length; i += 2) {
+                        const key = name(xs[i]);
+                        if (!key?.startsWith(":") ||
+                            !allowed.includes(key.slice(1)) ||
+                            out.has(key.slice(1)) ||
+                            !xs[i + 1])
+                            return shape("Use each supported command option once with a value.", xs[i]);
+                        out.set(key.slice(1), xs[i + 1]);
+                    }
+                    return out;
+                };
+                const actor = (e) => {
+                    if (!e)
+                        return { k: "literal", value: "scenario", at: at() };
+                    if (e._tag === "Str")
+                        return { k: "literal", value: e.value, at: at(e) };
+                    if (!local.has(name(e) ?? "") && !actorAliases.has(name(e) ?? ""))
+                        return reference("Unknown scenario actor alias.", e);
+                    return { k: "entity", name: name(e), at: at(e) };
+                };
+                const fields = (e, declared) => {
+                    if (!e)
+                        return [];
+                    if (e._tag !== "Map")
+                        return shape("Use a keyword-keyed values record.", e);
+                    const seen = new Set();
+                    return e.pairs.map(([key, v]) => {
+                        const field = declared.find((f) => `:${f.name}` === name(key));
+                        if (!field)
+                            return reference("Unknown evidence field.", key);
+                        if (seen.has(field.name))
+                            return shape("Evidence fields must be unique.", key);
+                        seen.add(field.name);
+                        const result = value(v, field.type);
+                        if (result.k === "instance")
+                            return mismatch(v);
+                        return { name: field.name, value: result, at: at(key) };
+                    });
+                };
+                const actors = [];
+                for (const declaration of declarations.filter((e) => head(e) === "actor")) {
+                    const xs = list(declaration), alias = name(xs[1]), opts = options(declaration, 2, ["kind", "groups"]);
+                    if (!alias || alias.startsWith(":"))
+                        shape("Use (actor alias :kind :human|:agent :groups [group-id...]).", declaration);
+                    if (actors.some((a) => a.name === alias))
+                        shape("Actor profiles must be unique.", xs[1]);
+                    const kind = opts.has("kind") ? name(opts.get("kind")) : ":human", groups = opts.get("groups");
+                    if (kind !== ":human" && kind !== ":agent")
+                        mismatch(opts.get("kind"));
+                    if (groups && groups._tag !== "Vector")
+                        mismatch(groups);
+                    const names = list(groups).map((g) => {
+                        if (g._tag !== "Str" || !g.value.trim())
+                            return mismatch(g);
+                        return g.value;
+                    });
+                    actors.push({
+                        name: alias,
+                        kind: kind === ":agent" ? "agent" : "human",
+                        groups: [...new Set(names)],
+                        at: at(declaration),
+                    });
+                }
+                const record = (e) => {
+                    const xs = list(e), kind = head(e);
+                    if (kind !== "evidence" && kind !== "signal")
+                        return shape("Use an evidence or signal record.", e);
+                    const opts = options(e, kind === "evidence" ? 2 : 3, kind === "evidence"
+                        ? ["for", "requirement", "requirement-cycle", "by", "status", "on", "values"]
+                        : ["state", "by", "on"]);
+                    const target = instance(kind === "evidence" ? opts.get("for") : xs[1]), component = ir.components.find((c) => c.name === target.component), common = {
+                        target,
+                        by: actor(opts.get("by")),
+                        ...(opts.has("on") ? { date: readDate(opts.get("on")) } : {}),
+                        at: at(e),
+                    };
+                    if (kind === "signal") {
+                        const machine = component.machines.find((m) => m.name === name(xs[2]));
+                        if (!machine)
+                            return reference("Unknown component machine.", xs[2]);
+                        const protocol = ir.machines.find((m) => m.name === machine.protocol), state = name(opts.get("state"));
+                        if (!protocol ||
+                            !state?.startsWith(":") ||
+                            !protocol.states.some((s) => s.name === state.slice(1)))
+                            return reference("Unknown machine state.", opts.get("state"));
+                        return { ...common, kind, machine: machine.name, state: state.slice(1) };
+                    }
+                    const evidence = ir.evidence.find((v) => v.name === name(xs[1]));
+                    if (!evidence || evidence.of !== component.name)
+                        return reference("Unknown evidence type for this component.", xs[1]);
+                    const requirement = component.requirements.find((r) => r.name === name(opts.get("requirement")));
+                    if (!requirement)
+                        return reference("Unknown evidence requirement.", opts.get("requirement"));
+                    const cycle = opts.get("requirement-cycle");
+                    if (cycle &&
+                        (cycle._tag !== "Num" ||
+                            !Number.isSafeInteger(Number(cycle.value)) ||
+                            Number(cycle.value) < 1 ||
+                            requirement.cycle?.k !== "call" ||
+                            requirement.cycle.fn !== "resource-generation"))
+                        return reference("Use a positive integer :requirement-cycle only for an explicitly resource-generation-cycled requirement.", cycle);
+                    const status = opts.has("status") ? name(opts.get("status")) : ":attested";
+                    if (!status || ![":submitted", ":attested", ":superseded"].includes(status))
+                        return mismatch(opts.get("status"));
+                    return {
+                        ...common,
+                        kind,
+                        evidence: evidence.name,
+                        requirement: requirement.name,
+                        ...(cycle
+                            ? { requirementCycle: Number(cycle.value) }
+                            : {}),
+                        status: status.slice(1),
+                        values: fields(opts.get("values"), evidence.fields),
+                    };
+                };
+                const command = (e) => {
+                    const xs = list(e), kind = head(e);
+                    if (kind === "evidence" || kind === "signal")
+                        return record(e);
+                    if (kind === "resource") {
+                        const target = instance(xs[1]), component = ir.components.find((c) => c.name === target.component), resource = component.resources?.find((r) => r.name === name(xs[2]));
+                        if (!resource)
+                            return reference("Unknown component resource.", xs[2]);
+                        const opts = options(e, 3, ["phase", "handle", "state", "by"]), phase = name(opts.get("phase")), handle = opts.get("handle"), state = name(opts.get("state"));
+                        if (phase !== ":acquire" && phase !== ":release")
+                            return mismatch(opts.get("phase"));
+                        if (handle?._tag !== "Str" || !handle.value.trim())
+                            return mismatch(handle);
+                        if (opts.has("state")) {
+                            const machine = component.machines.find((m) => m.name === resource.name), protocol = ir.machines.find((m) => m.name === machine.protocol);
+                            if (phase === ":release" ||
+                                !state?.startsWith(":") ||
+                                !protocol.states.some((s) => s.name === state.slice(1)))
+                                return reference("Unknown resource observation state.", opts.get("state"));
+                        }
+                        return {
+                            kind,
+                            target,
+                            name: resource.name,
+                            phase: phase.slice(1),
+                            handle: handle.value,
+                            ...(state ? { state: state.slice(1) } : {}),
+                            by: actor(opts.get("by")),
+                            at: at(e),
+                        };
+                    }
+                    if (kind === "decide") {
+                        const opts = options(e, 3, ["id", "by", "reason", "revoke"]), target = instance(xs[1]);
+                        const definition = ir.decisions?.find((d) => d.name === name(xs[2]) && d.of === target.component);
+                        if (!definition)
+                            return reference("Unknown decision on this component.", xs[2]);
+                        const text = (key) => {
+                            const v = opts.get(key);
+                            if (!v)
+                                return undefined;
+                            if (v._tag !== "Str" || !v.value.trim())
+                                return mismatch(v);
+                            return v.value;
+                        };
+                        const id = text("id"), revoke = text("revoke"), rawReason = opts.get("reason"), reason = rawReason ? value(rawReason, definition.reason) : undefined;
+                        if (reason && reason.k !== "literal")
+                            return mismatch(rawReason);
+                        return {
+                            kind,
+                            target,
+                            decision: definition.name,
+                            by: actor(opts.get("by")),
+                            ...(id ? { id } : {}),
+                            ...(revoke ? { revoke } : {}),
+                            ...(reason?.k === "literal" ? { reason: reason.value } : {}),
+                            at: at(e),
+                        };
+                    }
+                    if (kind === "set") {
+                        const opts = options(e, 4, ["by", "kind", "subject"]), entity = local.get(name(xs[1]) ?? "");
+                        if (!entity)
+                            return reference("Unknown given entity alias.", xs[1]);
+                        const field = entity.fields.find((f) => `:${f.name}` === name(xs[2]));
+                        if (!field)
+                            return reference("Unknown entity field.", xs[2]);
+                        if (!xs[3])
+                            return shape("Set needs a field value.", e);
+                        const result = value(xs[3], field.type);
+                        if (result.k === "instance")
+                            return mismatch(xs[3]);
+                        const commandKind = opts.get("kind"), subject = opts.get("subject");
+                        if (commandKind && !name(commandKind)?.startsWith(":"))
+                            return mismatch(commandKind);
+                        if (subject && !local.has(name(subject) ?? ""))
+                            return reference("Unknown command subject alias.", subject);
+                        return {
+                            kind,
+                            ...(commandKind ? { commandKind: name(commandKind).slice(1) } : {}),
+                            ...(subject ? { subject: name(subject) } : {}),
+                            entity: name(xs[1]),
+                            field: field.name,
+                            value: result,
+                            by: actor(opts.get("by")),
+                            at: at(e),
+                        };
+                    }
+                    if (kind === "accept") {
+                        const opts = options(e, 3, ["decision", "by", "id", "revoke", "reason"]), target = instance(xs[1]), component = ir.components.find((c) => c.name === target.component), requirement = component.requirements.find((r) => r.name === name(xs[2]));
+                        if (!requirement?.accepts)
+                            return reference("Use a requirement that accepts prior evidence.", xs[2]);
+                        const decision = opts.has("decision") ? name(opts.get("decision")) : ":accepted";
+                        if (decision !== ":accepted" && decision !== ":declined")
+                            return mismatch(opts.get("decision"));
+                        const strings = {};
+                        for (const key of ["id", "revoke"])
+                            if (opts.has(key)) {
+                                const v = opts.get(key);
+                                if (v._tag !== "Str" || !v.value.trim())
+                                    return mismatch(v);
+                                strings[key] = v.value;
+                            }
+                        const contract = ir.decisions?.find((d) => d.name ===
+                            priorCycleOperationName(ir.decisions ?? [], component.name, requirement.accepts.with ?? requirement.name, decision.slice(1)));
+                        if (opts.has("reason")) {
+                            const reason = value(opts.get("reason"), contract?.reason ?? ["Option", "String"]);
+                            if (reason.k !== "literal")
+                                return mismatch(opts.get("reason"));
+                            strings.reason = reason.value;
+                        }
+                        return {
+                            ...strings,
+                            kind,
+                            target,
+                            requirement: requirement.name,
+                            decision: decision.slice(1),
+                            by: actor(opts.get("by")),
+                            at: at(e),
+                        };
+                    }
+                    if (kind !== "perform")
+                        return shape("Use set, perform, accept, evidence or signal commands.", e);
+                    const opts = options(e, 3, ["by", "unsigned", "values", "signature", "amend"]), target = instance(xs[1]), component = ir.components.find((c) => c.name === target.component), action = component.actions.find((a) => a.name === name(xs[2]));
+                    if (!action)
+                        return reference("Unknown component action.", xs[2]);
+                    const unsigned = opts.get("unsigned");
+                    if (unsigned && unsigned._tag !== "Bool")
+                        return mismatch(unsigned);
+                    const rawAmend = opts.get("amend");
+                    let amend;
+                    if (rawAmend) {
+                        if (rawAmend._tag !== "Map" || rawAmend.pairs.length !== 2)
+                            return mismatch(rawAmend);
+                        const values = new Map(rawAmend.pairs.map(([key, value]) => [name(key), value]));
+                        const previous = values.get(":previous"), reason = values.get(":reason");
+                        if (previous?._tag !== "Str" || reason?._tag !== "Str")
+                            return mismatch(rawAmend);
+                        amend = { previous: previous.value, reason: reason.value };
+                    }
+                    const rawSignature = opts.get("signature");
+                    let signature;
+                    if (rawSignature) {
+                        if (rawSignature._tag !== "Map" || rawSignature.pairs.length !== 4)
+                            return mismatch(rawSignature);
+                        const values = new Map(rawSignature.pairs.map(([key, value]) => [name(key), value]));
+                        const consent = values.get(":consent"), intent = values.get(":intent"), method = values.get(":method"), device = values.get(":device");
+                        if (consent?._tag !== "Bool" ||
+                            intent?._tag !== "Bool" ||
+                            method?._tag !== "Str" ||
+                            device?._tag !== "Str")
+                            return mismatch(rawSignature);
+                        signature = {
+                            consent: consent.value,
+                            intent: intent.value,
+                            method: method.value,
+                            device: device.value,
+                        };
+                    }
+                    const via = action.via;
+                    const interaction = via.kind === "interaction"
+                        ? ir.interactions.find((i) => i.name === via.name)
+                        : undefined;
+                    const evidence = interaction && ir.evidence.find((v) => v.name === interaction.produces);
+                    return {
+                        kind,
+                        target,
+                        action: action.name,
+                        by: actor(opts.get("by")),
+                        unsigned: unsigned?._tag === "Bool" ? unsigned.value : false,
+                        ...(signature ? { signature } : {}),
+                        ...(amend ? { amend } : {}),
+                        values: fields(opts.get("values"), evidence?.fields ?? []),
+                        at: at(e),
+                    };
+                };
+                const files = declarations
+                    .filter((e) => head(e) === "file")
+                    .map((e) => {
+                    const xs = list(e), digest = xs[1], opts = options(e, 2, ["home", "media-type", "size", "scan", "redacted", "on"]), home = opts.get("home"), media = opts.get("media-type"), size = opts.get("size"), scan = opts.get("scan"), redacted = opts.get("redacted");
+                    if (digest?._tag !== "Str" || !fileDigest(digest.value))
+                        return mismatch(digest);
+                    if (!local.has(name(home) ?? ""))
+                        return reference("File metadata needs a given entity home.", home);
+                    if (media?._tag !== "Str" || !fileMediaType(media.value))
+                        return mismatch(media);
+                    if (size?._tag !== "Num" ||
+                        !Number.isSafeInteger(Number(size.value)) ||
+                        Number(size.value) < 0)
+                        return mismatch(size);
+                    const state = scan ? name(scan)?.replace(/^:/, "") : "pending";
+                    if (!state || !["pending", "clean", "rejected"].includes(state))
+                        return mismatch(scan);
+                    if (redacted && redacted._tag !== "Bool")
+                        return mismatch(redacted);
+                    return {
+                        home: name(home),
+                        digest: digest.value,
+                        mediaType: media.value,
+                        size: Number(size.value),
+                        scan: state,
+                        redacted: redacted?._tag === "Bool" ? redacted.value : false,
+                        ...(opts.has("on") ? { date: readDate(opts.get("on")) } : {}),
+                        at: at(e),
+                    };
+                });
+                const records = declarations
+                    .filter((e) => head(e) !== "entity" && head(e) !== "actor" && head(e) !== "file")
+                    .map(record);
+                let pending = [];
+                let previous;
+                const steps = [];
+                for (const block of blocks) {
+                    if (head(block) === "given")
+                        continue;
+                    if (head(block) === "do") {
+                        pending.push(...list(block).slice(1).map(command));
+                        continue;
+                    }
+                    if (head(block) !== "at")
+                        shape("Expected a dated at block.", block);
+                    const xs = list(block), current = readDate(xs[1]);
+                    if (previous && timePointKey(current) < timePointKey(previous))
+                        fail("E_SCENARIO_DATE", "Scenario dates must be nondecreasing.", xs[1], "Order at blocks from earliest to latest; historical fact dates are data, not clock rewinds.");
+                    previous = current;
+                    const expects = xs.slice(2).map((e) => {
+                        const parts = list(e), selector = list(parts[1]), kind = name(selector[0]);
+                        if (head(e) !== "expect" || parts.length !== 3)
+                            return shape("Use (expect (selector ...) expected).", e);
+                        if (kind === "property") {
+                            if (selector.length !== 4 || name(selector[2]) !== ":for")
+                                return shape("Use (property name :for given-alias).", selector[2] ?? parts[1]);
+                            const property = ir.properties?.find((p) => p.name === name(selector[1]) && p.world === account.name);
+                            if (!property)
+                                return reference("Unknown property in this world.", selector[1]);
+                            const alias = name(selector[3]), entity = local.get(alias ?? "");
+                            if (!entity)
+                                return reference("Unknown given alias for this property.", selector[3]);
+                            if (entity.name !== property.binding.entity)
+                                return mismatch(selector[3]);
+                            if (current !== property.date)
+                                return fail("E_SCENARIO_DATE", "Property replay must use its fixed date.", xs[1], `Observe this property on ${property.date}.`);
+                            if (parts[2]?._tag !== "Bool")
+                                return mismatch(parts[2]);
+                            return {
+                                kind,
+                                name: property.name,
+                                binding: alias,
+                                expected: parts[2].value,
+                                at: at(e),
+                            };
+                        }
+                        if (kind === "rejected") {
+                            if (selector.length !== 2)
+                                return shape("Use (rejected N) with the one-based command index in this observation.", parts[1]);
+                            const n = selector[1];
+                            if (n?._tag !== "Num" ||
+                                !Number.isSafeInteger(Number(n.value)) ||
+                                Number(n.value) < 1)
+                                return mismatch(n);
+                            if (Number(n.value) > pending.length)
+                                return reference("No command with this index in the dated block.", n);
+                            const expected = parts[2];
+                            if (expected._tag !== "Bool" && !name(expected)?.startsWith(":"))
+                                return mismatch(expected);
+                            return {
+                                kind,
+                                command: Number(n.value),
+                                expected: expected._tag === "Bool" ? expected.value : name(expected).slice(1),
+                                at: at(e),
+                            };
+                        }
+                        if (kind === "retention") {
+                            if (selector.length !== 3)
+                                return shape("Use (retention occurrence until|eligible).", parts[1]);
+                            const target = instance(selector[1]), component = ir.components.find((c) => c.name === target.component), field = name(selector[2]), expected = parts[2];
+                            if (!component.retention)
+                                return reference("This component has no retention declaration.", selector[1]);
+                            if (field !== "until" && field !== "eligible")
+                                return reference("Select retention until or eligible.", selector[2]);
+                            if (field === "eligible" && name(expected) !== "nil" && expected._tag !== "Bool")
+                                return mismatch(expected);
+                            return {
+                                kind,
+                                target,
+                                name: "retention",
+                                field,
+                                expected: name(expected) === "nil"
+                                    ? null
+                                    : field === "until"
+                                        ? readDate(expected)
+                                        : expected._tag === "Bool"
+                                            ? expected.value
+                                            : null,
+                                at: at(e),
+                            };
+                        }
+                        if (selector.length !== 3 ||
+                            !["status", "due", "work", "why", "blocked", "resource"].includes(kind ?? ""))
+                            return shape("Select status, due, work, why or blocked on an occurrence and clause.", e);
+                        const target = instance(selector[1]), component = ir.components.find((c) => c.name === target.component), clause = name(selector[2]);
+                        if (kind === "resource") {
+                            if (!component.resources?.some((r) => r.name === clause))
+                                return reference("Unknown component resource.", selector[2]);
+                            const expected = name(parts[2]);
+                            if (!expected?.startsWith(":") ||
+                                ![
+                                    "acquire",
+                                    "release",
+                                    "acquiring",
+                                    "acquired",
+                                    "releasing",
+                                    "released",
+                                    "failed",
+                                    "uncertain",
+                                    "timed-out",
+                                    "waiting",
+                                    "unknown",
+                                    "absent",
+                                ].includes(expected.slice(1)))
+                                return mismatch(parts[2]);
+                            return {
+                                kind,
+                                target,
+                                name: clause,
+                                expected: expected.slice(1),
+                                at: at(e),
+                            };
+                        }
+                        if (kind === "work") {
+                            const prior = clause?.startsWith("accept-prior:") &&
+                                component.requirements.some((r) => r.name === clause.slice(13) && r.accepts?.from);
+                            const reuse = clause?.startsWith("accept-reuse:") &&
+                                component.requirements.some((r) => r.name === clause.slice(13) && r.reuse?.confirm);
+                            if (!component.actions.some((a) => a.name === clause) && !prior && !reuse)
+                                return reference("Unknown scenario action.", selector[2]);
+                            const expected = parts[2];
+                            if (expected?._tag !== "Map" || expected.pairs.length !== 1)
+                                return shape("Work expects {:state :eligible|:waiting|:dispatched|:held|:absent}.", expected);
+                            const pair = expected.pairs[0];
+                            if (name(pair[0]) !== ":state")
+                                return shape("Use :state in a work expectation.", pair[0]);
+                            const state = name(pair[1]);
+                            if (!state?.startsWith(":") ||
+                                !["eligible", "waiting", "dispatched", "held", "absent"].includes(state.slice(1)))
+                                return mismatch(pair[1]);
+                            return {
+                                kind,
+                                target,
+                                name: clause,
+                                expected: state.slice(1),
+                                at: at(e),
+                            };
+                        }
+                        if (!component.requirements.some((r) => r.name === clause) &&
+                            !(kind === "status" && component.outputs.some((o) => o.name === clause)))
+                            return reference("Unknown scenario requirement/output.", selector[2]);
+                        if (kind === "due")
+                            return {
+                                kind,
+                                target,
+                                name: clause,
+                                expected: name(parts[2]) === "nil" ? null : readDate(parts[2]),
+                                at: at(e),
+                            };
+                        if (kind === "why") {
+                            if (parts[2]?._tag !== "Str" || !parts[2].value.trim())
+                                return mismatch(parts[2]);
+                            return { kind, target, name: clause, expected: parts[2].value, at: at(e) };
+                        }
+                        if (kind === "blocked") {
+                            if (parts[2]?._tag !== "Bool")
+                                return mismatch(parts[2]);
+                            return { kind, target, name: clause, expected: parts[2].value, at: at(e) };
+                        }
+                        const status = name(parts[2]);
+                        if (!status?.startsWith(":") ||
+                            !["Unknown", "NotApplicable", "Open", "Overdue", "Satisfied", "Waived"].includes(status.slice(1)))
+                            return mismatch(parts[2]);
+                        return {
+                            kind: "status",
+                            target,
+                            name: clause,
+                            expected: status.slice(1),
+                            at: at(e),
+                        };
+                    });
+                    steps.push({
+                        kind: "at",
+                        date: current,
+                        expects,
+                        ...(pending.length ? { commands: pending } : {}),
+                        at: at(block),
+                    });
+                    pending = [];
+                }
+                if (pending.length)
+                    shape("A do block needs a following dated at block.", blocks.at(-1));
+                if (!steps.length)
+                    shape("A scenario needs at least one dated assertion block.");
+                const xs = list(form), doc = xs[2];
+                scenarios.push({
+                    name: name(xs[1]),
+                    ...(doc?._tag === "Str" ? { doc: doc.value } : {}),
+                    world: account.name,
+                    given,
+                    ...(files.length ? { files } : {}),
+                    ...(actors.length ? { actors } : {}),
+                    ...(records.length ? { records } : {}),
+                    steps,
+                    at: at(),
+                });
+            }
+            catch (error) {
+                if (!(error instanceof InvalidScenario))
+                    throw error;
+                diagnostics.push({
+                    code: error.code,
+                    severity: "error",
+                    message: error.message,
+                    at: error.at,
+                    help: error.help,
+                });
+            }
+        }
+    return { scenarios, diagnostics };
+};