worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,242 @@
+import { advanceTargets } from "../../ir-checks/index.js";
+const walk = (value, f) => {
+    if (!value || typeof value !== "object")
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((v) => walk(v, f));
+        return;
+    }
+    const object = value;
+    f(object);
+    for (const [key, child] of Object.entries(object))
+        if (key !== "at")
+            walk(child, f);
+};
+const references = (set) => [...set].sort().map((key) => {
+    const split = key.indexOf("\0");
+    return { kind: key.slice(0, split), name: key.slice(split + 1) };
+});
+export const definitionReferences = (ir) => {
+    const components = new Map(ir.components.map((c) => [c.name, c]));
+    const rows = new Map();
+    for (const c of ir.components) {
+        for (const r of c.requirements)
+            rows.set(`${c.name}/${r.name}`, {
+                component: c.name,
+                name: r.name,
+                kind: "requirement",
+                refs: new Set(),
+            });
+        for (const r of c.invariants)
+            rows.set(`${c.name}/invariant:${r.name}`, {
+                component: c.name,
+                name: r.name,
+                kind: "invariant",
+                refs: new Set(),
+            });
+        if (c.retention)
+            rows.set(`${c.name}/retention`, {
+                component: c.name,
+                name: "retention",
+                kind: "retention",
+                refs: new Set(),
+            });
+    }
+    const mark = (component, name, ref, seen = new Set()) => {
+        const key = `${component}/${name}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        const row = rows.get(key);
+        if (row) {
+            row.refs.add(ref);
+            return;
+        }
+        const c = components.get(component), output = c?.outputs.find((o) => o.name === name);
+        for (const path of output?.paths ?? []) {
+            let owner = c;
+            for (const segment of path.segments.slice(0, -1))
+                owner = components.get(owner?.slots.find((s) => s.name === segment)?.component ?? "");
+            if (owner && path.segments.length)
+                mark(owner.name, path.segments.at(-1), ref, seen);
+        }
+    };
+    const evidence = (component, name, ref) => {
+        for (const r of components.get(component)?.requirements ?? [])
+            walk(r.satisfiedBy, (e) => {
+                if (e.k === "ref" && e.kind === "evidence" && e.name === name)
+                    mark(component, r.name, ref);
+            });
+    };
+    const action = (component, name, ref) => {
+        if (name.startsWith("accept-reuse:"))
+            mark(component, name.slice(13), ref);
+        if (name.startsWith("accept-prior:")) {
+            const requirement = name.slice(13);
+            mark(component, requirement, ref);
+            const from = components.get(component)?.requirements.find((r) => r.name === requirement)
+                ?.accepts?.from;
+            if (from)
+                mark(component, from, ref);
+        }
+        const a = components.get(component)?.actions.find((a) => a.name === name);
+        if (!a)
+            return;
+        for (const target of advanceTargets(a))
+            mark(component, target, ref);
+        walk(a.needs, (e) => {
+            if (e.k === "ref" && e.kind === "evidence" && typeof e.name === "string")
+                evidence(component, e.name, ref);
+        });
+    };
+    const predicate = (expr, ref) => walk(expr, (e) => {
+        const target = e.target;
+        if (e.k === "status" && target && typeof e.name === "string")
+            mark(target.component, e.name, ref);
+        if (e.k === "attested" && target && typeof e.evidence === "string")
+            evidence(target.component, e.evidence, ref);
+    });
+    for (const p of ir.properties ?? [])
+        predicate(p.predicate, `property\0${p.name}`);
+    for (const s of ir.scenarios ?? []) {
+        const ref = `scenario\0${s.name}`;
+        for (const record of s.records ?? [])
+            if (record.kind === "evidence")
+                mark(record.target.component, record.requirement, ref);
+        for (const step of s.steps) {
+            for (const command of step.commands ?? []) {
+                if (command.kind === "decide") {
+                    const decision = ir.decisions?.find((d) => d.name === command.decision && d.of === command.target.component);
+                    if (decision)
+                        mark(decision.of, decision.applies, ref);
+                }
+                else if (command.kind === "perform")
+                    action(command.target.component, command.action, ref);
+                else if (command.kind === "accept")
+                    action(command.target.component, `accept-prior:${command.requirement}`, ref);
+                else if (command.kind === "evidence")
+                    mark(command.target.component, command.requirement, ref);
+                else if (command.kind === "signal") {
+                    for (const r of components.get(command.target.component)?.requirements ?? [])
+                        walk(r.satisfiedBy, (e) => {
+                            if (e.k === "var" && e.name === command.machine)
+                                mark(command.target.component, r.name, ref);
+                        });
+                }
+                else if (command.kind === "resource") {
+                    const c = components.get(command.target.component), r = c?.resources?.find((r) => r.name === command.name);
+                    if (r && command.phase === "acquire")
+                        for (const a of c.actions)
+                            if (a.via.kind === "connector" &&
+                                a.via.connector === r.acquire.connector &&
+                                a.via.capability === r.acquire.capability)
+                                action(c.name, a.name, ref);
+                }
+                else {
+                    for (const row of rows.values())
+                        if (row.kind === "invariant" &&
+                            components
+                                .get(row.component)
+                                ?.invariants.some((i) => i.name === row.name && i.forbids.action === (command.commandKind ?? "set")))
+                            row.refs.add(ref);
+                }
+            }
+            for (const expect of step.expects) {
+                if (expect.kind === "property") {
+                    const p = ir.properties?.find((p) => p.name === expect.name && p.world === s.world);
+                    if (p)
+                        predicate(p.predicate, ref);
+                }
+                else if (expect.kind !== "rejected") {
+                    if (expect.kind === "work")
+                        action(expect.target.component, expect.name, ref);
+                    else
+                        mark(expect.target.component, expect.name, ref);
+                }
+            }
+        }
+    }
+    return new Map([...rows].map(([key, row]) => [key, references(row.refs)]));
+};
+/** Advisory reference analysis deliberately over-approximates reads; it proves no reachability. */
+export const requirementDiagnostics = (ir) => {
+    const refs = definitionReferences(ir), consumed = new Set();
+    const components = new Map(ir.components.map((c) => [c.name, c]));
+    const refType = (type) => {
+        if (!Array.isArray(type))
+            return [];
+        if (type[0] === "Option")
+            return refType(type[1]);
+        return type[0] === "Id" && typeof type[1] === "string" && components.has(type[1])
+            ? [type[1]]
+            : [];
+    };
+    const owners = (e, c) => {
+        if (e.k === "var") {
+            if (e.name === "self")
+                return [c.name];
+            const slot = c.slots.find((s) => s.name === e.name);
+            return slot ? [slot.component] : refType(c.inputs.find((i) => i.name === e.name)?.type);
+        }
+        if (e.k === "if")
+            return [...new Set([...owners(e.then, c), ...owners(e.else, c)])];
+        if (e.k === "inst")
+            return owners(e.of, c).flatMap((owner) => {
+                const component = components.get(owner);
+                const slot = component.slots.find((s) => s.name === e.field);
+                return slot
+                    ? [slot.component]
+                    : refType(component.inputs.find((i) => i.name === e.field)?.type);
+            });
+        return [];
+    };
+    for (const c of ir.components) {
+        for (const output of c.outputs)
+            for (const path of output.paths) {
+                let owner = c;
+                for (const segment of path.segments.slice(0, -1))
+                    owner = components.get(owner?.slots.find((s) => s.name === segment)?.component ?? "");
+                if (owner && path.segments.length)
+                    consumed.add(`${owner.name}/${path.segments.at(-1)}`);
+            }
+        walk(c, (e) => {
+            if (e.k === "var" && c.requirements.some((r) => r.name === e.name))
+                consumed.add(`${c.name}/${String(e.name)}`);
+            if (e.k !== "inst" || typeof e.field !== "string")
+                return;
+            const targets = owners(e.of, c);
+            // An indirect owner that cannot be resolved still conservatively consumes that name.
+            for (const owner of targets.length ? targets : ir.components.map((c) => c.name))
+                consumed.add(`${owner}/${e.field}`);
+        });
+    }
+    // Derive parameters can hide the owning component; treating every matching name as
+    // consumed avoids false warnings without enumerating possible runtime occurrences.
+    walk(ir.derives, (e) => {
+        if (e.k === "inst" && typeof e.field === "string")
+            for (const c of ir.components)
+                consumed.add(`${c.name}/${e.field}`);
+    });
+    const diagnostics = [];
+    for (const c of ir.components)
+        for (const r of c.requirements) {
+            const key = `${c.name}/${r.name}`;
+            if (!(refs.get(key) ?? []).some((ref) => ref.kind === "scenario"))
+                diagnostics.push({
+                    code: "W_NO_SCENARIO",
+                    severity: "warning",
+                    at: r.at,
+                    message: `${key} has no authored scenario reference.`,
+                    help: `Add a scenario that observes it, for example (at "<date>" (expect (status (${c.name} <subject>) ${String(r.name)}) :Open)), or one that expects an output containing it or records work or evidence advancing it. Run worldvm coverage to see executed branches. Advisory: check still passes.`,
+                });
+            if (!consumed.has(key))
+                diagnostics.push({
+                    code: "W_UNREACHABLE_REQUIREMENT",
+                    severity: "warning",
+                    at: r.at,
+                    message: `${key} has no status consumer.`,
+                    help: `Nothing reads this requirement's status, so no output or parent reports it. Add it to an output, for example (output done (all-of ${String(r.name)} …)), or read it with (satisfied? <component>.${String(r.name)}) from another component; remove it if unintended. Advisory: this is not a reachability proof.`,
+                });
+        }
+    return diagnostics;
+};

package/dist/_internal/forma/world/digest.d.ts

@@ -0,0 +1 @@
+export { sha256, canonicalJson, contentDigest } from "../../ir-checks/index.js";

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

@@ -0,0 +1 @@
+export { sha256, canonicalJson, contentDigest } from "../../ir-checks/index.js";

package/dist/_internal/forma/world/documentation.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../world-ir/types.generated.js";
+/** These named declarations are published contracts; private children keep their grammar. */
+export declare const documentationDiagnostics: (ir: IR.WorldIR) => readonly IR.Diagnostic[];

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

@@ -0,0 +1,38 @@
+/** These named declarations are published contracts; private children keep their grammar. */
+export const documentationDiagnostics = (ir) => [
+    ...ir.libraries,
+    ...ir.roles,
+    ...ir.entities,
+    ...ir.calendars,
+    ...ir.derives,
+    ...ir.evidence,
+    ...(ir.decisions ?? []),
+    ...ir.interactions,
+    ...(ir.collects ?? []),
+    ...(ir.bundles ?? []),
+    ...(ir.documents ?? []),
+    ...(ir.notices ?? []),
+    ...(ir.vaults ?? []),
+    ...(ir.agents ?? []),
+    ...ir.layouts,
+    ...ir.connectors,
+    ...ir.machines,
+    ...(ir.componentContracts ?? []),
+    ...(ir.componentImports ?? []),
+    ...ir.components,
+    ...ir.accounts,
+    ...ir.accounts.flatMap((a) => a.policies ?? []),
+    ...(ir.references ?? []),
+    ...(ir.scenarios ?? []),
+    ...(ir.properties ?? []),
+].flatMap((declaration) => declaration.doc?.trim()
+    ? []
+    : [
+        {
+            code: "E_MISSING_DOC",
+            severity: "error",
+            message: `Published declaration ${declaration.name} needs a nonempty docstring.`,
+            at: declaration.at,
+            help: "Add a nonempty docstring immediately after the declaration name. Describe its public contract; the first sentence is its summary.",
+        },
+    ]);

package/dist/_internal/forma/world/homes.d.ts

@@ -0,0 +1,4 @@
+import type * as IR from "../../world-ir/types.generated.js";
+export declare const inputHomeOf: (component: IR.Component) => IR.InputHome;
+/** Compare symbolic identities, never assume two references of the same type are equal. */
+export declare const homeDiagnostics: (ir: IR.WorldIR) => readonly IR.Diagnostic[];

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

@@ -0,0 +1,202 @@
+// Lowering publishes input homes; occurrence/missing variants belong to legacy wire data.
+export const inputHomeOf = (component) => {
+    if (component.home?.kind !== "input")
+        throw new Error(`Expected a checked input home for ${component.name}`);
+    return component.home;
+};
+/** Compare symbolic identities, never assume two references of the same type are equal. */
+export const homeDiagnostics = (ir) => {
+    const components = new Map(ir.components.map((c) => [c.name, c]));
+    const derives = new Map(ir.derives.map((d) => [d.name, d]));
+    const diagnostics = [];
+    const reported = new Set();
+    const reference = (type) => {
+        if (!Array.isArray(type))
+            return undefined;
+        if (type[0] === "Option")
+            return reference(type[1]);
+        return type[0] === "Id" && typeof type[1] === "string" ? type[1] : undefined;
+    };
+    const componentOf = (v) => components.get(reference(v.type) ?? "");
+    const instance = (c, inputs) => ({
+        identity: JSON.stringify([c.name, c.key.map((k) => inputs.get(k)?.identity)]),
+        type: ["Id", c.name],
+        inputs,
+    });
+    const scopeOf = (v) => new Map([
+        ...componentOf(v).inputs.map((f) => [f.name, field(v, f.name)]),
+        ["self", v],
+        ["attached", field(v, "attached")],
+    ]);
+    const field = (v, name) => {
+        const bound = v.inputs?.get(name);
+        if (bound)
+            return bound;
+        const c = componentOf(v);
+        const slot = c?.slots.find((s) => s.name === name);
+        if (slot)
+            return instance(components.get(slot.component), new Map(slot.bind.map((b) => [b.input, value(b.expr, scopeOf(v))])));
+        const owner = reference(v.type);
+        const fields = c?.inputs ??
+            ir.roles.find((r) => r.name === owner)?.fields ??
+            ir.entities.find((e) => e.name === owner)?.fields;
+        return {
+            identity: JSON.stringify([v.identity, name]),
+            type: name === "attached" && c
+                ? ["List", ["Id", ir.libraries[0]?.subject ?? ""]]
+                : fields?.find((f) => f.name === name)?.type,
+        };
+    };
+    const home = (v) => {
+        const h = inputHomeOf(componentOf(v));
+        return h.path.reduce(field, v).identity;
+    };
+    const unknown = (e) => ({
+        identity: JSON.stringify([e.at.src, e.at.from, e.at.to]),
+        type: undefined,
+    });
+    const argumentsOf = (d, args, scope, active) => new Map(d.params.map((p, i) => [
+        p.name,
+        args[i]
+            ? value(args[i], scope, active)
+            : {
+                identity: `missing:${p.name}`,
+                type: p.type,
+            },
+    ]));
+    const value = (e, scope, active = new Set()) => {
+        switch (e.k) {
+            case "var":
+                return scope.get(e.name) ?? unknown(e);
+            case "inst":
+            case "read":
+                return field(value(e.of, scope, active), e.field);
+            case "attr":
+                return field(value(e.of, scope, active), e.attr.split("/").at(-1));
+            case "lit":
+            case "kw":
+                return { identity: JSON.stringify([e.k, e.v]), type: undefined };
+            case "if": {
+                const a = value(e.then, scope, active), b = value(e.else, scope, active);
+                return a.identity === b.identity ? a : { ...unknown(e), type: a.type };
+            }
+            case "call": {
+                const d = derives.get(e.fn);
+                if (d && !active.has(d.name))
+                    return value(d.body, argumentsOf(d, e.args, scope, active), new Set([...active, d.name]));
+                if (e.fn === "filter" || e.fn === "spells")
+                    return value(e.args[e.fn === "filter" ? 1 : 0], scope, active);
+                return unknown(e);
+            }
+            case "list":
+                return {
+                    ...unknown(e),
+                    type: ["List", e.items[0] ? (value(e.items[0], scope, active).type ?? "Any") : "Any"],
+                };
+            default:
+                return unknown(e);
+        }
+    };
+    for (const c of ir.components) {
+        const inputs = new Map(c.inputs.map((f) => [f.name, { identity: f.name, type: f.type }]));
+        const self = instance(c, inputs);
+        const scope = scopeOf(self);
+        const warn = (at, label, published) => {
+            const key = JSON.stringify([c.name, at.src, at.from, at.to]);
+            if (reported.has(key))
+                return;
+            reported.add(key);
+            diagnostics.push({
+                code: "W_CROSS_HOME_READ",
+                severity: "warning",
+                at,
+                message: `${c.name} reads ${label} through a home not proven equal to its own.`,
+                help: published
+                    ? "Expect eventual consistency here, or bind the components to the same home."
+                    : "Publish an output on the other component and read it with eventual consistency, or bind it to the same home.",
+            });
+        };
+        const walk = (e, env, active = new Set()) => {
+            switch (e.k) {
+                case "inst": {
+                    const owner = value(e.of, env);
+                    const target = componentOf(owner);
+                    if (target &&
+                        !target.inputs.some((f) => f.name === e.field) &&
+                        home(owner) !== home(self))
+                        warn(e.at, `${target.name}.${e.field}`, false);
+                    walk(e.of, env, active);
+                    break;
+                }
+                case "read":
+                case "attr":
+                    walk(e.of, env, active);
+                    break;
+                case "if":
+                    walk(e.test, env, active);
+                    walk(e.then, env, active);
+                    walk(e.else, env, active);
+                    break;
+                case "list":
+                    e.items.forEach((x) => walk(x, env, active));
+                    break;
+                case "fn": {
+                    const inner = new Map(env);
+                    e.params.forEach((p) => inner.set(p, { ...unknown(e), identity: `${unknown(e).identity}:${p}` }));
+                    walk(e.body, inner, active);
+                    break;
+                }
+                case "call": {
+                    for (const [i, arg] of e.args.entries()) {
+                        if (i === 0 && arg.k === "fn" && (e.fn === "map" || e.fn === "filter")) {
+                            const list = value(e.args[1], env);
+                            const inner = new Map(env);
+                            arg.params.forEach((p) => inner.set(p, {
+                                identity: `${list.identity}:element`,
+                                type: Array.isArray(list.type) && list.type[0] === "List" ? list.type[1] : undefined,
+                            }));
+                            walk(arg.body, inner, active);
+                        }
+                        else
+                            walk(arg, env, active);
+                    }
+                    const d = derives.get(e.fn);
+                    if (d && !active.has(d.name))
+                        walk(d.body, argumentsOf(d, e.args, env, active), new Set([...active, d.name]));
+                    break;
+                }
+            }
+        };
+        // Component expressions occur in requirements, actions, bindings, invariants and retention.
+        const visit = (node) => {
+            if (!node || typeof node !== "object")
+                return;
+            if ("k" in node)
+                walk(node, scope);
+            else
+                Object.values(node).forEach(visit);
+        };
+        visit(c);
+        for (const interaction of ir.interactions)
+            if (ir.evidence.find((e) => e.name === interaction.produces)?.of === c.name)
+                visit(interaction);
+        for (const output of c.outputs)
+            for (const path of output.paths) {
+                let owner = self;
+                let crossing = false;
+                let published = false;
+                for (const segment of path.segments) {
+                    const target = componentOf(owner);
+                    if (target.slots.some((s) => s.name === segment)) {
+                        owner = field(owner, segment);
+                        crossing ||= home(owner) !== home(self);
+                    }
+                    else
+                        published = target.outputs.some((o) => o.name === segment);
+                }
+                if (crossing)
+                    warn(path.at, path.segments.join("."), published);
+            }
+    }
+    return diagnostics;
+};

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

@@ -0,0 +1,6 @@
+export { compileWorld, KERNEL_FUNCTIONS, type CompileResult, type SourceFile } from "./compile.js";
+export { canonicalJson, contentDigest, sha256 } from "./digest.js";
+export type * from "../../world-ir/types.generated.js";
+export { CHILD_FORMS, suggestForm, TOP_LEVEL_FORMS } from "./authoring-help.js";
+export { definitionReferences, type DefinitionReference } from "./coverage.js";
+export { DIAGNOSTIC_RENAMES, diagnosticCode, coreDiagnostics, OLD_OPERATORS } from "./surface.js";

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

@@ -0,0 +1,5 @@
+export { compileWorld, KERNEL_FUNCTIONS } from "./compile.js";
+export { canonicalJson, contentDigest, sha256 } from "./digest.js";
+export { CHILD_FORMS, suggestForm, TOP_LEVEL_FORMS } from "./authoring-help.js";
+export { definitionReferences } from "./coverage.js";
+export { DIAGNOSTIC_RENAMES, diagnosticCode, coreDiagnostics, OLD_OPERATORS } from "./surface.js";

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

@@ -0,0 +1,4 @@
+import type { PrincipalIR } from "../../../ir-checks/index.js";
+import type * as IR from "../../../world-ir/types.generated.js";
+import { type LoweringContext } from "./context.js";
+export declare const lowerAccounts: (context: LoweringContext, entityIR: readonly IR.Entity[], components: readonly IR.Component[], principals: PrincipalIR) => IR.Account[];

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

@@ -0,0 +1,36 @@
+import { lowerPolicies } from "./policies.js";
+import { checkAccountParams } from "./param-bounds.js";
+import { contentDigest } from "../digest.js";
+import {} from "./context.js";
+import { mapPairs, option, symName, VALUE } from "./syntax.js";
+export const lowerAccounts = (context, entityIR, components, principals) => {
+    const { byForm, payload, formOf, docOf, lowerExpr, at } = context;
+    return byForm("account").map((d) => {
+        const p = payload(d);
+        const form = formOf(d);
+        checkAccountParams(context, d, form, components);
+        const policies = lowerPolicies(context, d, form, components, principals);
+        const packaged = entityIR.filter((e) => e.ns.split(".")[0] === p.package);
+        return {
+            name: d.summary.name,
+            ...docOf(p.doc),
+            requires: p.requires,
+            package: {
+                name: p.package,
+                ...(p.version ? { version: p.version } : {}),
+                digest: contentDigest(packaged),
+            },
+            params: mapPairs(option(form, "params")).map(([k, v]) => ({
+                name: symName(k).replace(/^:/, ""),
+                value: lowerExpr(d, v, new Map([
+                    ["today", VALUE],
+                    ["now", VALUE],
+                ])),
+            })),
+            ...(policies.length ? { policies: [policies[0], ...policies.slice(1)] } : {}),
+            upgrade: p.upgrade,
+            forEach: p["for-each"].map((f) => ({ role: f.role, component: f.component })),
+            at: at(d, form),
+        };
+    });
+};

package/dist/_internal/forma/world/lowering/action-policy.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 lowerActionPolicy: (context: LoweringContext, d: ElaboratedDeclaration, form: SExpr) => Pick<IR.Action, "dispatch" | "onIneligible">;

package/dist/_internal/forma/world/lowering/action-policy.js

@@ -0,0 +1,16 @@
+import { LowerError, option, symName } from "./syntax.js";
+export const lowerActionPolicy = (context, d, form) => {
+    const mode = (key, values, code) => {
+        const syntax = option(form, key);
+        if (!syntax)
+            return undefined;
+        const literal = symName(syntax);
+        const value = literal?.startsWith(":") ? literal.slice(1) : undefined;
+        if (!values.includes(value))
+            throw new LowerError(code, `Unsupported :${key} policy.`, context.at(d, syntax), `Choose a literal keyword: ${values.map((v) => ":" + v).join(", ")}.`);
+        return value;
+    };
+    const dispatch = mode("dispatch", ["auto", "claim", "manual"], "E_DISPATCH");
+    const onIneligible = mode("on-ineligible", ["withdraw", "keep", "review"], "E_ON_INELIGIBLE");
+    return { ...(dispatch ? { dispatch } : {}), ...(onIneligible ? { onIneligible } : {}) };
+};

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

@@ -0,0 +1,6 @@
+import type * as IR from "../../../world-ir/types.generated.js";
+import type { SourceFile } from "../compile.js";
+import type { LoweringContext } from "./context.js";
+/** Closed read syntax gets actionable spans before generic descriptor validation. */
+export declare const agentSourceDiagnostics: (files: readonly SourceFile[]) => IR.Diagnostic[];
+export declare const lowerAgents: (context: LoweringContext, components: readonly IR.Component[]) => IR.Agent[];