worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,190 @@
+import { sourceSyntax } from "../source-syntax.js";
+import { collectionType, isLocalDate, normalizeInstant, fileDigest, } from "../../../ir-checks/index.js";
+import {} from "@forma-language/forma/reader";
+import {} from "./context.js";
+import { children, headOf, items, LowerError, mapPairs, option, spanOf, symName, } from "./syntax.js";
+const layoutChildren = (form) => {
+    const parts = items(form), out = [];
+    for (let i = 2; i < parts.length; i++) {
+        const part = parts[i];
+        if (symName(part)?.startsWith(":"))
+            i++;
+        else if (part._tag === "List")
+            out.push(part);
+    }
+    return out;
+};
+const layoutItemDiagnostic = (item, at) => ({
+    code: "E_LAYOUT_ITEM",
+    severity: "error",
+    message: `Unknown layout item head ${headOf(item) ?? "(empty)"}.`,
+    at,
+    help: "Use field, group, widget or sign as layout items; put conditions in :show-when.",
+});
+/** Report the actual item before native child validation widens its span to the layout. */
+export const layoutSourceDiagnostics = (files) => {
+    const diagnostics = [];
+    for (const file of files) {
+        const parsed = sourceSyntax(file);
+        if (parsed.errors.length)
+            continue;
+        const visit = (item) => {
+            const head = headOf(item);
+            if (head === "group")
+                layoutChildren(item).forEach(visit);
+            else if (!["field", "widget", "sign"].includes(head ?? ""))
+                diagnostics.push(layoutItemDiagnostic(item, spanOf(file.id, item)));
+        };
+        for (const form of parsed.forms)
+            if (headOf(form) === "layout")
+                for (const step of children(form, "step"))
+                    layoutChildren(step).forEach(visit);
+    }
+    return diagnostics;
+};
+export const lowerInteractions = (context, evidenceByName) => {
+    const { byForm, payload, formOf, componentScope, docOf, lowerExpr, at } = context;
+    return byForm("interaction").map((d) => {
+        const p = payload(d);
+        const form = formOf(d);
+        const evidence = evidenceByName.get(p.produces);
+        const scope = componentScope(evidence.of);
+        const bindings = new Map();
+        for (const [key, value] of mapPairs(option(form, "prefill"))) {
+            const field = symName(key).replace(/^:/, "");
+            bindings.set(field, { field, from: lowerExpr(d, value, scope) });
+        }
+        for (const [target, key] of mapPairs(option(form, "proposes"))) {
+            const field = symName(key);
+            bindings.set(field, { ...bindings.get(field), field, target: lowerExpr(d, target, scope) });
+        }
+        for (const [key, value] of mapPairs(option(form, "binds"))) {
+            const field = symName(key).replace(/^:/, ""), from = lowerExpr(d, value, scope);
+            bindings.set(field, { field, from, target: from });
+        }
+        const fixed = option(form, "fixes");
+        if (fixed && fixed._tag !== "Map")
+            throw new LowerError("E_FIXES_SHAPE", ":fixes must be a map of evidence fields to scalar literals.", at(d, fixed));
+        const fixes = mapPairs(fixed).map(([key, value]) => {
+            const field = symName(key)?.replace(/^:/, ""), declared = evidence.fields.find((f) => f.name === field);
+            if (!declared || !symName(key)?.startsWith(":"))
+                throw new LowerError("E_UNKNOWN_FIELD", "A fixed value must name a declared evidence field.", at(d, key));
+            if (bindings.has(field))
+                throw new LowerError("E_FIXES_CONFLICT", "A fixed field cannot also use :binds, :prefill or :proposes.", at(d, key));
+            const scalar = value._tag === "Str" || value._tag === "Bool"
+                ? value.value
+                : value._tag === "Num"
+                    ? Number(value.value)
+                    : symName(value)?.startsWith(":")
+                        ? symName(value).slice(1)
+                        : undefined;
+            const keyword = symName(value)?.startsWith(":") ?? false;
+            const fits = (type) => {
+                if (!type)
+                    return false;
+                switch (type.kind) {
+                    case "union":
+                        return type.members.some(fits);
+                    case "literal":
+                        return keyword && scalar === type.value;
+                    case "Keyword":
+                        return keyword;
+                    case "String":
+                        return value._tag === "Str";
+                    case "Bool":
+                        return typeof scalar === "boolean";
+                    case "Int":
+                        return typeof scalar === "number" && Number.isSafeInteger(scalar);
+                    case "Float":
+                        return typeof scalar === "number" && Number.isFinite(scalar);
+                    case "Date":
+                        return value._tag === "Str" && isLocalDate(value.value);
+                    case "Instant":
+                        return value._tag === "Str" && !!normalizeInstant(value.value);
+                    case "File":
+                        return value._tag === "Str" && !!fileDigest(value.value);
+                }
+            };
+            if (scalar === undefined || !fits(collectionType(declared.type, context.authoredTypes)))
+                throw new LowerError("E_FIXES_TYPE", "The fixed literal does not match the evidence field type.", at(d, value));
+            return { field: field, value: scalar };
+        });
+        if (new Set(fixes.map((f) => f.field)).size !== fixes.length)
+            throw new LowerError("E_FIXES_CONFLICT", "A field may be fixed only once.", at(d, fixed));
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            actor: p.actor,
+            produces: p.produces,
+            binds: [...bindings.values()],
+            ...(fixes.length ? { fixes } : {}),
+            ...(p.layout ? { layout: p.layout } : {}),
+            at: at(d, form),
+        };
+    });
+};
+export const lowerLayouts = (context, interactionIR, evidenceByName) => {
+    const { byForm, formOf, fieldScope, lowerExpr, source, at, docOf, payload } = context;
+    return byForm("layout").map((d) => {
+        const form = formOf(d);
+        const owner = interactionIR.find((i) => i.layout === d.summary.name);
+        const scope = fieldScope(owner ? evidenceByName.get(owner.produces).fields : []);
+        const item = (x) => {
+            const head = headOf(x);
+            const name = symName(items(x)[1]) ?? "";
+            const label = option(x, "label");
+            const showWhen = option(x, "show-when");
+            const common = {
+                ...(label?._tag === "Str" ? { label: label.value } : {}),
+                ...(showWhen ? { showWhen: lowerExpr(d, showWhen, scope) } : {}),
+            };
+            if (head === "field") {
+                if (interactionIR.some((i) => i.layout === d.summary.name && i.fixes?.some((f) => f.field === name)))
+                    throw new LowerError("E_FIXES_LAYOUT", `Fixed field ${name} must be omitted from the layout.`, at(d, x));
+                const options = option(x, "options");
+                return {
+                    kind: "field",
+                    name,
+                    ...common,
+                    ...(options
+                        ? {
+                            options: mapPairs(options).map(([k, v]) => ({
+                                value: symName(k).replace(/^:/, ""),
+                                label: v._tag === "Str" ? v.value : source(d, v),
+                            })),
+                        }
+                        : {}),
+                    at: at(d, x),
+                };
+            }
+            if (head === "group")
+                return {
+                    kind: "group",
+                    name,
+                    ...common,
+                    items: layoutChildren(x).map(item),
+                    at: at(d, x),
+                };
+            if (head === "widget")
+                return { kind: "widget", name, at: at(d, x) };
+            if (head === "sign")
+                return { kind: "sign", at: at(d, x) };
+            const error = layoutItemDiagnostic(x, at(d, x));
+            throw new LowerError(error.code, error.message, error.at, error.help);
+        };
+        return {
+            name: d.summary.name,
+            ...docOf(payload(d).doc),
+            steps: children(form, "step").map((step) => {
+                const label = items(step)[2];
+                return {
+                    name: symName(items(step)[1]),
+                    ...(label?._tag === "Str" ? { label: label.value } : {}),
+                    items: layoutChildren(step).map(item),
+                    at: at(d, step),
+                };
+            }),
+            at: at(d, form),
+        };
+    });
+};

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

@@ -0,0 +1,5 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type LoweringContext } from "./context.js";
+export declare const lowerRoles: (context: LoweringContext) => IR.Role[];
+export declare const lowerCalendars: (context: LoweringContext) => IR.Calendar[];
+export declare const lowerLibraries: (context: LoweringContext, libraryContent: object) => IR.Library[];

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

@@ -0,0 +1,41 @@
+import { lowerFileFields } from "./files.js";
+import { lowerSealedFields } from "./vaults.js";
+import { contentDigest } from "../digest.js";
+import {} from "./context.js";
+export const lowerRoles = (context) => {
+    const { byForm, docOf, roles, at, formOf } = context;
+    return byForm("role").map((d) => ({
+        name: d.summary.name,
+        ...docOf(roles.get(d.summary.name).doc),
+        fields: lowerSealedFields(context, d, lowerFileFields(context, d, roles.get(d.summary.name).fields.map((f) => ({ name: f.name, type: f.type })))),
+        at: at(d, formOf(d)),
+    }));
+};
+export const lowerCalendars = (context) => {
+    const { byForm, payload, docOf, at, formOf } = context;
+    return byForm("calendar").map((d) => {
+        const p = payload(d);
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            version: p.version,
+            weekend: p.weekend,
+            holidays: p.holidays.map(({ kind: _kind, ...h }) => h),
+            at: at(d, formOf(d)),
+        };
+    });
+};
+export const lowerLibraries = (context, libraryContent) => {
+    const { byForm, libraries, docOf, at, formOf } = context;
+    return byForm("library").map((d) => {
+        const p = libraries.find((l) => l.name === d.summary.name);
+        return {
+            name: p.name,
+            ...docOf(p.doc),
+            version: p.version,
+            subject: p.subject,
+            digest: contentDigest({ ...p, ...libraryContent }),
+            at: at(d, formOf(d)),
+        };
+    });
+};

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

@@ -0,0 +1,6 @@
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type { SExpr } from "@forma-language/forma/reader";
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { LoweringContext } from "./context.js";
+import { type Scope } from "./syntax.js";
+export declare const lowerMilestones: (context: LoweringContext, declaration: ElaboratedDeclaration, form: SExpr, scope: Scope) => IR.Milestone[];

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

@@ -0,0 +1,17 @@
+import { children, items, LowerError, option, symName } from "./syntax.js";
+export const lowerMilestones = (context, declaration, form, scope) => {
+    const names = new Set();
+    return children(form, "milestone").map((milestone) => {
+        const name = symName(items(milestone)[1]);
+        if (names.has(name))
+            throw new LowerError("E_MILESTONE_NAME", "Duplicate milestone name.", context.at(declaration, items(milestone)[1]), "Use a unique name for each milestone in this component.");
+        names.add(name);
+        const label = option(milestone, "label");
+        return {
+            name,
+            ...(label?._tag === "Str" ? { label: label.value } : {}),
+            when: context.lowerExpr(declaration, option(milestone, "when"), scope),
+            at: context.at(declaration, milestone),
+        };
+    });
+};

package/dist/_internal/forma/world/lowering/notices.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 lowerNotices: (cx: LoweringContext, documents: readonly IR.Document[]) => IR.Notice[];

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

@@ -0,0 +1,33 @@
+import { noticeHelp } from "../../../ir-checks/index.js";
+import { lowerRecordSeal } from "./vaults.js";
+import { LowerError, option, symName } from "./syntax.js";
+export const lowerNotices = (cx, documents) => cx.byForm("notice").map((d) => {
+    const form = cx.formOf(d), of = option(form, "of"), doc = option(form, "document"), to = option(form, "to"), owner = symName(of), document = symName(doc);
+    const fail = (code, node, message) => {
+        throw new LowerError(code, message, cx.at(d, node ?? form), noticeHelp);
+    };
+    if (!owner || !cx.components.has(owner))
+        return fail("E_NOTICE_DOCUMENT", of, "Name a declared owning component.");
+    if (!documents.some((x) => x.name === document && x.of === owner))
+        return fail("E_NOTICE_DOCUMENT", doc, "Choose a document owned by the notice's component.");
+    if (!to)
+        return fail("E_NOTICE_RECIPIENT", form, "Choose one entity recipient.");
+    let recipient;
+    try {
+        recipient = cx.lowerExpr(d, to, cx.componentScope(owner));
+    }
+    catch (error) {
+        if (!(error instanceof LowerError))
+            throw error;
+        return fail("E_NOTICE_RECIPIENT", to, "Choose an entity reference in the component's key-closed scope.");
+    }
+    return {
+        name: d.summary.name,
+        ...lowerRecordSeal(cx, d),
+        ...cx.docOf(cx.payload(d).doc),
+        of: owner,
+        document: document,
+        to: recipient,
+        at: cx.at(d, form),
+    };
+});

package/dist/_internal/forma/world/lowering/param-bounds.d.ts

@@ -0,0 +1,15 @@
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type { SExpr } from "@forma-language/forma/reader";
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { LoweringContext } from "./context.js";
+import { type Fields } from "./syntax.js";
+export declare const policyError: (context: LoweringContext, d: ElaboratedDeclaration, value: SExpr, message: string, assistance?: string) => never;
+export declare const policyMap: (context: LoweringContext, d: ElaboratedDeclaration, value: SExpr | undefined) => readonly (readonly [SExpr, SExpr])[];
+export declare const lowerPolicyNumber: (context: LoweringContext, d: ElaboratedDeclaration, value: SExpr) => IR.PolicyNumber;
+export declare const lowerParamBounds: (context: LoweringContext, d: ElaboratedDeclaration, form: SExpr, params: Fields) => IR.ParamBound[];
+export declare const lowerPolicyParams: (context: LoweringContext, d: ElaboratedDeclaration, form: SExpr, component: IR.Component) => {
+    name: string;
+    value: IR.PolicyNumber;
+    at: IR.Span;
+}[];
+export declare const checkAccountParams: (context: LoweringContext, d: ElaboratedDeclaration, form: SExpr, components: readonly IR.Component[]) => void;

package/dist/_internal/forma/world/lowering/param-bounds.js

@@ -0,0 +1,71 @@
+import { policyBoundValid, policyParameterType, policyValueWithin } from "../../../ir-checks/index.js";
+import { headOf, items, LowerError, mapPairs, option, symName } from "./syntax.js";
+const help = "Declare :param-bounds with fixed :default/:min/:max and :tighten :lower or :higher. Use safe nonnegative integers or one fixed duration unit; policy values must stay in the declared tightening interval.";
+export const policyError = (context, d, value, message, assistance = help) => {
+    throw new LowerError("E_POLICY_LOOSENS", message, context.at(d, value), assistance);
+};
+export const policyMap = (context, d, value) => {
+    if (!value)
+        return [];
+    if (value._tag !== "Map")
+        return policyError(context, d, value, "Policy data must be an explicit map.");
+    const pairs = mapPairs(value), names = pairs.map(([key]) => symName(key)?.replace(/^:/, ""));
+    if (names.some((name) => !name) || new Set(names).size !== names.length)
+        return policyError(context, d, value, "Policy maps need unique named keys.");
+    return pairs;
+};
+export const lowerPolicyNumber = (context, d, value) => {
+    const unit = value._tag === "Num" ? "integer" : headOf(value), number = value._tag === "Num" ? value : items(value)[1];
+    if (!unit ||
+        !["integer", "days", "years", "hours", "minutes"].includes(unit) ||
+        number?._tag !== "Num" ||
+        (value._tag !== "Num" && items(value).length !== 2) ||
+        !Number.isSafeInteger(Number(number.value)) ||
+        Number(number.value) < 0)
+        return policyError(context, d, value, "A policy parameter requires a fixed nonnegative safe integer or duration.");
+    return { n: Number(number.value), unit: unit };
+};
+export const lowerParamBounds = (context, d, form, params) => policyMap(context, d, option(form, "param-bounds")).map(([key, value]) => {
+    const name = symName(key).replace(/^:/, ""), param = params.find((p) => p.name === name);
+    const type = param ? policyParameterType(param.type, context.authoredTypes) : null;
+    if (!type)
+        return policyError(context, d, key, "Bounds must name an Int or Duration parameter declared by this component.");
+    const pairs = policyMap(context, d, value), names = pairs.map(([k]) => symName(k));
+    if (pairs.length !== 4 ||
+        [":default", ":min", ":max", ":tighten"].some((k) => !names.includes(k)))
+        return policyError(context, d, value, "Bounds require exactly :default, :min, :max and :tighten.");
+    const get = (name) => pairs.find(([k]) => symName(k) === name)[1];
+    const direction = symName(get(":tighten"));
+    if (direction !== ":lower" && direction !== ":higher")
+        return policyError(context, d, get(":tighten"), "Unknown tightening direction.");
+    const bound = {
+        name,
+        default: lowerPolicyNumber(context, d, get(":default")),
+        min: lowerPolicyNumber(context, d, get(":min")),
+        max: lowerPolicyNumber(context, d, get(":max")),
+        tighten: direction === ":lower" ? "lower" : "higher",
+        at: context.at(d, value),
+    };
+    if (!policyBoundValid(bound) || (type === "integer") !== (bound.default.unit === "integer"))
+        return policyError(context, d, value, "Bounds must share the parameter's unit and tighten from its library default.");
+    return bound;
+});
+export const lowerPolicyParams = (context, d, form, component) => policyMap(context, d, option(form, "params")).map(([key, value]) => {
+    const name = symName(key).replace(/^:/, ""), bound = component.paramBounds?.find((b) => b.name === name);
+    if (!bound)
+        return policyError(context, d, key, `Parameter ${name} has no declared library tightening bounds.`);
+    const parsed = lowerPolicyNumber(context, d, value);
+    if (!policyValueWithin(bound, parsed))
+        return policyError(context, d, value, `Parameter ${name} exceeds its library tightening bounds.`);
+    return { name, value: parsed, at: context.at(d, value) };
+});
+export const checkAccountParams = (context, d, form, components) => {
+    for (const [key, value] of mapPairs(option(form, "params"))) {
+        const name = symName(key)?.replace(/^:/, "");
+        for (const bound of components
+            .flatMap((c) => c.paramBounds ?? [])
+            .filter((b) => b.name === name))
+            if (!policyValueWithin(bound, lowerPolicyNumber(context, d, value)))
+                policyError(context, d, value, `Account parameter ${name} exceeds its library tightening bounds.`);
+    }
+};

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

@@ -0,0 +1,6 @@
+import { type PrincipalIR } from "../../../ir-checks/index.js";
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type { SExpr } from "@forma-language/forma/reader";
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { LoweringContext } from "./context.js";
+export declare const lowerPolicies: (context: LoweringContext, d: ElaboratedDeclaration, account: SExpr, components: readonly IR.Component[], model: PrincipalIR) => IR.AccountPolicy[];

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

@@ -0,0 +1,95 @@
+import { principalActionKey, principalKinds } from "../../../ir-checks/index.js";
+import { lowerEffective } from "./effective.js";
+import { lowerPolicyParams, policyError, policyMap } from "./param-bounds.js";
+import { children, items, LowerError, option, symName } from "./syntax.js";
+const help = "Target a declared component; cite a source, add Truth constraints and restrict named actions. Read only keyed inputs and pure facts/time; do not replace law satisfaction or authority.";
+const closed = (component, expr, fail, bound = new Set()) => {
+    if (expr.k === "var" &&
+        !bound.has(expr.name) &&
+        (expr.name === "self" || component.requirements.some((r) => r.name === expr.name)))
+        fail(expr, "Policies cannot depend on their own requirement status.");
+    if (expr.k === "var" &&
+        !bound.has(expr.name) &&
+        component.inputs.some((i) => i.name === expr.name) &&
+        !component.key.includes(expr.name))
+        fail(expr, "Policy reads a component input outside its key.");
+    if (expr.k === "inst" ||
+        (expr.k === "ref" && expr.kind !== "evidence" && expr.kind !== "calendar"))
+        fail(expr, "Policies cannot depend on component or decision status projections.");
+    if (expr.k === "call")
+        expr.args.forEach((a) => closed(component, a, fail, bound));
+    if (expr.k === "list")
+        expr.items.forEach((a) => closed(component, a, fail, bound));
+    if (expr.k === "fn")
+        closed(component, expr.body, fail, new Set([...bound, ...expr.params]));
+    if (expr.k === "if")
+        [expr.test, expr.then, expr.else].forEach((a) => closed(component, a, fail, bound));
+    if (expr.k === "read" || expr.k === "attr")
+        closed(component, expr.of, fail, bound);
+};
+export const lowerPolicies = (context, d, account, components, model) => {
+    const names = new Set();
+    return children(account, "policy").map((form) => {
+        const name = symName(items(form)[1]), doc = items(form)[2], of = symName(option(form, "of"));
+        if (names.has(name))
+            return policyError(context, d, items(form)[1], "Policy names must be unique within an account.", help);
+        names.add(name);
+        const component = components.find((c) => c.name === of);
+        if (!component)
+            return policyError(context, d, option(form, "of"), "Policy target is not a declared component.", help);
+        const expression = (value, guard = false) => {
+            const scope = new Map(context.componentScope(of));
+            if (guard)
+                component.params.forEach((param) => scope.delete(param.name));
+            let expr;
+            try {
+                expr = context.lowerExpr(d, value, scope);
+            }
+            catch (error) {
+                if (!(error instanceof LowerError))
+                    throw error;
+                return policyError(context, d, value, error.message, help);
+            }
+            closed(component, expr, (e, message) => {
+                throw new LowerError("E_POLICY_LOOSENS", message, e.at, help);
+            });
+            return expr;
+        };
+        const when = option(form, "when"), require = option(form, "require"), cites = context.citations(d, form).cites ?? [];
+        if (!cites.length)
+            return policyError(context, d, option(form, "cites") ?? form, "Account policies require a specific source citation.", help);
+        const assignments = policyMap(context, d, option(form, "assign")).map(([key, value]) => {
+            const action = symName(key).replace(/^:/, ""), original = component.actions.find((a) => a.name === action);
+            if (!original || original.via.kind !== "interaction" || !original.assignee)
+                return policyError(context, d, key, "Policy assignments restrict declared human actions with existing assignees.", help);
+            const assignee = expression(value);
+            const kinds = principalKinds({
+                ...model,
+                components: components.map((c) => c.name !== of
+                    ? c
+                    : { ...c, actions: [{ ...original, assignee, assigneeKind: undefined }] }),
+            });
+            if (kinds.diagnostics.length) {
+                const error = kinds.diagnostics[0];
+                throw new LowerError(error.code, error.message, error.at, error.help);
+            }
+            const assigneeKind = kinds.assignees.get(principalActionKey(of, action));
+            if (!assigneeKind)
+                return policyError(context, d, value, "An assignment restriction must name an entity or group.", help);
+            return { action, assignee, assigneeKind, at: context.at(d, value) };
+        });
+        const effective = lowerEffective(context, d, form);
+        return {
+            name,
+            doc: doc?._tag === "Str" ? doc.value : "",
+            of,
+            cites: [cites[0], ...cites.slice(1)],
+            ...(when ? { when: expression(when, true) } : {}),
+            ...(require ? { require: expression(require) } : {}),
+            params: lowerPolicyParams(context, d, form, component),
+            assign: assignments,
+            ...(effective ? { effective } : {}),
+            at: context.at(d, form),
+        };
+    });
+};

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

@@ -0,0 +1,62 @@
+import { type PrincipalIR } from "../../../ir-checks/index.js";
+import type * as IR from "../../../world-ir/types.generated.js";
+export declare const lowerPrincipals: (model: PrincipalIR, components: readonly IR.Component[], decisions: readonly IR.Decision[]) => {
+    components: {
+        requirements: IR.Requirement[];
+        actions: IR.Action[];
+        library?: string;
+        operations?: ReadonlyArray<string>;
+        milestones?: ReadonlyArray<IR.Milestone>;
+        holds?: ReadonlyArray<IR.Hold>;
+        resources?: readonly [IR.Resource, ...IR.Resource[]];
+        name: string;
+        doc?: string;
+        key: ReadonlyArray<string>;
+        home: IR.Home;
+        inputs: ReadonlyArray<IR.Field>;
+        params: ReadonlyArray<IR.Field>;
+        paramBounds?: readonly [IR.ParamBound, ...IR.ParamBound[]];
+        cycle?: IR.Expr;
+        slots: ReadonlyArray<IR.Slot>;
+        outputs: ReadonlyArray<IR.Output>;
+        machines: ReadonlyArray<{
+            readonly name: string;
+            readonly protocol: string;
+            readonly at: IR.Span;
+        }>;
+        invariants: ReadonlyArray<{
+            readonly name: string;
+            readonly cites?: ReadonlyArray<IR.Citation>;
+            readonly forbids: {
+                readonly action: string;
+                readonly subject: IR.Expr;
+            };
+            readonly while: IR.Expr;
+            readonly at: IR.Span;
+        }>;
+        retention?: {
+            readonly until: IR.Expr;
+            readonly disposal: string;
+            readonly cites?: ReadonlyArray<IR.Citation>;
+            readonly at: IR.Span;
+        };
+        at: IR.Span;
+    }[];
+    decisions: {
+        byKind: "group" | "individual";
+        name: string;
+        doc?: string;
+        of: string;
+        by: IR.Expr;
+        applies: string;
+        when?: IR.Expr;
+        effect: "approve" | "reject" | "waive" | "defer" | "accept" | "add";
+        reason: IR.TypeRef;
+        until?: IR.Expr;
+        expires?: IR.Expr;
+        approvals?: IR.Expr;
+        distinctFrom?: ReadonlyArray<IR.Expr>;
+        cites?: ReadonlyArray<IR.Citation>;
+        at: IR.Span;
+    }[];
+};

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

@@ -0,0 +1,32 @@
+import { principalActionKey, principalEscalationKey, principalKinds, } from "../../../ir-checks/index.js";
+import { LowerError } from "./syntax.js";
+export const lowerPrincipals = (model, components, decisions) => {
+    const kinds = principalKinds(model), diagnostic = kinds.diagnostics[0];
+    if (diagnostic)
+        throw new LowerError(diagnostic.code, diagnostic.message, diagnostic.at, diagnostic.help);
+    return {
+        components: components.map((component) => ({
+            ...component,
+            requirements: component.requirements.map((requirement) => requirement.escalate
+                ? {
+                    ...requirement,
+                    escalate: requirement.escalate.map((step, index) => {
+                        const kind = kinds.escalations.get(principalEscalationKey(component.name, requirement.name, index));
+                        return { ...step, whoKind: kind };
+                    }),
+                }
+                : requirement),
+            actions: component.actions.map((action) => {
+                const kind = kinds.assignees.get(principalActionKey(component.name, action.name));
+                return kind ? { ...action, assigneeKind: kind } : action;
+            }),
+        })),
+        decisions: decisions.map((decision) => {
+            const kind = kinds.authorities.get(decision.name);
+            return {
+                ...decision,
+                byKind: kind === "entity" ? "individual" : "group",
+            };
+        }),
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import { type SExpr } from "@forma-language/forma/reader";
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { SourceFile } from "../compile.js";
+import type { LoweringContext } from "./context.js";
+import { type Scope } from "./syntax.js";
+/** Check closed syntax before nested Expr validation so malformed maps get actionable spans. */
+export declare const recurrenceDiagnostics: (files: readonly SourceFile[]) => IR.Diagnostic[];
+export declare const lowerRecurrence: (context: LoweringContext, declaration: ElaboratedDeclaration, form: SExpr, scope: Scope) => IR.Recurrence | undefined;