worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,116 @@
+import { sourceSyntax } from "../source-syntax.js";
+import {} from "@forma-language/forma/reader";
+import { agentReadHelp, sensitiveClasses } from "../../../ir-checks/index.js";
+import { headOf, items, LowerError, mapPairs, spanOf, symName } from "./syntax.js";
+const fail = (at, message) => {
+    throw new LowerError("E_AGENT_SENSITIVE_READ", message, at, agentReadHelp);
+};
+const read = (form, at) => {
+    const parts = items(form), options = new Map();
+    for (let n = parts[2]?._tag === "Str" ? 3 : 2; n < parts.length; n += 2) {
+        const key = parts[n], name = symName(key), value = parts[n + 1];
+        if (!name || ![":of", ":reads", ":may-read"].includes(name) || options.has(name) || !value)
+            fail(at(key), "Only unique :of, :reads and :may-read options belong in a static agent read contract.");
+        options.set(name, value);
+    }
+    const owner = options.get(":of"), paths = options.get(":reads"), grants = options.get(":may-read");
+    if (!owner || !symName(owner) || symName(owner).startsWith(":"))
+        fail(at(owner ?? form), "Name a declared owning component.");
+    if (paths?._tag !== "Vector" || !items(paths).length)
+        fail(at(paths ?? form), "Declare a nonempty vector of concrete field paths.");
+    const seenPaths = new Set();
+    for (const path of items(paths)) {
+        const name = symName(path), parts = name?.split(".");
+        if (!name ||
+            name.startsWith(":") ||
+            !parts ||
+            parts.length < 2 ||
+            parts.some((p) => !p) ||
+            seenPaths.has(name))
+            fail(at(path), "Read unique concrete input.field paths, not arbitrary expressions.");
+        seenPaths.add(name);
+    }
+    if (grants && grants._tag !== "Vector")
+        fail(at(grants), "Use a vector of exact class/vault grant maps.");
+    const seenGrants = new Set();
+    for (const grant of items(grants)) {
+        const pairs = mapPairs(grant), keys = pairs.map(([k]) => symName(k)), classification = symName(pairs.find(([k]) => symName(k) === ":class")?.[1]), vault = symName(pairs.find(([k]) => symName(k) === ":vault")?.[1]);
+        if (pairs.length !== 2 ||
+            new Set(keys).size !== 2 ||
+            !keys.every((k) => k === ":class" || k === ":vault") ||
+            !sensitiveClasses.some((c) => classification === `:${c}`) ||
+            !vault ||
+            vault.startsWith(":"))
+            fail(at(grant), "Each grant needs exactly one declared :class and named :vault.");
+        const key = `${classification}:${vault}`;
+        if (seenGrants.has(key))
+            fail(at(grant), "Class/vault grants must be unique.");
+        seenGrants.add(key);
+    }
+    return { owner: owner, paths: items(paths), grants: items(grants) };
+};
+/** Closed read syntax gets actionable spans before generic descriptor validation. */
+export const agentSourceDiagnostics = (files) => {
+    const names = new Set();
+    for (const file of files) {
+        if (!file.text.includes("agent"))
+            continue;
+        try {
+            const parsed = sourceSyntax(file);
+            if (parsed.errors.length)
+                continue;
+            for (const form of parsed.forms)
+                if (headOf(form) === "agent") {
+                    read(form, (e) => spanOf(file.id, e));
+                    const name = symName(items(form)[1]);
+                    if (!name || names.has(name))
+                        fail(spanOf(file.id, items(form)[1] ?? form), "Agent names must be unique.");
+                    names.add(name);
+                }
+        }
+        catch (error) {
+            if (!(error instanceof LowerError))
+                continue;
+            return [
+                {
+                    code: error.code,
+                    severity: "error",
+                    message: error.message,
+                    at: error.at,
+                    help: agentReadHelp,
+                },
+            ];
+        }
+    }
+    return [];
+};
+export const lowerAgents = (context, components) => context.byForm("agent").map((d) => {
+    const form = context.formOf(d), syntax = read(form, (e) => context.at(d, e)), owner = symName(syntax.owner), found = components.filter((c) => c.name === owner);
+    if (found.length !== 1)
+        fail(context.at(d, syntax.owner), "Name one declared component for this read contract.");
+    const scope = context.componentScope(owner);
+    return {
+        name: d.summary.name,
+        ...context.docOf(context.payload(d).doc),
+        of: owner,
+        reads: syntax.paths.map((path) => {
+            try {
+                return context.lowerExpr(d, path, scope);
+            }
+            catch (error) {
+                if (!(error instanceof LowerError))
+                    throw error;
+                return fail(context.at(d, path), "The requested field path is not statically resolvable.");
+            }
+        }),
+        mayRead: syntax.grants.map((grant) => {
+            const pairs = mapPairs(grant);
+            return {
+                class: symName(pairs.find(([k]) => symName(k) === ":class")[1]).slice(1),
+                vault: symName(pairs.find(([k]) => symName(k) === ":vault")[1]),
+                at: context.at(d, grant),
+            };
+        }),
+        at: context.at(d, form),
+    };
+});

package/dist/_internal/forma/world/lowering/bundles.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 lowerBundles: (cx: LoweringContext) => IR.Bundle[];

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

@@ -0,0 +1,13 @@
+import { LowerError, option, symName } from "./syntax.js";
+export const lowerBundles = (cx) => cx.byForm("bundle").map((d) => {
+    const form = cx.formOf(d), label = option(form, "label");
+    if (label?._tag !== "Str" || !label.value.trim())
+        throw new LowerError("E_BUNDLE_LABEL", "A bundle needs a nonempty presentation label.", cx.at(d, label ?? form), 'Add :label "Finish onboarding" or another readable session title.');
+    return {
+        name: d.summary.name,
+        ...cx.docOf(cx.payload(d).doc),
+        role: symName(option(form, "for")),
+        label: label.value,
+        at: cx.at(d, form),
+    };
+});

package/dist/_internal/forma/world/lowering/child-parameters.d.ts

@@ -0,0 +1,14 @@
+import type { LoweringContext } from "./context.js";
+export declare const lowerChildParameters: (cx: LoweringContext, d: Parameters<typeof cx.formOf>[0], slot: Parameters<typeof cx.at>[1], child: string) => {
+    with?: never;
+} | {
+    with: readonly [{
+        name: string;
+        value: import("../../../world-ir/types.generated.js").PolicyNumber;
+        at: import("../../../world-ir/types.generated.js").Span;
+    }, ...{
+        name: string;
+        value: import("../../../world-ir/types.generated.js").PolicyNumber;
+        at: import("../../../world-ir/types.generated.js").Span;
+    }[]];
+};

package/dist/_internal/forma/world/lowering/child-parameters.js

@@ -0,0 +1,36 @@
+import { policyValueWithin } from "../../../ir-checks/index.js";
+import { lowerParamBounds, lowerPolicyNumber } from "./param-bounds.js";
+import { option, symName, LowerError } from "./syntax.js";
+export const lowerChildParameters = (cx, d, slot, child) => {
+    const value = option(slot, "with");
+    if (!value)
+        return {};
+    const fail = (at, message) => {
+        throw new LowerError("E_PARAM_OUT_OF_BOUNDS", message, cx.at(d, at), "Use :with {:parameter fixed-value} for the child's declared Int/Duration bounds, in the declared unit and tightening interval. Provide fixed literals in an acyclic composition; expressions and unbounded parameters are not supported.");
+    };
+    if (value._tag !== "Map")
+        return fail(value, ":with requires a parameter map.");
+    const target = cx.byForm("component").find((x) => x.summary.name === child), payload = cx.components.get(child), bounds = lowerParamBounds(cx, target, cx.formOf(target), payload.params), names = new Set();
+    const params = value.pairs.map(([key, v]) => {
+        const name = symName(key)?.replace(/^:/, "");
+        if (!name || names.has(name))
+            return fail(key, "Name each child parameter once.");
+        names.add(name);
+        const bound = bounds.find((b) => b.name === name);
+        if (!bound)
+            return fail(key, "Only bounded parameters declared by the child may be set.");
+        let parsed;
+        try {
+            parsed = lowerPolicyNumber(cx, d, v);
+        }
+        catch (error) {
+            if (error instanceof LowerError)
+                return fail(v, "A child parameter needs a fixed safe integer or duration literal.");
+            throw error;
+        }
+        if (!policyValueWithin(bound, parsed))
+            return fail(v, "The child parameter is outside its declared tightening interval or unit.");
+        return { name, value: parsed, at: cx.at(d, v) };
+    });
+    return params.length ? { with: [params[0], ...params.slice(1)] } : {};
+};

package/dist/_internal/forma/world/lowering/collects.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 lowerCollects: (context: LoweringContext, layouts: readonly IR.Layout[]) => IR.Collect[];

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

@@ -0,0 +1,51 @@
+import { collectionType } from "../../../ir-checks/index.js";
+import { headOf, items, LowerError, option, symName } from "./syntax.js";
+export const lowerCollects = (context, layouts) => context.byForm("collect").map((declaration) => {
+    const form = context.formOf(declaration), facts = items(option(form, "facts")).map((f) => symName(f).replace(/^:/, "")), layout = option(form, "layout"), name = symName(layout), found = layouts.find((l) => l.name === name);
+    const role = context.roles.get(symName(option(form, "from")));
+    if (facts.some((name) => !collectionType(role.fields.find((f) => f.name === name).type, context.authoredTypes)))
+        throw new LowerError("E_COLLECT_TYPE", "Collection supports scalar source fields only.", context.at(declaration, option(form, "facts")), "Collect scalar strings, enums, numbers, booleans or dates/instants; relationship and structured fields need a separate typed operation.");
+    const shown = [];
+    let unconditional = true;
+    const visit = (item) => {
+        if (item.kind === "field") {
+            shown.push(item.name);
+            if (item.showWhen)
+                unconditional = false;
+        }
+        else if (item.kind === "group") {
+            if (item.showWhen)
+                unconditional = false;
+            item.items.forEach(visit);
+        }
+        else
+            unconditional = false;
+    };
+    found?.steps.forEach((step) => step.items.forEach(visit));
+    if (!found ||
+        !unconditional ||
+        shown.length !== facts.length ||
+        new Set(shown).size !== shown.length ||
+        facts.some((f) => !shown.includes(f)))
+        throw new LowerError("E_COLLECT_LAYOUT", "A collection layout must show exactly its source facts unconditionally.", context.at(declaration, layout), "Use a declared layout with each collected field exactly once, optionally in unconditional groups; omit guards, widgets and document signatures.");
+    const interval = option(form, "confirm-after");
+    let confirmAfter;
+    if (interval) {
+        const unit = headOf(interval), value = items(interval)[1], n = value?._tag === "Num" ? Number(value.value) : NaN;
+        if ((unit !== "days" && unit !== "years" && unit !== "hours" && unit !== "minutes") ||
+            items(interval).length !== 2 ||
+            !Number.isSafeInteger(n) ||
+            n <= 0)
+            throw new LowerError("E_COLLECT_INTERVAL", "Confirmation windows must be fixed positive safe-integer durations.", context.at(declaration, interval), "Use (days N), (years N), (hours N) or (minutes N) with a positive safe-integer literal; zero, dynamic and fractional windows are not supported.");
+        confirmAfter = { n, unit, at: context.at(declaration, interval) };
+    }
+    return {
+        name: declaration.summary.name,
+        ...context.docOf(context.payload(declaration).doc),
+        from: symName(option(form, "from")),
+        facts: [facts[0], ...facts.slice(1)],
+        layout: name,
+        ...(confirmAfter ? { confirmAfter } : {}),
+        at: context.at(declaration, form),
+    };
+});

package/dist/_internal/forma/world/lowering/component-operations.d.ts

@@ -0,0 +1,6 @@
+import type { LoweringContext } from "./context.js";
+export declare const lowerComponentOperations: (cx: LoweringContext, d: Parameters<typeof cx.formOf>[0]) => {
+    operations?: never;
+} | {
+    operations: string[];
+};

package/dist/_internal/forma/world/lowering/component-operations.js

@@ -0,0 +1,26 @@
+import { items, option, symName, LowerError } from "./syntax.js";
+export const lowerComponentOperations = (cx, d) => {
+    const form = cx.formOf(d), value = option(form, "operations");
+    if (!value)
+        return {};
+    const fail = (at) => {
+        throw new LowerError("E_NOT_AN_OPERATION", "Public operations must select unique, unambiguous authored actions or decisions owned by this component.", cx.at(d, at), "Use :operations [action-name decision-name] with owned authored names; use [] to expose none. Private helpers and requirements are not operations.");
+    };
+    if (value._tag !== "Vector")
+        return fail(value);
+    const owner = d.summary.name, actions = cx.components.get(owner).actions.map((a) => a.name), decisions = cx
+        .byForm("decision")
+        .filter((x) => symName(option(cx.formOf(x), "of")) === owner)
+        .map((x) => x.summary.name);
+    const names = [];
+    for (const item of items(value)) {
+        const name = symName(item);
+        if (!name ||
+            name.startsWith(":") ||
+            names.includes(name) ||
+            [...actions, ...decisions].filter((n) => n === name).length !== 1)
+            fail(item);
+        names.push(name);
+    }
+    return { operations: names };
+};

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

@@ -0,0 +1,7 @@
+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 lowerComponents: (context: LoweringContext) => IR.Component[];
+export declare function lowerAccepts(context: LoweringContext, d: ElaboratedDeclaration, e: SExpr, scope: Scope): IR.Accepts;

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

@@ -0,0 +1,236 @@
+import { canonicalConditionText } from "../surface.js";
+import { lowerChildParameters } from "./child-parameters.js";
+import { lowerComponentOperations } from "./component-operations.js";
+import { stableWorkIdentity } from "../../../ir-checks/index.js";
+import {} from "@forma-language/forma/descriptor";
+import {} from "@forma-language/forma/reader";
+import {} from "./context.js";
+import { lowerDiscretionary } from "./discretionary.js";
+import { lowerEscalations } from "./escalations.js";
+import { lowerReuse } from "./reuse.js";
+import { lowerRenewal } from "./renewal.js";
+import { lowerEffective } from "./effective.js";
+import { lowerRecurrence } from "./recurrences.js";
+import { lowerMilestones } from "./milestones.js";
+import { lowerParamBounds } from "./param-bounds.js";
+import { lowerHolds } from "./holds.js";
+import { lowerResources } from "./resources.js";
+import { lowerActionPolicy } from "./action-policy.js";
+import { childNamed, children, headOf, items, LowerError, mapPairs, option, symName, } from "./syntax.js";
+export const lowerComponents = (context) => {
+    const { byForm, components, formOf, componentScope, docOf, homeOf, lowerExpr, lowerTyped, maybe, citations, labelOf, at, source, } = context;
+    return byForm("component").map((d) => {
+        const c = components.get(d.summary.name);
+        const form = formOf(d);
+        const scope = componentScope(d.summary.name);
+        const cycle = option(form, "cycle");
+        const paramBounds = lowerParamBounds(context, d, form, c.params);
+        const holds = lowerHolds(context, d, form, scope);
+        const resources = lowerResources(context, d, form, scope);
+        const milestones = lowerMilestones(context, d, form, scope);
+        const outputPath = (segments, here) => {
+            let owner = d.summary.name;
+            for (const [i, segment] of segments.entries()) {
+                const component = components.get(owner);
+                const last = i === segments.length - 1;
+                const slot = component.slots.find((s) => s.name === segment);
+                if (slot && !last) {
+                    owner = slot.component;
+                    continue;
+                }
+                if (last &&
+                    (slot ||
+                        component.outputs.some((o) => o.name === segment) ||
+                        component.requirements.some((r) => r.name === segment)))
+                    return;
+                throw new LowerError("E_OUTPUT_PATH", `${segments.join(".")} does not name an output, requirement or child of ${owner}.`, here, "Use a declared local requirement or a published child output; private data fields are not status outputs.");
+            }
+        };
+        return {
+            name: d.summary.name,
+            ...lowerComponentOperations(context, d),
+            ...(option(form, "library") ? { library: symName(option(form, "library")) } : {}),
+            ...docOf(c.doc),
+            ...(holds.length ? { holds } : {}),
+            ...(resources.length ? { resources: [resources[0], ...resources.slice(1)] } : {}),
+            ...(milestones.length ? { milestones } : {}),
+            key: c.key,
+            home: homeOf(d.summary.name),
+            inputs: c.inputs,
+            params: c.params,
+            ...(paramBounds.length
+                ? { paramBounds: [paramBounds[0], ...paramBounds.slice(1)] }
+                : {}),
+            ...(cycle ? { cycle: lowerExpr(d, cycle, scope) } : {}),
+            requirements: c.requirements.map((r) => {
+                const x = childNamed(form, "requirement", r.name);
+                const accepts = option(x, "accepts");
+                const reuse = lowerReuse(context, d, x);
+                const lowerOption = (key) => maybe(d, option(x, key), scope);
+                const appliesWhen = lowerOption("applies-when");
+                const requirementCycle = lowerOption("cycle");
+                const due = lowerOption("due");
+                const remind = lowerOption("remind");
+                const renewWithin = lowerRenewal(context, d, x);
+                const effective = lowerEffective(context, d, x);
+                const recur = lowerRecurrence(context, d, x, scope);
+                const escalate = lowerEscalations(context, d, x, scope);
+                return {
+                    ...lowerDiscretionary(context, d, x, r.name),
+                    name: r.name,
+                    ...citations(d, x),
+                    ...labelOf(r.label),
+                    ...(appliesWhen ? { appliesWhen } : {}),
+                    satisfiedBy: lowerExpr(d, option(x, "satisfied-by"), scope),
+                    ...(reuse ? { reuse } : {}),
+                    ...(accepts ? { accepts: lowerAccepts(context, d, accepts, scope) } : {}),
+                    ...(requirementCycle ? { cycle: requirementCycle } : {}),
+                    ...(recur ? { recur } : {}),
+                    ...(effective ? { effective } : {}),
+                    ...(due ? { due } : {}),
+                    ...(remind ? { remind } : {}),
+                    ...(renewWithin ? { renewWithin } : {}),
+                    ...(escalate.length ? { escalate } : {}),
+                    at: at(d, x),
+                };
+            }),
+            actions: c.actions.map((a) => {
+                const x = childNamed(form, "action", a.name);
+                const via = option(x, "via");
+                const assignee = option(x, "assignee");
+                const idempotency = option(x, "idempotency");
+                const targets = typeof a.advances === "string" ? [a.advances] : a.advances;
+                const targetAt = at(d, option(x, "advances"));
+                if (!targets.length || new Set(targets).size !== targets.length)
+                    throw new LowerError("E_ADVANCES", "Advance a nonempty list of unique requirement names.", targetAt, "Use one declared requirement name or a nonempty vector of distinct local names.");
+                if (targets.length > 1 &&
+                    targets.some((name) => {
+                        const requirement = childNamed(form, "requirement", name);
+                        return ["cycle", "recur", "renew-within", "accepts", "reuse"].some((key) => option(requirement, key));
+                    }))
+                    throw new LowerError("E_ADVANCES_SCOPE", "Multi-target work requires ordinary requirements in one occurrence.", targetAt, "Use separate actions for recurring, renewal or prior-cycle proof; share a keyed component or declare evidence reuse explicitly.");
+                const action = {
+                    ...lowerActionPolicy(context, d, x),
+                    name: a.name,
+                    ...labelOf(a.label),
+                    advances: typeof a.advances === "string"
+                        ? a.advances
+                        : [targets[0], ...targets.slice(1)],
+                    needs: items(option(x, "needs")).map((n) => ({
+                        expr: lowerExpr(d, n, scope),
+                        text: canonicalConditionText(source(d, n)),
+                    })),
+                    ...(assignee ? { assignee: lowerExpr(d, assignee, scope) } : {}),
+                    ...(assignee
+                        ? {
+                            assigneeKind: ["role", "entity"].includes(lowerTyped(d, assignee, scope).type.t)
+                                ? "entity"
+                                : "group",
+                        }
+                        : {}),
+                    via: headOf(via) === "interaction"
+                        ? { kind: "interaction", name: symName(items(via)[1]) }
+                        : {
+                            kind: "connector",
+                            connector: headOf(via),
+                            capability: symName(items(via)[1]),
+                        },
+                    ...(idempotency
+                        ? { idempotency: items(idempotency).map((i) => lowerExpr(d, i, scope)) }
+                        : {}),
+                    at: at(d, x),
+                };
+                if (targets.length > 1 && !stableWorkIdentity(c, action))
+                    throw new LowerError("E_ADVANCES_SCOPE", "Multi-target work identity must stay in its entity home.", at(d, option(x, "idempotency")), "Use stable component key inputs and include its first entity reference, or use self. Computed facts/constants cannot identify shared work.");
+                return action;
+            }),
+            slots: c.slots.map((s) => {
+                const x = childNamed(form, s.mode, s.name);
+                const appliesWhen = maybe(d, option(x, "applies-when"), scope);
+                return {
+                    ...lowerDiscretionary(context, d, x, s.name),
+                    mode: s.mode,
+                    name: s.name,
+                    component: s.component,
+                    ...lowerChildParameters(context, d, x, s.component),
+                    bind: mapPairs(option(x, "bind")).map(([k, v]) => ({
+                        input: symName(k).replace(/^:/, ""),
+                        expr: lowerExpr(d, v, scope),
+                    })),
+                    ...(appliesWhen ? { appliesWhen } : {}),
+                    at: at(d, x),
+                };
+            }),
+            outputs: c.outputs.map((o) => {
+                const x = childNamed(form, "output", o.name);
+                const expr = items(x).at(-1);
+                const op = headOf(expr);
+                if (op !== "all-of" && op !== "any-of" && op !== "status-of")
+                    throw new LowerError("E_OUTPUT", "An output is (all-of …), (any-of …) or (status-of …).", at(d, expr));
+                return {
+                    name: o.name,
+                    ...labelOf(o.label),
+                    op,
+                    paths: items(expr)
+                        .slice(1)
+                        .map((p) => {
+                        const segments = symName(p).split(".");
+                        outputPath(segments, at(d, p));
+                        return { segments, at: at(d, p) };
+                    }),
+                    at: at(d, x),
+                };
+            }),
+            machines: c.machines.map((m) => ({
+                name: m.name,
+                protocol: m.protocol,
+                at: at(d, childNamed(form, "machine", m.name)),
+            })),
+            invariants: c.invariants.map((i) => {
+                const x = childNamed(form, "invariant", i.name);
+                const forbids = option(x, "forbids");
+                return {
+                    name: i.name,
+                    ...citations(d, x),
+                    forbids: {
+                        action: symName(option(forbids, "action-kind") ?? items(forbids)[1]).replace(/^:/, ""),
+                        subject: lowerExpr(d, option(forbids, "subject"), scope),
+                    },
+                    while: lowerExpr(d, option(x, "while"), scope),
+                    at: at(d, x),
+                };
+            }),
+            ...(c.retention[0]
+                ? (() => {
+                    const x = children(form, "retention")[0];
+                    return {
+                        retention: {
+                            ...citations(d, x),
+                            until: lowerExpr(d, option(x, "until"), scope),
+                            disposal: c.retention[0].disposal,
+                            at: at(d, x),
+                        },
+                    };
+                })()
+                : {}),
+            at: at(d, form),
+        };
+    });
+};
+export function lowerAccepts(context, d, e, scope) {
+    const { at, lowerExpr } = context;
+    if (headOf(e) !== "prior-cycle")
+        throw new LowerError("E_ACCEPTS", "Only (prior-cycle …) acceptance is supported.", at(d, e));
+    const name = (key) => symName(option(e, key));
+    const within = option(e, "within");
+    const confirm = option(e, "confirm");
+    const label = option(e, "label");
+    return {
+        kind: "prior-cycle",
+        ...(name("from") ? { from: name("from") } : {}),
+        ...(name("with") ? { with: name("with") } : {}),
+        ...(within ? { within: lowerExpr(d, within, scope) } : {}),
+        ...(confirm ? { confirm: lowerExpr(d, confirm, scope) } : {}),
+        ...(label?._tag === "Str" ? { label: label.value } : {}),
+    };
+}

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

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

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

@@ -0,0 +1,31 @@
+import {} from "./context.js";
+export const lowerConnectors = (context) => {
+    const { byForm, payload, docOf, at, formOf } = context;
+    return byForm("connector").map((d) => {
+        const p = payload(d);
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            capabilities: p.capabilities,
+            signals: p.signals,
+            owns: p.owns,
+            at: at(d, formOf(d)),
+        };
+    });
+};
+export const lowerMachines = (context) => {
+    const { byForm, payload, docOf, at, formOf } = context;
+    return byForm("machine").map((d) => {
+        const p = payload(d);
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            signal: p.signal,
+            initial: p.initial,
+            final: p.final,
+            states: p.states.map((s) => ({ name: s.name, label: s.label })),
+            transitions: p.transitions.map((t) => ({ from: t.from, to: t.to })),
+            at: at(d, formOf(d)),
+        };
+    });
+};

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

@@ -0,0 +1,80 @@
+import { type ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import { type SExpr } from "@forma-language/forma/reader";
+import type { SourceFile } from "../compile.js";
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type ComponentPayload, type Fields, type SType, type Scope } from "./syntax.js";
+export declare const makeSyntaxContext: (files: readonly SourceFile[], declarations: readonly ElaboratedDeclaration[]) => {
+    authoredTypes: IR.TypeAlias[];
+    byForm: (form: string) => ElaboratedDeclaration[];
+    payload: <T>(d: ElaboratedDeclaration) => T;
+    formOf: (d: ElaboratedDeclaration) => SExpr;
+    at: (d: ElaboratedDeclaration, e: SExpr) => IR.Span;
+    source: (d: ElaboratedDeclaration, e: SExpr) => string;
+};
+export type SyntaxContext = ReturnType<typeof makeSyntaxContext>;
+export declare const createLoweringContext: (files: readonly SourceFile[], declarations: readonly ElaboratedDeclaration[]) => {
+    references: IR.Source[];
+    citations: (d: ElaboratedDeclaration, form: SExpr) => {
+        cites?: readonly IR.Citation[];
+    };
+    roles: Map<string, {
+        doc?: string;
+        fields: Fields;
+    }>;
+    entities: Map<string, {
+        doc?: string;
+        ns: string;
+        "ns-declared": boolean;
+        display?: string;
+        fields: Fields;
+        implements: ReadonlyArray<{
+            role: string;
+            field: string;
+            path: string;
+        }>;
+    }>;
+    components: Map<string, ComponentPayload>;
+    derives: Map<string, {
+        doc?: string;
+        params: Fields;
+        returns: IR.TypeRef;
+    }>;
+    evidenceNames: Set<string>;
+    decisionNames: Set<string>;
+    calendarNames: Set<string>;
+    libraries: {
+        name: string;
+        doc?: string;
+        version: string;
+        subject: string;
+    }[];
+    subject: string | undefined;
+    typeOf: (ref: IR.TypeRef | undefined, seen?: ReadonlySet<string>) => SType;
+    homeOf: (name: string, visiting?: ReadonlySet<string>) => IR.InputHome | undefined;
+    fieldType: (owner: SType, field: string) => SType | undefined;
+    componentScope: (name: string) => Scope;
+    fieldScope: (fields: Fields) => Scope;
+    lowerExpr: (d: ElaboratedDeclaration, e: SExpr, scope: Scope) => IR.Expr;
+    lowerTyped: (d: ElaboratedDeclaration, e: SExpr, scope: Scope, paramTypes?: readonly SType[]) => {
+        expr: IR.Expr;
+        type: SType;
+    };
+    maybe: (d: ElaboratedDeclaration, e: SExpr | undefined, scope: Scope) => IR.Expr | undefined;
+    docOf: (doc: string | undefined) => {
+        doc?: never;
+    } | {
+        doc: string;
+    };
+    labelOf: (label: string | undefined) => {
+        label?: never;
+    } | {
+        label: string;
+    };
+    authoredTypes: IR.TypeAlias[];
+    byForm: (form: string) => ElaboratedDeclaration[];
+    payload: <T>(d: ElaboratedDeclaration) => T;
+    formOf: (d: ElaboratedDeclaration) => SExpr;
+    at: (d: ElaboratedDeclaration, e: SExpr) => IR.Span;
+    source: (d: ElaboratedDeclaration, e: SExpr) => string;
+};
+export type LoweringContext = ReturnType<typeof createLoweringContext>;