@lute-lang/runtime 0.0.0-stage → 0.40.0

package/dist/generated/Ir.d.ts

@@ -0,0 +1,2535 @@
+import * as Schema from "effect/Schema";
+/**
+ * §4.3 injection provenance (lute_check::inject::Provenance): why a compiler-injected record exists. Present only on injected records; its presence is the injection marker (IR 0.37.0 drops the constant `injected` flag).
+ */
+export declare const provenance: Schema.Struct<{
+    readonly by: Schema.String;
+    readonly explanation: Schema.String;
+}>;
+export type provenance = typeof provenance.Type;
+/**
+ * §4.3 component source stamp on component-expanded records (D8).
+ */
+export declare const source: Schema.Struct<{
+    readonly component: Schema.String;
+}>;
+export type source = typeof source.Type;
+/**
+ * a resolved record position (dsl 0.37.0 §5.3), unique within the artifact; its first segment is the one-based section number. Build-local execution ordering only — never an identity. Fields that carry a position: every command `position`; `choice.converge`/`options[].target`; `hub.converge`/`return`/`options[].target`; `match.converge`/`otherwise`/`arms[].target`; `jump.target`; `quest.objectives[].body`; `on.body`; `entry.body`; `beat.body`.
+ */
+export declare const position: Schema.String;
+export type position = typeof position.Type;
+/**
+ * dsl 0.37.0 §5.1: the normative grouping of a record's `kind`, read by runtime dispatch before `kind`. content: line; staging: bg, music, sfx, vfx, actor, camera, cg, video, sequence; state: set, assert, retract; control: choice, match, hub, jump, end, barrier; declaration: quest, on, entry, accept, beat; plugin: plugin.
+ */
+export declare const family: Schema.Literals<readonly ["content", "staging", "state", "control", "declaration", "plugin"]>;
+export type family = typeof family.Type;
+/**
+ * dsl 0.37.0 §5.2: a record's resolved timing, replacing the flattened 0.36 stamp fields. Omitted when every member is absent; each member is omitted when absent. A runtime reads timing only from here.
+ */
+export declare const timing: Schema.Struct<{
+    readonly wait: Schema.optionalKey<Schema.Boolean>;
+    readonly duration: Schema.optionalKey<Schema.Number>;
+    readonly delay: Schema.optionalKey<Schema.Number>;
+    readonly at: Schema.optionalKey<Schema.Number>;
+    readonly timeline: Schema.optionalKey<Schema.Int>;
+}>;
+export type timing = typeof timing.Type;
+/**
+ * dsl 0.37.0 §3.6: one presentation segment of a modified line — a coalesced text run or a pause leaf.
+ */
+export declare const segment: Schema.Union<readonly [Schema.Struct<{
+    readonly text: Schema.String;
+    readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly rate: Schema.optionalKey<Schema.Number>;
+}>, Schema.Struct<{
+    readonly pause: Schema.Number;
+}>]>;
+export type segment = typeof segment.Type;
+export declare const segments: Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+    readonly text: Schema.String;
+    readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly rate: Schema.optionalKey<Schema.Number>;
+}>, Schema.Struct<{
+    readonly pause: Schema.Number;
+}>]>>>;
+export type segments = typeof segments.Type;
+/**
+ * Portable CEL expression AST (dsl 0.32.0 §7, expr.rs). Serialized as an UNTAGGED serde enum — each variant is a bare object distinguished by its keys. A plain JSON walker evaluates it; the parallel `cel` string field carries the standard CEL expression.
+ */
+export declare const exprNode: Schema.Union<readonly [Schema.Struct<{
+    readonly int: Schema.Int;
+}>, Schema.Struct<{
+    readonly double: Schema.Number;
+}>, Schema.Struct<{
+    readonly bool: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly string: Schema.String;
+}>, Schema.Struct<{
+    readonly list: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+    readonly path: Schema.String;
+}>, Schema.Struct<{
+    readonly index: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly key: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly has: Schema.String;
+}>, Schema.Struct<{
+    readonly op: Schema.Literals<readonly ["!", "-"]>;
+    readonly l: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literals<readonly ["&&", "||", "==", "!=", "<", "<=", ">", ">=", "+", "-", "*", "/", "%", "in"]>;
+    readonly l: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly r: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly cond: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly then: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly else: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly call: Schema.String;
+    readonly args: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>]>;
+export type exprNode = typeof exprNode.Type;
+/**
+ * dsl 0.32.0 §7: CEL slot object carrying standard CEL expression text, lowered portable expr AST, and optional authored source text.
+ */
+export declare const celSlot: Schema.Struct<{
+    readonly cel: Schema.String;
+    readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly authored: Schema.optionalKey<Schema.String>;
+}>;
+export type celSlot = typeof celSlot.Type;
+/**
+ * dsl 0.32.0 §1.4 / §7: the CEL environment (variables and host function signatures) expressions were checked against.
+ */
+export declare const celEnv: Schema.Struct<{
+    readonly variables: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly type: Schema.String;
+    }>>;
+    readonly functions: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly overloads: Schema.$Array<Schema.Struct<{
+            readonly params: Schema.$Array<Schema.String>;
+            readonly result: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type celEnv = typeof celEnv.Type;
+/**
+ * One {{…}} interpolation placeholder (IR A3), internally tagged on `kind` (lowercase). The runtime substitutes it against live state; the enclosing `text` keeps the verbatim {{…}} marker.
+ */
+export declare const placeholder: Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"path">;
+    readonly path: Schema.String;
+    readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"ref">;
+    readonly ref: Schema.String;
+    readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"reserved">;
+    readonly token: Schema.String;
+    readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"occasionTarget">;
+    readonly entityKind: Schema.String;
+    readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+}>]>;
+export type placeholder = typeof placeholder.Type;
+/**
+ * dsl 0.24.0 §4 / 0.25.0 §8 / 0.27.0 §7: the interpolation's format hint ({{user.deaths:ordinal}}), omitted when none was written. The engine renders the value in that format (a locale-aware engine localizes it). `ordinal`: a non-negative integer as an English ordinal (1st 2nd 3rd 4th … 11th 12th 13th … 21st 22nd … 101st 111th). `ordinalWord`: an ordinal word (first second … twentieth for 1–20, the `ordinal` digits above). `cardinalWord`: a cardinal word (one two … twenty for 1–20, the digits otherwise). `plural`: the placeholder's `forms` — the first when the number is 1, the second otherwise, with `#word` replaced by the number as a cardinal word, `#Word` by that word capitalized and any other `#` by the number. The text hints apply to the text the value renders as (a label, a cast name, a string): `capitalize` upper-cases its first letter; `start` renders the member's declared `labelForms` `start` form, else `capitalize`; `indefinite` renders the declared `indefinite` form, else `an` (before a vowel) or `a`, a space and the text. Any other value renders unchanged.
+ */
+export declare const placeholderFormat: Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>;
+export type placeholderFormat = typeof placeholderFormat.Type;
+/**
+ * member → the label forms a kind's `labels:` entry declares beside its text (`{ text, start, indefinite }`): `start` is what a `:start` placeholder renders, `indefinite` what an `:indefinite` one renders. Omitted when no member declares a form; an absent form falls back (see `placeholderFormat`).
+ */
+export declare const labelForms: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly start: Schema.optionalKey<Schema.String>;
+    readonly indefinite: Schema.optionalKey<Schema.String>;
+}>>;
+export type labelForms = typeof labelForms.Type;
+/**
+ * dsl 0.27.0 §7: a `plural` placeholder's forms as written in {{n:plural(lantern|lanterns)}} — the English singular, then the plural; a `#` in a form stands for the number. Present exactly when `format` is `plural`; an engine may localize the count from them.
+ */
+export declare const placeholderForms: Schema.$Array<Schema.String>;
+export type placeholderForms = typeof placeholderForms.Type;
+/**
+ * dsl 0.37.0 D6: the line's authored delivery role. Every role carries a `voiceKey` — a key is a join, not a recording obligation.
+ */
+export declare const role: Schema.Literals<readonly ["dialogue", "narration", "mono", "os", "vo"]>;
+export type role = typeof role.Type;
+/**
+ * One merged relational entity kind (dsl 0.3.0 §3.1).
+ */
+export declare const entityKindEntry: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly members: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly open: Schema.Boolean;
+    readonly labels: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly labelForms: Schema.optionalKey<Schema.suspend<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly start: Schema.optionalKey<Schema.String>;
+        readonly indefinite: Schema.optionalKey<Schema.String>;
+    }>>>>;
+}>;
+export type entityKindEntry = typeof entityKindEntry.Type;
+/**
+ * One merged relational `enums:` entry (dsl 0.3.0 §3).
+ */
+export declare const enumEntry: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly members: Schema.$Array<Schema.String>;
+}>;
+export type enumEntry = typeof enumEntry.Type;
+/**
+ * One merged relation declaration (dsl 0.3.0 §4).
+ */
+export declare const relationEntry: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly tier: Schema.optionalKey<Schema.String>;
+    readonly derive: Schema.Boolean;
+    readonly reserved: Schema.Boolean;
+    readonly key: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+    readonly excludes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export type relationEntry = typeof relationEntry.Type;
+/**
+ * One seed `facts:` ground tuple (dsl 0.3.0 §4).
+ */
+export declare const seedFactEntry: Schema.Struct<{
+    readonly relation: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+}>;
+export type seedFactEntry = typeof seedFactEntry.Type;
+/**
+ * One rule term (dsl 0.3.0 §7.1), tagged on `kind`. Bools lower to a Const with value "true"/"false".
+ */
+export declare const termEntry: Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"var">;
+    readonly name: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"const">;
+    readonly value: Schema.String;
+}>]>;
+export type termEntry = typeof termEntry.Type;
+/**
+ * One rule atom: a relation applied to terms (dsl 0.3.0 §7.1).
+ */
+export declare const atomEntry: Schema.Struct<{
+    readonly relation: Schema.String;
+    readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"var">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"const">;
+        readonly value: Schema.String;
+    }>]>>>;
+}>;
+export type atomEntry = typeof atomEntry.Type;
+/**
+ * One rule body literal (dsl 0.3.0 §7.1), tagged on `kind`: a positive/negated atom, a CEL guard, or a term comparison.
+ */
+export declare const bodyEntry: Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"atom">;
+    readonly atom: Schema.suspend<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"var">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"const">;
+            readonly value: Schema.String;
+        }>]>>>;
+    }>>;
+    readonly negated: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"guard">;
+    readonly cel: Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"cmp">;
+    readonly lhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"var">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"const">;
+        readonly value: Schema.String;
+    }>]>>;
+    readonly rhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"var">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"const">;
+        readonly value: Schema.String;
+    }>]>>;
+    readonly negated: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"count">;
+    readonly atom: Schema.suspend<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"var">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"const">;
+            readonly value: Schema.String;
+        }>]>>>;
+    }>>;
+    readonly distinct: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly op: Schema.Literals<readonly ["==", "!=", "<", "<=", ">", ">="]>;
+    readonly n: Schema.Int;
+}>]>;
+export type bodyEntry = typeof bodyEntry.Type;
+/**
+ * One Datalog rule (dsl 0.3.0 §7.1), emitted as STRUCTURED data. Lute performs NO evaluation (D1); the engine runs the least-fixpoint over this rule set.
+ */
+export declare const ruleEntry: Schema.Struct<{
+    readonly head: Schema.suspend<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"var">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"const">;
+            readonly value: Schema.String;
+        }>]>>>;
+    }>>;
+    readonly body: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"atom">;
+        readonly atom: Schema.suspend<Schema.Struct<{
+            readonly relation: Schema.String;
+            readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"var">;
+                readonly name: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"const">;
+                readonly value: Schema.String;
+            }>]>>>;
+        }>>;
+        readonly negated: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"guard">;
+        readonly cel: Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"cmp">;
+        readonly lhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"var">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"const">;
+            readonly value: Schema.String;
+        }>]>>;
+        readonly rhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"var">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"const">;
+            readonly value: Schema.String;
+        }>]>>;
+        readonly negated: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"count">;
+        readonly atom: Schema.suspend<Schema.Struct<{
+            readonly relation: Schema.String;
+            readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"var">;
+                readonly name: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"const">;
+                readonly value: Schema.String;
+            }>]>>>;
+        }>>;
+        readonly distinct: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly op: Schema.Literals<readonly ["==", "!=", "<", "<=", ">", ">="]>;
+        readonly n: Schema.Int;
+    }>]>>>;
+    readonly raw: Schema.String;
+}>;
+export type ruleEntry = typeof ruleEntry.Type;
+/**
+ * One advisory graph edge (connectivity spec §2.6, T13): a single node's raw declared `after` (scene, bundle beat) or `follows` (quest), verbatim.
+ */
+export declare const prereqEdgeEntry: Schema.Union<readonly [Schema.Struct<{
+    readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly follows: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+export type prereqEdgeEntry = typeof prereqEdgeEntry.Type;
+/**
+ * A parsed `after` prerequisite formula: `visited("id")` / `completed("q")` / `active("q")` atoms joined by `&&` (`and`) / `||` (`or`), each binary node a two-element array left, right.
+ */
+export declare const prereqFormula: Schema.Union<readonly [Schema.Struct<{
+    readonly visited: Schema.String;
+}>, Schema.Struct<{
+    readonly completed: Schema.String;
+}>, Schema.Struct<{
+    readonly active: Schema.String;
+}>, Schema.Struct<{
+    readonly and: Schema.Tuple<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+}>, Schema.Struct<{
+    readonly or: Schema.Tuple<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+}>]>;
+export type prereqFormula = typeof prereqFormula.Type;
+/**
+ * Scene-kind envelope meta (dsl 0.15.0 §2/§3). Present when `kind` == "scene". Since 0.15.0 only `id` is required — the four legacy identity keys demote to optional.
+ */
+export declare const sceneMeta: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly character: Schema.optionalKey<Schema.String>;
+    readonly season: Schema.optionalKey<Schema.Int>;
+    readonly episode: Schema.optionalKey<Schema.Int>;
+    readonly episodeId: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean]>>]>>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly beat: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly on: Schema.String;
+        readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly prefix: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly priority: Schema.Int;
+        readonly once: Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>;
+        readonly also: Schema.optionalKey<Schema.Literal<true>>;
+        readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly share: Schema.optionalKey<Schema.String>;
+        readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    }>>>;
+}>;
+export type sceneMeta = typeof sceneMeta.Type;
+/**
+ * dsl 0.26.0 §5: a `target: "kind:<kind>"` beat, resolved. It answers a raise for `<prefix>.<member>` of every listed member; while it runs, `occasion.target` is the raised member id.
+ */
+export declare const targetKind: Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly prefix: Schema.String;
+    readonly members: Schema.$Array<Schema.String>;
+}>;
+export type targetKind = typeof targetKind.Type;
+/**
+ * dsl 0.27.0 §3 (T2-10): a `for: "kind:<kind>"` beat on an untargeted `select: sequence` occasion, resolved. Each raise presents the beat once per listed member whose `when` holds (judged at the raise with `occasion.target` bound to that member), in list order; while one presentation runs, `occasion.target` is that member id. `once` spends the beat, not a member.
+ */
+export declare const forKind: Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly members: Schema.$Array<Schema.String>;
+}>;
+export type forKind = typeof forKind.Type;
+/**
+ * A scene beat (dsl 0.21.0 §3.1; docs/runtime/beats-and-occasions.md): the occasion the scene answers and how it competes with the other candidates when the engine raises it.
+ */
+export declare const sceneBeat: Schema.Struct<{
+    readonly on: Schema.String;
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly priority: Schema.Int;
+    readonly once: Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>;
+    readonly also: Schema.optionalKey<Schema.Literal<true>>;
+    readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly share: Schema.optionalKey<Schema.String>;
+    readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+}>;
+export type sceneBeat = typeof sceneBeat.Type;
+/**
+ * Quest-kind envelope meta (dsl 0.2.0 §6.1, dsl 0.15.0 §3, dsl 0.19.0 §2.1). MAY serialize as {} when none of id/title/contentLang/extra/plugin are authored. Present when `kind` == "quest".
+ */
+export declare const questMeta: Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly contentLang: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean]>>]>>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type questMeta = typeof questMeta.Type;
+/**
+ * One folded state slot (§4.1): the engine's init/type table entry.
+ */
+export declare const stateEntry: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly type: Schema.String;
+    readonly domain: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly default: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly owner: Schema.optionalKey<Schema.Literals<readonly ["engine"]>>;
+    readonly provenance: Schema.optionalKey<Schema.String>;
+    readonly labels: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly labelForms: Schema.optionalKey<Schema.suspend<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly start: Schema.optionalKey<Schema.String>;
+        readonly indefinite: Schema.optionalKey<Schema.String>;
+    }>>>>;
+}>;
+export type stateEntry = typeof stateEntry.Type;
+/**
+ * The origin of an Effect's value (IR A12, untagged).
+ */
+export declare const effectSource: Schema.Union<readonly [Schema.Struct<{
+    readonly bridgeResult: Schema.String;
+}>, Schema.Struct<{
+    readonly op: Schema.String;
+    readonly by: Schema.Number;
+}>, Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>]>;
+export type effectSource = typeof effectSource.Type;
+/**
+ * A resolved plugin state-write binding (IR A12): where a bridge result / increment / literal lands. The runtime applies it after the bridge call — no manifest lookup, no per-plugin knowledge.
+ */
+export declare const effect: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly from: Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+        readonly bridgeResult: Schema.String;
+    }>, Schema.Struct<{
+        readonly op: Schema.String;
+        readonly by: Schema.Number;
+    }>, Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>]>>;
+}>;
+export type effect = typeof effect.Type;
+/**
+ * One <choice> option.
+ */
+export declare const choiceOption: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+    readonly lineId: Schema.String;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly target: Schema.suspend<Schema.String>;
+    readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"path">;
+        readonly path: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ref">;
+        readonly ref: Schema.String;
+        readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"reserved">;
+        readonly token: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"occasionTarget">;
+        readonly entityKind: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>]>>>>;
+    readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type choiceOption = typeof choiceOption.Type;
+/**
+ * One <hub> option: a choice option plus always-present once/exit revisit flags.
+ */
+export declare const hubOption: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+    readonly lineId: Schema.String;
+    readonly once: Schema.Boolean;
+    readonly exit: Schema.Boolean;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly target: Schema.suspend<Schema.String>;
+    readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"path">;
+        readonly path: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ref">;
+        readonly ref: Schema.String;
+        readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"reserved">;
+        readonly token: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"occasionTarget">;
+        readonly entityKind: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>]>>>>;
+    readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type hubOption = typeof hubOption.Type;
+/**
+ * One <match> arm.
+ */
+export declare const matchArm: Schema.Struct<{
+    readonly is: Schema.optionalKey<Schema.String>;
+    readonly test: Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly target: Schema.suspend<Schema.String>;
+}>;
+export type matchArm = typeof matchArm.Type;
+/**
+ * One `<reward id= kind= target= amount= when= outcome=/>` declaration (dsl 0.16.0 §2/§3). Pure data — the compiler NEVER synthesizes handler bodies or `Command::Set` records for a reward; the reference engine (`crates/lute-cli/src/runner.rs` `Runner::emit_grants`) emits deterministic `grant` transcript events at each fresh lifecycle transition, and `lute trace` mirrors those events (`crates/lute-trace/src/walk.rs`).
+ */
+export declare const rewardEntry: Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly kind: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly amount: Schema.optionalKey<Schema.Int>;
+    readonly amountMin: Schema.optionalKey<Schema.Int>;
+    readonly amountMax: Schema.optionalKey<Schema.Int>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+    readonly credits: Schema.optionalKey<Schema.String>;
+}>;
+export type rewardEntry = typeof rewardEntry.Type;
+/**
+ * One objective inlined in QuestCmd.objectives (dsl 0.2.0 §6.4). Declaration data only; the engine derives completion (all non-optional objectives done ⇒ quest complete).
+ */
+export declare const objectiveEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly done: Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly visibleWhen: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly optional: Schema.Boolean;
+    readonly body: Schema.NullOr<Schema.suspend<Schema.String>>;
+    readonly quest: Schema.optionalKey<Schema.String>;
+    readonly rewards: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly kind: Schema.String;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly amount: Schema.optionalKey<Schema.Int>;
+        readonly amountMin: Schema.optionalKey<Schema.Int>;
+        readonly amountMax: Schema.optionalKey<Schema.Int>;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+        readonly credits: Schema.optionalKey<Schema.String>;
+    }>>>>;
+    readonly on: Schema.optionalKey<Schema.String>;
+    readonly by: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly until: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+}>;
+export type objectiveEntry = typeof objectiveEntry.Type;
+/**
+ * A spoken or narrated content line (dsl 0.37.0 §5.3).
+ */
+export declare const cmdLine: Schema.Struct<{
+    readonly kind: Schema.Literal<"line">;
+    readonly family: Schema.Literal<"content">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly role: Schema.suspend<Schema.Literals<readonly ["dialogue", "narration", "mono", "os", "vo"]>>;
+    readonly speaker: Schema.String;
+    readonly text: Schema.String;
+    readonly emotion: Schema.optionalKey<Schema.String>;
+    readonly variant: Schema.optionalKey<Schema.Int>;
+    readonly action: Schema.optionalKey<Schema.String>;
+    readonly dialogMotion: Schema.optionalKey<Schema.String>;
+    readonly as: Schema.optionalKey<Schema.String>;
+    readonly lineId: Schema.String;
+    readonly voiceKey: Schema.String;
+    readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"path">;
+        readonly path: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ref">;
+        readonly ref: Schema.String;
+        readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"reserved">;
+        readonly token: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"occasionTarget">;
+        readonly entityKind: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>]>>>>;
+    readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly segments: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+        readonly text: Schema.String;
+        readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly rate: Schema.optionalKey<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly pause: Schema.Number;
+    }>]>>>>>;
+    readonly localeSegments: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+        readonly text: Schema.String;
+        readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly rate: Schema.optionalKey<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly pause: Schema.Number;
+    }>]>>>>>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdLine = typeof cmdLine.Type;
+/**
+ * `::bg` (dsl 0.37.0 §5.3): sets the stage backdrop. Every field optional.
+ */
+export declare const cmdBg: Schema.Struct<{
+    readonly kind: Schema.Literal<"bg">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly location: Schema.optionalKey<Schema.String>;
+    readonly time: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdBg = typeof cmdBg.Type;
+/**
+ * `::music` (dsl 0.37.0 §5.3). `playback` is a project `musicPlayback` member.
+ */
+export declare const cmdMusic: Schema.Struct<{
+    readonly kind: Schema.Literal<"music">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly playback: Schema.optionalKey<Schema.String>;
+    readonly stop: Schema.optionalKey<Schema.Literal<true>>;
+    readonly mood: Schema.optionalKey<Schema.String>;
+    readonly volume: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdMusic = typeof cmdMusic.Type;
+/**
+ * `::sfx` (dsl 0.37.0 §5.3).
+ */
+export declare const cmdSfx: Schema.Struct<{
+    readonly kind: Schema.Literal<"sfx">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly sound: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdSfx = typeof cmdSfx.Type;
+/**
+ * `::vfx` (dsl 0.37.0 §5.3).
+ */
+export declare const cmdVfx: Schema.Struct<{
+    readonly kind: Schema.Literal<"vfx">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly type: Schema.String;
+    readonly label: Schema.optionalKey<Schema.String>;
+    readonly transition: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdVfx = typeof cmdVfx.Type;
+/**
+ * `::actor` (dsl 0.37.0 §5.1/§5.3): an authored actor record or a compiler-injected one (anchor, preload, position reset, hide — §7.4). Injected records carry `provenance`; `posReset` and `preload` appear only on injected records.
+ */
+export declare const cmdActor: Schema.Struct<{
+    readonly kind: Schema.Literal<"actor">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly character: Schema.String;
+    readonly anchor: Schema.optionalKey<Schema.String>;
+    readonly action: Schema.optionalKey<Schema.String>;
+    readonly exit: Schema.optionalKey<Schema.Boolean>;
+    readonly emotion: Schema.optionalKey<Schema.String>;
+    readonly costume: Schema.optionalKey<Schema.String>;
+    readonly posReset: Schema.optionalKey<Schema.Boolean>;
+    readonly preload: Schema.optionalKey<Schema.Boolean>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdActor = typeof cmdActor.Type;
+/**
+ * `::camera` (dsl 0.37.0 D1, §5.3): opaque project-domain members; at least one is present after checking. No numeric transform is synthesized.
+ */
+export declare const cmdCamera: Schema.Union<readonly [Schema.Struct<{
+    readonly focus: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly framing: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly move: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly transition: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+export type cmdCamera = typeof cmdCamera.Type;
+/**
+ * `::cg` (dsl 0.37.0 D2, §5.3): a CG image.
+ */
+export declare const cmdCg: Schema.Struct<{
+    readonly kind: Schema.Literal<"cg">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly assetId: Schema.String;
+    readonly display: Schema.String;
+    readonly layout: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdCg = typeof cmdCg.Type;
+/**
+ * `::video` (dsl 0.37.0 D2, §5.3).
+ */
+export declare const cmdVideo: Schema.Struct<{
+    readonly kind: Schema.Literal<"video">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly assetId: Schema.String;
+    readonly display: Schema.String;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdVideo = typeof cmdVideo.Type;
+/**
+ * `::sequence{name}` (dsl 0.37.0 D3, §5.3): a reference to a project-declared external cinematic. Carries only its name and resolved `timing` (`wait` defaults to true); no bound characters. The reference runner records it without simulating the sequence.
+ */
+export declare const cmdSequence: Schema.Struct<{
+    readonly kind: Schema.Literal<"sequence">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly name: Schema.String;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdSequence = typeof cmdSequence.Type;
+/**
+ * A state write (§4.4).
+ */
+export declare const cmdSet: Schema.Struct<{
+    readonly kind: Schema.Literal<"set">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly path: Schema.String;
+    readonly op: Schema.String;
+    readonly value: Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdSet = typeof cmdSet.Type;
+/**
+ * One asserted fact delta (dsl 0.3.0 §5). DATA only — the engine applies it as a positive write to the relation's fact set.
+ */
+export declare const cmdAssert: Schema.Struct<{
+    readonly kind: Schema.Literal<"assert">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly relation: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdAssert = typeof cmdAssert.Type;
+/**
+ * One retracted fact delta (dsl 0.3.0 §5). The engine applies it as a negative write; "_" positions are a bulk wildcard the engine resolves.
+ */
+export declare const cmdRetract: Schema.Struct<{
+    readonly kind: Schema.Literal<"retract">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly relation: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdRetract = typeof cmdRetract.Type;
+/**
+ * `<choice>` (dsl 0.37.0 §5.3): a player selection; each option's segment is followed by `converge`.
+ */
+export declare const cmdChoice: Schema.Struct<{
+    readonly kind: Schema.Literal<"choice">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly branchId: Schema.String;
+    readonly selectionKey: Schema.String;
+    readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly text: Schema.String;
+        readonly lineId: Schema.String;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.suspend<Schema.String>;
+        readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"path">;
+            readonly path: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ref">;
+            readonly ref: Schema.String;
+            readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reserved">;
+            readonly token: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"occasionTarget">;
+            readonly entityKind: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>]>>>>;
+        readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    }>>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly prompt: Schema.optionalKey<Schema.String>;
+    readonly timeout: Schema.optionalKey<Schema.Int>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdChoice = typeof cmdChoice.Type;
+/**
+ * `<match>` (dsl 0.37.0 §5.3): the first arm whose test holds runs; otherwise `otherwise`, then `converge`.
+ */
+export declare const cmdMatch: Schema.Struct<{
+    readonly kind: Schema.Literal<"match">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly subject: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly arms: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly is: Schema.optionalKey<Schema.String>;
+        readonly test: Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly target: Schema.suspend<Schema.String>;
+    }>>>;
+    readonly otherwise: Schema.optionalKey<Schema.suspend<Schema.String>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdMatch = typeof cmdMatch.Type;
+/**
+ * <hub> (§7.3.2): a choice plus revisit semantics; re-presentation is a runtime property of the hub kind (no backward jump emitted).
+ */
+export declare const cmdHub: Schema.Struct<{
+    readonly kind: Schema.Literal<"hub">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly selectionKey: Schema.String;
+    readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly text: Schema.String;
+        readonly lineId: Schema.String;
+        readonly once: Schema.Boolean;
+        readonly exit: Schema.Boolean;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.suspend<Schema.String>;
+        readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"path">;
+            readonly path: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ref">;
+            readonly ref: Schema.String;
+            readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reserved">;
+            readonly token: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"occasionTarget">;
+            readonly entityKind: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>]>>>>;
+        readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    }>>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly prompt: Schema.optionalKey<Schema.String>;
+    readonly return: Schema.optionalKey<Schema.suspend<Schema.String>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdHub = typeof cmdHub.Type;
+/**
+ * Unconditional control-flow jump. Carries no `timing`, `provenance`, or `source`.
+ */
+export declare const cmdJump: Schema.Struct<{
+    readonly kind: Schema.Literal<"jump">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly target: Schema.suspend<Schema.String>;
+}>;
+export type cmdJump = typeof cmdJump.Type;
+/**
+ * dsl 0.8.0 §3: terminate the walk at this record. Equivalent to falling off the end of `commands`, except `reason` is carried.
+ */
+export declare const cmdEnd: Schema.Struct<{
+    readonly kind: Schema.Literal<"end">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdEnd = typeof cmdEnd.Type;
+/**
+ * A timeline join point (dsl 0.37.0 §5.2). Carries no `timing`: its join fields are direct, so they cannot collide with a record's timing. The reference runner records it as a join and simulates no elapsed time.
+ */
+export declare const cmdBarrier: Schema.Struct<{
+    readonly kind: Schema.Literal<"barrier">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly timeline: Schema.Int;
+    readonly at: Schema.Number;
+}>;
+export type cmdBarrier = typeof cmdBarrier.Type;
+/**
+ * <quest> declaration head (dsl 0.2.0 §6.3). Objective completion bodies and <on> arms follow as their own positioned records.
+ */
+export declare const cmdQuest: Schema.Struct<{
+    readonly kind: Schema.Literal<"quest">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly start: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly fail: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly objectives: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly titleLineId: Schema.optionalKey<Schema.String>;
+        readonly done: Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly visibleWhen: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly optional: Schema.Boolean;
+        readonly body: Schema.NullOr<Schema.suspend<Schema.String>>;
+        readonly quest: Schema.optionalKey<Schema.String>;
+        readonly rewards: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly id: Schema.optionalKey<Schema.String>;
+            readonly kind: Schema.String;
+            readonly target: Schema.optionalKey<Schema.String>;
+            readonly amount: Schema.optionalKey<Schema.Int>;
+            readonly amountMin: Schema.optionalKey<Schema.Int>;
+            readonly amountMax: Schema.optionalKey<Schema.Int>;
+            readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+            readonly credits: Schema.optionalKey<Schema.String>;
+        }>>>>;
+        readonly on: Schema.optionalKey<Schema.String>;
+        readonly by: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly until: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>>>;
+    readonly rewards: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly kind: Schema.String;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly amount: Schema.optionalKey<Schema.Int>;
+        readonly amountMin: Schema.optionalKey<Schema.Int>;
+        readonly amountMax: Schema.optionalKey<Schema.Int>;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+        readonly credits: Schema.optionalKey<Schema.String>;
+    }>>>>;
+    readonly rearm: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly tier: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["run"]>, Schema.String]>>;
+    readonly activate: Schema.optionalKey<Schema.Literals<readonly ["accept"]>>;
+    readonly complete: Schema.optionalKey<Schema.Literals<readonly ["any"]>>;
+    readonly accept: Schema.optionalKey<Schema.Literals<readonly ["external"]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdQuest = typeof cmdQuest.Type;
+/**
+ * <on> event-condition-action record (dsl 0.2.0 §4, §6.6): an independent event rule.
+ */
+export declare const cmdOn: Schema.Struct<{
+    readonly kind: Schema.Literal<"on">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly event: Schema.String;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdOn = typeof cmdOn.Type;
+/**
+ * <entry> declaration head of a lore artifact (dsl 0.19.0 §7, docs/runtime/lore-entries.md): content the engine looks up rather than plays.
+ */
+export declare const cmdEntry: Schema.Struct<{
+    readonly kind: Schema.Literal<"entry">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly category: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly series: Schema.optionalKey<Schema.String>;
+    readonly order: Schema.optionalKey<Schema.Int>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly on: Schema.optionalKey<Schema.String>;
+    readonly priority: Schema.optionalKey<Schema.Int>;
+    readonly once: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "day", "slot", "week"]>, Schema.String]>>;
+    readonly share: Schema.optionalKey<Schema.String>;
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdEntry = typeof cmdEntry.Type;
+/**
+ * `::accept{quest}` (dsl 0.21.0 §7a.3): the player accepts an accept-driven quest at this point — the scene-side form of the engine's accept action. The engine activates the quest if its state is `unset` (stamping `activatedAt` as for any activation) and ignores the record otherwise (docs/runtime/quest-lifecycle.md).
+ */
+export declare const cmdAccept: Schema.Struct<{
+    readonly kind: Schema.Literal<"accept">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly quest: Schema.String;
+    readonly applies: Schema.optionalKey<Schema.Literals<readonly ["nextRun"]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdAccept = typeof cmdAccept.Type;
+/**
+ * A bundle beat's declaration head in a lore artifact (dsl 0.23.0 §4, docs/runtime/beats-and-occasions.md): a scene-like beat written in a lore document. It is the first record of its own addressing unit; the engine presents its body like a scene when the beat wins its occasion.
+ */
+export declare const cmdBeat: Schema.Struct<{
+    readonly kind: Schema.Literal<"beat">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly on: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly priority: Schema.Int;
+    readonly once: Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>;
+    readonly also: Schema.optionalKey<Schema.Literal<true>>;
+    readonly share: Schema.optionalKey<Schema.String>;
+    readonly after: Schema.optionalKey<Schema.String>;
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdBeat = typeof cmdBeat.Type;
+/**
+ * Plugin-directive passthrough (Rust `Command::Plugin`), serialized as kind `plugin`. Declared fields and effects are opaque to core. Plugin `stampAttrs` cross-cutting attrs appear as further top-level keys beside `timing`.
+ */
+export declare const cmdPlugin: Schema.Struct<{
+    readonly kind: Schema.Literal<"plugin">;
+    readonly family: Schema.Literal<"plugin">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly tag: Schema.String;
+    readonly plugin: Schema.optionalKey<Schema.String>;
+    readonly fields: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly effects: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly from: Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+            readonly bridgeResult: Schema.String;
+        }>, Schema.Struct<{
+            readonly op: Schema.String;
+            readonly by: Schema.Number;
+        }>, Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>]>>;
+    }>>>>;
+    readonly retracts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly asserts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>;
+export type cmdPlugin = typeof cmdPlugin.Type;
+/**
+ * Kind-polymorphic envelope meta (untagged): SceneMeta when kind==scene, QuestMeta when kind==quest, LoreMeta when kind==lore. The shapes overlap (a bare `{"id": …}` fits all three, since dsl 0.19.0 §2.1 gives quest and lore documents an optional `id`), so this is `anyOf`, not `oneOf`: the top-level allOf pins the exact one by `kind`.
+ */
+export declare const artifactMeta: Schema.Union<readonly [Schema.suspend<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly character: Schema.optionalKey<Schema.String>;
+    readonly season: Schema.optionalKey<Schema.Int>;
+    readonly episode: Schema.optionalKey<Schema.Int>;
+    readonly episodeId: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean]>>]>>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly beat: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly on: Schema.String;
+        readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly prefix: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly priority: Schema.Int;
+        readonly once: Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>;
+        readonly also: Schema.optionalKey<Schema.Literal<true>>;
+        readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly share: Schema.optionalKey<Schema.String>;
+        readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly contentLang: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Number, Schema.Boolean]>>]>>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly series: Schema.optionalKey<Schema.String>;
+    readonly contentLang: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>>]>;
+export type artifactMeta = typeof artifactMeta.Type;
+/**
+ * Lore-kind envelope meta (dsl 0.19.0 §7): `id?`, `title?`, `series?`, `contentLang?`, `extra?`, `plugin?` — every field skipped when unauthored, so it MAY serialize as {}. Present when `kind` == "lore".
+ */
+export declare const loreMeta: Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly series: Schema.optionalKey<Schema.String>;
+    readonly contentLang: Schema.optionalKey<Schema.String>;
+    readonly extra: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly plugin: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type loreMeta = typeof loreMeta.Type;
+/**
+ * One row of `project.index.json` `entries` (dsl 0.19.0 §7; `lute compile --all`): every `<entry>` in the project, documents in path order, entries in document order within each. The index itself is not an artifact; this row shape is published here for engines that read it. `entries` is omitted from the index when the project has no lore.
+ */
+export declare const indexEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly document: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly category: Schema.optionalKey<Schema.String>;
+    readonly series: Schema.optionalKey<Schema.String>;
+    readonly order: Schema.optionalKey<Schema.Int>;
+}>;
+export type indexEntry = typeof indexEntry.Type;
+/**
+ * One row of `project.index.json` `beats` (dsl 0.21.0 §8; `lute compile --all`): every scene, entry and bundle beat in the project, documents in path order, declaration order within each. Row order is the selection tiebreak after priority (docs/runtime/beats-and-occasions.md). `beats` is omitted from the index when the project has no beats.
+ */
+export declare const indexBeat: Schema.Struct<{
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["scene", "entry", "bundle"]>;
+    readonly document: Schema.String;
+    readonly on: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly priority: Schema.Int;
+    readonly once: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>>;
+    readonly spentBy: Schema.optionalKey<Schema.String>;
+    readonly when: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly share: Schema.optionalKey<Schema.String>;
+}>;
+export type indexBeat = typeof indexBeat.Type;
+/**
+ * dsl 0.37.0 §5.3: one authored document section. Purely descriptive — control flow never references it.
+ */
+export declare const sectionEntry: Schema.Struct<{
+    readonly section: Schema.Int;
+    readonly heading: Schema.String;
+    readonly id: Schema.optionalKey<Schema.String>;
+}>;
+export type sectionEntry = typeof sectionEntry.Type;
+/**
+ * dsl 0.24.0 §1: the project's declared clock, verbatim from the schema's `clock:` block. Carried on the artifact root and on `project.index.json` (`lute compile --all`) as `clock`. The engine derives the reserved read-only paths from it — `clock.index` = `(day - 1) * len(slots) + slotIndex` (`day - 1` without slots; monotone), `clock.weekday` = `(week.first + day - 1) mod week.length`, `clock.weekdayLabel` = `week.labelsclock.weekday` — none of which is a `state` row, and spends `once: day|slot` beats by it. An advance moves the clock forward only (the last slot wraps to the first slot of the next day), settles quests and raises `raise` (`dayEnd` / `dayStart` at each midnight it crosses, `slot` where it stops) when declared. dsl 0.27.0 §4: a finite clock (`last` / `days`) stops at its last position — an advance whose destination lies past it walks there (raising `dayEnd` / `dayStart` at each midnight it crosses on the way), raises the last day's `dayEnd` (never `slot`) and ends the clock; any later advance is the usage error `E-CLOCK-END` until a new run starts the clock over.
+ */
+export declare const clockDecl: Schema.Struct<{
+    readonly day: Schema.String;
+    readonly slot: Schema.optionalKey<Schema.String>;
+    readonly slots: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly raise: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly slot: Schema.optionalKey<Schema.String>;
+        readonly dayStart: Schema.optionalKey<Schema.String>;
+        readonly dayEnd: Schema.optionalKey<Schema.String>;
+    }>]>>;
+    readonly raiseAtStart: Schema.optionalKey<Schema.Literal<true>>;
+    readonly week: Schema.optionalKey<Schema.Struct<{
+        readonly length: Schema.Int;
+        readonly first: Schema.Int;
+        readonly labels: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>;
+    readonly last: Schema.optionalKey<Schema.Struct<{
+        readonly day: Schema.Int;
+        readonly slot: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly days: Schema.optionalKey<Schema.Int>;
+}>;
+export type clockDecl = typeof clockDecl.Type;
+/**
+ * The serializable capability occasion shape in project.index.json, without description or raisedWhen.
+ */
+export declare const indexOccasion: Schema.Struct<{}>;
+export type indexOccasion = typeof indexOccasion.Type;
+/**
+ * A closed state member domain, keyed by state path in project.index.json.
+ */
+export declare const indexStateDomain: Schema.Struct<{}>;
+export type indexStateDomain = typeof indexStateDomain.Type;
+/**
+ * The optional capability unions carried by project.index.json.
+ */
+export declare const projectIndex: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type projectIndex = typeof projectIndex.Type;
+/**
+ * One command record (dsl 0.37.0 §5.3), tagged on `kind` with its `family`. An engine MUST error on an unknown `kind` (version-negotiation policy, top-level description); it MUST ignore unknown FIELDS within a known record.
+ */
+export declare const Command: Schema.Union<readonly [Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"line">;
+    readonly family: Schema.Literal<"content">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly role: Schema.suspend<Schema.Literals<readonly ["dialogue", "narration", "mono", "os", "vo"]>>;
+    readonly speaker: Schema.String;
+    readonly text: Schema.String;
+    readonly emotion: Schema.optionalKey<Schema.String>;
+    readonly variant: Schema.optionalKey<Schema.Int>;
+    readonly action: Schema.optionalKey<Schema.String>;
+    readonly dialogMotion: Schema.optionalKey<Schema.String>;
+    readonly as: Schema.optionalKey<Schema.String>;
+    readonly lineId: Schema.String;
+    readonly voiceKey: Schema.String;
+    readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"path">;
+        readonly path: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ref">;
+        readonly ref: Schema.String;
+        readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"reserved">;
+        readonly token: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"occasionTarget">;
+        readonly entityKind: Schema.String;
+        readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+    }>]>>>>;
+    readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly segments: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+        readonly text: Schema.String;
+        readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly rate: Schema.optionalKey<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly pause: Schema.Number;
+    }>]>>>>>;
+    readonly localeSegments: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+        readonly text: Schema.String;
+        readonly styles: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly rate: Schema.optionalKey<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly pause: Schema.Number;
+    }>]>>>>>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"bg">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly location: Schema.optionalKey<Schema.String>;
+    readonly time: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"music">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly playback: Schema.optionalKey<Schema.String>;
+    readonly stop: Schema.optionalKey<Schema.Literal<true>>;
+    readonly mood: Schema.optionalKey<Schema.String>;
+    readonly volume: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"sfx">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly sound: Schema.optionalKey<Schema.String>;
+    readonly assetId: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"vfx">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly type: Schema.String;
+    readonly label: Schema.optionalKey<Schema.String>;
+    readonly transition: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"actor">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly character: Schema.String;
+    readonly anchor: Schema.optionalKey<Schema.String>;
+    readonly action: Schema.optionalKey<Schema.String>;
+    readonly exit: Schema.optionalKey<Schema.Boolean>;
+    readonly emotion: Schema.optionalKey<Schema.String>;
+    readonly costume: Schema.optionalKey<Schema.String>;
+    readonly posReset: Schema.optionalKey<Schema.Boolean>;
+    readonly preload: Schema.optionalKey<Schema.Boolean>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+    readonly focus: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly framing: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly move: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly transition: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"cg">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly assetId: Schema.String;
+    readonly display: Schema.String;
+    readonly layout: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"video">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly assetId: Schema.String;
+    readonly display: Schema.String;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"sequence">;
+    readonly family: Schema.Literal<"staging">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly name: Schema.String;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"set">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly path: Schema.String;
+    readonly op: Schema.String;
+    readonly value: Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"assert">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly relation: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"retract">;
+    readonly family: Schema.Literal<"state">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly relation: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"choice">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly branchId: Schema.String;
+    readonly selectionKey: Schema.String;
+    readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly text: Schema.String;
+        readonly lineId: Schema.String;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.suspend<Schema.String>;
+        readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"path">;
+            readonly path: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ref">;
+            readonly ref: Schema.String;
+            readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reserved">;
+            readonly token: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"occasionTarget">;
+            readonly entityKind: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>]>>>>;
+        readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    }>>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly prompt: Schema.optionalKey<Schema.String>;
+    readonly timeout: Schema.optionalKey<Schema.Int>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"match">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly subject: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly arms: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly is: Schema.optionalKey<Schema.String>;
+        readonly test: Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly target: Schema.suspend<Schema.String>;
+    }>>>;
+    readonly otherwise: Schema.optionalKey<Schema.suspend<Schema.String>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"hub">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly selectionKey: Schema.String;
+    readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly text: Schema.String;
+        readonly lineId: Schema.String;
+        readonly once: Schema.Boolean;
+        readonly exit: Schema.Boolean;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.suspend<Schema.String>;
+        readonly placeholders: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"path">;
+            readonly path: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ref">;
+            readonly ref: Schema.String;
+            readonly expr: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+            readonly forms: Schema.optionalKey<Schema.suspend<Schema.$Array<Schema.String>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reserved">;
+            readonly token: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"occasionTarget">;
+            readonly entityKind: Schema.String;
+            readonly format: Schema.optionalKey<Schema.suspend<Schema.Literals<readonly ["ordinal", "ordinalWord", "cardinalWord", "plural", "capitalize", "start", "indefinite"]>>>;
+        }>]>>>>;
+        readonly texts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    }>>>;
+    readonly converge: Schema.suspend<Schema.String>;
+    readonly prompt: Schema.optionalKey<Schema.String>;
+    readonly return: Schema.optionalKey<Schema.suspend<Schema.String>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"jump">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly target: Schema.suspend<Schema.String>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"end">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"barrier">;
+    readonly family: Schema.Literal<"control">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly timeline: Schema.Int;
+    readonly at: Schema.Number;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"quest">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly start: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly fail: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly objectives: Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly titleLineId: Schema.optionalKey<Schema.String>;
+        readonly done: Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly visibleWhen: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly optional: Schema.Boolean;
+        readonly body: Schema.NullOr<Schema.suspend<Schema.String>>;
+        readonly quest: Schema.optionalKey<Schema.String>;
+        readonly rewards: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly id: Schema.optionalKey<Schema.String>;
+            readonly kind: Schema.String;
+            readonly target: Schema.optionalKey<Schema.String>;
+            readonly amount: Schema.optionalKey<Schema.Int>;
+            readonly amountMin: Schema.optionalKey<Schema.Int>;
+            readonly amountMax: Schema.optionalKey<Schema.Int>;
+            readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+            readonly credits: Schema.optionalKey<Schema.String>;
+        }>>>>;
+        readonly on: Schema.optionalKey<Schema.String>;
+        readonly by: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly until: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>>>;
+    readonly rewards: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly kind: Schema.String;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly amount: Schema.optionalKey<Schema.Int>;
+        readonly amountMin: Schema.optionalKey<Schema.Int>;
+        readonly amountMax: Schema.optionalKey<Schema.Int>;
+        readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["failed"]>>;
+        readonly credits: Schema.optionalKey<Schema.String>;
+    }>>>>;
+    readonly rearm: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly tier: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["run"]>, Schema.String]>>;
+    readonly activate: Schema.optionalKey<Schema.Literals<readonly ["accept"]>>;
+    readonly complete: Schema.optionalKey<Schema.Literals<readonly ["any"]>>;
+    readonly accept: Schema.optionalKey<Schema.Literals<readonly ["external"]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"on">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly event: Schema.String;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"entry">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly category: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly series: Schema.optionalKey<Schema.String>;
+    readonly order: Schema.optionalKey<Schema.Int>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly on: Schema.optionalKey<Schema.String>;
+    readonly priority: Schema.optionalKey<Schema.Int>;
+    readonly once: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "day", "slot", "week"]>, Schema.String]>>;
+    readonly share: Schema.optionalKey<Schema.String>;
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"accept">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly quest: Schema.String;
+    readonly applies: Schema.optionalKey<Schema.Literals<readonly ["nextRun"]>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"beat">;
+    readonly family: Schema.Literal<"declaration">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly id: Schema.String;
+    readonly on: Schema.String;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly titleLineId: Schema.optionalKey<Schema.String>;
+    readonly when: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly priority: Schema.Int;
+    readonly once: Schema.Union<readonly [Schema.Literals<readonly ["run", "user", "none", "day", "slot", "week"]>, Schema.String]>;
+    readonly also: Schema.optionalKey<Schema.Literal<true>>;
+    readonly share: Schema.optionalKey<Schema.String>;
+    readonly after: Schema.optionalKey<Schema.String>;
+    readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly prefix: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly spentBy: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly cel: Schema.String;
+        readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly authored: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+    readonly body: Schema.suspend<Schema.String>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>, Schema.suspend<Schema.Struct<{
+    readonly kind: Schema.Literal<"plugin">;
+    readonly family: Schema.Literal<"plugin">;
+    readonly position: Schema.suspend<Schema.String>;
+    readonly tag: Schema.String;
+    readonly plugin: Schema.optionalKey<Schema.String>;
+    readonly fields: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly effects: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly from: Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+            readonly bridgeResult: Schema.String;
+        }>, Schema.Struct<{
+            readonly op: Schema.String;
+            readonly by: Schema.Number;
+        }>, Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>]>>;
+    }>>>>;
+    readonly retracts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly asserts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly relation: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly timing: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly wait: Schema.optionalKey<Schema.Boolean>;
+        readonly duration: Schema.optionalKey<Schema.Number>;
+        readonly delay: Schema.optionalKey<Schema.Number>;
+        readonly at: Schema.optionalKey<Schema.Number>;
+        readonly timeline: Schema.optionalKey<Schema.Int>;
+    }>>>;
+    readonly provenance: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly by: Schema.String;
+        readonly explanation: Schema.String;
+    }>>>;
+    readonly source: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+        readonly component: Schema.String;
+    }>>>;
+}>>]>;
+export type Command = typeof Command.Type;