worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,68 @@
+import { documentHelp } from "../../../ir-checks/index.js";
+import { lowerEffective } from "./effective.js";
+import { lowerRecordSeal } from "./vaults.js";
+import { LowerError, option, items, mapPairs, symName } from "./syntax.js";
+export const lowerDocuments = (cx, evidence) => cx.byForm("document").map((d) => {
+    const form = cx.formOf(d), of = symName(option(form, "of")), from = option(form, "from"), edition = option(form, "edition"), template = option(form, "template");
+    const fail = (code, node, message) => {
+        throw new LowerError(code, message, cx.at(d, node ?? form), documentHelp);
+    };
+    if (!cx.byForm("component").some((c) => c.summary.name === of))
+        return fail("E_DOCUMENT_SOURCE", option(form, "of"), "Name an owning component.");
+    if (from?._tag !== "Vector" || !from.items.length)
+        return fail("E_DOCUMENT_SOURCE", from, "Choose a nonempty vector of owned evidence types.");
+    const sources = [];
+    for (const node of from.items) {
+        const name = symName(node);
+        if (!name || sources.includes(name) || !evidence.some((e) => e.name === name && e.of === of))
+            return fail("E_DOCUMENT_SOURCE", node, "Choose unique evidence owned by the document's component.");
+        sources.push(name);
+    }
+    if (edition?._tag !== "Str" || !edition.value.trim())
+        return fail("E_DOCUMENT_TEMPLATE", edition, "Use a fixed nonempty edition.");
+    const map = (node, allowed) => {
+        if (node?._tag !== "Map")
+            return fail("E_DOCUMENT_TEMPLATE", node, "Use a fixed template/field map.");
+        const pairs = mapPairs(node), keys = pairs.map(([k]) => symName(k));
+        if (new Set(keys).size !== keys.length || keys.some((k) => !k || !allowed.includes(k)))
+            return fail("E_DOCUMENT_TEMPLATE", node, "Use the declared template/field options once.");
+        return new Map(pairs.map(([k, v]) => [symName(k), v]));
+    };
+    const options = map(template, [":title", ":fields"]), title = options.get(":title"), fields = options.get(":fields");
+    if (title?._tag !== "Str" || !title.value.trim())
+        return fail("E_DOCUMENT_TEMPLATE", title ?? template, "Use a fixed nonempty document title.");
+    if (fields?._tag !== "Vector" || !fields.items.length)
+        return fail("E_DOCUMENT_TEMPLATE", fields ?? template, "Choose a nonempty ordered field vector.");
+    const mapped = fields.items.map((node) => {
+        const opts = map(node, [":label", ":from"]), label = opts.get(":label"), source = opts.get(":from");
+        if (label?._tag !== "Str" || !label.value.trim())
+            return fail("E_DOCUMENT_TEMPLATE", label ?? node, "Use a fixed nonempty field label.");
+        const parts = items(source), type = symName(parts[0]), field = symName(parts[1]);
+        if (source?._tag !== "Vector" || parts.length !== 2 || !type || !field)
+            return fail("E_DOCUMENT_SOURCE", source ?? node, "Use [Evidence field] for a document field.");
+        return { label: label.value, evidence: type, field, at: cx.at(d, parts[1]) };
+    });
+    const effective = lowerEffective(cx, d, form);
+    if (!effective)
+        return fail("E_DOCUMENT_TEMPLATE", form, "Pin an effective date window for the template edition.");
+    return {
+        name: d.summary.name,
+        ...lowerRecordSeal(cx, d),
+        ...cx.docOf(cx.payload(d).doc),
+        of: of,
+        ...(option(form, "resource")
+            ? {
+                resource: {
+                    name: symName(option(form, "resource")) ?? "",
+                    at: cx.at(d, option(form, "resource")),
+                },
+            }
+            : {}),
+        sources: sources,
+        edition: edition.value,
+        title: title.value,
+        fields: mapped,
+        effective,
+        at: cx.at(d, form),
+    };
+});

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

@@ -0,0 +1,5 @@
+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 lowerEffective: (context: LoweringContext, declaration: ElaboratedDeclaration, form: SExpr) => IR.Effective | undefined;

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

@@ -0,0 +1,26 @@
+import { isLocalDate } from "../../../ir-checks/index.js";
+import { LowerError, mapPairs, option, symName } from "./syntax.js";
+export const lowerEffective = (context, declaration, form) => {
+    const value = option(form, "effective");
+    if (!value)
+        return undefined;
+    const pairs = mapPairs(value), keys = pairs.map(([k]) => symName(k));
+    if (value._tag !== "Map" ||
+        !keys.length ||
+        keys.length > 2 ||
+        new Set(keys).size !== keys.length ||
+        keys.some((k) => k !== ":from" && k !== ":until"))
+        throw new LowerError("E_EFFECTIVE_SHAPE", "Effective dates require :from and/or :until.", context.at(declaration, value), 'Use :effective {:from "YYYY-MM-DD" :until "YYYY-MM-DD"}; either boundary may be omitted.');
+    const date = (syntax) => {
+        if (syntax._tag !== "Str" || !isLocalDate(syntax.value))
+            throw new LowerError("E_EFFECTIVE_DATE", "Effective boundaries are fixed local-date literals.", context.at(declaration, syntax), 'Use a real "YYYY-MM-DD" date in release metadata; put fact-dependent conditions in :applies-when.');
+        return syntax.value;
+    };
+    const fromSyntax = pairs.find(([k]) => symName(k) === ":from")?.[1];
+    const untilSyntax = pairs.find(([k]) => symName(k) === ":until")?.[1];
+    const from = fromSyntax ? date(fromSyntax) : undefined, until = untilSyntax ? date(untilSyntax) : undefined;
+    if (from && until && from >= until)
+        throw new LowerError("E_EFFECTIVE_ORDER", "The exclusive end must follow the start.", context.at(declaration, untilSyntax), "Choose :until after :from; the start is inclusive and the end exclusive.");
+    const at = context.at(declaration, value);
+    return from ? { from, ...(until ? { until } : {}), at } : { until: until, at };
+};

package/dist/_internal/forma/world/lowering/entities.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 lowerEntities: (context: LoweringContext) => IR.Entity[];

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

@@ -0,0 +1,43 @@
+import { lowerFileFields } from "./files.js";
+import { lowerSealedFields } from "./vaults.js";
+import {} from "./context.js";
+import { mapPairs, option, symName } from "./syntax.js";
+export const lowerEntities = (context) => {
+    const { byForm, entities, formOf, typeOf, docOf, at } = context;
+    return byForm("entity").map((d) => {
+        const e = entities.get(d.summary.name);
+        const form = formOf(d);
+        const attrsOf = (path) => {
+            const attrs = [];
+            let owner = d.summary.name;
+            for (const field of path) {
+                const entity = entities.get(owner);
+                attrs.push(`${entity.ns}/${field}`);
+                const ref = typeOf(entity.fields.find((f) => f.name === field)?.type);
+                owner = ref.t === "entity" ? ref.name : owner;
+            }
+            return attrs;
+        };
+        return {
+            name: d.summary.name,
+            ...docOf(e.doc),
+            ns: e.ns,
+            nsDeclared: e["ns-declared"],
+            ...(e.display ? { display: e.display } : {}),
+            fields: lowerSealedFields(context, d, lowerFileFields(context, d, e.fields.map((f) => ({ name: f.name, type: f.type, attr: `${e.ns}/${f.name}` })))),
+            implements: e.implements.map((b) => {
+                const path = b.path.split(".");
+                const bindings = mapPairs(option(form, "implements")).find(([k]) => symName(k) === b.role)?.[1];
+                const target = mapPairs(bindings).find(([k]) => symName(k) === `:${b.field}`)?.[1];
+                return {
+                    role: b.role,
+                    field: b.field,
+                    path,
+                    attrs: attrsOf(path),
+                    at: at(d, target ?? form),
+                };
+            }),
+            at: at(d, form),
+        };
+    });
+};

package/dist/_internal/forma/world/lowering/escalations.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 lowerEscalations: (context: LoweringContext, declaration: ElaboratedDeclaration, form: SExpr, scope: Scope) => IR.Escalation[];

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

@@ -0,0 +1,31 @@
+import { headOf, items, LowerError, option, symName } from "./syntax.js";
+export const lowerEscalations = (context, declaration, form, scope) => {
+    const ladder = option(form, "escalate");
+    if (!ladder)
+        return [];
+    const fail = (syntax) => {
+        throw new LowerError("E_ESCALATE_SHAPE", "Invalid escalation ladder.", context.at(declaration, syntax), "Use a literal vector of (after-due (days N) :notify who) or :reassign who steps.");
+    };
+    if (ladder._tag !== "Vector")
+        fail(ladder);
+    return items(ladder).map((step) => {
+        const parts = items(step), delay = parts[1], kind = symName(parts[2]);
+        if (headOf(step) !== "after-due" || parts.length !== 4)
+            fail(step);
+        if (kind !== ":notify" && kind !== ":reassign")
+            fail(parts[2]);
+        const count = items(delay)[1];
+        const afterDays = count?._tag === "Num" ? Number(count.value) : NaN;
+        if (headOf(delay) !== "days" ||
+            items(delay).length !== 2 ||
+            !Number.isSafeInteger(afterDays) ||
+            afterDays < 0)
+            throw new LowerError("E_ESCALATE_DELAY", "Escalation offsets are fixed nonnegative day counts.", context.at(declaration, delay), "Use (days N) with a nonnegative safe-integer literal; dynamic offsets and sub-day/year clocks are not supported.");
+        return {
+            afterDays,
+            kind: kind.slice(1),
+            who: context.lowerExpr(declaration, parts[3], scope),
+            at: context.at(declaration, step),
+        };
+    });
+};

package/dist/_internal/forma/world/lowering/evidence.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 lowerEvidence: (context: LoweringContext) => IR.Evidence[];

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

@@ -0,0 +1,75 @@
+import { auditPolicyValid, signatureHelp } from "../../../ir-checks/index.js";
+import { lowerFileFields } from "./files.js";
+import { lowerRecordSeal } from "./vaults.js";
+import {} from "./context.js";
+import { childNamed, headOf, isSym, items, option, symName, mapPairs, LowerError, VALUE, } from "./syntax.js";
+export const lowerEvidence = (context) => {
+    const { byForm, payload, formOf, fieldScope, docOf, labelOf, lowerExpr, at } = context;
+    return byForm("evidence").map((d) => {
+        const p = payload(d);
+        const form = formOf(d);
+        const scope = fieldScope(p.fields);
+        const expires = option(form, "expires");
+        const attestForms = items(form).filter((x) => headOf(x) === "attest");
+        const raw = attestForms.map((f) => option(f, "audit")).find(Boolean);
+        let audit;
+        if (raw) {
+            const pairs = mapPairs(raw);
+            const value = Object.fromEntries(pairs.map(([k, v]) => [symName(k)?.replace(/^:/, ""), v._tag === "Str" ? v.value : null]));
+            if (raw._tag !== "Map" ||
+                pairs.length !== 2 ||
+                pairs.some(([key]) => ![":consent", ":intent"].includes(symName(key) ?? "")) ||
+                !auditPolicyValid(value) ||
+                attestForms.length !== 1 ||
+                p.attest[0]?.covers !== "all" ||
+                !p.attest[0]?.method.trim())
+                throw new LowerError("E_ATTEST_AUDIT", "An audited attestation needs fixed consent, intent, method and complete coverage.", at(d, raw), signatureHelp);
+            audit = value;
+        }
+        return {
+            name: d.summary.name,
+            ...lowerRecordSeal(context, d),
+            ...(items(form).find((f) => headOf(f) === "amend")
+                ? { amend: { at: at(d, items(form).find((f) => headOf(f) === "amend")) } }
+                : {}),
+            ...docOf(p.doc),
+            of: p.of,
+            ...labelOf(p.label),
+            fields: lowerFileFields(context, d, p.fields),
+            // signed-on is the attestation date; a declared field of the same name shadows it.
+            ...(expires
+                ? { expires: lowerExpr(d, expires, new Map([["signed-on", VALUE], ...scope])) }
+                : {}),
+            rules: p.rules.map((r) => {
+                const rule = childNamed(form, "rule", r.name);
+                const requires = option(rule, "requires");
+                const oneOf = headOf(requires) === "one-of";
+                const when = option(rule, "when");
+                return {
+                    name: r.name,
+                    ...(when ? { when: lowerExpr(d, when, scope) } : {}),
+                    requires: {
+                        mode: oneOf ? "one-of" : "all",
+                        fields: (oneOf || headOf(requires) === "all-of"
+                            ? items(requires).slice(1)
+                            : isSym(requires)
+                                ? [requires]
+                                : items(requires)).map((x) => symName(x)),
+                    },
+                    at: at(d, rule),
+                };
+            }),
+            ...(p.attest[0]
+                ? {
+                    attest: {
+                        signer: p.attest[0].signer,
+                        covers: p.attest[0].covers,
+                        method: p.attest[0].method,
+                        ...(audit ? { audit } : {}),
+                    },
+                }
+                : {}),
+            at: at(d, form),
+        };
+    });
+};

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

@@ -0,0 +1,4 @@
+import type { ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type LoweringContext } from "./context.js";
+export declare const lowerFileFields: <F extends IR.Field>(context: LoweringContext, d: ElaboratedDeclaration, fields: readonly F[]) => F[];

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

@@ -0,0 +1,56 @@
+import { fileShape, fileMediaType, filePolicyHelp } from "../../../ir-checks/index.js";
+import {} from "./context.js";
+import { items, mapPairs, option, symName, LowerError } from "./syntax.js";
+export const lowerFileFields = (context, d, fields) => {
+    const form = context.formOf(d), raw = option(form, "files"), fail = (node, message) => {
+        throw new LowerError("E_FILE_POLICY", message, context.at(d, node), filePolicyHelp);
+    }, name = (node) => symName(node)?.replace(/^:/, "");
+    if (raw && raw._tag !== "Map")
+        return fail(raw, "File policies must be a fixed named map.");
+    const policies = new Map();
+    for (const [key, value] of mapPairs(raw)) {
+        const fieldName = name(key), field = fields.find((f) => f.name === fieldName);
+        if (!field ||
+            !fieldName ||
+            policies.has(fieldName) ||
+            fileShape(field.type, context.authoredTypes) !== "file")
+            return fail(key, "A file policy names one unique File-typed field.");
+        if (value._tag !== "Map")
+            return fail(value, "A file policy is a fixed :accept/:max-bytes map.");
+        const pairs = mapPairs(value), seen = new Set();
+        for (const [key] of pairs) {
+            const optionName = name(key);
+            if (!optionName || !["accept", "max-bytes"].includes(optionName) || seen.has(optionName))
+                return fail(key, "File policies allow unique :accept and :max-bytes only.");
+            seen.add(optionName);
+        }
+        const accept = pairs.find(([k]) => name(k) === "accept")?.[1], limit = pairs.find(([k]) => name(k) === "max-bytes")?.[1];
+        if (accept?._tag !== "Vector" || !accept.items.length)
+            return fail(accept ?? value, "Accepted media types must be a nonempty literal vector.");
+        const media = [];
+        for (const item of accept.items) {
+            if (item._tag !== "Str" || !fileMediaType(item.value))
+                return fail(item, "Use a fixed lowercase media type without a wildcard.");
+            media.push(item.value);
+        }
+        if (new Set(media).size !== media.length)
+            return fail(accept, "Accepted media types must be unique.");
+        if (limit?._tag !== "Num" ||
+            !Number.isSafeInteger(Number(limit.value)) ||
+            Number(limit.value) <= 0)
+            return fail(limit ?? value, "The file byte limit must be a positive fixed safe integer.");
+        policies.set(fieldName, {
+            accept: [...media].sort(),
+            maxBytes: Number(limit.value),
+            at: context.at(d, value),
+        });
+    }
+    const fieldMap = items(form).find((node) => node._tag === "Map" &&
+        fields.every((f) => mapPairs(node).some(([k, v]) => name(k) === f.name && v._tag !== "Map")));
+    return fields.map((field) => {
+        const shape = fileShape(field.type, context.authoredTypes), policy = policies.get(field.name), typeNode = mapPairs(fieldMap).find(([k]) => name(k) === field.name)?.[1] ?? form;
+        if (shape === "unsupported" || (shape === "file" && !policy))
+            return fail(typeNode, "Each single File field needs its own fixed upload policy.");
+        return policy ? { ...field, file: policy } : field;
+    });
+};

package/dist/_internal/forma/world/lowering/holds.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 lowerHolds: (context: LoweringContext, declaration: ElaboratedDeclaration, form: SExpr, scope: Scope) => IR.Hold[];

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

@@ -0,0 +1,35 @@
+import { children, items, LowerError, option, symName } from "./syntax.js";
+export const lowerHolds = (context, declaration, form, scope) => {
+    const names = new Set();
+    return children(form, "hold").map((hold) => {
+        const name = symName(items(hold)[1]);
+        if (names.has(name))
+            throw new LowerError("E_HOLD_NAME", "Duplicate hold name.", context.at(declaration, items(hold)[1]), "Use a unique name for each hold in this component.");
+        names.add(name);
+        const policy = option(hold, "pauses");
+        const help = "Use a literal nonempty vector of :dispatch, :remind and/or :escalate.";
+        const fail = (syntax) => {
+            throw new LowerError("E_HOLD_PAUSES", "Invalid hold pause policy.", context.at(declaration, syntax), help);
+        };
+        if (policy._tag !== "Vector" || !policy.items.length)
+            fail(policy);
+        const pauses = items(policy).map((syntax) => {
+            const value = symName(syntax);
+            if (value === ":due")
+                throw new LowerError("E_HOLD_PAUSES_DUE", "A hold cannot suspend a due-date clock.", context.at(declaration, syntax), "Cite the source permitting an extension in a :defer decision with an explicit :until date; holds never change due dates.");
+            if (value === ":dispatch" || value === ":remind" || value === ":escalate")
+                return value.slice(1);
+            return fail(syntax);
+        });
+        const label = option(hold, "label");
+        const unique = [...new Set(pauses)];
+        return {
+            name,
+            ...(label?._tag === "Str" ? { label: label.value } : {}),
+            while: context.lowerExpr(declaration, option(hold, "while"), scope),
+            pauses: [unique[0], ...unique.slice(1)],
+            ...context.citations(declaration, hold),
+            at: context.at(declaration, hold),
+        };
+    });
+};

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

@@ -0,0 +1,89 @@
+import { type ElaboratedDeclaration } from "@forma-language/forma/descriptor";
+import type { SourceFile } from "../compile.js";
+import type * as IR from "../../../world-ir/types.generated.js";
+export declare const lower: (files: readonly SourceFile[], declarations: readonly ElaboratedDeclaration[]) => {
+    entities: IR.Entity[];
+    accounts: IR.Account[];
+    types: IR.TypeAlias[];
+    roles: IR.Role[];
+    calendars: IR.Calendar[];
+    derives: IR.Derive[];
+    evidence: IR.Evidence[];
+    interactions: IR.Interaction[];
+    layouts: IR.Layout[];
+    connectors: IR.Connector[];
+    machines: IR.Machine[];
+    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;
+    }[];
+    bundles?: IR.Bundle[];
+    collects?: IR.Collect[];
+    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;
+    }[];
+    references?: IR.Source[];
+    notices?: IR.Notice[];
+    documents?: IR.Document[];
+    componentImports?: readonly [IR.ComponentImport, ...IR.ComponentImport[]];
+    componentContracts?: readonly [IR.ComponentContract, ...IR.ComponentContract[]];
+    vaults?: [IR.Vault, ...IR.Vault[]];
+    agents?: [IR.Agent, ...IR.Agent[]];
+    format: "worldvm/world-ir@1";
+    sources: {
+        id: string;
+        sha256: string;
+    }[];
+    libraries: IR.Library[];
+};

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

@@ -0,0 +1,115 @@
+import { lowerAgents } from "./agents.js";
+import { lowerNotices } from "./notices.js";
+import { lowerVaults } from "./vaults.js";
+import { lowerDocuments } from "./documents.js";
+import { lowerContracts } from "./contracts.js";
+import { lowerBundles } from "./bundles.js";
+import { reuseProblem } from "../../../ir-checks/index.js";
+import { LowerError } from "./syntax.js";
+import { lowerCollects } from "./collects.js";
+import {} from "@forma-language/forma/descriptor";
+import { sha256 } from "../digest.js";
+import { lowerAccounts } from "./accounts.js";
+import { lowerComponents } from "./components.js";
+import { lowerConnectors, lowerMachines } from "./connectors.js";
+import { createLoweringContext } from "./context.js";
+import { lowerDecisions } from "./decisions.js";
+import { lowerDerives } from "./derives.js";
+import { lowerEntities } from "./entities.js";
+import { lowerEvidence } from "./evidence.js";
+import { lowerInteractions, lowerLayouts } from "./interactions.js";
+import { lowerCalendars, lowerLibraries, lowerRoles } from "./library.js";
+import { lowerPrincipals } from "./principals.js";
+export const lower = (files, declarations) => {
+    const context = createLoweringContext(files, declarations);
+    const { references, authoredTypes } = context;
+    const roleIR = lowerRoles(context);
+    const entityIR = lowerEntities(context);
+    const calendarIR = lowerCalendars(context);
+    const deriveIR = lowerDerives(context);
+    const evidenceIR = lowerEvidence(context);
+    const documentIR = lowerDocuments(context, evidenceIR);
+    const noticeIR = lowerNotices(context, documentIR);
+    const evidenceByName = new Map(evidenceIR.map((e) => [e.name, e]));
+    const interactionIR = lowerInteractions(context, evidenceByName);
+    const layoutIR = lowerLayouts(context, interactionIR, evidenceByName);
+    const collectIR = lowerCollects(context, layoutIR);
+    const bundleIR = lowerBundles(context);
+    const connectorIR = lowerConnectors(context);
+    const machineIR = lowerMachines(context);
+    const rawComponents = lowerComponents(context);
+    const rawDecisions = lowerDecisions(context, rawComponents);
+    const { components: componentIR, decisions: decisionIR } = lowerPrincipals({
+        types: authoredTypes,
+        roles: roleIR,
+        entities: entityIR,
+        derives: deriveIR,
+        components: rawComponents,
+        decisions: rawDecisions,
+    }, rawComponents, rawDecisions);
+    const vaults = lowerVaults(context, {
+        types: authoredTypes,
+        roles: roleIR,
+        entities: entityIR,
+        components: componentIR,
+        derives: deriveIR,
+    });
+    const contractIR = lowerContracts(context, {
+        ...(vaults.length ? { vaults: vaults } : {}),
+        types: authoredTypes,
+        roles: roleIR,
+        components: componentIR,
+        evidence: evidenceIR,
+        interactions: interactionIR,
+        decisions: decisionIR,
+        connectors: connectorIR,
+    });
+    const agents = lowerAgents(context, componentIR);
+    const libraryContent = {
+        ...(agents.length ? { agents: agents } : {}),
+        ...(vaults.length ? { vaults: vaults } : {}),
+        ...contractIR,
+        ...(documentIR.length ? { documents: documentIR } : {}),
+        ...(noticeIR.length ? { notices: noticeIR } : {}),
+        ...(references.length ? { references } : {}),
+        ...(decisionIR.length ? { decisions: decisionIR } : {}),
+        ...(collectIR.length ? { collects: collectIR } : {}),
+        ...(bundleIR.length ? { bundles: bundleIR } : {}),
+        types: authoredTypes,
+        roles: roleIR,
+        calendars: calendarIR,
+        derives: deriveIR,
+        evidence: evidenceIR,
+        interactions: interactionIR,
+        layouts: layoutIR,
+        connectors: connectorIR,
+        machines: machineIR,
+        components: componentIR,
+    };
+    const reuseError = reuseProblem({
+        ...libraryContent,
+        format: "worldvm/world-ir@1",
+        sources: [],
+        libraries: [],
+        entities: entityIR,
+        accounts: [],
+    });
+    if (reuseError)
+        throw new LowerError(reuseError.code, reuseError.message, reuseError.at, reuseError.help);
+    const libraryIR = lowerLibraries(context, libraryContent);
+    const accountIR = lowerAccounts(context, entityIR, componentIR, {
+        types: authoredTypes,
+        roles: roleIR,
+        entities: entityIR,
+        components: componentIR,
+        derives: deriveIR,
+    });
+    return {
+        format: "worldvm/world-ir@1",
+        sources: files.map((f) => ({ id: f.id, sha256: sha256(f.text) })),
+        libraries: libraryIR,
+        ...libraryContent,
+        entities: entityIR,
+        accounts: accountIR,
+    };
+};

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

@@ -0,0 +1,7 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { SourceFile } from "../compile.js";
+import { type LoweringContext } from "./context.js";
+/** Report the actual item before native child validation widens its span to the layout. */
+export declare const layoutSourceDiagnostics: (files: readonly SourceFile[]) => IR.Diagnostic[];
+export declare const lowerInteractions: (context: LoweringContext, evidenceByName: ReadonlyMap<string, IR.Evidence>) => IR.Interaction[];
+export declare const lowerLayouts: (context: LoweringContext, interactionIR: readonly IR.Interaction[], evidenceByName: ReadonlyMap<string, IR.Evidence>) => IR.Layout[];