@lute-lang/runtime 0.0.0-stage → 0.39.0

package/dist/index-eqt12qy0.js

@@ -0,0 +1,857 @@
+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/Bundle.ts
+var exports_Bundle = {};
+__export(exports_Bundle, {
+  IndexDocuments: () => IndexDocuments,
+  Bundle: () => Bundle
+});
+import { Schema } from "effect";
+var Bundle = Schema.Struct({
+  index: Schema.Json,
+  artifacts: Schema.Record(Schema.String, Schema.Json)
+});
+var IndexDocuments = Schema.Struct({
+  documents: Schema.Array(Schema.Struct({ artifact: Schema.String }))
+});
+
+// src/Errors.ts
+var exports_Errors = {};
+__export(exports_Errors, {
+  fromRejected: () => fromRejected,
+  WasmLoadError: () => WasmLoadError,
+  SnapshotVersionMismatch: () => SnapshotVersionMismatch,
+  SnapshotProjectMismatch: () => SnapshotProjectMismatch,
+  RuntimeHalted: () => RuntimeHalted,
+  RuntimeBusy: () => RuntimeBusy,
+  RequestMismatch: () => RequestMismatch,
+  OptionUnavailable: () => OptionUnavailable,
+  IrVersionMismatch: () => IrVersionMismatch,
+  InvalidInput: () => InvalidInput,
+  InputLogError: () => InputLogError,
+  BundleUnreadable: () => BundleUnreadable,
+  BundleNotFound: () => BundleNotFound,
+  BundleMalformed: () => BundleMalformed,
+  BridgeShapeMismatch: () => BridgeShapeMismatch
+});
+import { Effect, Schema as Schema2 } from "effect";
+
+class RuntimeBusy extends Schema2.TaggedError()("RuntimeBusy", {
+  code: Schema2.Literal("E-RUNTIME-BUSY"),
+  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 }) {
+}
+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-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 })
+};
+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 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, {
+  value: () => value,
+  url: () => url,
+  directory: () => directory,
+  BundleSource: () => BundleSource
+});
+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 decodeDocuments = Schema3.decodeUnknownEffect(IndexDocuments);
+var assemble = (read) => Effect2.gen(function* () {
+  const readJson = (path) => Effect2.flatMap(read(path), (text) => Effect2.mapError(decodeJson(text), (error) => new BundleMalformed({ path, message: error.message })));
+  const index = yield* readJson(INDEX);
+  const { documents } = yield* Effect2.mapError(decodeDocuments(index), (error) => new BundleMalformed({ path: INDEX, message: error.message }));
+  const artifacts = yield* Effect2.forEach(documents, ({ artifact }) => Effect2.map(readJson(artifact), (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, {
+  parseOptions: () => parseOptions,
+  WritesInput: () => WritesInput,
+  WorldView: () => WorldView,
+  World: () => World,
+  Verdict: () => Verdict,
+  Value: () => Value,
+  StreamLine: () => StreamLine,
+  StateWrite: () => StateWrite,
+  Snapshot: () => Snapshot,
+  Seed: () => Seed,
+  SaveInput: () => SaveInput,
+  Rejected: () => Rejected,
+  Premise: () => Premise,
+  PickInput: () => PickInput,
+  Output: () => Output,
+  MenuOptionAwait: () => MenuOptionAwait,
+  MenuAwait: () => MenuAwait,
+  Input: () => Input,
+  GuardRead: () => GuardRead,
+  Event: () => Event,
+  Continuation: () => Continuation,
+  ClockView: () => ClockView,
+  ClockPosition: () => ClockPosition,
+  ClockAt: () => ClockAt,
+  Candidate: () => Candidate,
+  Cadence: () => Cadence,
+  BeatOnce: () => BeatOnce,
+  BeatKind: () => BeatKind,
+  Await: () => Await,
+  Atom: () => Atom,
+  Answer: () => Answer,
+  AdvanceBy: () => AdvanceBy
+});
+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({
+    document: Schema4.String,
+    fields: Schema4.Record(Schema4.String, Schema4.String),
+    position: Schema4.String,
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    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 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 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({
+    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")
+  }),
+  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,
+  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.Number))
+});
+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 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
+    })
+  })
+]);
+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)
+});
+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),
+  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, {
+  memory: () => memory,
+  keyValueStore: () => keyValueStore,
+  LogEntry: () => LogEntry,
+  InputLog: () => InputLog
+});
+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, {
+  layerFromBytes: () => layerFromBytes,
+  fromBytes: () => fromBytes,
+  LuteWasm: () => LuteWasm
+});
+import { Context as Context3, Effect as Effect4, Layer as Layer3 } from "effect";
+import * as Glue from "./wasm/lute_runtime_wasm.js";
+
+class LuteWasm 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(LuteWasm, fromBytes(bytes));
+
+// src/Program.ts
+var exports_Program = {};
+__export(exports_Program, {
+  rejection: () => rejection,
+  make: () => make
+});
+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) => {
+  const state = { [TypeId]: TypeId };
+  handles.set(state, handle);
+  return state;
+};
+var handleOf = (state) => {
+  const handle = handles.get(state);
+  return handle === undefined ? Effect5.die(new Error("a RuntimeState must come from a Program of this package")) : Effect5.succeed(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 (value2) => Effect5.orDie(encode(value2));
+};
+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 decodeClock = fromBinding(Schema6.NullOr(ClockAt));
+var decodeView = fromBinding(WorldView);
+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 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), (output2) => ({ state: wrap(state), output: output2 }));
+});
+var make = (raw) => ({
+  fingerprint: raw.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* handleOf(state);
+    const json = yield* encodeInput(input);
+    return yield* stepOf(raw.step(handle, json));
+  }),
+  snapshot: Effect5.fn("Lute.Program.snapshot")(function* (state) {
+    const handle = yield* handleOf(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));
+    });
+  }),
+  candidates: Effect5.fn("Lute.Program.candidates")(function* (state, occasion, target) {
+    const handle = yield* handleOf(state);
+    return yield* decodeCandidates(raw.candidates(handle, occasion, target));
+  }),
+  eligibility: Effect5.fn("Lute.Program.eligibility")(function* (state, beat, member) {
+    const handle = yield* handleOf(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* handleOf(state);
+    const clock = yield* decodeClock(raw.clock(handle));
+    return Option2.fromNullOr(clock);
+  }),
+  terminal: Effect5.fn("Lute.Program.terminal")(function* (state) {
+    const handle = yield* handleOf(state);
+    return raw.terminal(handle);
+  }),
+  view: Effect5.fn("Lute.Program.view")(function* (state, options) {
+    const handle = yield* handleOf(state);
+    return yield* decodeView(raw.view(handle, options?.facts === true));
+  }),
+  free: Effect5.sync(() => raw.free())
+});
+
+// src/LuteRuntime.ts
+var exports_LuteRuntime = {};
+__export(exports_LuteRuntime, {
+  layer: () => layer,
+  LuteRuntime: () => LuteRuntime
+});
+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* LuteWasm;
+  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, {
+  layer: () => layer2,
+  Session: () => Session
+});
+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 }
+  };
+  yield* log.reset(options);
+  const current = yield* SubscriptionRef.make({
+    state: started.state,
+    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 });
+    yield* SubscriptionRef.set(current, { state: step.state, 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);
+    yield* log.reset({ snapshot });
+    yield* SubscriptionRef.set(current, { state, await: snapshot.await });
+    yield* PubSub.publish(awaits, snapshot.await);
+  });
+  return {
+    fingerprint: program.fingerprint,
+    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, exports_Bundle, WasmLoadError, exports_Errors, directory, url, exports_BundleSource, exports_Contract, LogEntry, memory, keyValueStore, exports_InputLog, LuteWasm, fromBytes, exports_LuteWasm, exports_Program, layer, exports_LuteRuntime, layer2 as layer1, exports_Session };