worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/world-ir/types.generated.d.ts

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