worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/forma/world/lowering/context.js

@@ -0,0 +1,316 @@
+import { sourceSyntax } from "../source-syntax.js";
+import {} from "@forma-language/forma/descriptor";
+import {} from "@forma-language/forma/reader";
+import { sourceContext } from "./sources.js";
+import { KERNEL_FUNCTIONS, LowerError, VALUE, headOf, children, isSym, option, items, spanOf, symName, typeRef, } from "./syntax.js";
+export const makeSyntaxContext = (files, declarations) => {
+    const text = new Map(files.map((f) => [f.id, f.text]));
+    const syntax = new Map();
+    const authoredTypes = [];
+    for (const file of files) {
+        for (const form of sourceSyntax(file).forms) {
+            syntax.set(`${file.id}@${form.loc.start}`, form);
+            if (headOf(form) === "type" && isSym(items(form)[1]))
+                authoredTypes.push({
+                    name: symName(items(form)[1]),
+                    type: typeRef(items(form)[2]),
+                    at: spanOf(file.id, form),
+                });
+        }
+    }
+    const byForm = (form) => declarations.filter((d) => d.formName === form);
+    const payload = (d) => d.payload;
+    const formOf = (d) => {
+        const found = syntax.get(`${d.sourceId}@${d.span.startOffset}`);
+        if (!found)
+            throw new Error(`No syntax for ${d.summary.name}`);
+        return found;
+    };
+    const at = (d, e) => spanOf(d.sourceId, e);
+    const source = (d, e) => text.get(d.sourceId).slice(e.loc.start, e.loc.end);
+    return { authoredTypes, byForm, payload, formOf, at, source };
+};
+export const createLoweringContext = (files, declarations) => {
+    const base = makeSyntaxContext(files, declarations);
+    const { authoredTypes, byForm, payload, formOf, at, source } = base;
+    const { references, citations } = sourceContext(base);
+    const roles = new Map(byForm("role").map((d) => [d.summary.name, payload(d)]));
+    const entities = new Map(byForm("entity").map((d) => [
+        d.summary.name,
+        payload(d),
+    ]));
+    const components = new Map(byForm("component").map((d) => [d.summary.name, payload(d)]));
+    const derives = new Map(byForm("derive").map((d) => [
+        d.summary.name,
+        payload(d),
+    ]));
+    const evidenceNames = new Set(byForm("evidence").map((d) => d.summary.name));
+    const decisionNames = new Set(byForm("decision").map((d) => d.summary.name));
+    const calendarNames = new Set(byForm("calendar").map((d) => d.summary.name));
+    const libraries = byForm("library").map((d) => payload(d));
+    const subject = libraries[0]?.subject;
+    const typeOf = (ref, seen = new Set()) => {
+        if (typeof ref === "string") {
+            const alias = authoredTypes.find((alias) => alias.name === ref);
+            if (alias && !seen.has(ref))
+                return typeOf(alias.type, new Set([...seen, ref]));
+        }
+        if (Array.isArray(ref)) {
+            const [head, arg] = ref;
+            if (head === "Option")
+                return typeOf(arg, seen);
+            if (head === "List")
+                return { t: "list", of: typeOf(arg, seen) };
+            if (head === "Id" && typeof arg === "string")
+                return roles.has(arg)
+                    ? { t: "role", name: arg }
+                    : entities.has(arg)
+                        ? { t: "entity", name: arg }
+                        : components.has(arg)
+                            ? { t: "inst", name: arg }
+                            : VALUE;
+        }
+        return VALUE;
+    };
+    const homeOf = (name, visiting = new Set()) => {
+        if (visiting.has(name))
+            return undefined;
+        const component = components.get(name);
+        const first = component.key[0];
+        const type = typeOf(component.inputs.find((f) => f.name === first)?.type);
+        if (first && (type.t === "role" || type.t === "entity"))
+            return { kind: "input", path: [first] };
+        if (first && type.t === "inst") {
+            const target = homeOf(type.name, new Set([...visiting, name]));
+            if (!target)
+                return undefined;
+            return {
+                kind: "input",
+                path: [first, ...target.path],
+            };
+        }
+        return undefined;
+    };
+    const fieldType = (owner, field) => {
+        if (owner.t === "role") {
+            const found = roles.get(owner.name)?.fields.find((f) => f.name === field);
+            return found ? typeOf(found.type) : undefined;
+        }
+        if (owner.t === "entity") {
+            const found = entities.get(owner.name)?.fields.find((f) => f.name === field);
+            return found ? typeOf(found.type) : undefined;
+        }
+        if (owner.t === "inst") {
+            const c = components.get(owner.name);
+            if (!c)
+                return undefined;
+            if (field === "attached")
+                return { t: "list", of: subject ? { t: "role", name: subject } : VALUE };
+            const input = c.inputs.find((f) => f.name === field);
+            if (input)
+                return typeOf(input.type);
+            if ([...c.requirements, ...c.outputs].some((r) => r.name === field))
+                return { t: "status" };
+        }
+        return undefined;
+    };
+    const componentScope = (name) => {
+        const c = components.get(name);
+        return new Map([
+            ...c.inputs.map((f) => [f.name, typeOf(f.type)]),
+            ...c.params.map((f) => [f.name, VALUE]),
+            ["self", { t: "inst", name }],
+            ["attached", { t: "list", of: subject ? { t: "role", name: subject } : VALUE }],
+            ["today", VALUE],
+            ["now", VALUE],
+            ...c.requirements.map((r) => [r.name, { t: "status" }]),
+            ...c.machines.map((m) => [m.name, { t: "machine" }]),
+        ]);
+    };
+    const fieldScope = (fields) => new Map([
+        ...fields.map((f) => [f.name, VALUE]),
+        ["today", VALUE],
+        ["now", VALUE],
+    ]);
+    // ── Expressions ──
+    const lowerExpr = (d, e, scope) => lowerTyped(d, e, scope).expr;
+    const lowerTyped = (d, e, scope, paramTypes = []) => {
+        const here = at(d, e);
+        switch (e._tag) {
+            case "Num":
+                return { expr: { k: "lit", v: Number(e.value), at: here }, type: VALUE };
+            case "Str":
+            case "Bool":
+                return { expr: { k: "lit", v: e.value, at: here }, type: VALUE };
+            case "Vector": {
+                const lowered = e.items.map((x) => lowerTyped(d, x, scope));
+                return {
+                    expr: { k: "list", items: lowered.map((x) => x.expr), at: here },
+                    type: { t: "list", of: lowered[0]?.type ?? VALUE },
+                };
+            }
+            case "Sym": {
+                if (e.name === "nil")
+                    return { expr: { k: "lit", v: null, at: here }, type: VALUE };
+                if (e.name.startsWith(":"))
+                    return { expr: { k: "kw", v: e.name.slice(1), at: here }, type: VALUE };
+                const [root, ...fields] = e.name.split(".");
+                let type = scope.get(root);
+                let expr;
+                if (type)
+                    expr = { k: "var", name: root, at: here };
+                else if (fields.length === 0 && evidenceNames.has(e.name))
+                    return { expr: { k: "ref", kind: "evidence", name: e.name, at: here }, type: VALUE };
+                else if (fields.length === 0 && byForm("notice").some((n) => n.summary.name === e.name))
+                    return { expr: { k: "ref", kind: "notice", name: e.name, at: here }, type: VALUE };
+                else if (fields.length === 0 && decisionNames.has(e.name))
+                    return { expr: { k: "ref", kind: "decision", name: e.name, at: here }, type: VALUE };
+                else if (fields.length === 0 && calendarNames.has(e.name))
+                    return { expr: { k: "ref", kind: "calendar", name: e.name, at: here }, type: VALUE };
+                else
+                    throw new LowerError("E_LOWER", `${e.name} is not in scope here.`, here);
+                let path = root;
+                for (const field of fields) {
+                    path = `${path}.${field}`;
+                    const next = fieldType(type, field);
+                    if (!next || type.t === "list" || type.t === "value")
+                        throw new LowerError("E_LOWER", `${path} does not name a field.`, here);
+                    expr =
+                        type.t === "role"
+                            ? { k: "read", role: type.name, field, of: expr, meta: { path }, at: here }
+                            : type.t === "entity"
+                                ? {
+                                    k: "attr",
+                                    attr: `${entities.get(type.name).ns}/${field}`,
+                                    of: expr,
+                                    meta: { path },
+                                    at: here,
+                                }
+                                : { k: "inst", field, of: expr, at: here };
+                    type = next;
+                }
+                return { expr, type: type };
+            }
+            case "List": {
+                const head = symName(e.items[0]);
+                const args = e.items.slice(1);
+                if (head === "table" && d.formName !== "derive")
+                    throw new LowerError("E_TABLE_SCOPE", "Tables belong inside a derive.", here, "Move the table into a named derive and call it with the selector as a parameter.");
+                if (head === "added-on") {
+                    const owner = d.formName === "component" ? d.summary.name : symName(option(formOf(d), "of"));
+                    const declaration = byForm("component").find((c) => c.summary.name === owner);
+                    const literal = symName(args[0]);
+                    const target = literal?.startsWith(":") ? literal.slice(1) : undefined;
+                    const targets = declaration
+                        ? [
+                            ...children(formOf(declaration), "requirement"),
+                            ...children(formOf(declaration), "child"),
+                        ]
+                        : [];
+                    if (args.length !== 1 ||
+                        !targets.some((item) => symName(items(item)[1]) === target && option(item, "discretionary")))
+                        throw new LowerError("E_DISCRETIONARY_TARGET", "added-on requires an owned discretionary item.", at(d, args[0] ?? e), "Use the literal keyword of an owned discretionary requirement or child, such as :review.");
+                    return {
+                        expr: {
+                            k: "call",
+                            fn: head,
+                            args: [{ k: "kw", v: target, at: at(d, args[0]) }],
+                            at: here,
+                        },
+                        type: VALUE,
+                    };
+                }
+                if (head === "if") {
+                    const [test, then, otherwise] = args.map((x) => lowerTyped(d, x, scope));
+                    return {
+                        expr: { k: "if", test: test.expr, then: then.expr, else: otherwise.expr, at: here },
+                        type: then.type,
+                    };
+                }
+                if (head === "fn") {
+                    const params = items(args[0]).map((p) => symName(p));
+                    const inner = new Map(scope);
+                    params.forEach((p, i) => inner.set(p, paramTypes[i] ?? VALUE));
+                    const body = lowerTyped(d, args[1], inner);
+                    return { expr: { k: "fn", params, body: body.expr, at: here }, type: VALUE };
+                }
+                if (!head)
+                    throw new LowerError("E_LOWER", "Expected a function call.", here);
+                if (head === "and" || head === "or" || head === "not") {
+                    const operands = args.map((arg) => lowerTyped(d, arg, scope));
+                    const values = operands.map((operand) => operand.expr);
+                    const canonicalArgs = head === "not" || (operands.length === 1 && operands[0].type.t === "list")
+                        ? values
+                        : [{ k: "list", items: values, at: here }];
+                    return {
+                        expr: {
+                            k: "call",
+                            fn: head === "and" ? "all?" : head === "or" ? "any?" : "negate",
+                            args: canonicalArgs,
+                            at: here,
+                        },
+                        type: VALUE,
+                    };
+                }
+                // != is an authoring alias of not=; lowering to not= keeps one IR spelling.
+                if (head === "!=")
+                    return lowerTyped(d, { ...e, items: [{ ...e.items[0], name: "not=" }, ...e.items.slice(1)] }, scope, paramTypes);
+                // Higher-order calls: a function argument's parameter is an element of the list argument.
+                const listIndex = head === "spells" ? 0 : head === "map" || head === "filter" ? 1 : -1;
+                const listArg = listIndex >= 0 ? lowerTyped(d, args[listIndex], scope) : undefined;
+                const element = listArg?.type.t === "list" ? listArg.type.of : VALUE;
+                const lowered = args.map((x, i) => i === listIndex ? listArg : lowerTyped(d, x, scope, headOf(x) === "fn" ? [element] : []));
+                const derive = derives.get(head);
+                if (!derive && !KERNEL_FUNCTIONS.has(head))
+                    throw new LowerError("E_LOWER", `${head} is not a kernel function or a derive.`, here);
+                const type = derive
+                    ? typeOf(derive.returns)
+                    : head === "map"
+                        ? { t: "list", of: VALUE }
+                        : head === "filter" || head === "spells"
+                            ? { t: "list", of: head === "spells" ? (listArg?.type ?? VALUE) : element }
+                            : VALUE;
+                return {
+                    expr: {
+                        k: "call",
+                        fn: head,
+                        args: lowered.map((x) => x.expr),
+                        ...(derive ? { derive: true } : {}),
+                        at: here,
+                    },
+                    type,
+                };
+            }
+            default:
+                throw new LowerError("E_LOWER", `Unsupported expression ${e._tag}.`, here);
+        }
+    };
+    const maybe = (d, e, scope) => e === undefined ? undefined : lowerExpr(d, e, scope);
+    const docOf = (doc) => (doc === undefined ? {} : { doc });
+    const labelOf = (label) => (label === undefined ? {} : { label });
+    // ── Declarations ──
+    return {
+        ...base,
+        references,
+        citations,
+        roles,
+        entities,
+        components,
+        derives,
+        evidenceNames,
+        decisionNames,
+        calendarNames,
+        libraries,
+        subject,
+        typeOf,
+        homeOf,
+        fieldType,
+        componentScope,
+        fieldScope,
+        lowerExpr,
+        lowerTyped,
+        maybe,
+        docOf,
+        labelOf,
+    };
+};

package/dist/_internal/forma/world/lowering/contracts.d.ts

@@ -0,0 +1,7 @@
+import { componentContractSurface } from "../../../ir-checks/index.js";
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { LoweringContext } from "./context.js";
+export declare const lowerContracts: (cx: LoweringContext, ir: Parameters<typeof componentContractSurface>[0]) => {
+    componentImports?: readonly [IR.ComponentImport, ...IR.ComponentImport[]];
+    componentContracts?: readonly [IR.ComponentContract, ...IR.ComponentContract[]];
+};

package/dist/_internal/forma/world/lowering/contracts.js

@@ -0,0 +1,73 @@
+import { componentContractDigest, componentContractSurface } from "../../../ir-checks/index.js";
+import { items, option, symName, LowerError } from "./syntax.js";
+export const lowerContracts = (cx, ir) => {
+    const error = (d, value, message, code = "E_COMPONENT_CONTRACT") => {
+        throw new LowerError(code, message, cx.at(d, value), "Export an explicitly library-owned component with unique declared outputs, actions/decisions and connector services. Import its named contract from the exact provider library version.");
+    };
+    const contracts = cx.byForm("component-contract").map((d) => {
+        const form = cx.formOf(d), owner = option(form, "library"), target = option(form, "of");
+        const library = cx.libraries.find((l) => l.name === symName(owner)), component = ir.components.find((c) => c.name === symName(target));
+        if (!library)
+            error(d, owner, "The exporting library must be declared.");
+        if (!component || component.library !== library.name)
+            error(d, target, "Export a component owned by the named library.");
+        const names = (key, valid) => {
+            const value = option(form, key);
+            if (!value && key === "capabilities")
+                return [];
+            if (!value)
+                return error(d, form, `:${key} must be an explicit vector.`);
+            if (value._tag !== "Vector")
+                return error(d, value, `:${key} must be an explicit vector.`);
+            const result = [];
+            for (const item of items(value)) {
+                const name = symName(item);
+                if (!name || !valid.includes(name) || result.includes(name))
+                    error(d, item, `:${key} needs unique declared names.`, key === "operations" ? "E_NOT_AN_OPERATION" : "E_COMPONENT_CONTRACT");
+                result.push(name);
+            }
+            return result;
+        };
+        const surface = componentContractSurface(ir, component, names("outputs", component.outputs.map((o) => o.name)), names("operations", [
+            ...(component.operations ?? [
+                ...component.actions.map((a) => a.name),
+                ...(ir.decisions ?? []).filter((x) => x.of === component.name).map((x) => x.name),
+            ]),
+        ]), names("capabilities", ir.connectors.map((c) => c.name)));
+        const contract = { name: d.summary.name, library: library.name, ...surface };
+        return {
+            ...contract,
+            ...cx.docOf(cx.payload(d).doc),
+            digest: componentContractDigest(contract),
+            at: cx.at(d, form),
+        };
+    });
+    const imports = cx.byForm("component-import").map((d) => {
+        const form = cx.formOf(d), get = (key) => option(form, key);
+        const consumer = symName(get("library")), provider = symName(get("from")), contract = contracts.find((c) => c.name === symName(get("contract")));
+        if (!cx.libraries.some((l) => l.name === consumer))
+            error(d, get("library"), "Declare the consuming library.", "E_COMPONENT_IMPORT");
+        if (!contract || contract.library !== provider)
+            error(d, get("contract"), "Import a named contract exported by this provider.", "E_COMPONENT_IMPORT");
+        const version = get("version");
+        if (version._tag !== "Str" ||
+            !cx.libraries.some((l) => l.name === provider && l.version === version.value))
+            error(d, version, "Pin the declared provider library version.", "E_COMPONENT_IMPORT");
+        return {
+            name: d.summary.name,
+            ...cx.docOf(cx.payload(d).doc),
+            library: consumer,
+            from: provider,
+            version: version.value,
+            contract: contract.name,
+            digest: contract.digest,
+            at: cx.at(d, form),
+        };
+    });
+    return {
+        ...(contracts.length
+            ? { componentContracts: [contracts[0], ...contracts.slice(1)] }
+            : {}),
+        ...(imports.length ? { componentImports: [imports[0], ...imports.slice(1)] } : {}),
+    };
+};

package/dist/_internal/forma/world/lowering/decisions.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type LoweringContext } from "./context.js";
+export declare const lowerDecisions: (context: LoweringContext, componentIR: readonly IR.Component[]) => IR.Decision[];

package/dist/_internal/forma/world/lowering/decisions.js

@@ -0,0 +1,164 @@
+import { priorCycleDecisions, reuseDecisions } from "../../../ir-checks/index.js";
+import { inputHomeOf } from "../homes.js";
+import { contentDigest } from "../digest.js";
+import {} from "./context.js";
+import { childNamed, items, LowerError, option, symName, typeRef } from "./syntax.js";
+const closed = (component, name, e, bound = new Set()) => {
+    if (e.k === "var" &&
+        !bound.has(e.name) &&
+        component.inputs.some((i) => i.name === e.name) &&
+        !component.key.includes(e.name))
+        throw new LowerError("E_READ_OUTSIDE_KEY", `Decision ${name} reads non-key input ${e.name}.`, e.at, "Read only key inputs and their reference paths, or include this input in the component key.");
+    if (e.k === "fn")
+        closed(component, name, e.body, new Set([...bound, ...e.params]));
+    if (e.k === "call")
+        e.args.forEach((a) => closed(component, name, a, bound));
+    if (e.k === "list")
+        e.items.forEach((a) => closed(component, name, a, bound));
+    if (e.k === "if") {
+        closed(component, name, e.test, bound);
+        closed(component, name, e.then, bound);
+        closed(component, name, e.else, bound);
+    }
+    if (e.k === "read" || e.k === "attr" || e.k === "inst")
+        closed(component, name, e.of, bound);
+};
+export const lowerDecisions = (context, componentIR) => {
+    const { byForm, formOf, at, componentScope, lowerExpr, authoredTypes, docOf, payload, lowerTyped, citations, } = context;
+    const decisionIR = byForm("decision").map((d) => {
+        const form = formOf(d), name = d.summary.name, owner = symName(option(form, "of"));
+        const component = componentIR.find((c) => c.name === owner);
+        const applies = option(form, "applies"), effect = option(form, "effect");
+        const target = symName(applies);
+        const kind = symName(effect).replace(/^:/, "");
+        const targets = [
+            ...component.requirements,
+            ...component.slots.filter((s) => s.mode === "child"),
+        ].filter((r) => r.name === target);
+        if (kind === "add"
+            ? targets.length !== 1 || targets[0].discretionary !== name
+            : !component.requirements.some((r) => r.name === target))
+            throw new LowerError("E_DECISION_TARGET", `${owner}/${target} is not an owned target for this decision.`, at(d, applies), kind === "add"
+                ? "Choose one owned requirement or child whose :discretionary names this add decision."
+                : "Choose a requirement declared on the decision's :of component.");
+        if (!["approve", "reject", "waive", "defer", "accept", "add"].includes(kind))
+            throw new LowerError("E_DECISION_EFFECT", `Unsupported decision effect ${kind}.`, at(d, effect), "Choose :approve, :reject, :waive, :defer, :accept or :add.");
+        const scope = componentScope(owner);
+        const expression = (key) => {
+            const syntax = option(form, key);
+            if (!syntax)
+                return undefined;
+            const expr = lowerExpr(d, syntax, scope);
+            closed(component, name, expr);
+            return expr;
+        };
+        const by = expression("by"), when = expression("when"), until = expression("until"), expires = expression("expires"), approvals = expression("approvals");
+        if (approvals?.k === "lit" && (!Number.isSafeInteger(approvals.v) || Number(approvals.v) < 1))
+            throw new LowerError("E_DECISION_APPROVALS", "A decision requires a positive integer approval count.", approvals.at, "Use a positive integer or an Int expression that produces a positive count.");
+        const exclusions = option(form, "distinct-from");
+        if (exclusions && exclusions._tag !== "Vector")
+            throw new LowerError("E_DECISION_DISTINCT", "Decision exclusions must be a vector.", at(d, exclusions), "Use a vector of entity references, such as [person].");
+        const distinctFrom = exclusions
+            ? items(exclusions).map((syntax) => {
+                const lowered = lowerTyped(d, syntax, scope);
+                if (!["role", "entity"].includes(lowered.type.t))
+                    throw new LowerError("E_DECISION_DISTINCT", "A decision exclusion must resolve to an entity reference.", at(d, syntax), "Use an entity reference from the component key or its reference paths.");
+                closed(component, name, lowered.expr);
+                return lowered.expr;
+            })
+            : undefined;
+        const byKind = ["role", "entity"].includes(lowerTyped(d, option(form, "by"), scope).type.t)
+            ? "individual"
+            : "group";
+        if (byKind === "individual" &&
+            distinctFrom?.some((e) => contentDigest(e) === contentDigest(by)))
+            throw new LowerError("E_SELF_APPROVAL", "The decision authority is explicitly excluded from signing.", at(d, option(form, "by")), "Choose a different principal or a reviewer group; the excluded person cannot approve their own work.");
+        const reason = option(form, "reason");
+        const supportedReason = (t, seen = new Set()) => {
+            if (Array.isArray(t)) {
+                if (t[0] === "Option" || t[0] === "Brand")
+                    return t.length === 2 && supportedReason(t[1], seen);
+                return (t[0] === "Union" &&
+                    t.length > 1 &&
+                    t.slice(1).every((v) => typeof v === "string" && v.startsWith(":")));
+            }
+            if (typeof t !== "string" || seen.has(t))
+                return false;
+            const alias = authoredTypes.find((a) => a.name === t);
+            return alias
+                ? supportedReason(alias.type, new Set([...seen, t]))
+                : ["String", "Keyword", "Group", "Int", "Float", "Bool", "Date"].includes(t);
+        };
+        if (reason && !supportedReason(typeRef(reason)))
+            throw new LowerError("E_DECISION_REASON", "Unsupported decision reason type.", at(d, reason), "Use a scalar reason type, a keyword union, or an Option/Brand/alias of one; structured records belong in evidence.");
+        return {
+            name,
+            ...docOf(payload(d).doc),
+            of: owner,
+            by,
+            byKind,
+            applies: target,
+            effect: kind,
+            reason: reason ? typeRef(reason) : ["Option", "String"],
+            ...(when ? { when } : {}),
+            ...(until ? { until } : {}),
+            ...(expires ? { expires } : {}),
+            ...(approvals ? { approvals } : {}),
+            ...(distinctFrom ? { distinctFrom } : {}),
+            ...citations(d, form),
+            at: at(d, form),
+        };
+    });
+    for (const component of componentIR)
+        for (const requirement of component.requirements)
+            for (const definition of reuseDecisions(component, requirement))
+                if (!decisionIR.some((d) => d.name === definition.name && d.of === definition.of))
+                    decisionIR.push(definition);
+    for (const component of componentIR)
+        for (const requirement of component.requirements)
+            if (requirement.accepts) {
+                if (requirement.accepts.with) {
+                    const target = component.requirements.find((r) => r.name === requirement.accepts.with);
+                    if (requirement.accepts.from || !target?.accepts?.from || target.accepts.with) {
+                        const declaration = byForm("component").find((d) => d.summary.name === component.name);
+                        const syntax = option(childNamed(formOf(declaration), "requirement", requirement.name), "accepts");
+                        throw new LowerError("E_DECISION_TARGET", "Prior-cycle :with must name a direct owned confirmation.", at(declaration, syntax), "Use :from for an owned confirmation, or :with naming a direct owned confirmation with :from; do not combine them or chain aliases.");
+                    }
+                    continue;
+                }
+                if (!requirement.accepts.from)
+                    continue;
+                const path = inputHomeOf(component).path;
+                let by = { k: "var", name: path[0], at: requirement.at };
+                for (const field of path.slice(1))
+                    by = { k: "inst", of: by, field, at: requirement.at };
+                if (requirement.accepts.confirm)
+                    by = requirement.accepts.confirm;
+                closed(component, `prior-cycle ${requirement.name}`, by);
+                if (requirement.accepts.within)
+                    closed(component, `prior-cycle ${requirement.name}`, requirement.accepts.within);
+                const declaration = byForm("component").find((d) => d.summary.name === component.name);
+                const syntax = option(childNamed(formOf(declaration), "requirement", requirement.name), "accepts");
+                const confirm = option(syntax, "confirm");
+                const byKind = confirm &&
+                    !["role", "entity"].includes(lowerTyped(declaration, confirm, componentScope(component.name)).type.t)
+                    ? "group"
+                    : "individual";
+                const explicit = decisionIR.filter((d) => d.of === component.name && d.applies === requirement.name && d.effect === "accept");
+                if (explicit.length > 1)
+                    throw new LowerError("E_DECISION_TARGET", "Prior-cycle confirmation has multiple accept policies.", requirement.at, "Declare one accept decision per prior-cycle requirement so confirmation has a single authority policy.");
+                const defaults = priorCycleDecisions({
+                    component: component.name,
+                    requirement: requirement.name,
+                    by,
+                    byKind,
+                    at: requirement.at,
+                    ...(requirement.cites ? { cites: requirement.cites } : {}),
+                });
+                decisionIR.push(...(explicit[0]
+                    ? [{ ...explicit[0], name: defaults[1].name, effect: "reject" }]
+                    : defaults));
+            }
+    // Library identity is its content, not its spans.
+    return decisionIR;
+};

package/dist/_internal/forma/world/lowering/derives.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type LoweringContext } from "./context.js";
+export declare const lowerDerives: (context: LoweringContext) => IR.Derive[];

package/dist/_internal/forma/world/lowering/derives.js

@@ -0,0 +1,22 @@
+import {} from "./context.js";
+import { items, VALUE } from "./syntax.js";
+export const lowerDerives = (context) => {
+    const { byForm, derives, formOf, typeOf, docOf, lowerExpr, at } = context;
+    return byForm("derive").map((d) => {
+        const p = derives.get(d.summary.name);
+        const form = formOf(d);
+        const scope = new Map([
+            ...p.params.map((f) => [f.name, typeOf(f.type)]),
+            ["today", VALUE],
+            ["now", VALUE],
+        ]);
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            params: p.params,
+            returns: p.returns,
+            body: lowerExpr(d, items(form).at(-1), scope),
+            at: at(d, form),
+        };
+    });
+};

package/dist/_internal/forma/world/lowering/discretionary.d.ts

@@ -0,0 +1,7 @@
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type { SExpr } from "@forma-language/forma/reader";
+import type { LoweringContext } from "./context.js";
+/** One named operation owns authority and timing; the item only opts into that operation. */
+export declare const lowerDiscretionary: (context: LoweringContext, owner: ElaboratedDeclaration, item: SExpr, target: string) => {
+    readonly discretionary?: string;
+};

package/dist/_internal/forma/world/lowering/discretionary.js

@@ -0,0 +1,15 @@
+import { LowerError, option, symName } from "./syntax.js";
+/** One named operation owns authority and timing; the item only opts into that operation. */
+export const lowerDiscretionary = (context, owner, item, target) => {
+    const syntax = option(item, "discretionary");
+    if (!syntax)
+        return {};
+    const name = symName(syntax), decision = context.byForm("decision").find((d) => d.summary.name === name);
+    const form = decision ? context.formOf(decision) : undefined;
+    if (!form ||
+        symName(option(form, "of")) !== owner.summary.name ||
+        symName(option(form, "applies")) !== target ||
+        symName(option(form, "effect")) !== ":add")
+        throw new LowerError("E_DISCRETIONARY_TARGET", "Discretionary work must name its owned add decision.", context.at(owner, syntax), "Name an owned decision with :effect :add and :applies naming this requirement or child.");
+    return { discretionary: name };
+};

package/dist/_internal/forma/world/lowering/documents.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { LoweringContext } from "./context.js";
+export declare const lowerDocuments: (cx: LoweringContext, evidence: readonly IR.Evidence[]) => IR.Document[];