@lute-lang/runtime 0.40.0 → 0.41.1

package/dist/index-tecmws3f.js

@@ -0,0 +1,2168 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/generated/Ir.ts
+var exports_Ir = {};
+__export(exports_Ir, {
+  Command: () => Command,
+  artifactMeta: () => artifactMeta,
+  atomEntry: () => atomEntry,
+  bodyEntry: () => bodyEntry,
+  celEnv: () => celEnv,
+  celSlot: () => celSlot,
+  choiceOption: () => choiceOption,
+  clockDecl: () => clockDecl,
+  cmdAccept: () => cmdAccept,
+  cmdActor: () => cmdActor,
+  cmdAssert: () => cmdAssert,
+  cmdBarrier: () => cmdBarrier,
+  cmdBeat: () => cmdBeat,
+  cmdBg: () => cmdBg,
+  cmdCamera: () => cmdCamera,
+  cmdCg: () => cmdCg,
+  cmdChoice: () => cmdChoice,
+  cmdEnd: () => cmdEnd,
+  cmdEntry: () => cmdEntry,
+  cmdHub: () => cmdHub,
+  cmdJump: () => cmdJump,
+  cmdLine: () => cmdLine,
+  cmdMatch: () => cmdMatch,
+  cmdMusic: () => cmdMusic,
+  cmdOn: () => cmdOn,
+  cmdPlugin: () => cmdPlugin,
+  cmdQuest: () => cmdQuest,
+  cmdRetract: () => cmdRetract,
+  cmdSequence: () => cmdSequence,
+  cmdSet: () => cmdSet,
+  cmdSfx: () => cmdSfx,
+  cmdVfx: () => cmdVfx,
+  cmdVideo: () => cmdVideo,
+  effect: () => effect,
+  effectSource: () => effectSource,
+  entityKindEntry: () => entityKindEntry,
+  enumEntry: () => enumEntry,
+  exprNode: () => exprNode,
+  family: () => family,
+  fieldType: () => fieldType,
+  forKind: () => forKind,
+  hubOption: () => hubOption,
+  indexBeat: () => indexBeat,
+  indexDef: () => indexDef,
+  indexDocument: () => indexDocument,
+  indexEntry: () => indexEntry,
+  indexOccasion: () => indexOccasion,
+  indexStateDomain: () => indexStateDomain,
+  labelForms: () => labelForms,
+  loreMeta: () => loreMeta,
+  matchArm: () => matchArm,
+  objectiveEntry: () => objectiveEntry,
+  placeholder: () => placeholder,
+  placeholderFormat: () => placeholderFormat,
+  placeholderForms: () => placeholderForms,
+  position: () => position,
+  prereqEdgeEntry: () => prereqEdgeEntry,
+  prereqFormula: () => prereqFormula,
+  projectIndex: () => projectIndex,
+  provenance: () => provenance,
+  questMeta: () => questMeta,
+  relationEntry: () => relationEntry,
+  rewardEntry: () => rewardEntry,
+  role: () => role,
+  ruleEntry: () => ruleEntry,
+  sceneBeat: () => sceneBeat,
+  sceneMeta: () => sceneMeta,
+  sectionEntry: () => sectionEntry,
+  seedFactEntry: () => seedFactEntry,
+  segment: () => segment,
+  segments: () => segments,
+  source: () => source,
+  stateEntry: () => stateEntry,
+  targetKind: () => targetKind,
+  termEntry: () => termEntry,
+  timing: () => timing
+});
+import * as Schema from "effect/Schema";
+var provenance = Schema.Struct({
+  by: Schema.String,
+  explanation: Schema.String
+});
+var source = Schema.Struct({
+  component: Schema.String
+});
+var position = Schema.String;
+var family = Schema.Literals([
+  "content",
+  "staging",
+  "state",
+  "control",
+  "declaration",
+  "plugin"
+]);
+var timing = Schema.Struct({
+  wait: Schema.optionalKey(Schema.Boolean),
+  duration: Schema.optionalKey(Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))),
+  delay: Schema.optionalKey(Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))),
+  at: Schema.optionalKey(Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))),
+  timeline: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))))
+});
+var segment = Schema.Union([
+  Schema.Struct({
+    text: Schema.String,
+    styles: Schema.optionalKey(Schema.Array(Schema.String)),
+    rate: Schema.optionalKey(Schema.Number)
+  }),
+  Schema.Struct({
+    pause: Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))
+  })
+]);
+var segments = Schema.Array(Schema.suspend(() => segment));
+var exprNode = Schema.Union([
+  Schema.Struct({
+    int: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(-9007199254740992)))
+  }),
+  Schema.Struct({
+    double: Schema.Number
+  }),
+  Schema.Struct({
+    bool: Schema.Boolean
+  }),
+  Schema.Struct({
+    string: Schema.String
+  }),
+  Schema.Struct({
+    list: Schema.Array(Schema.Json)
+  }),
+  Schema.Struct({
+    path: Schema.String
+  }),
+  Schema.Struct({
+    index: Schema.Json,
+    key: Schema.Json
+  }),
+  Schema.Struct({
+    has: Schema.String
+  }),
+  Schema.Struct({
+    op: Schema.Literals([
+      "!",
+      "-"
+    ]),
+    l: Schema.Json
+  }),
+  Schema.Struct({
+    op: Schema.Literals([
+      "&&",
+      "||",
+      "==",
+      "!=",
+      "<",
+      "<=",
+      ">",
+      ">=",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "in"
+    ]),
+    l: Schema.Json,
+    r: Schema.Json
+  }),
+  Schema.Struct({
+    cond: Schema.Json,
+    then: Schema.Json,
+    else: Schema.Json
+  }),
+  Schema.Struct({
+    call: Schema.String,
+    args: Schema.Array(Schema.Json)
+  }),
+  Schema.Struct({
+    param: Schema.String
+  })
+]);
+var celSlot = Schema.Struct({
+  cel: Schema.String,
+  expr: Schema.Json,
+  authored: Schema.optionalKey(Schema.String)
+});
+var celEnv = Schema.Struct({
+  variables: Schema.Array(Schema.Struct({
+    name: Schema.String,
+    type: Schema.String
+  })),
+  functions: Schema.Array(Schema.Struct({
+    name: Schema.String,
+    overloads: Schema.Array(Schema.Struct({
+      params: Schema.Array(Schema.String),
+      result: Schema.String
+    }))
+  }))
+});
+var placeholder = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("path"),
+    path: Schema.String,
+    format: Schema.optionalKey(Schema.suspend(() => placeholderFormat)),
+    forms: Schema.optionalKey(Schema.suspend(() => placeholderForms))
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("ref"),
+    ref: Schema.String,
+    expr: Schema.optionalKey(Schema.suspend(() => celSlot)),
+    format: Schema.optionalKey(Schema.suspend(() => placeholderFormat)),
+    forms: Schema.optionalKey(Schema.suspend(() => placeholderForms))
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("reserved"),
+    token: Schema.String,
+    format: Schema.optionalKey(Schema.suspend(() => placeholderFormat))
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("occasionTarget"),
+    entityKind: Schema.String,
+    format: Schema.optionalKey(Schema.suspend(() => placeholderFormat))
+  })
+]).pipe(Schema.toTaggedUnion("kind"));
+var placeholderFormat = Schema.Literals([
+  "ordinal",
+  "ordinalWord",
+  "cardinalWord",
+  "plural",
+  "capitalize",
+  "start",
+  "indefinite"
+]);
+var labelForms = Schema.Record(Schema.String, Schema.Struct({
+  start: Schema.optionalKey(Schema.String),
+  indefinite: Schema.optionalKey(Schema.String)
+}));
+var placeholderForms = Schema.Array(Schema.String);
+var role = Schema.Literals([
+  "dialogue",
+  "narration",
+  "mono",
+  "os",
+  "vo"
+]);
+var entityKindEntry = Schema.Struct({
+  name: Schema.String,
+  members: Schema.optionalKey(Schema.Array(Schema.String)),
+  open: Schema.Boolean,
+  labels: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  labelForms: Schema.optionalKey(Schema.suspend(() => labelForms))
+});
+var enumEntry = Schema.Struct({
+  name: Schema.String,
+  members: Schema.Array(Schema.String),
+  labels: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+});
+var relationEntry = Schema.Struct({
+  name: Schema.String,
+  args: Schema.Array(Schema.String),
+  tier: Schema.optionalKey(Schema.String),
+  derive: Schema.Boolean,
+  reserved: Schema.Boolean,
+  key: Schema.optionalKey(Schema.Array(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))))),
+  excludes: Schema.optionalKey(Schema.Array(Schema.String))
+});
+var seedFactEntry = Schema.Struct({
+  relation: Schema.String,
+  args: Schema.Array(Schema.String)
+});
+var termEntry = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("var"),
+    name: Schema.String
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("const"),
+    value: Schema.String
+  })
+]).pipe(Schema.toTaggedUnion("kind"));
+var atomEntry = Schema.Struct({
+  relation: Schema.String,
+  terms: Schema.Array(Schema.suspend(() => termEntry))
+});
+var bodyEntry = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("atom"),
+    atom: Schema.suspend(() => atomEntry),
+    negated: Schema.Boolean
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("guard"),
+    cel: Schema.suspend(() => celSlot)
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("cmp"),
+    lhs: Schema.suspend(() => termEntry),
+    rhs: Schema.suspend(() => termEntry),
+    negated: Schema.Boolean
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("count"),
+    atom: Schema.suspend(() => atomEntry),
+    distinct: Schema.optionalKey(Schema.Array(Schema.String)),
+    op: Schema.Literals([
+      "==",
+      "!=",
+      "<",
+      "<=",
+      ">",
+      ">="
+    ]),
+    n: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))
+  })
+]).pipe(Schema.toTaggedUnion("kind"));
+var ruleEntry = Schema.Struct({
+  head: Schema.suspend(() => atomEntry),
+  body: Schema.Array(Schema.suspend(() => bodyEntry)),
+  raw: Schema.String
+});
+var prereqEdgeEntry = Schema.Struct({
+  node: Schema.String,
+  after: Schema.optionalKey(Schema.String),
+  follows: Schema.optionalKey(Schema.String),
+  formula: Schema.optionalKey(Schema.Json)
+}).check(Schema.makeFilter((value) => [
+  [
+    "after"
+  ],
+  [
+    "follows"
+  ]
+].filter((keys) => keys.every((key) => (key in value))).length === 1 || "expected exactly one of the key sets: after | follows"));
+var prereqFormula = Schema.Union([
+  Schema.Struct({
+    visited: Schema.String
+  }),
+  Schema.Struct({
+    completed: Schema.String
+  }),
+  Schema.Struct({
+    active: Schema.String
+  }),
+  Schema.Struct({
+    and: Schema.Tuple([
+      Schema.Json,
+      Schema.Json
+    ])
+  }),
+  Schema.Struct({
+    or: Schema.Tuple([
+      Schema.Json,
+      Schema.Json
+    ])
+  })
+]);
+var sceneMeta = Schema.Struct({
+  id: Schema.String,
+  character: Schema.optionalKey(Schema.String),
+  season: Schema.optionalKey(Schema.Int),
+  episode: Schema.optionalKey(Schema.Int),
+  episodeId: Schema.optionalKey(Schema.String),
+  title: Schema.optionalKey(Schema.String),
+  extra: Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([
+    Schema.String,
+    Schema.Int,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Array(Schema.Union([
+      Schema.String,
+      Schema.Int,
+      Schema.Number,
+      Schema.Boolean
+    ]))
+  ]))),
+  plugin: Schema.optionalKey(Schema.Json),
+  beat: Schema.optionalKey(Schema.suspend(() => sceneBeat))
+});
+var targetKind = Schema.Struct({
+  kind: Schema.String,
+  prefix: Schema.String,
+  members: Schema.Array(Schema.String)
+});
+var forKind = Schema.Struct({
+  kind: Schema.String,
+  members: Schema.Array(Schema.String)
+});
+var sceneBeat = Schema.Struct({
+  on: Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$")))),
+  targetKind: Schema.optionalKey(Schema.suspend(() => targetKind)),
+  forKind: Schema.optionalKey(Schema.suspend(() => forKind)),
+  target: Schema.optionalKey(Schema.String),
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  priority: Schema.Int,
+  once: Schema.Union([
+    Schema.Literals([
+      "run",
+      "user",
+      "none",
+      "day",
+      "slot",
+      "week"
+    ]),
+    Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^season:[A-Za-z0-9_][A-Za-z0-9_-]*$"))))
+  ]),
+  also: Schema.optionalKey(Schema.Literal(true)),
+  spentBy: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  share: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  advances: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "slot",
+      "day"
+    ]),
+    Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1)))
+  ]))
+});
+var questMeta = Schema.Struct({
+  id: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*(\\.[A-Za-z0-9_][A-Za-z0-9_-]*)*$"))))),
+  title: Schema.optionalKey(Schema.String),
+  contentLang: Schema.optionalKey(Schema.String),
+  extra: Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([
+    Schema.String,
+    Schema.Int,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Array(Schema.Union([
+      Schema.String,
+      Schema.Int,
+      Schema.Number,
+      Schema.Boolean
+    ]))
+  ]))),
+  plugin: Schema.optionalKey(Schema.Json)
+});
+var stateEntry = Schema.Struct({
+  path: Schema.String,
+  type: Schema.String,
+  domain: Schema.optionalKey(Schema.Array(Schema.String)),
+  default: Schema.optionalKey(Schema.Json),
+  owner: Schema.optionalKey(Schema.Literals([
+    "engine"
+  ])),
+  provenance: Schema.optionalKey(Schema.String),
+  labels: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  labelForms: Schema.optionalKey(Schema.suspend(() => labelForms))
+});
+var effectSource = Schema.Union([
+  Schema.Struct({
+    bridgeResult: Schema.String
+  }),
+  Schema.Struct({
+    op: Schema.String,
+    by: Schema.Number
+  }),
+  Schema.Union([
+    Schema.Boolean,
+    Schema.Number,
+    Schema.String
+  ])
+]);
+var effect = Schema.Struct({
+  path: Schema.String,
+  from: Schema.suspend(() => effectSource)
+});
+var choiceOption = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  lineId: Schema.String,
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  target: Schema.suspend(() => position),
+  placeholders: Schema.optionalKey(Schema.Array(Schema.suspend(() => placeholder))),
+  texts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+});
+var hubOption = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  lineId: Schema.String,
+  once: Schema.Boolean,
+  exit: Schema.Boolean,
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  target: Schema.suspend(() => position),
+  placeholders: Schema.optionalKey(Schema.Array(Schema.suspend(() => placeholder))),
+  texts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+});
+var matchArm = Schema.Struct({
+  is: Schema.optionalKey(Schema.String),
+  test: Schema.suspend(() => celSlot),
+  target: Schema.suspend(() => position)
+});
+var rewardEntry = Schema.Struct({
+  id: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z][A-Za-z0-9_-]{0,63}$"))))),
+  kind: Schema.String,
+  target: Schema.optionalKey(Schema.String),
+  amount: Schema.optionalKey(Schema.Int),
+  amountMin: Schema.optionalKey(Schema.Int),
+  amountMax: Schema.optionalKey(Schema.Int),
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  outcome: Schema.optionalKey(Schema.Literals([
+    "failed"
+  ])),
+  credits: Schema.optionalKey(Schema.String)
+});
+var objectiveEntry = Schema.Struct({
+  id: Schema.String,
+  title: Schema.optionalKey(Schema.String),
+  titleLineId: Schema.optionalKey(Schema.String),
+  done: Schema.suspend(() => celSlot),
+  visibleWhen: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  optional: Schema.Boolean,
+  body: Schema.NullOr(Schema.suspend(() => position)),
+  quest: Schema.optionalKey(Schema.String),
+  rewards: Schema.optionalKey(Schema.Array(Schema.suspend(() => rewardEntry))),
+  on: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  by: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  target: Schema.optionalKey(Schema.String),
+  until: Schema.optionalKey(Schema.suspend(() => celSlot))
+});
+var cmdLine = Schema.Struct({
+  kind: Schema.Literal("line"),
+  family: Schema.Literal("content"),
+  position: Schema.suspend(() => position),
+  role: Schema.suspend(() => role),
+  speaker: Schema.String,
+  text: Schema.String,
+  emotion: Schema.optionalKey(Schema.String),
+  variant: Schema.optionalKey(Schema.Int),
+  action: Schema.optionalKey(Schema.String),
+  dialogMotion: Schema.optionalKey(Schema.String),
+  as: Schema.optionalKey(Schema.String),
+  lineId: Schema.String,
+  voiceKey: Schema.String,
+  placeholders: Schema.optionalKey(Schema.Array(Schema.suspend(() => placeholder))),
+  texts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  segments: Schema.optionalKey(Schema.suspend(() => segments)),
+  localeSegments: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => segments))),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdBg = Schema.Struct({
+  kind: Schema.Literal("bg"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  location: Schema.optionalKey(Schema.String),
+  time: Schema.optionalKey(Schema.String),
+  assetId: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdMusic = Schema.Struct({
+  kind: Schema.Literal("music"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  playback: Schema.optionalKey(Schema.String),
+  stop: Schema.optionalKey(Schema.Literal(true)),
+  mood: Schema.optionalKey(Schema.String),
+  volume: Schema.optionalKey(Schema.String),
+  assetId: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdSfx = Schema.Struct({
+  kind: Schema.Literal("sfx"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  sound: Schema.optionalKey(Schema.String),
+  assetId: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdVfx = Schema.Struct({
+  kind: Schema.Literal("vfx"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  type: Schema.String,
+  label: Schema.optionalKey(Schema.String),
+  transition: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdActor = Schema.Struct({
+  kind: Schema.Literal("actor"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  character: Schema.String,
+  anchor: Schema.optionalKey(Schema.String),
+  action: Schema.optionalKey(Schema.String),
+  exit: Schema.optionalKey(Schema.Boolean),
+  emotion: Schema.optionalKey(Schema.String),
+  costume: Schema.optionalKey(Schema.String),
+  posReset: Schema.optionalKey(Schema.Boolean),
+  preload: Schema.optionalKey(Schema.Boolean),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdCamera = Schema.Struct({
+  kind: Schema.Literal("camera"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  focus: Schema.optionalKey(Schema.String),
+  framing: Schema.optionalKey(Schema.String),
+  move: Schema.optionalKey(Schema.String),
+  transition: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+}).check(Schema.makeFilter((value) => [
+  [
+    "focus"
+  ],
+  [
+    "framing"
+  ],
+  [
+    "move"
+  ],
+  [
+    "transition"
+  ]
+].filter((keys) => keys.every((key) => (key in value))).length >= 1 || "expected at least one of the key sets: focus | framing | move | transition"));
+var cmdCg = Schema.Struct({
+  kind: Schema.Literal("cg"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  assetId: Schema.String,
+  display: Schema.String,
+  layout: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdVideo = Schema.Struct({
+  kind: Schema.Literal("video"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  assetId: Schema.String,
+  display: Schema.String,
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdSequence = Schema.Struct({
+  kind: Schema.Literal("sequence"),
+  family: Schema.Literal("staging"),
+  position: Schema.suspend(() => position),
+  name: Schema.String,
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdSet = Schema.Struct({
+  kind: Schema.Literal("set"),
+  family: Schema.Literal("state"),
+  position: Schema.suspend(() => position),
+  path: Schema.String,
+  op: Schema.String,
+  value: Schema.suspend(() => celSlot),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdAssert = Schema.Struct({
+  kind: Schema.Literal("assert"),
+  family: Schema.Literal("state"),
+  position: Schema.suspend(() => position),
+  relation: Schema.String,
+  args: Schema.Array(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdRetract = Schema.Struct({
+  kind: Schema.Literal("retract"),
+  family: Schema.Literal("state"),
+  position: Schema.suspend(() => position),
+  relation: Schema.String,
+  args: Schema.Array(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdChoice = Schema.Struct({
+  kind: Schema.Literal("choice"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  branchId: Schema.String,
+  selectionKey: Schema.String,
+  options: Schema.Array(Schema.suspend(() => choiceOption)),
+  converge: Schema.suspend(() => position),
+  prompt: Schema.optionalKey(Schema.String),
+  timeout: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1)))),
+  default: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdMatch = Schema.Struct({
+  kind: Schema.Literal("match"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  subject: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  arms: Schema.Array(Schema.suspend(() => matchArm)),
+  otherwise: Schema.optionalKey(Schema.suspend(() => position)),
+  converge: Schema.suspend(() => position),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdHub = Schema.Struct({
+  kind: Schema.Literal("hub"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  id: Schema.String,
+  selectionKey: Schema.String,
+  options: Schema.Array(Schema.suspend(() => hubOption)),
+  converge: Schema.suspend(() => position),
+  prompt: Schema.optionalKey(Schema.String),
+  return: Schema.optionalKey(Schema.suspend(() => position)),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdJump = Schema.Struct({
+  kind: Schema.Literal("jump"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  target: Schema.suspend(() => position)
+});
+var cmdEnd = Schema.Struct({
+  kind: Schema.Literal("end"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  reason: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdBarrier = Schema.Struct({
+  kind: Schema.Literal("barrier"),
+  family: Schema.Literal("control"),
+  position: Schema.suspend(() => position),
+  timeline: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+  at: Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))
+});
+var cmdQuest = Schema.Struct({
+  kind: Schema.Literal("quest"),
+  family: Schema.Literal("declaration"),
+  position: Schema.suspend(() => position),
+  id: Schema.String,
+  title: Schema.optionalKey(Schema.String),
+  titleLineId: Schema.optionalKey(Schema.String),
+  start: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  fail: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  objectives: Schema.Array(Schema.suspend(() => objectiveEntry)),
+  rewards: Schema.optionalKey(Schema.Array(Schema.suspend(() => rewardEntry))),
+  rearm: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  tier: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "run"
+    ]),
+    Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^season:[A-Za-z0-9_][A-Za-z0-9_-]*$"))))
+  ])),
+  activate: Schema.optionalKey(Schema.Literals([
+    "accept"
+  ])),
+  complete: Schema.optionalKey(Schema.Literals([
+    "any"
+  ])),
+  accept: Schema.optionalKey(Schema.Literals([
+    "external"
+  ])),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdOn = Schema.Struct({
+  kind: Schema.Literal("on"),
+  family: Schema.Literal("declaration"),
+  position: Schema.suspend(() => position),
+  event: Schema.String,
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  body: Schema.suspend(() => position),
+  target: Schema.optionalKey(Schema.String),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdEntry = Schema.Struct({
+  kind: Schema.Literal("entry"),
+  family: Schema.Literal("declaration"),
+  position: Schema.suspend(() => position),
+  id: Schema.String,
+  target: Schema.optionalKey(Schema.String),
+  category: Schema.optionalKey(Schema.String),
+  title: Schema.optionalKey(Schema.String),
+  titleLineId: Schema.optionalKey(Schema.String),
+  series: Schema.optionalKey(Schema.String),
+  order: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))),
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  body: Schema.suspend(() => position),
+  on: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  priority: Schema.optionalKey(Schema.Int),
+  once: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "run",
+      "user",
+      "day",
+      "slot",
+      "week"
+    ]),
+    Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^season:[A-Za-z0-9_][A-Za-z0-9_-]*$"))))
+  ])),
+  share: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  targetKind: Schema.optionalKey(Schema.suspend(() => targetKind)),
+  forKind: Schema.optionalKey(Schema.suspend(() => forKind)),
+  spentBy: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  advances: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "slot",
+      "day"
+    ]),
+    Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1)))
+  ])),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdAccept = Schema.Struct({
+  kind: Schema.Literal("accept"),
+  family: Schema.Literal("declaration"),
+  position: Schema.suspend(() => position),
+  quest: Schema.String,
+  applies: Schema.optionalKey(Schema.Literals([
+    "nextRun"
+  ])),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdBeat = Schema.Struct({
+  kind: Schema.Literal("beat"),
+  family: Schema.Literal("declaration"),
+  position: Schema.suspend(() => position),
+  id: Schema.String,
+  on: Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$")))),
+  target: Schema.optionalKey(Schema.String),
+  title: Schema.optionalKey(Schema.String),
+  titleLineId: Schema.optionalKey(Schema.String),
+  when: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  priority: Schema.Int,
+  once: Schema.Union([
+    Schema.Literals([
+      "run",
+      "user",
+      "none",
+      "day",
+      "slot",
+      "week"
+    ]),
+    Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^season:[A-Za-z0-9_][A-Za-z0-9_-]*$"))))
+  ]),
+  also: Schema.optionalKey(Schema.Literal(true)),
+  share: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  after: Schema.optionalKey(Schema.String),
+  targetKind: Schema.optionalKey(Schema.suspend(() => targetKind)),
+  forKind: Schema.optionalKey(Schema.suspend(() => forKind)),
+  spentBy: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  advances: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "slot",
+      "day"
+    ]),
+    Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1)))
+  ])),
+  body: Schema.suspend(() => position),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var cmdPlugin = Schema.Struct({
+  kind: Schema.Literal("plugin"),
+  family: Schema.Literal("plugin"),
+  position: Schema.suspend(() => position),
+  tag: Schema.String,
+  plugin: Schema.optionalKey(Schema.String),
+  fields: Schema.Json,
+  effects: Schema.optionalKey(Schema.Array(Schema.suspend(() => effect))),
+  retracts: Schema.optionalKey(Schema.Array(Schema.Struct({
+    relation: Schema.String,
+    args: Schema.Array(Schema.String)
+  }))),
+  asserts: Schema.optionalKey(Schema.Array(Schema.Struct({
+    relation: Schema.String,
+    args: Schema.Array(Schema.String)
+  }))),
+  timing: Schema.optionalKey(Schema.suspend(() => timing)),
+  provenance: Schema.optionalKey(Schema.suspend(() => provenance)),
+  source: Schema.optionalKey(Schema.suspend(() => source))
+});
+var artifactMeta = Schema.Union([
+  Schema.suspend(() => sceneMeta),
+  Schema.suspend(() => questMeta),
+  Schema.suspend(() => loreMeta)
+]);
+var loreMeta = Schema.Struct({
+  id: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*(\\.[A-Za-z0-9_][A-Za-z0-9_-]*)*$"))))),
+  title: Schema.optionalKey(Schema.String),
+  series: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+  contentLang: Schema.optionalKey(Schema.String),
+  extra: Schema.optionalKey(Schema.Json),
+  plugin: Schema.optionalKey(Schema.Json)
+});
+var indexEntry = Schema.Struct({
+  category: Schema.optionalKey(Schema.String),
+  document: Schema.String,
+  id: Schema.String,
+  order: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))),
+  series: Schema.optionalKey(Schema.String),
+  target: Schema.optionalKey(Schema.String)
+});
+var indexBeat = Schema.Struct({
+  advances: Schema.optionalKey(Schema.Union([
+    Schema.Literals([
+      "slot",
+      "day"
+    ]),
+    Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1)))
+  ])),
+  document: Schema.String,
+  forKind: Schema.optionalKey(Schema.suspend(() => forKind)),
+  id: Schema.String,
+  kind: Schema.Literals([
+    "scene",
+    "entry",
+    "bundle"
+  ]),
+  on: Schema.String,
+  once: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^(run|user|none|day|slot|week|season:.+)$"))))),
+  priority: Schema.Int,
+  share: Schema.optionalKey(Schema.String),
+  spentBy: Schema.optionalKey(Schema.String),
+  target: Schema.optionalKey(Schema.String),
+  targetKind: Schema.optionalKey(Schema.suspend(() => targetKind)),
+  title: Schema.optionalKey(Schema.String),
+  when: Schema.optionalKey(Schema.String)
+});
+var sectionEntry = Schema.Struct({
+  section: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1))),
+  heading: Schema.String,
+  id: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z][A-Za-z0-9_-]{0,63}$")))))
+});
+var clockDecl = Schema.Struct({
+  day: Schema.String,
+  slot: Schema.optionalKey(Schema.String),
+  slots: Schema.optionalKey(Schema.Array(Schema.String)),
+  raise: Schema.optionalKey(Schema.Union([
+    Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$")))),
+    Schema.Struct({
+      slot: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+      dayStart: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$"))))),
+      dayEnd: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isPattern(new RegExp("^[A-Za-z0-9_][A-Za-z0-9_-]*$")))))
+    })
+  ])),
+  raiseAtStart: Schema.optionalKey(Schema.Literal(true)),
+  week: Schema.optionalKey(Schema.Struct({
+    length: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1))),
+    first: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+    labels: Schema.optionalKey(Schema.Array(Schema.String))
+  })),
+  last: Schema.optionalKey(Schema.Struct({
+    day: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1))),
+    slot: Schema.optionalKey(Schema.String)
+  })),
+  days: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1))))
+});
+var indexOccasion = Schema.Struct({
+  judge: Schema.optionalKey(Schema.Literals([
+    "after",
+    "before"
+  ])),
+  outsideRun: Schema.optionalKey(Schema.Boolean),
+  payload: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => fieldType))),
+  select: Schema.Literals([
+    "first",
+    "all",
+    "sequence"
+  ]),
+  target: Schema.Union([
+    Schema.Boolean,
+    Schema.Struct({
+      entity: Schema.String,
+      members: Schema.optionalKey(Schema.Array(Schema.String)),
+      prefix: Schema.String
+    })
+  ])
+});
+var indexStateDomain = Schema.Struct({
+  kind: Schema.String,
+  members: Schema.Array(Schema.String)
+});
+var projectIndex = Schema.Struct({
+  beats: Schema.optionalKey(Schema.Array(Schema.suspend(() => indexBeat))),
+  bridgeResults: Schema.optionalKey(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.suspend(() => fieldType)))),
+  capabilitySnapshot: Schema.String,
+  cast: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  clock: Schema.optionalKey(Schema.suspend(() => clockDecl)),
+  defs: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => indexDef))),
+  documents: Schema.Array(Schema.suspend(() => indexDocument)),
+  entities: Schema.Array(Schema.suspend(() => entityKindEntry)),
+  entries: Schema.optionalKey(Schema.Array(Schema.suspend(() => indexEntry))),
+  enums: Schema.Array(Schema.suspend(() => enumEntry)),
+  gates: Schema.optionalKey(Schema.Array(Schema.Struct({
+    occasion: Schema.String,
+    raisedWhen: Schema.suspend(() => celSlot)
+  }))),
+  identityRenames: Schema.optionalKey(Schema.Array(Schema.Struct({
+    from: Schema.String,
+    to: Schema.String
+  }))),
+  irVersion: Schema.String,
+  occasions: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => indexOccasion))),
+  outsideRun: Schema.optionalKey(Schema.Array(Schema.String)),
+  prereqEdges: Schema.Array(Schema.suspend(() => prereqEdgeEntry)),
+  relations: Schema.Array(Schema.suspend(() => relationEntry)),
+  requiredSemantics: Schema.Array(Schema.String),
+  rules: Schema.Array(Schema.suspend(() => ruleEntry)),
+  seasons: Schema.optionalKey(Schema.Array(Schema.Struct({
+    live: Schema.suspend(() => celSlot),
+    name: Schema.String
+  }))),
+  seedFacts: Schema.Array(Schema.suspend(() => seedFactEntry)),
+  stateDomains: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => indexStateDomain))),
+  terminal: Schema.optionalKey(Schema.suspend(() => celSlot)),
+  terminalPersists: Schema.optionalKey(Schema.Boolean),
+  worldEvents: Schema.optionalKey(Schema.Array(Schema.String))
+});
+var indexDocument = Schema.Struct({
+  artifact: Schema.String,
+  key: Schema.String,
+  kind: Schema.Literals([
+    "scene",
+    "quest",
+    "lore"
+  ]),
+  path: Schema.String
+});
+var indexDef = Schema.Struct({
+  authored: Schema.optionalKey(Schema.String),
+  cel: Schema.String,
+  expr: Schema.Json,
+  host: Schema.optionalKey(Schema.Boolean),
+  params: Schema.optionalKey(Schema.Array(Schema.Struct({
+    name: Schema.String,
+    type: Schema.suspend(() => fieldType)
+  })))
+});
+var fieldType = Schema.Union([
+  Schema.Literals([
+    "bool",
+    "int",
+    "double",
+    "string",
+    "narrativeTime"
+  ]),
+  Schema.Struct({
+    enum: Schema.Array(Schema.String)
+  }),
+  Schema.Struct({
+    list: Schema.suspend(() => fieldType)
+  }),
+  Schema.Struct({
+    record: Schema.Array(Schema.Struct({
+      default: Schema.optionalKey(Schema.Json),
+      name: Schema.String,
+      required: Schema.Boolean,
+      shape: Schema.optionalKey(Schema.String),
+      type: Schema.suspend(() => fieldType)
+    }))
+  }),
+  Schema.Struct({
+    map: Schema.Struct({
+      key: Schema.suspend(() => fieldType),
+      value: Schema.suspend(() => fieldType)
+    })
+  }),
+  Schema.Struct({
+    enumFromOption: Schema.String
+  }),
+  Schema.Struct({
+    providerRef: Schema.String
+  }),
+  Schema.Struct({
+    domain: Schema.String
+  }),
+  Schema.Struct({
+    entity: Schema.String
+  }),
+  Schema.Struct({
+    slotId: Schema.Struct({
+      namespace: Schema.String
+    })
+  }),
+  Schema.Struct({
+    assetKind: Schema.String
+  })
+]);
+var Command = Schema.Union([
+  Schema.suspend(() => cmdLine),
+  Schema.suspend(() => cmdBg),
+  Schema.suspend(() => cmdMusic),
+  Schema.suspend(() => cmdSfx),
+  Schema.suspend(() => cmdVfx),
+  Schema.suspend(() => cmdActor),
+  Schema.suspend(() => cmdCamera),
+  Schema.suspend(() => cmdCg),
+  Schema.suspend(() => cmdVideo),
+  Schema.suspend(() => cmdSequence),
+  Schema.suspend(() => cmdSet),
+  Schema.suspend(() => cmdAssert),
+  Schema.suspend(() => cmdRetract),
+  Schema.suspend(() => cmdChoice),
+  Schema.suspend(() => cmdMatch),
+  Schema.suspend(() => cmdHub),
+  Schema.suspend(() => cmdJump),
+  Schema.suspend(() => cmdEnd),
+  Schema.suspend(() => cmdBarrier),
+  Schema.suspend(() => cmdQuest),
+  Schema.suspend(() => cmdOn),
+  Schema.suspend(() => cmdEntry),
+  Schema.suspend(() => cmdAccept),
+  Schema.suspend(() => cmdBeat),
+  Schema.suspend(() => cmdPlugin)
+]);
+
+// src/Errors.ts
+var exports_Errors = {};
+__export(exports_Errors, {
+  BridgeShapeMismatch: () => BridgeShapeMismatch,
+  BundleMalformed: () => BundleMalformed,
+  BundleNotFound: () => BundleNotFound,
+  BundleUnreadable: () => BundleUnreadable,
+  EvaluationError: () => EvaluationError,
+  InputLogError: () => InputLogError,
+  InvalidInput: () => InvalidInput,
+  IrVersionMismatch: () => IrVersionMismatch,
+  OccasionGateClosed: () => OccasionGateClosed,
+  OptionUnavailable: () => OptionUnavailable,
+  RequestMismatch: () => RequestMismatch,
+  RuntimeBusy: () => RuntimeBusy,
+  RuntimeHalted: () => RuntimeHalted,
+  SnapshotProjectMismatch: () => SnapshotProjectMismatch,
+  SnapshotVersionMismatch: () => SnapshotVersionMismatch,
+  TimeoutUnavailable: () => TimeoutUnavailable,
+  WasmLoadError: () => WasmLoadError,
+  fromGateRejected: () => fromGateRejected,
+  fromQueryRejected: () => fromQueryRejected,
+  fromRejected: () => fromRejected
+});
+import { Effect, Schema as Schema2 } from "effect";
+
+class RuntimeBusy extends Schema2.TaggedError()("RuntimeBusy", {
+  code: Schema2.Literal("E-RUNTIME-BUSY"),
+  message: Schema2.String
+}) {
+}
+
+class TimeoutUnavailable extends Schema2.TaggedError()("TimeoutUnavailable", {
+  code: Schema2.Literal("E-RUNTIME-TIMEOUT"),
+  message: Schema2.String
+}) {
+}
+
+class RequestMismatch extends Schema2.TaggedError()("RequestMismatch", {
+  code: Schema2.Literal("E-RUNTIME-REQUEST"),
+  message: Schema2.String
+}) {
+}
+
+class OptionUnavailable extends Schema2.TaggedError()("OptionUnavailable", {
+  code: Schema2.Literal("E-RUNTIME-OPTION"),
+  message: Schema2.String
+}) {
+}
+
+class BridgeShapeMismatch extends Schema2.TaggedError()("BridgeShapeMismatch", {
+  code: Schema2.Literal("E-RUNTIME-BRIDGE-SHAPE"),
+  message: Schema2.String
+}) {
+}
+
+class InvalidInput extends Schema2.TaggedError()("InvalidInput", {
+  code: Schema2.Literal("E-RUNTIME-INPUT"),
+  message: Schema2.String
+}) {
+}
+
+class RuntimeHalted extends Schema2.TaggedError()("RuntimeHalted", {
+  code: Schema2.Literal("E-RUNTIME-HALTED"),
+  message: Schema2.String
+}) {
+}
+
+class IrVersionMismatch extends Schema2.TaggedError()("IrVersionMismatch", {
+  code: Schema2.Literal("E-RUNTIME-IR-VERSION"),
+  message: Schema2.String
+}) {
+}
+
+class SnapshotProjectMismatch extends Schema2.TaggedError()("SnapshotProjectMismatch", { code: Schema2.Literal("E-RUNTIME-SNAPSHOT-PROJECT"), message: Schema2.String }) {
+}
+
+class SnapshotVersionMismatch extends Schema2.TaggedError()("SnapshotVersionMismatch", { code: Schema2.Literal("E-RUNTIME-SNAPSHOT-VERSION"), message: Schema2.String }) {
+}
+
+class OccasionGateClosed extends Schema2.TaggedError()("OccasionGateClosed", {
+  code: Schema2.Literal("E-OCCASION-GATE"),
+  message: Schema2.String
+}) {
+}
+var byCode = {
+  "E-RUNTIME-BUSY": (message) => new RuntimeBusy({ code: "E-RUNTIME-BUSY", message }),
+  "E-RUNTIME-REQUEST": (message) => new RequestMismatch({ code: "E-RUNTIME-REQUEST", message }),
+  "E-RUNTIME-OPTION": (message) => new OptionUnavailable({ code: "E-RUNTIME-OPTION", message }),
+  "E-RUNTIME-BRIDGE-SHAPE": (message) => new BridgeShapeMismatch({ code: "E-RUNTIME-BRIDGE-SHAPE", message }),
+  "E-RUNTIME-TIMEOUT": (message) => new TimeoutUnavailable({ code: "E-RUNTIME-TIMEOUT", message }),
+  "E-RUNTIME-INPUT": (message) => new InvalidInput({ code: "E-RUNTIME-INPUT", message }),
+  "E-RUNTIME-HALTED": (message) => new RuntimeHalted({ code: "E-RUNTIME-HALTED", message }),
+  "E-RUNTIME-IR-VERSION": (message) => new IrVersionMismatch({ code: "E-RUNTIME-IR-VERSION", message }),
+  "E-RUNTIME-SNAPSHOT-PROJECT": (message) => new SnapshotProjectMismatch({ code: "E-RUNTIME-SNAPSHOT-PROJECT", message }),
+  "E-RUNTIME-SNAPSHOT-VERSION": (message) => new SnapshotVersionMismatch({ code: "E-RUNTIME-SNAPSHOT-VERSION", message }),
+  "E-OCCASION-GATE": (message) => new OccasionGateClosed({ code: "E-OCCASION-GATE", message })
+};
+var fromRejected = (rejected) => {
+  const make = byCode[rejected.code];
+  return make === undefined ? Effect.die(new Error(`unknown runtime rejection ${rejected.code}: ${rejected.message}`)) : Effect.fail(make(rejected.message));
+};
+
+class EvaluationError extends Schema2.TaggedError()("EvaluationError", {
+  code: Schema2.Literal("E-RUNTIME-EVAL"),
+  message: Schema2.String
+}) {
+}
+var fromQueryRejected = (rejected) => {
+  switch (rejected.code) {
+    case "E-RUNTIME-INPUT":
+      return Effect.fail(new InvalidInput({ code: "E-RUNTIME-INPUT", message: rejected.message }));
+    case "E-RUNTIME-EVAL":
+      return Effect.fail(new EvaluationError({ code: "E-RUNTIME-EVAL", message: rejected.message }));
+    default:
+      return Effect.die(new Error(`unknown query rejection ${rejected.code}: ${rejected.message}`));
+  }
+};
+var fromGateRejected = (rejected) => rejected.code === "E-RUNTIME-INPUT" ? Effect.fail(new InvalidInput({ code: "E-RUNTIME-INPUT", message: rejected.message })) : Effect.die(new Error(`unknown gate rejection ${rejected.code}: ${rejected.message}`));
+
+class BundleNotFound extends Schema2.TaggedError()("BundleNotFound", {
+  path: Schema2.String,
+  message: Schema2.String
+}) {
+}
+
+class BundleUnreadable extends Schema2.TaggedError()("BundleUnreadable", {
+  path: Schema2.String,
+  message: Schema2.String
+}) {
+}
+
+class BundleMalformed extends Schema2.TaggedError()("BundleMalformed", {
+  path: Schema2.String,
+  message: Schema2.String
+}) {
+}
+
+class WasmLoadError extends Schema2.TaggedError()("WasmLoadError", {
+  message: Schema2.String
+}) {
+}
+
+class InputLogError extends Schema2.TaggedError()("InputLogError", {
+  message: Schema2.String
+}) {
+}
+
+// src/BundleSource.ts
+var exports_BundleSource = {};
+__export(exports_BundleSource, {
+  BundleSource: () => BundleSource,
+  directory: () => directory,
+  url: () => url,
+  value: () => value
+});
+import { Context, Effect as Effect2, FileSystem, Layer, Path, Schema as Schema3 } from "effect";
+import * as HttpClient from "effect/http/HttpClient";
+class BundleSource extends Context.Service()("@lute-lang/runtime/BundleSource") {
+}
+var INDEX = "project.index.json";
+var decodeJson = Schema3.decodeUnknownEffect(Schema3.fromJsonString(Schema3.Json));
+var decodeIndex = Schema3.decodeUnknownEffect(Schema3.fromJsonString(projectIndex), { onExcessProperty: "error" });
+var assemble = (read) => Effect2.gen(function* () {
+  const index = yield* Effect2.flatMap(read(INDEX), (text) => Effect2.mapError(decodeIndex(text), (error) => new BundleMalformed({ path: INDEX, message: error.message })));
+  const artifacts = yield* Effect2.forEach(index.documents, ({ artifact }) => Effect2.flatMap(read(artifact), (text) => Effect2.mapError(decodeJson(text), (error) => new BundleMalformed({ path: artifact, message: error.message }))).pipe(Effect2.map((json) => [artifact, json])));
+  return { index, artifacts: Object.fromEntries(artifacts) };
+});
+var value = (bundle) => Layer.succeed(BundleSource, { load: Effect2.succeed(bundle) });
+var directory = (root) => Layer.effect(BundleSource, Effect2.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const read = (file) => {
+    const full = path.join(root, file);
+    return Effect2.mapError(fs.readFileString(full), (error) => error.reason._tag === "NotFound" ? new BundleNotFound({ path: full, message: error.message }) : new BundleUnreadable({ path: full, message: error.message }));
+  };
+  return { load: Effect2.withSpan(assemble(read), "Lute.BundleSource.directory", { attributes: { root } }) };
+}));
+var url = (base) => Layer.effect(BundleSource, Effect2.gen(function* () {
+  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const read = (file) => {
+    const href = new URL(file, base).href;
+    return client.get(href).pipe(Effect2.flatMap((response) => response.text), Effect2.mapError((error) => error.reason._tag === "StatusCodeError" && error.reason.response.status === 404 ? new BundleNotFound({ path: href, message: error.message }) : new BundleUnreadable({ path: href, message: error.message })));
+  };
+  return { load: Effect2.withSpan(assemble(read), "Lute.BundleSource.url", { attributes: { base } }) };
+}));
+
+// src/generated/Contract.ts
+var exports_Contract = {};
+__export(exports_Contract, {
+  AdvanceBy: () => AdvanceBy,
+  Answer: () => Answer,
+  Atom: () => Atom,
+  Await: () => Await,
+  BeatKind: () => BeatKind,
+  BeatOnce: () => BeatOnce,
+  Cadence: () => Cadence,
+  Candidate: () => Candidate,
+  ClockAt: () => ClockAt,
+  ClockPosition: () => ClockPosition,
+  ClockView: () => ClockView,
+  Continuation: () => Continuation,
+  Evaluation: () => Evaluation,
+  Event: () => Event,
+  Gate: () => Gate,
+  GuardRead: () => GuardRead,
+  Input: () => Input,
+  MenuAwait: () => MenuAwait,
+  MenuOptionAwait: () => MenuOptionAwait,
+  Output: () => Output,
+  PickInput: () => PickInput,
+  Premise: () => Premise,
+  Rejected: () => Rejected,
+  SaveInput: () => SaveInput,
+  Seed: () => Seed,
+  Snapshot: () => Snapshot,
+  Stage: () => Stage,
+  StageActor: () => StageActor,
+  StageBackground: () => StageBackground,
+  StageCg: () => StageCg,
+  StageMusic: () => StageMusic,
+  StageVideo: () => StageVideo,
+  StateWrite: () => StateWrite,
+  StreamLine: () => StreamLine,
+  Value: () => Value,
+  Verdict: () => Verdict,
+  World: () => World,
+  WorldView: () => WorldView,
+  WritesInput: () => WritesInput,
+  fieldType: () => fieldType2,
+  parseOptions: () => parseOptions
+});
+import * as Schema4 from "effect/Schema";
+var parseOptions = { onExcessProperty: "error" };
+var AdvanceBy = Schema4.Union([
+  Schema4.String,
+  Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+  Schema4.Struct({
+    to: Schema4.String
+  }),
+  Schema4.Struct({
+    to: Schema4.suspend(() => ClockPosition)
+  })
+]);
+var Atom = Schema4.Union([
+  Schema4.Struct({
+    visited: Schema4.String
+  }),
+  Schema4.Struct({
+    completed: Schema4.String
+  }),
+  Schema4.Struct({
+    active: Schema4.String
+  })
+]);
+var Await = Schema4.Union([
+  Schema4.Struct({
+    menu: Schema4.suspend(() => MenuAwait),
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    type: Schema4.Literal("awaitChoice")
+  }),
+  Schema4.Struct({
+    attrs: Schema4.Record(Schema4.String, Schema4.Json),
+    document: Schema4.String,
+    position: Schema4.String,
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    results: Schema4.Record(Schema4.String, Schema4.suspend(() => fieldType2)),
+    tag: Schema4.String,
+    type: Schema4.Literal("awaitBridge")
+  }),
+  Schema4.Struct({
+    type: Schema4.Literal("idle")
+  }),
+  Schema4.Struct({
+    reason: Schema4.String,
+    type: Schema4.Literal("ended")
+  }),
+  Schema4.Struct({
+    kind: Schema4.String,
+    message: Schema4.String,
+    site: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+    type: Schema4.Literal("halted")
+  })
+]).pipe(Schema4.toTaggedUnion("type"));
+var BeatKind = Schema4.Literals([
+  "scene",
+  "entry",
+  "bundle"
+]);
+var BeatOnce = Schema4.String.pipe(Schema4.check(Schema4.isPattern(new RegExp("^(run|user|none|day|slot|week|season:.+)$"))));
+var Candidate = Schema4.Struct({
+  also: Schema4.Boolean,
+  document: Schema4.String,
+  forMember: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  id: Schema4.String,
+  kind: Schema4.suspend(() => BeatKind),
+  priority: Schema4.Int,
+  read: Schema4.Boolean,
+  rejudged: Schema4.Boolean,
+  verdict: Schema4.suspend(() => Verdict)
+});
+var ClockAt = Schema4.Struct({
+  day: Schema4.Int,
+  slot: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0)))
+});
+var ClockPosition = Schema4.Struct({
+  slot: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  weekday: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var ClockView = Schema4.Struct({
+  day: Schema4.Int,
+  ended: Schema4.optionalKey(Schema4.NullOr(Schema4.Boolean)),
+  last: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  slot: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  weekday: Schema4.optionalKey(Schema4.NullOr(Schema4.Int)),
+  weekdayLabel: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var Evaluation = Schema4.Struct({
+  unresolved: Schema4.optionalKey(Schema4.Array(Schema4.String)),
+  value: Schema4.suspend(() => Value)
+});
+var Event = Schema4.Union([
+  Schema4.Struct({
+    document: Schema4.String,
+    record: Schema4.Json,
+    type: Schema4.Literal("record")
+  }),
+  Schema4.Struct({
+    beat: Schema4.String,
+    document: Schema4.String,
+    kind: Schema4.String,
+    occasion: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+    target: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+    type: Schema4.Literal("presentation")
+  }),
+  Schema4.Struct({
+    beat: Schema4.String,
+    document: Schema4.String,
+    reason: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+    type: Schema4.Literal("presentationEnd")
+  }),
+  Schema4.Struct({
+    commands: Schema4.Array(Schema4.Json),
+    document: Schema4.String,
+    type: Schema4.Literal("quest")
+  }),
+  Schema4.Struct({
+    from: Schema4.Json,
+    passed: Schema4.optionalKey(Schema4.Json),
+    to: Schema4.Json,
+    type: Schema4.Literal("clock")
+  })
+]).pipe(Schema4.toTaggedUnion("type"));
+var Gate = Schema4.Struct({
+  open: Schema4.Boolean,
+  unresolved: Schema4.optionalKey(Schema4.Array(Schema4.String))
+});
+var GuardRead = Schema4.Union([
+  Schema4.Struct({
+    kind: Schema4.Literal("path"),
+    value: Schema4.Tuple([
+      Schema4.String,
+      Schema4.suspend(() => Value)
+    ])
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("fact"),
+    value: Schema4.String
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("derived"),
+    value: Schema4.Struct({
+      base: Schema4.Array(Schema4.String),
+      fact: Schema4.String,
+      rules: Schema4.Array(Schema4.Tuple([
+        Schema4.String,
+        Schema4.Array(Schema4.String)
+      ]))
+    })
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("visited"),
+    value: Schema4.String
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("holds"),
+    value: Schema4.String
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("seen"),
+    value: Schema4.String
+  })
+]).pipe(Schema4.toTaggedUnion("kind"));
+var Input = Schema4.Union([
+  Schema4.Struct({
+    occasion: Schema4.String,
+    payload: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.Json)),
+    pick: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => PickInput))),
+    target: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+    type: Schema4.Literal("raiseOccasion"),
+    writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
+  }),
+  Schema4.Struct({
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    type: Schema4.Literal("timeout")
+  }),
+  Schema4.Struct({
+    option: Schema4.String,
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    type: Schema4.Literal("choose")
+  }),
+  Schema4.Struct({
+    fields: Schema4.Record(Schema4.String, Schema4.Json),
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    type: Schema4.Literal("bridgeResult"),
+    writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
+  }),
+  Schema4.Struct({
+    by: Schema4.suspend(() => AdvanceBy),
+    pick: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => PickInput))),
+    type: Schema4.Literal("advanceClock"),
+    writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
+  }),
+  Schema4.Struct({
+    type: Schema4.Literal("hostWrite"),
+    writes: Schema4.suspend(() => WritesInput)
+  }),
+  Schema4.Struct({
+    name: Schema4.String,
+    type: Schema4.Literal("worldEvent")
+  }),
+  Schema4.Struct({
+    type: Schema4.Literal("newRun"),
+    writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
+  })
+]).pipe(Schema4.toTaggedUnion("type"));
+var MenuAwait = Schema4.Struct({
+  construct: Schema4.String,
+  default: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  document: Schema4.String,
+  id: Schema4.String,
+  options: Schema4.Array(Schema4.suspend(() => MenuOptionAwait)),
+  position: Schema4.String,
+  presentation: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+  prompt: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  timeout: Schema4.optionalKey(Schema4.NullOr(Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0)))))
+});
+var MenuOptionAwait = Schema4.Struct({
+  exit: Schema4.Boolean,
+  id: Schema4.String,
+  once: Schema4.Boolean,
+  verdict: Schema4.String
+});
+var Output = Schema4.Struct({
+  await: Schema4.suspend(() => Await),
+  eventVersion: Schema4.String,
+  events: Schema4.Array(Schema4.suspend(() => Event))
+});
+var PickInput = Schema4.Union([
+  Schema4.String,
+  Schema4.Struct({
+    beat: Schema4.String
+  })
+]);
+var Premise = Schema4.Union([
+  Schema4.Struct({
+    once: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => BeatOnce))),
+    premise: Schema4.Literal("spent"),
+    reason: Schema4.String
+  }),
+  Schema4.Struct({
+    chapters: Schema4.Boolean,
+    premise: Schema4.Literal("after"),
+    raw: Schema4.String,
+    unmet: Schema4.Array(Schema4.suspend(() => Atom))
+  }),
+  Schema4.Struct({
+    premise: Schema4.Literal("spentBy"),
+    raw: Schema4.String
+  }),
+  Schema4.Struct({
+    premise: Schema4.Literal("when"),
+    raw: Schema4.String
+  }),
+  Schema4.Struct({
+    occasion: Schema4.String,
+    premise: Schema4.Literal("gate"),
+    raw: Schema4.String,
+    reads: Schema4.Array(Schema4.suspend(() => GuardRead))
+  }),
+  Schema4.Struct({
+    occasion: Schema4.String,
+    premise: Schema4.Literal("terminal"),
+    raw: Schema4.String
+  })
+]).pipe(Schema4.toTaggedUnion("premise"));
+var Rejected = Schema4.Struct({
+  code: Schema4.String,
+  message: Schema4.String
+});
+var SaveInput = Schema4.Struct({
+  entriesRead: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.Array(Schema4.String))),
+  presented: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.Array(Schema4.String))),
+  questInstances: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))))),
+  quests: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.String)),
+  visited: Schema4.optionalKey(Schema4.Array(Schema4.String))
+});
+var Seed = Schema4.Struct({
+  derive: Schema4.optionalKey(Schema4.Boolean),
+  facts: Schema4.optionalKey(Schema4.Array(Schema4.String)),
+  save: Schema4.optionalKey(Schema4.suspend(() => SaveInput)),
+  state: Schema4.optionalKey(Schema4.Array(Schema4.suspend(() => StateWrite)))
+});
+var StateWrite = Schema4.Struct({
+  add: Schema4.optionalKey(Schema4.NullOr(Schema4.Number)),
+  path: Schema4.String,
+  value: Schema4.optionalKey(Schema4.Json)
+});
+var StreamLine = Schema4.Union([
+  Schema4.Struct({
+    output: Schema4.suspend(() => Output),
+    seed: Schema4.suspend(() => Seed)
+  }),
+  Schema4.Struct({
+    input: Schema4.suspend(() => Input),
+    output: Schema4.suspend(() => Output)
+  }),
+  Schema4.Struct({
+    input: Schema4.suspend(() => Input),
+    rejected: Schema4.suspend(() => Rejected)
+  }),
+  Schema4.Struct({
+    rejected: Schema4.suspend(() => Rejected),
+    seed: Schema4.suspend(() => Seed)
+  })
+]);
+var Value = Schema4.Union([
+  Schema4.Struct({
+    kind: Schema4.Literal("bool"),
+    value: Schema4.Boolean
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("int"),
+    value: Schema4.Int
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("double"),
+    value: Schema4.Number
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("str"),
+    value: Schema4.String
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("unknown")
+  }),
+  Schema4.Struct({
+    kind: Schema4.Literal("error"),
+    value: Schema4.String
+  })
+]).pipe(Schema4.toTaggedUnion("kind"));
+var Verdict = Schema4.Union([
+  Schema4.Struct({
+    verdict: Schema4.Literal("eligible")
+  }),
+  Schema4.Struct({
+    premise: Schema4.suspend(() => Premise),
+    verdict: Schema4.Literal("ineligible")
+  }),
+  Schema4.Struct({
+    verdict: Schema4.Literal("unknown"),
+    why: Schema4.String
+  })
+]).pipe(Schema4.toTaggedUnion("verdict"));
+var WorldView = Schema4.Struct({
+  clock: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => ClockView))),
+  facts: Schema4.optionalKey(Schema4.UniqueArray(Schema4.String)),
+  quests: Schema4.Record(Schema4.String, Schema4.String),
+  state: Schema4.Record(Schema4.String, Schema4.suspend(() => Value))
+});
+var WritesInput = Schema4.Struct({
+  accept: Schema4.optionalKey(Schema4.Array(Schema4.String)),
+  facts: Schema4.optionalKey(Schema4.Array(Schema4.String)),
+  retract: Schema4.optionalKey(Schema4.Array(Schema4.String)),
+  state: Schema4.optionalKey(Schema4.Array(Schema4.suspend(() => StateWrite)))
+});
+var fieldType2 = Schema4.Union([
+  Schema4.Literals([
+    "bool",
+    "int",
+    "double",
+    "string",
+    "narrativeTime"
+  ]),
+  Schema4.Struct({
+    enum: Schema4.Array(Schema4.String)
+  }),
+  Schema4.Struct({
+    list: Schema4.suspend(() => fieldType2)
+  }),
+  Schema4.Struct({
+    record: Schema4.Array(Schema4.Struct({
+      default: Schema4.optionalKey(Schema4.Json),
+      name: Schema4.String,
+      required: Schema4.Boolean,
+      shape: Schema4.optionalKey(Schema4.String),
+      type: Schema4.suspend(() => fieldType2)
+    }))
+  }),
+  Schema4.Struct({
+    map: Schema4.Struct({
+      key: Schema4.suspend(() => fieldType2),
+      value: Schema4.suspend(() => fieldType2)
+    })
+  }),
+  Schema4.Struct({
+    enumFromOption: Schema4.String
+  }),
+  Schema4.Struct({
+    providerRef: Schema4.String
+  }),
+  Schema4.Struct({
+    domain: Schema4.String
+  }),
+  Schema4.Struct({
+    entity: Schema4.String
+  }),
+  Schema4.Struct({
+    slotId: Schema4.Struct({
+      namespace: Schema4.String
+    })
+  }),
+  Schema4.Struct({
+    assetKind: Schema4.String
+  })
+]);
+var Answer = Schema4.Union([
+  Schema4.Struct({
+    choice: Schema4.Struct({
+      id: Schema4.String,
+      option: Schema4.String
+    })
+  }),
+  Schema4.Struct({
+    bridge: Schema4.Struct({
+      fields: Schema4.Record(Schema4.String, Schema4.Json),
+      tag: Schema4.String,
+      writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
+    })
+  })
+]);
+var Cadence = Schema4.Struct({
+  latched: Schema4.Record(Schema4.String, Schema4.NullOr(Schema4.suspend(() => ClockAt))),
+  live: Schema4.Record(Schema4.String, Schema4.Boolean),
+  rearm: Schema4.Record(Schema4.String, Schema4.Boolean),
+  spentSeason: Schema4.UniqueArray(Schema4.String),
+  windows: Schema4.UniqueArray(Schema4.String)
+});
+var Continuation = Schema4.Struct({
+  answers: Schema4.Array(Schema4.suspend(() => Answer)),
+  before: Schema4.suspend(() => World),
+  delivered: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+  input: Schema4.suspend(() => Input),
+  pending: Schema4.suspend(() => Await),
+  stage: Schema4.suspend(() => Stage)
+});
+var Stage = Schema4.Struct({
+  actors: Schema4.Array(Schema4.suspend(() => StageActor)),
+  bg: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageBackground))),
+  cg: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageCg))),
+  music: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageMusic))),
+  video: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageVideo)))
+});
+var StageActor = Schema4.Struct({
+  anchor: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  character: Schema4.String,
+  costume: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  emotion: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageBackground = Schema4.Struct({
+  assetId: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  location: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  time: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageCg = Schema4.Struct({
+  assetId: Schema4.String,
+  layout: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageMusic = Schema4.Struct({
+  assetId: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  mood: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  playback: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  volume: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageVideo = Schema4.Struct({
+  assetId: Schema4.String
+});
+var World = Schema4.Struct({
+  accepts: Schema4.Array(Schema4.String),
+  advanceCascadeDepth: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+  cadence: Schema4.suspend(() => Cadence),
+  clockAdvancedByBeat: Schema4.Boolean,
+  deferBy: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  deferHandlers: Schema4.Boolean,
+  deferredHandlers: Schema4.Array(Schema4.Tuple([
+    Schema4.String,
+    Schema4.String
+  ])),
+  derive: Schema4.optionalKey(Schema4.NullOr(Schema4.Boolean)),
+  facts: Schema4.UniqueArray(Schema4.Tuple([
+    Schema4.String,
+    Schema4.Array(Schema4.String)
+  ])),
+  failedObjectives: Schema4.UniqueArray(Schema4.String),
+  nextRunAccepts: Schema4.Array(Schema4.String),
+  questInstances: Schema4.Record(Schema4.String, Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0)))),
+  quests: Schema4.Record(Schema4.String, Schema4.String),
+  shareSpentBy: Schema4.Record(Schema4.String, Schema4.String),
+  spentAt: Schema4.Record(Schema4.String, Schema4.suspend(() => ClockAt)),
+  spentRun: Schema4.UniqueArray(Schema4.String),
+  spentUser: Schema4.UniqueArray(Schema4.String),
+  stage: Schema4.suspend(() => Stage),
+  state: Schema4.Record(Schema4.String, Schema4.suspend(() => Value)),
+  visited: Schema4.UniqueArray(Schema4.String)
+});
+var Snapshot = Schema4.Struct({
+  await: Schema4.suspend(() => Await),
+  continuation: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => Continuation))),
+  project: Schema4.String,
+  request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+  snapshotVersion: Schema4.String,
+  world: Schema4.suspend(() => World)
+});
+
+// src/InputLog.ts
+var exports_InputLog = {};
+__export(exports_InputLog, {
+  InputLog: () => InputLog,
+  LogEntry: () => LogEntry,
+  keyValueStore: () => keyValueStore,
+  memory: () => memory
+});
+import { Context as Context2, Effect as Effect3, Layer as Layer2, Option, Ref, Schema as Schema5 } from "effect";
+import * as KeyValueStore from "effect/persistence/KeyValueStore";
+var LogEntry = Schema5.Union([
+  Schema5.Struct({ seed: Seed }),
+  Schema5.Struct({ snapshot: Snapshot }),
+  Schema5.Struct({ input: Input })
+]);
+
+class InputLog extends Context2.Service()("@lute-lang/runtime/InputLog") {
+}
+var memory = Layer2.effect(InputLog, Effect3.map(Ref.make([]), (log) => ({
+  reset: (start) => Ref.set(log, [start]),
+  append: (entry) => Ref.update(log, (entries) => [...entries, entry]),
+  entries: Ref.get(log)
+})));
+var keyValueStore = (key) => Layer2.effect(InputLog, Effect3.gen(function* () {
+  const store = KeyValueStore.toSchemaStore(yield* KeyValueStore.KeyValueStore, Schema5.Array(LogEntry));
+  const entries = store.get(key).pipe(Effect3.map(Option.getOrElse(() => [])), Effect3.mapError((error) => new InputLogError({ message: error.message })));
+  return {
+    reset: (start) => Effect3.mapError(store.set(key, [start]), (error) => new InputLogError({ message: error.message })),
+    append: (entry) => entries.pipe(Effect3.flatMap((logged) => store.set(key, [...logged, entry])), Effect3.mapError((error) => new InputLogError({ message: error.message }))),
+    entries
+  };
+}));
+
+// src/LuteWasm.ts
+var exports_LuteWasm = {};
+__export(exports_LuteWasm, {
+  LuteWasm: () => LuteWasm2,
+  fromBytes: () => fromBytes,
+  layerFromBytes: () => layerFromBytes
+});
+import { Context as Context3, Effect as Effect4, Layer as Layer3 } from "effect";
+import * as Glue from "./wasm/lute_runtime_wasm.js";
+
+class LuteWasm2 extends Context3.Service()("@lute-lang/runtime/LuteWasm") {
+}
+var fromBytes = (bytes) => Effect4.try({
+  try: () => {
+    const { buffer, byteOffset, byteLength } = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    if (!(buffer instanceof ArrayBuffer))
+      throw new TypeError("the bytes live in a SharedArrayBuffer");
+    Glue.initSync({ module: new Uint8Array(buffer, byteOffset, byteLength) });
+    return { Program: Glue.Program };
+  },
+  catch: (cause) => new WasmLoadError({ message: `cannot instantiate the runtime binding: ${String(cause)}` })
+});
+var layerFromBytes = (bytes) => Layer3.effect(LuteWasm2, fromBytes(bytes));
+
+// src/Program.ts
+var exports_Program = {};
+__export(exports_Program, {
+  make: () => make,
+  rejection: () => rejection
+});
+import { Effect as Effect5, Option as Option2, Schema as Schema6 } from "effect";
+var TypeId = "~@lute-lang/runtime/RuntimeState";
+var handles = new WeakMap;
+var wrap = (handle, fingerprint) => {
+  const state = { [TypeId]: TypeId };
+  handles.set(state, { handle, fingerprint });
+  return state;
+};
+var handleOf = (state, fingerprint) => Effect5.suspend(() => {
+  const owned = handles.get(state);
+  if (owned === undefined) {
+    return Effect5.die(new Error("a RuntimeState must come from a Program of this package"));
+  }
+  if (owned.fingerprint !== fingerprint) {
+    return Effect5.die(new Error(`a RuntimeState of bundle ${owned.fingerprint} was given to a Program of bundle ${fingerprint}: ` + "a state is valid only for programs of the bundle fingerprint that created it"));
+  }
+  return Effect5.succeed(owned.handle);
+});
+var fromBinding = (schema) => {
+  const decode = Schema6.decodeUnknownEffect(Schema6.fromJsonString(schema), parseOptions);
+  return (json) => Effect5.orDie(decode(json));
+};
+var toBinding = (schema) => {
+  const encode = Schema6.encodeEffect(Schema6.fromJsonString(schema), parseOptions);
+  return (value) => Effect5.orDie(encode(value));
+};
+var decodeOutput = fromBinding(Output);
+var decodeRejected = fromBinding(Rejected);
+var decodeSnapshot = fromBinding(Snapshot);
+var decodeCandidates = fromBinding(Schema6.Array(Candidate));
+var decodeCandidate = fromBinding(Schema6.NullOr(Candidate));
+var decodeStage = fromBinding(Stage);
+var decodeClock = fromBinding(Schema6.NullOr(ClockAt));
+var decodeView = fromBinding(WorldView);
+var decodeEvaluation = fromBinding(Evaluation);
+var decodeGate = fromBinding(Gate);
+var encodeExpr = toBinding(Schema6.Json);
+var encodeSeed = toBinding(Seed);
+var encodeInput = toBinding(Input);
+var encodeSnapshot = toBinding(Snapshot);
+var rejection = (json) => Effect5.flatMap(decodeRejected(json), fromRejected);
+var settle = (result, success) => Effect5.suspend(() => {
+  const { ok, rejected } = result;
+  if (ok)
+    return success();
+  if (rejected !== undefined)
+    return rejection(rejected);
+  return Effect5.die(new Error("the runtime binding returned neither a value nor a rejection"));
+}).pipe(Effect5.ensuring(Effect5.sync(() => result.free())));
+var queryOf = (result, decode, reject) => Effect5.suspend(() => {
+  const { ok, value, rejected } = result;
+  if (ok && value !== undefined)
+    return decode(value);
+  if (!ok && rejected !== undefined)
+    return Effect5.flatMap(decodeRejected(rejected), reject);
+  return Effect5.die(new Error("the runtime binding returned neither an answer nor a rejection"));
+}).pipe(Effect5.ensuring(Effect5.sync(() => result.free())));
+var make = (raw) => {
+  const fingerprint = raw.fingerprint;
+  const own = (state) => handleOf(state, fingerprint);
+  const stepOf = (result) => settle(result, () => {
+    const { state, output } = result;
+    return state === undefined || output === undefined ? Effect5.die(new Error("the runtime binding accepted an input without a state and output")) : Effect5.map(decodeOutput(output), (output) => ({ state: wrap(state, fingerprint), output }));
+  });
+  return {
+    fingerprint,
+    begin: Effect5.fn("Lute.Program.begin")(function* (seed) {
+      const json = yield* encodeSeed(seed);
+      return yield* stepOf(raw.begin(json));
+    }),
+    step: Effect5.fn("Lute.Program.step")(function* (state, input) {
+      const handle = yield* own(state);
+      const json = yield* encodeInput(input);
+      return yield* stepOf(raw.step(handle, json));
+    }),
+    snapshot: Effect5.fn("Lute.Program.snapshot")(function* (state) {
+      const handle = yield* own(state);
+      return yield* decodeSnapshot(raw.snapshot(handle));
+    }),
+    restore: Effect5.fn("Lute.Program.restore")(function* (snapshot) {
+      const json = yield* encodeSnapshot(snapshot);
+      const result = raw.restore(json);
+      return yield* settle(result, () => {
+        const { state } = result;
+        return state === undefined ? Effect5.die(new Error("the runtime binding restored a snapshot without a state")) : Effect5.succeed(wrap(state, fingerprint));
+      });
+    }),
+    candidates: Effect5.fn("Lute.Program.candidates")(function* (state, occasion, target) {
+      const handle = yield* own(state);
+      return yield* decodeCandidates(raw.candidates(handle, occasion, target));
+    }),
+    eligibility: Effect5.fn("Lute.Program.eligibility")(function* (state, beat, member) {
+      const handle = yield* own(state);
+      const candidate = yield* decodeCandidate(raw.eligibility(handle, beat, member));
+      return Option2.fromNullOr(candidate);
+    }),
+    clock: Effect5.fn("Lute.Program.clock")(function* (state) {
+      const handle = yield* own(state);
+      const clock = yield* decodeClock(raw.clock(handle));
+      return Option2.fromNullOr(clock);
+    }),
+    terminal: Effect5.fn("Lute.Program.terminal")(function* (state) {
+      const handle = yield* own(state);
+      return raw.terminal(handle);
+    }),
+    stage: Effect5.fn("Lute.Program.stage")(function* (state) {
+      const handle = yield* own(state);
+      return yield* decodeStage(raw.stage(handle));
+    }),
+    view: Effect5.fn("Lute.Program.view")(function* (state, options) {
+      const handle = yield* own(state);
+      return yield* decodeView(raw.view(handle, options?.facts === true));
+    }),
+    evaluate: Effect5.fn("Lute.Program.evaluate")(function* (state, expr) {
+      const handle = yield* own(state);
+      const json = yield* encodeExpr(expr);
+      return yield* queryOf(raw.evaluate(handle, json), decodeEvaluation, fromQueryRejected);
+    }),
+    def: Effect5.fn("Lute.Program.def")(function* (state, name, args) {
+      const handle = yield* own(state);
+      const json = args === undefined ? undefined : JSON.stringify(args);
+      return yield* queryOf(raw.def(handle, name, json), decodeEvaluation, fromQueryRejected);
+    }),
+    gate: Effect5.fn("Lute.Program.gate")(function* (state, occasion, target) {
+      const handle = yield* own(state);
+      return yield* queryOf(raw.gate(handle, occasion, target), decodeGate, fromGateRejected);
+    }),
+    free: Effect5.sync(() => raw.free())
+  };
+};
+
+// src/LuteRuntime.ts
+var exports_LuteRuntime = {};
+__export(exports_LuteRuntime, {
+  LuteRuntime: () => LuteRuntime,
+  layer: () => layer
+});
+import { Context as Context4, Effect as Effect6, Layer as Layer4 } from "effect";
+class LuteRuntime extends Context4.Service()("@lute-lang/runtime/LuteRuntime") {
+}
+var layer = Layer4.effect(LuteRuntime, Effect6.gen(function* () {
+  const wasm = yield* LuteWasm2;
+  const acquire = Effect6.fn("Lute.LuteRuntime.load")(function* (bundle) {
+    const result = wasm.Program.load(JSON.stringify(bundle.index), JSON.stringify(bundle.artifacts));
+    const { ok, program, rejected } = result;
+    result.free();
+    if (ok && program !== undefined)
+      return make(program);
+    if (rejected !== undefined)
+      return yield* rejection(rejected);
+    return yield* Effect6.die(new Error("the runtime binding returned neither a program nor a rejection"));
+  });
+  return {
+    load: (bundle) => Effect6.acquireRelease(acquire(bundle), (program) => program.free)
+  };
+}));
+
+// src/Session.ts
+var exports_Session = {};
+__export(exports_Session, {
+  Session: () => Session,
+  layer: () => layer2
+});
+import { Context as Context5, Effect as Effect7, Layer as Layer5, PubSub, Semaphore, Stream, SubscriptionRef } from "effect";
+class Session extends Context5.Service()("@lute-lang/runtime/Session") {
+}
+var layer2 = (options) => Layer5.effect(Session, Effect7.gen(function* () {
+  const runtime = yield* LuteRuntime;
+  const log = yield* InputLog;
+  const bundle = yield* (yield* BundleSource).load;
+  const program = yield* runtime.load(bundle);
+  const started = "seed" in options ? yield* program.begin(options.seed) : {
+    state: yield* program.restore(options.snapshot),
+    output: { eventVersion: options.snapshot.snapshotVersion, events: [], await: options.snapshot.await }
+  };
+  const stage = yield* program.stage(started.state);
+  yield* log.reset(options);
+  const current = yield* SubscriptionRef.make({
+    state: started.state,
+    stage,
+    await: started.output.await
+  });
+  const events = yield* PubSub.unbounded();
+  const awaits = yield* PubSub.unbounded();
+  yield* Effect7.addFinalizer(() => Effect7.andThen(PubSub.shutdown(events), PubSub.shutdown(awaits)));
+  const lock = yield* Semaphore.make(1);
+  const send = Effect7.fn("Lute.Session.send")(function* (input) {
+    const { state } = yield* SubscriptionRef.get(current);
+    const step = yield* program.step(state, input);
+    yield* log.append({ input });
+    const stage = yield* program.stage(step.state);
+    yield* SubscriptionRef.set(current, { state: step.state, stage, await: step.output.await });
+    yield* PubSub.publishAll(events, step.output.events);
+    yield* PubSub.publish(awaits, step.output.await);
+    return step.output;
+  });
+  const restore = Effect7.fn("Lute.Session.restore")(function* (snapshot) {
+    const state = yield* program.restore(snapshot);
+    const stage = yield* program.stage(state);
+    yield* log.reset({ snapshot });
+    yield* SubscriptionRef.set(current, { state, stage, await: snapshot.await });
+    yield* PubSub.publish(awaits, snapshot.await);
+  });
+  return {
+    fingerprint: program.fingerprint,
+    program,
+    started: started.output,
+    send: (input) => lock.withPermits(1)(send(input)),
+    current,
+    events: Effect7.map(PubSub.subscribe(events), Stream.fromSubscription),
+    awaits: Effect7.map(PubSub.subscribe(awaits), Stream.fromSubscription),
+    save: SubscriptionRef.get(current).pipe(Effect7.flatMap(({ state }) => program.snapshot(state)), Effect7.withSpan("Lute.Session.save")),
+    restore: (snapshot) => lock.withPermits(1)(restore(snapshot))
+  };
+}));
+
+export { __export, projectIndex, exports_Ir, WasmLoadError, exports_Errors, directory, url, exports_BundleSource, exports_Contract, LogEntry, memory, keyValueStore, exports_InputLog, LuteWasm2, fromBytes, exports_LuteWasm, exports_Program, layer, exports_LuteRuntime, layer2, exports_Session };