worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/world-ir/schema.generated.js

@@ -0,0 +1,1127 @@
+// Generated from packages/world-ir/ir.lisp. Run pnpm --filter @worldvm/forma generate-ir.
+import { Schema } from "effect";
+export const Span = Schema.Struct({
+    src: Schema.String,
+    from: Schema.Number,
+    to: Schema.Number,
+    line: Schema.Number,
+    col: Schema.Number,
+});
+export const TypeRef = Schema.Union([
+    Schema.String,
+    Schema.Array(Schema.suspend(() => TypeRef)),
+]);
+export const Expr = Schema.Union([
+    Schema.Struct({
+        k: Schema.Literal("lit"),
+        v: Schema.Union([Schema.Null, Schema.Union([Schema.String, Schema.Number, Schema.Boolean])]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("kw"),
+        v: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("var"),
+        name: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("ref"),
+        kind: Schema.Union([
+            Schema.Literal("evidence"),
+            Schema.Literal("calendar"),
+            Schema.Literal("decision"),
+            Schema.Literal("notice"),
+        ]),
+        name: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("read"),
+        role: Schema.String,
+        field: Schema.String,
+        of: Schema.suspend(() => Expr),
+        meta: Schema.Struct({ path: Schema.String }),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("attr"),
+        attr: Schema.String,
+        of: Schema.suspend(() => Expr),
+        meta: Schema.Struct({ path: Schema.String, via: Schema.optionalKey(Schema.String) }),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("inst"),
+        field: Schema.String,
+        of: Schema.suspend(() => Expr),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("call"),
+        fn: Schema.String,
+        args: Schema.Array(Schema.suspend(() => Expr)),
+        derive: Schema.optionalKey(Schema.Literal(true)),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("if"),
+        test: Schema.suspend(() => Expr),
+        then: Schema.suspend(() => Expr),
+        else: Schema.suspend(() => Expr),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("fn"),
+        params: Schema.Array(Schema.String),
+        body: Schema.suspend(() => Expr),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("list"),
+        items: Schema.Array(Schema.suspend(() => Expr)),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const FilePolicy = Schema.Struct({
+    accept: Schema.NonEmptyArray(Schema.String),
+    maxBytes: Schema.Int,
+    at: Schema.suspend(() => Span),
+});
+export const Seal = Schema.Struct({
+    vault: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const Field = Schema.Struct({
+    name: Schema.String,
+    type: Schema.suspend(() => TypeRef),
+    file: Schema.optionalKey(Schema.suspend(() => FilePolicy)),
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+});
+export const Source = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    kind: Schema.Union([
+        Schema.Literal("law"),
+        Schema.Literal("regulation"),
+        Schema.Literal("guidance"),
+        Schema.Literal("framework"),
+        Schema.Literal("contract"),
+        Schema.Literal("policy"),
+    ]),
+    jurisdiction: Schema.optionalKey(Schema.String),
+    url: Schema.String,
+    asOf: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const Citation = Schema.Struct({
+    source: Schema.String,
+    clause: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const SensitiveClass = Schema.Union([
+    Schema.Literal("pii"),
+    Schema.Literal("financial"),
+    Schema.Literal("health"),
+    Schema.Literal("immigration"),
+]);
+export const AgentReadGrant = Schema.Struct({
+    class: Schema.suspend(() => SensitiveClass),
+    vault: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const Agent = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    of: Schema.String,
+    reads: Schema.NonEmptyArray(Schema.suspend(() => Expr)),
+    mayRead: Schema.Array(Schema.suspend(() => AgentReadGrant)),
+    at: Schema.suspend(() => Span),
+});
+export const VaultKey = Schema.Struct({
+    kind: Schema.Union([Schema.Literal("occurrence"), Schema.Literal("subject")]),
+    target: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const VaultErasure = Schema.Struct({
+    kind: Schema.Union([Schema.Literal("held-until-retained"), Schema.Literal("on-request")]),
+    at: Schema.suspend(() => Span),
+});
+export const VaultDisposal = Schema.Struct({
+    name: Schema.String,
+    by: Schema.suspend(() => Expr),
+    byKind: Schema.Union([Schema.Literal("individual"), Schema.Literal("group")]),
+    approvals: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(9007199254740991)),
+    at: Schema.suspend(() => Span),
+});
+export const Vault = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    key: Schema.suspend(() => VaultKey),
+    holds: Schema.NonEmptyArray(Schema.suspend(() => SensitiveClass)),
+    retain: Schema.suspend(() => Expr),
+    cites: Schema.NonEmptyArray(Schema.suspend(() => Citation)),
+    erasure: Schema.suspend(() => VaultErasure),
+    dispose: Schema.suspend(() => VaultDisposal),
+    at: Schema.suspend(() => Span),
+});
+export const Library = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    version: Schema.String,
+    subject: Schema.String,
+    digest: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const TypeAlias = Schema.Struct({
+    name: Schema.String,
+    type: Schema.suspend(() => TypeRef),
+    at: Schema.suspend(() => Span),
+});
+export const Role = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    fields: Schema.Array(Schema.suspend(() => Field)),
+    at: Schema.suspend(() => Span),
+});
+export const EntityField = Schema.Struct({
+    name: Schema.String,
+    type: Schema.suspend(() => TypeRef),
+    attr: Schema.String,
+    file: Schema.optionalKey(Schema.suspend(() => FilePolicy)),
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+});
+export const Binding = Schema.Struct({
+    role: Schema.String,
+    field: Schema.String,
+    path: Schema.Array(Schema.String),
+    attrs: Schema.Array(Schema.String),
+    at: Schema.suspend(() => Span),
+});
+export const Entity = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    ns: Schema.String,
+    nsDeclared: Schema.Boolean,
+    display: Schema.optionalKey(Schema.String),
+    fields: Schema.Array(Schema.suspend(() => EntityField)),
+    implements: Schema.Array(Schema.suspend(() => Binding)),
+    at: Schema.suspend(() => Span),
+});
+export const Holiday = Schema.Struct({
+    name: Schema.String,
+    label: Schema.String,
+    month: Schema.Number,
+    day: Schema.optionalKey(Schema.Number),
+    weekday: Schema.optionalKey(Schema.String),
+    nth: Schema.optionalKey(Schema.Number),
+    observed: Schema.Boolean,
+});
+export const Calendar = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    version: Schema.String,
+    weekend: Schema.Array(Schema.String),
+    holidays: Schema.Array(Schema.suspend(() => Holiday)),
+    at: Schema.suspend(() => Span),
+});
+export const Derive = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    params: Schema.Array(Schema.suspend(() => Field)),
+    returns: Schema.suspend(() => TypeRef),
+    body: Schema.suspend(() => Expr),
+    at: Schema.suspend(() => Span),
+});
+export const Rule = Schema.Struct({
+    name: Schema.String,
+    when: Schema.optionalKey(Schema.suspend(() => Expr)),
+    requires: Schema.Struct({
+        mode: Schema.Union([Schema.Literal("all"), Schema.Literal("one-of")]),
+        fields: Schema.Array(Schema.String),
+    }),
+    at: Schema.suspend(() => Span),
+});
+export const AmendmentPolicy = Schema.Struct({
+    at: Schema.suspend(() => Span),
+});
+export const AmendmentInput = Schema.Struct({
+    previous: Schema.String,
+    reason: Schema.String,
+});
+export const SignaturePolicy = Schema.Struct({
+    consent: Schema.String,
+    intent: Schema.String,
+});
+export const SignatureInput = Schema.Struct({
+    consent: Schema.Boolean,
+    intent: Schema.Boolean,
+    method: Schema.String,
+    device: Schema.String,
+});
+export const Evidence = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    of: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    fields: Schema.Array(Schema.suspend(() => Field)),
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+    expires: Schema.optionalKey(Schema.suspend(() => Expr)),
+    rules: Schema.Array(Schema.suspend(() => Rule)),
+    amend: Schema.optionalKey(Schema.suspend(() => AmendmentPolicy)),
+    attest: Schema.optionalKey(Schema.Struct({
+        signer: Schema.String,
+        covers: Schema.String,
+        method: Schema.String,
+        audit: Schema.optionalKey(Schema.suspend(() => SignaturePolicy)),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const InteractionBinding = Schema.Struct({
+    field: Schema.String,
+    from: Schema.optionalKey(Schema.suspend(() => Expr)),
+    target: Schema.optionalKey(Schema.suspend(() => Expr)),
+});
+export const Interaction = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    actor: Schema.String,
+    produces: Schema.String,
+    binds: Schema.Array(Schema.suspend(() => InteractionBinding)),
+    fixes: Schema.optionalKey(Schema.Array(Schema.Struct({
+        field: Schema.String,
+        value: Schema.Union([Schema.String, Schema.Number, Schema.Boolean]),
+    }))),
+    layout: Schema.optionalKey(Schema.String),
+    at: Schema.suspend(() => Span),
+});
+export const LayoutItem = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("field"),
+        name: Schema.String,
+        label: Schema.optionalKey(Schema.String),
+        showWhen: Schema.optionalKey(Schema.suspend(() => Expr)),
+        options: Schema.optionalKey(Schema.Array(Schema.Struct({ value: Schema.String, label: Schema.String }))),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("group"),
+        name: Schema.String,
+        label: Schema.optionalKey(Schema.String),
+        showWhen: Schema.optionalKey(Schema.suspend(() => Expr)),
+        items: Schema.Array(Schema.suspend(() => LayoutItem)),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("widget"),
+        name: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("sign"),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const Layout = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    steps: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        label: Schema.optionalKey(Schema.String),
+        items: Schema.Array(Schema.suspend(() => LayoutItem)),
+        at: Schema.suspend(() => Span),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const Connector = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    capabilities: Schema.Array(Schema.String),
+    signals: Schema.Array(Schema.String),
+    owns: Schema.Array(Schema.String),
+    at: Schema.suspend(() => Span),
+});
+export const Machine = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    signal: Schema.String,
+    initial: Schema.String,
+    final: Schema.Array(Schema.String),
+    states: Schema.Array(Schema.Struct({ name: Schema.String, label: Schema.String })),
+    transitions: Schema.Array(Schema.Struct({ from: Schema.String, to: Schema.String })),
+    at: Schema.suspend(() => Span),
+});
+export const InputHome = Schema.Struct({
+    kind: Schema.Literal("input"),
+    path: Schema.NonEmptyArray(Schema.String),
+});
+export const Home = Schema.suspend(() => InputHome);
+export const Milestone = Schema.Struct({
+    name: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    when: Schema.suspend(() => Expr),
+    at: Schema.suspend(() => Span),
+});
+export const DayOffset = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(9007199254740991));
+export const Escalation = Schema.Struct({
+    afterDays: Schema.suspend(() => DayOffset),
+    kind: Schema.Union([Schema.Literal("notify"), Schema.Literal("reassign")]),
+    who: Schema.suspend(() => Expr),
+    whoKind: Schema.optionalKey(Schema.Union([Schema.Literal("entity"), Schema.Literal("group")])),
+    at: Schema.suspend(() => Span),
+});
+export const Hold = Schema.Struct({
+    name: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    while: Schema.suspend(() => Expr),
+    pauses: Schema.NonEmptyArray(Schema.Union([
+        Schema.Literal("dispatch"),
+        Schema.Literal("remind"),
+        Schema.Literal("escalate"),
+    ])),
+    cites: Schema.optionalKey(Schema.Array(Schema.suspend(() => Citation))),
+    at: Schema.suspend(() => Span),
+});
+export const Accepts = Schema.Struct({
+    kind: Schema.Literal("prior-cycle"),
+    from: Schema.optionalKey(Schema.String),
+    with: Schema.optionalKey(Schema.String),
+    within: Schema.optionalKey(Schema.suspend(() => Expr)),
+    confirm: Schema.optionalKey(Schema.suspend(() => Expr)),
+    label: Schema.optionalKey(Schema.String),
+});
+export const Recurrence = Schema.Struct({
+    every: Schema.Struct({
+        n: Schema.Int.check(Schema.isGreaterThan(0)),
+        unit: Schema.Union([Schema.Literal("days"), Schema.Literal("years")]),
+    }),
+    from: Schema.suspend(() => Expr),
+    at: Schema.suspend(() => Span),
+});
+export const Effective = Schema.Union([
+    Schema.Struct({
+        from: Schema.String.check(Schema.makeFilter((value) => /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+            !Number.isNaN(globalThis.Date.parse(value + "T00:00:00.000Z")) &&
+            new globalThis.Date(value + "T00:00:00.000Z").toISOString().slice(0, 10) === value)),
+        until: Schema.optionalKey(Schema.String.check(Schema.makeFilter((value) => /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+            !Number.isNaN(globalThis.Date.parse(value + "T00:00:00.000Z")) &&
+            new globalThis.Date(value + "T00:00:00.000Z").toISOString().slice(0, 10) === value))),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        from: Schema.optionalKey(Schema.String.check(Schema.makeFilter((value) => /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+            !Number.isNaN(globalThis.Date.parse(value + "T00:00:00.000Z")) &&
+            new globalThis.Date(value + "T00:00:00.000Z").toISOString().slice(0, 10) === value))),
+        until: Schema.String.check(Schema.makeFilter((value) => /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+            !Number.isNaN(globalThis.Date.parse(value + "T00:00:00.000Z")) &&
+            new globalThis.Date(value + "T00:00:00.000Z").toISOString().slice(0, 10) === value)),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const RenewalWindow = Schema.Struct({
+    n: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    unit: Schema.Union([Schema.Literal("days"), Schema.Literal("years")]),
+    at: Schema.suspend(() => Span),
+});
+export const Reuse = Schema.Struct({
+    scope: Schema.NonEmptyArray(Schema.suspend(() => Expr)),
+    within: Schema.suspend(() => ConfirmationWindow),
+    confirm: Schema.optionalKey(Schema.suspend(() => Expr)),
+    confirmKind: Schema.optionalKey(Schema.Union([Schema.Literal("entity"), Schema.Literal("group")])),
+    at: Schema.suspend(() => Span),
+});
+export const Notice = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    of: Schema.String,
+    document: Schema.String,
+    to: Schema.suspend(() => Expr),
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+    at: Schema.suspend(() => Span),
+});
+export const DocumentField = Schema.Struct({
+    label: Schema.String,
+    evidence: Schema.String,
+    field: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const Document = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    of: Schema.String,
+    resource: Schema.optionalKey(Schema.Struct({ name: Schema.String, at: Schema.suspend(() => Span) })),
+    sources: Schema.NonEmptyArray(Schema.String),
+    edition: Schema.String,
+    effective: Schema.suspend(() => Effective),
+    title: Schema.String,
+    fields: Schema.NonEmptyArray(Schema.suspend(() => DocumentField)),
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+    at: Schema.suspend(() => Span),
+});
+export const Requirement = Schema.Struct({
+    discretionary: Schema.optionalKey(Schema.String),
+    escalate: Schema.optionalKey(Schema.Array(Schema.suspend(() => Escalation))),
+    name: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    appliesWhen: Schema.optionalKey(Schema.suspend(() => Expr)),
+    satisfiedBy: Schema.suspend(() => Expr),
+    cites: Schema.optionalKey(Schema.Array(Schema.suspend(() => Citation))),
+    accepts: Schema.optionalKey(Schema.suspend(() => Accepts)),
+    reuse: Schema.optionalKey(Schema.suspend(() => Reuse)),
+    cycle: Schema.optionalKey(Schema.suspend(() => Expr)),
+    recur: Schema.optionalKey(Schema.suspend(() => Recurrence)),
+    effective: Schema.optionalKey(Schema.suspend(() => Effective)),
+    due: Schema.optionalKey(Schema.suspend(() => Expr)),
+    remind: Schema.optionalKey(Schema.suspend(() => Expr)),
+    renewWithin: Schema.optionalKey(Schema.suspend(() => RenewalWindow)),
+    at: Schema.suspend(() => Span),
+});
+export const Via = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("interaction"), name: Schema.String }),
+    Schema.Struct({
+        kind: Schema.Literal("connector"),
+        connector: Schema.String,
+        capability: Schema.String,
+    }),
+]);
+export const Action = Schema.Struct({
+    assigneeKind: Schema.optionalKey(Schema.Union([Schema.Literal("entity"), Schema.Literal("group")])),
+    dispatch: Schema.optionalKey(Schema.Union([Schema.Literal("auto"), Schema.Literal("claim"), Schema.Literal("manual")])),
+    onIneligible: Schema.optionalKey(Schema.Union([Schema.Literal("withdraw"), Schema.Literal("keep"), Schema.Literal("review")])),
+    name: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    advances: Schema.Union([Schema.String, Schema.NonEmptyArray(Schema.String)]),
+    needs: Schema.Array(Schema.Struct({ expr: Schema.suspend(() => Expr), text: Schema.String })),
+    assignee: Schema.optionalKey(Schema.suspend(() => Expr)),
+    via: Schema.suspend(() => Via),
+    idempotency: Schema.optionalKey(Schema.Array(Schema.suspend(() => Expr))),
+    at: Schema.suspend(() => Span),
+});
+export const Slot = Schema.Struct({
+    discretionary: Schema.optionalKey(Schema.String),
+    mode: Schema.Union([Schema.Literal("child"), Schema.Literal("attach")]),
+    name: Schema.String,
+    component: Schema.String,
+    bind: Schema.Array(Schema.Struct({ input: Schema.String, expr: Schema.suspend(() => Expr) })),
+    with: Schema.optionalKey(Schema.NonEmptyArray(Schema.Struct({
+        name: Schema.String,
+        value: Schema.suspend(() => PolicyNumber),
+        at: Schema.suspend(() => Span),
+    }))),
+    appliesWhen: Schema.optionalKey(Schema.suspend(() => Expr)),
+    at: Schema.suspend(() => Span),
+});
+export const Output = Schema.Struct({
+    name: Schema.String,
+    label: Schema.optionalKey(Schema.String),
+    op: Schema.Union([
+        Schema.Literal("all-of"),
+        Schema.Literal("any-of"),
+        Schema.Literal("status-of"),
+    ]),
+    paths: Schema.Array(Schema.Struct({
+        segments: Schema.Array(Schema.String),
+        at: Schema.suspend(() => Span),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const PolicyNumber = Schema.Struct({
+    n: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(9007199254740991)),
+    unit: Schema.Union([
+        Schema.Literal("integer"),
+        Schema.Literal("days"),
+        Schema.Literal("years"),
+        Schema.Literal("hours"),
+        Schema.Literal("minutes"),
+    ]),
+});
+export const ParamBound = Schema.Struct({
+    name: Schema.String,
+    default: Schema.suspend(() => PolicyNumber),
+    min: Schema.suspend(() => PolicyNumber),
+    max: Schema.suspend(() => PolicyNumber),
+    tighten: Schema.Union([Schema.Literal("lower"), Schema.Literal("higher")]),
+    at: Schema.suspend(() => Span),
+});
+export const AccountPolicy = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.String,
+    of: Schema.String,
+    cites: Schema.NonEmptyArray(Schema.suspend(() => Citation)),
+    when: Schema.optionalKey(Schema.suspend(() => Expr)),
+    require: Schema.optionalKey(Schema.suspend(() => Expr)),
+    params: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        value: Schema.suspend(() => PolicyNumber),
+        at: Schema.suspend(() => Span),
+    })),
+    assign: Schema.Array(Schema.Struct({
+        action: Schema.String,
+        assignee: Schema.suspend(() => Expr),
+        assigneeKind: Schema.Union([Schema.Literal("entity"), Schema.Literal("group")]),
+        at: Schema.suspend(() => Span),
+    })),
+    effective: Schema.optionalKey(Schema.suspend(() => Effective)),
+    at: Schema.suspend(() => Span),
+});
+export const ResourceCall = Schema.Struct({
+    connector: Schema.String,
+    capability: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const Resource = Schema.Struct({
+    name: Schema.String,
+    acquire: Schema.suspend(() => ResourceCall),
+    release: Schema.suspend(() => ResourceCall),
+    releaseWhen: Schema.suspend(() => Expr),
+    at: Schema.suspend(() => Span),
+});
+export const Component = Schema.Struct({
+    library: Schema.optionalKey(Schema.String),
+    operations: Schema.optionalKey(Schema.Array(Schema.String)),
+    milestones: Schema.optionalKey(Schema.Array(Schema.suspend(() => Milestone))),
+    holds: Schema.optionalKey(Schema.Array(Schema.suspend(() => Hold))),
+    resources: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => Resource))),
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    key: Schema.Array(Schema.String),
+    home: Schema.suspend(() => Home),
+    inputs: Schema.Array(Schema.suspend(() => Field)),
+    params: Schema.Array(Schema.suspend(() => Field)),
+    paramBounds: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => ParamBound))),
+    cycle: Schema.optionalKey(Schema.suspend(() => Expr)),
+    requirements: Schema.Array(Schema.suspend(() => Requirement)),
+    actions: Schema.Array(Schema.suspend(() => Action)),
+    slots: Schema.Array(Schema.suspend(() => Slot)),
+    outputs: Schema.Array(Schema.suspend(() => Output)),
+    machines: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        protocol: Schema.String,
+        at: Schema.suspend(() => Span),
+    })),
+    invariants: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        cites: Schema.optionalKey(Schema.Array(Schema.suspend(() => Citation))),
+        forbids: Schema.Struct({
+            action: Schema.String,
+            subject: Schema.suspend(() => Expr),
+        }),
+        while: Schema.suspend(() => Expr),
+        at: Schema.suspend(() => Span),
+    })),
+    retention: Schema.optionalKey(Schema.Struct({
+        until: Schema.suspend(() => Expr),
+        disposal: Schema.String,
+        cites: Schema.optionalKey(Schema.Array(Schema.suspend(() => Citation))),
+        at: Schema.suspend(() => Span),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const Account = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    requires: Schema.Array(Schema.Struct({ library: Schema.String, version: Schema.String })),
+    package: Schema.Struct({
+        name: Schema.String,
+        version: Schema.optionalKey(Schema.String),
+        digest: Schema.String,
+    }),
+    params: Schema.Array(Schema.Struct({ name: Schema.String, value: Schema.suspend(() => Expr) })),
+    policies: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => AccountPolicy))),
+    upgrade: Schema.Union([
+        Schema.Literal("open-only"),
+        Schema.Literal("review"),
+        Schema.Literal("next-cycle"),
+    ]),
+    forEach: Schema.Array(Schema.Struct({ role: Schema.String, component: Schema.String })),
+    at: Schema.suspend(() => Span),
+});
+export const ScenarioValue = Schema.Union([
+    Schema.Struct({
+        k: Schema.Literal("literal"),
+        value: Schema.Union([Schema.String, Schema.Number, Schema.Boolean, Schema.Null]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("entity"),
+        name: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("instance"),
+        component: Schema.String,
+        key: Schema.Array(Schema.suspend(() => ScenarioValue)),
+        cycle: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const ScenarioInstance = Schema.Struct({
+    k: Schema.Literal("instance"),
+    component: Schema.String,
+    key: Schema.Array(Schema.suspend(() => ScenarioValue)),
+    cycle: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+    at: Schema.suspend(() => Span),
+});
+export const ScenarioStatus = Schema.Union([
+    Schema.Literal("Unknown"),
+    Schema.Literal("NotApplicable"),
+    Schema.Literal("Open"),
+    Schema.Literal("Overdue"),
+    Schema.Literal("Satisfied"),
+    Schema.Literal("Waived"),
+]);
+export const ScenarioExpect = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("resource"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.Union([
+            Schema.Literal("acquire"),
+            Schema.Literal("release"),
+            Schema.Literal("acquiring"),
+            Schema.Literal("acquired"),
+            Schema.Literal("releasing"),
+            Schema.Literal("released"),
+            Schema.Literal("failed"),
+            Schema.Literal("uncertain"),
+            Schema.Literal("timed-out"),
+            Schema.Literal("waiting"),
+            Schema.Literal("unknown"),
+            Schema.Literal("absent"),
+        ]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("retention"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.Literal("retention"),
+        field: Schema.Union([Schema.Literal("until"), Schema.Literal("eligible")]),
+        expected: Schema.Union([Schema.String, Schema.Boolean, Schema.Null]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("property"),
+        name: Schema.String,
+        binding: Schema.String,
+        expected: Schema.Boolean,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("work"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.Union([
+            Schema.Literal("eligible"),
+            Schema.Literal("waiting"),
+            Schema.Literal("dispatched"),
+            Schema.Literal("held"),
+            Schema.Literal("absent"),
+        ]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("why"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("blocked"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.Boolean,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("rejected"),
+        command: Schema.Int.check(Schema.isGreaterThan(0)),
+        expected: Schema.Union([Schema.String, Schema.Boolean]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("status"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.suspend(() => ScenarioStatus),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("due"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        expected: Schema.Union([Schema.String, Schema.Null]),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const ScenarioField = Schema.Struct({
+    name: Schema.String,
+    value: Schema.suspend(() => ScenarioValue),
+    at: Schema.suspend(() => Span),
+});
+export const ScenarioFields = Schema.Array(Schema.suspend(() => ScenarioField));
+export const ScenarioRecord = Schema.Union([
+    Schema.Struct({
+        target: Schema.suspend(() => ScenarioInstance),
+        by: Schema.suspend(() => ScenarioValue),
+        date: Schema.optionalKey(Schema.String),
+        at: Schema.suspend(() => Span),
+        kind: Schema.Literal("evidence"),
+        evidence: Schema.String,
+        requirement: Schema.String,
+        requirementCycle: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+        status: Schema.Union([
+            Schema.Literal("submitted"),
+            Schema.Literal("attested"),
+            Schema.Literal("superseded"),
+        ]),
+        values: Schema.suspend(() => ScenarioFields),
+    }),
+    Schema.Struct({
+        target: Schema.suspend(() => ScenarioInstance),
+        by: Schema.suspend(() => ScenarioValue),
+        date: Schema.optionalKey(Schema.String),
+        at: Schema.suspend(() => Span),
+        kind: Schema.Literal("signal"),
+        machine: Schema.String,
+        state: Schema.String,
+    }),
+]);
+export const ScenarioCommand = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("resource"),
+        target: Schema.suspend(() => ScenarioInstance),
+        name: Schema.String,
+        phase: Schema.Union([Schema.Literal("acquire"), Schema.Literal("release")]),
+        handle: Schema.String,
+        state: Schema.optionalKey(Schema.String),
+        by: Schema.suspend(() => ScenarioValue),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("decide"),
+        target: Schema.suspend(() => ScenarioInstance),
+        decision: Schema.String,
+        by: Schema.suspend(() => ScenarioValue),
+        id: Schema.optionalKey(Schema.String),
+        revoke: Schema.optionalKey(Schema.String),
+        reason: Schema.optionalKey(Schema.Union([Schema.Null, Schema.Union([Schema.String, Schema.Number, Schema.Boolean])])),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.suspend(() => ScenarioRecord),
+    Schema.Struct({
+        kind: Schema.Literal("accept"),
+        target: Schema.suspend(() => ScenarioInstance),
+        requirement: Schema.String,
+        decision: Schema.Union([Schema.Literal("accepted"), Schema.Literal("declined")]),
+        by: Schema.suspend(() => ScenarioValue),
+        id: Schema.optionalKey(Schema.String),
+        revoke: Schema.optionalKey(Schema.String),
+        reason: Schema.optionalKey(Schema.Union([Schema.Null, Schema.Union([Schema.String, Schema.Number, Schema.Boolean])])),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("set"),
+        entity: Schema.String,
+        commandKind: Schema.optionalKey(Schema.String),
+        subject: Schema.optionalKey(Schema.String),
+        field: Schema.String,
+        value: Schema.suspend(() => ScenarioValue),
+        by: Schema.suspend(() => ScenarioValue),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("perform"),
+        target: Schema.suspend(() => ScenarioInstance),
+        action: Schema.String,
+        by: Schema.suspend(() => ScenarioValue),
+        unsigned: Schema.Boolean,
+        signature: Schema.optionalKey(Schema.suspend(() => SignatureInput)),
+        amend: Schema.optionalKey(Schema.suspend(() => AmendmentInput)),
+        values: Schema.suspend(() => ScenarioFields),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const ScenarioActor = Schema.Struct({
+    name: Schema.String,
+    kind: Schema.Union([Schema.Literal("human"), Schema.Literal("agent")]),
+    groups: Schema.Array(Schema.String),
+    at: Schema.suspend(() => Span),
+});
+export const ScenarioEntity = Schema.Struct({
+    name: Schema.String,
+    entity: Schema.String,
+    fields: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        value: Schema.suspend(() => ScenarioValue),
+        at: Schema.suspend(() => Span),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const ScenarioFile = Schema.Struct({
+    home: Schema.String,
+    digest: Schema.String,
+    mediaType: Schema.String,
+    size: Schema.Int,
+    scan: Schema.Union([
+        Schema.Literal("pending"),
+        Schema.Literal("clean"),
+        Schema.Literal("rejected"),
+    ]),
+    redacted: Schema.Boolean,
+    date: Schema.optionalKey(Schema.String),
+    at: Schema.suspend(() => Span),
+});
+export const Scenario = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    world: Schema.String,
+    given: Schema.Array(Schema.suspend(() => ScenarioEntity)),
+    files: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioFile))),
+    actors: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioActor))),
+    records: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioRecord))),
+    steps: Schema.Array(Schema.Struct({
+        kind: Schema.Literal("at"),
+        date: Schema.String,
+        expects: Schema.Array(Schema.suspend(() => ScenarioExpect)),
+        commands: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioCommand))),
+        at: Schema.suspend(() => Span),
+    })),
+    at: Schema.suspend(() => Span),
+});
+export const PropertyTarget = Schema.Struct({
+    component: Schema.String,
+    key: Schema.Array(Schema.suspend(() => PropertyExpr)),
+    cycle: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+    attachedTo: Schema.optionalKey(Schema.suspend(() => PropertyExpr)),
+    at: Schema.suspend(() => Span),
+});
+export const PropertyStatus = Schema.Struct({
+    k: Schema.Literal("status"),
+    target: Schema.suspend(() => PropertyTarget),
+    name: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const PropertyOperator = Schema.Union([
+    Schema.Literal("implies"),
+    Schema.Literal("and"),
+    Schema.Literal("or"),
+    Schema.Literal("not"),
+    Schema.Literal("="),
+    Schema.Literal("!="),
+    Schema.Literal("<"),
+    Schema.Literal("<="),
+    Schema.Literal(">"),
+    Schema.Literal(">="),
+    Schema.Literal("known?"),
+    Schema.Literal("unknown?"),
+    Schema.Literal("satisfied?"),
+    Schema.Literal("not-applicable?"),
+]);
+export const PropertyExpr = Schema.Union([
+    Schema.Struct({
+        k: Schema.Literal("observation"),
+        of: Schema.suspend(() => PropertyStatus),
+        query: Schema.Literal("work"),
+        action: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("observation"),
+        of: Schema.suspend(() => PropertyStatus),
+        query: Schema.Literal("due"),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("observation"),
+        of: Schema.suspend(() => PropertyStatus),
+        query: Schema.Literal("occurrence-count"),
+        cycle: Schema.optionalKey(Schema.suspend(() => PropertyExpr)),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("literal"),
+        value: Schema.Union([Schema.String, Schema.Number, Schema.Boolean, Schema.Null]),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("read"),
+        root: Schema.String,
+        attrs: Schema.Array(Schema.String),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("instance"),
+        target: Schema.suspend(() => PropertyTarget),
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.suspend(() => PropertyStatus),
+    Schema.Struct({
+        k: Schema.Literal("attested"),
+        target: Schema.suspend(() => PropertyTarget),
+        evidence: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    Schema.Struct({
+        k: Schema.Literal("call"),
+        op: Schema.suspend(() => PropertyOperator),
+        args: Schema.Array(Schema.suspend(() => PropertyExpr)),
+        at: Schema.suspend(() => Span),
+    }),
+]);
+export const Property = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    world: Schema.String,
+    date: Schema.String,
+    binding: Schema.Struct({
+        name: Schema.String,
+        entity: Schema.String,
+        at: Schema.suspend(() => Span),
+    }),
+    given: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioEntity))),
+    records: Schema.optionalKey(Schema.Array(Schema.suspend(() => ScenarioRecord))),
+    predicate: Schema.suspend(() => PropertyExpr),
+    at: Schema.suspend(() => Span),
+});
+export const Decision = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    of: Schema.String,
+    by: Schema.suspend(() => Expr),
+    byKind: Schema.optionalKey(Schema.Union([Schema.Literal("individual"), Schema.Literal("group")])),
+    applies: Schema.String,
+    when: Schema.optionalKey(Schema.suspend(() => Expr)),
+    effect: Schema.Union([
+        Schema.Literal("approve"),
+        Schema.Literal("reject"),
+        Schema.Literal("waive"),
+        Schema.Literal("defer"),
+        Schema.Literal("accept"),
+        Schema.Literal("add"),
+    ]),
+    reason: Schema.suspend(() => TypeRef),
+    until: Schema.optionalKey(Schema.suspend(() => Expr)),
+    expires: Schema.optionalKey(Schema.suspend(() => Expr)),
+    approvals: Schema.optionalKey(Schema.suspend(() => Expr)),
+    distinctFrom: Schema.optionalKey(Schema.Array(Schema.suspend(() => Expr))),
+    cites: Schema.optionalKey(Schema.Array(Schema.suspend(() => Citation))),
+    at: Schema.suspend(() => Span),
+});
+export const ConfirmationWindow = Schema.Struct({
+    n: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(9007199254740991)),
+    unit: Schema.Union([
+        Schema.Literal("days"),
+        Schema.Literal("years"),
+        Schema.Literal("hours"),
+        Schema.Literal("minutes"),
+    ]),
+    at: Schema.suspend(() => Span),
+});
+export const Collect = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    from: Schema.String,
+    facts: Schema.NonEmptyArray(Schema.String),
+    layout: Schema.String,
+    confirmAfter: Schema.optionalKey(Schema.suspend(() => ConfirmationWindow)),
+    at: Schema.suspend(() => Span),
+});
+export const Bundle = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    role: Schema.String,
+    label: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const ContractOperation = Schema.Struct({
+    name: Schema.String,
+    kind: Schema.Union([Schema.Literal("action"), Schema.Literal("decision")]),
+    input: Schema.Array(Schema.suspend(() => Field)),
+    result: Schema.String,
+    sealedBy: Schema.optionalKey(Schema.suspend(() => Seal)),
+    amendable: Schema.optionalKey(Schema.Boolean),
+    signature: Schema.optionalKey(Schema.Struct({
+        method: Schema.String,
+        audit: Schema.suspend(() => SignaturePolicy),
+    })),
+});
+export const ComponentContract = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    library: Schema.String,
+    component: Schema.String,
+    key: Schema.Array(Schema.String),
+    home: Schema.suspend(() => Home),
+    inputs: Schema.Array(Schema.suspend(() => Field)),
+    params: Schema.Array(Schema.suspend(() => Field)),
+    paramBounds: Schema.Array(Schema.suspend(() => ParamBound)),
+    types: Schema.Array(Schema.suspend(() => Field)),
+    roles: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        fields: Schema.Array(Schema.suspend(() => Field)),
+    })),
+    vaults: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => Vault))),
+    outputs: Schema.Array(Schema.Struct({ name: Schema.String, type: Schema.Literal("Status") })),
+    operations: Schema.Array(Schema.suspend(() => ContractOperation)),
+    capabilities: Schema.Array(Schema.Struct({ connector: Schema.String, capabilities: Schema.Array(Schema.String) })),
+    digest: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const ComponentImport = Schema.Struct({
+    name: Schema.String,
+    doc: Schema.optionalKey(Schema.String),
+    library: Schema.String,
+    from: Schema.String,
+    version: Schema.String,
+    contract: Schema.String,
+    digest: Schema.String,
+    at: Schema.suspend(() => Span),
+});
+export const WorldIR = Schema.Struct({
+    format: Schema.Literal("worldvm/world-ir@1"),
+    sources: Schema.Array(Schema.Struct({ id: Schema.String, sha256: Schema.String })),
+    references: Schema.optionalKey(Schema.Array(Schema.suspend(() => Source))),
+    scenarios: Schema.optionalKey(Schema.Array(Schema.suspend(() => Scenario))),
+    properties: Schema.optionalKey(Schema.Array(Schema.suspend(() => Property))),
+    decisions: Schema.optionalKey(Schema.Array(Schema.suspend(() => Decision))),
+    collects: Schema.optionalKey(Schema.Array(Schema.suspend(() => Collect))),
+    bundles: Schema.optionalKey(Schema.Array(Schema.suspend(() => Bundle))),
+    documents: Schema.optionalKey(Schema.Array(Schema.suspend(() => Document))),
+    notices: Schema.optionalKey(Schema.Array(Schema.suspend(() => Notice))),
+    vaults: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => Vault))),
+    agents: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => Agent))),
+    libraries: Schema.Array(Schema.suspend(() => Library)),
+    types: Schema.Array(Schema.suspend(() => TypeAlias)),
+    roles: Schema.Array(Schema.suspend(() => Role)),
+    entities: Schema.Array(Schema.suspend(() => Entity)),
+    calendars: Schema.Array(Schema.suspend(() => Calendar)),
+    derives: Schema.Array(Schema.suspend(() => Derive)),
+    evidence: Schema.Array(Schema.suspend(() => Evidence)),
+    interactions: Schema.Array(Schema.suspend(() => Interaction)),
+    layouts: Schema.Array(Schema.suspend(() => Layout)),
+    connectors: Schema.Array(Schema.suspend(() => Connector)),
+    machines: Schema.Array(Schema.suspend(() => Machine)),
+    componentContracts: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => ComponentContract))),
+    componentImports: Schema.optionalKey(Schema.NonEmptyArray(Schema.suspend(() => ComponentImport))),
+    components: Schema.Array(Schema.suspend(() => Component)),
+    accounts: Schema.Array(Schema.suspend(() => Account)),
+});
+export const Diagnostic = Schema.Struct({
+    code: Schema.String,
+    severity: Schema.Union([
+        Schema.Literal("error"),
+        Schema.Literal("warning"),
+        Schema.Literal("info"),
+    ]),
+    message: Schema.String,
+    help: Schema.optionalKey(Schema.String),
+    at: Schema.optionalKey(Schema.suspend(() => Span)),
+});
+export const Compiled = Schema.Struct({
+    ok: Schema.Boolean,
+    ir: Schema.Union([Schema.Null, Schema.suspend(() => WorldIR)]),
+    diagnostics: Schema.Array(Schema.suspend(() => Diagnostic)),
+});