@lute-lang/runtime 0.0.0-stage → 0.40.0

package/dist/Bundle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A compiled bundle: `project.index.json` and every artifact it lists, keyed
+ * by the index's `artifact` paths — the output of `lute compile --all`
+ * (spec 0.38.0 §4.1). The runtime validates it on load.
+ */
+import { Schema } from "effect";
+export declare const Bundle: Schema.Struct<{
+    readonly index: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly artifacts: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type Bundle = typeof Bundle.Type;
+/** The part of `project.index.json` a loader reads: where each artifact is. */
+export declare const IndexDocuments: Schema.Struct<{
+    readonly documents: Schema.$Array<Schema.Struct<{
+        readonly artifact: Schema.String;
+    }>>;
+}>;

package/dist/BundleSource.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Where a session's bundle comes from (spec 0.40.0 §5.1): a `lute compile
+ * --all` output directory, the same layout served over HTTP, or a value the
+ * host already holds.
+ */
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import * as HttpClient from "effect/http/HttpClient";
+import { Bundle } from "./Bundle.js";
+import type { BundleError } from "./Errors.js";
+declare const BundleSource_base: Context.ServiceClass<BundleSource, "@lute-lang/runtime/BundleSource", {
+    readonly load: Effect.Effect<Bundle, BundleError>;
+}>;
+export declare class BundleSource extends BundleSource_base {
+}
+/** A bundle the host already holds. */
+export declare const value: (bundle: Bundle) => Layer.Layer<BundleSource>;
+/** A `lute compile --all` output directory. */
+export declare const directory: (root: string) => Layer.Layer<BundleSource, never, FileSystem.FileSystem | Path.Path>;
+/** A `lute compile --all` output served under `base` (a URL ending in `/`). */
+export declare const url: (base: string) => Layer.Layer<BundleSource, never, HttpClient.HttpClient>;
+export {};

package/dist/Errors.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The typed failures of the runtime (spec 0.40.0 §5.3).
+ *
+ * A rejected input is an expected failure: each runtime code is its own
+ * tagged error, carrying the runtime's `code` and `message`. A code this
+ * package does not know is contract drift — a defect, never a typed error.
+ */
+import { Effect, Schema } from "effect";
+import type { Rejected } from "./generated/Contract.js";
+declare const RuntimeBusy_base: Schema.Class<RuntimeBusy, Schema.TaggedStruct<"RuntimeBusy", {
+    readonly code: Schema.Literal<"E-RUNTIME-BUSY">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-BUSY`: the current await does not accept this input. */
+export declare class RuntimeBusy extends RuntimeBusy_base {
+}
+declare const TimeoutUnavailable_base: Schema.Class<TimeoutUnavailable, Schema.TaggedStruct<"TimeoutUnavailable", {
+    readonly code: Schema.Literal<"E-RUNTIME-TIMEOUT">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-TIMEOUT`: the pending await is not a timed choice. */
+export declare class TimeoutUnavailable extends TimeoutUnavailable_base {
+}
+declare const RequestMismatch_base: Schema.Class<RequestMismatch, Schema.TaggedStruct<"RequestMismatch", {
+    readonly code: Schema.Literal<"E-RUNTIME-REQUEST">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-REQUEST`: an answer names another request than the pending await. */
+export declare class RequestMismatch extends RequestMismatch_base {
+}
+declare const OptionUnavailable_base: Schema.Class<OptionUnavailable, Schema.TaggedStruct<"OptionUnavailable", {
+    readonly code: Schema.Literal<"E-RUNTIME-OPTION">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-OPTION`: the chosen option is absent from the menu or not open. */
+export declare class OptionUnavailable extends OptionUnavailable_base {
+}
+declare const BridgeShapeMismatch_base: Schema.Class<BridgeShapeMismatch, Schema.TaggedStruct<"BridgeShapeMismatch", {
+    readonly code: Schema.Literal<"E-RUNTIME-BRIDGE-SHAPE">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-BRIDGE-SHAPE`: a bridge result misses or mistypes a read field. */
+export declare class BridgeShapeMismatch extends BridgeShapeMismatch_base {
+}
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<"InvalidInput", {
+    readonly code: Schema.Literal<"E-RUNTIME-INPUT">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-INPUT`: a seed or input names something the project lacks. */
+export declare class InvalidInput extends InvalidInput_base {
+}
+declare const RuntimeHalted_base: Schema.Class<RuntimeHalted, Schema.TaggedStruct<"RuntimeHalted", {
+    readonly code: Schema.Literal<"E-RUNTIME-HALTED">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-HALTED`: the state halted; restore an earlier snapshot. */
+export declare class RuntimeHalted extends RuntimeHalted_base {
+}
+declare const IrVersionMismatch_base: Schema.Class<IrVersionMismatch, Schema.TaggedStruct<"IrVersionMismatch", {
+    readonly code: Schema.Literal<"E-RUNTIME-IR-VERSION">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-IR-VERSION`: the bundle is not one this runtime executes. */
+export declare class IrVersionMismatch extends IrVersionMismatch_base {
+}
+declare const SnapshotProjectMismatch_base: Schema.Class<SnapshotProjectMismatch, Schema.TaggedStruct<"SnapshotProjectMismatch", {
+    readonly code: Schema.Literal<"E-RUNTIME-SNAPSHOT-PROJECT">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-SNAPSHOT-PROJECT`: the snapshot belongs to another bundle. */
+export declare class SnapshotProjectMismatch extends SnapshotProjectMismatch_base {
+}
+declare const SnapshotVersionMismatch_base: Schema.Class<SnapshotVersionMismatch, Schema.TaggedStruct<"SnapshotVersionMismatch", {
+    readonly code: Schema.Literal<"E-RUNTIME-SNAPSHOT-VERSION">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-SNAPSHOT-VERSION`: the snapshot is of another Event minor. */
+export declare class SnapshotVersionMismatch extends SnapshotVersionMismatch_base {
+}
+/** Every rejection the runtime returns. */
+export type RuntimeRejection = RuntimeBusy | RequestMismatch | OptionUnavailable | BridgeShapeMismatch | InvalidInput | TimeoutUnavailable | RuntimeHalted | IrVersionMismatch | SnapshotProjectMismatch | SnapshotVersionMismatch;
+/**
+ * Fail with the typed error of a runtime rejection; a code this package does
+ * not know dies.
+ */
+export declare const fromRejected: (rejected: Rejected) => Effect.Effect<never, RuntimeRejection>;
+declare const BundleNotFound_base: Schema.Class<BundleNotFound, Schema.TaggedStruct<"BundleNotFound", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The bundle's `project.index.json` or an artifact it lists does not exist. */
+export declare class BundleNotFound extends BundleNotFound_base {
+}
+declare const BundleUnreadable_base: Schema.Class<BundleUnreadable, Schema.TaggedStruct<"BundleUnreadable", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The bundle exists but could not be read. */
+export declare class BundleUnreadable extends BundleUnreadable_base {
+}
+declare const BundleMalformed_base: Schema.Class<BundleMalformed, Schema.TaggedStruct<"BundleMalformed", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A bundle file is not the JSON a bundle holds. */
+export declare class BundleMalformed extends BundleMalformed_base {
+}
+/** Why a bundle could not be loaded. */
+export type BundleError = BundleNotFound | BundleUnreadable | BundleMalformed;
+declare const WasmLoadError_base: Schema.Class<WasmLoadError, Schema.TaggedStruct<"WasmLoadError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The wasm binding could not be fetched or instantiated. */
+export declare class WasmLoadError extends WasmLoadError_base {
+}
+declare const InputLogError_base: Schema.Class<InputLogError, Schema.TaggedStruct<"InputLogError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The input log could not be read or written. */
+export declare class InputLogError extends InputLogError_base {
+}
+export {};

package/dist/InputLog.d.ts

@@ -0,0 +1,474 @@
+/**
+ * The recorded input log of a session (spec 0.38.0 §9: `(seed or snapshot,
+ * inputs)`). Replaying it against the same bundle reproduces every output;
+ * its entries have the `inputs.jsonl` line shape.
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import * as KeyValueStore from "effect/persistence/KeyValueStore";
+import { InputLogError } from "./Errors.js";
+export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
+    readonly seed: Schema.Struct<{
+        readonly derive: Schema.optionalKey<Schema.Boolean>;
+        readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly save: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly entriesRead: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+            readonly presented: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+            readonly questInstances: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Int>>;
+            readonly quests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly visited: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>>>;
+        readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+            readonly path: Schema.String;
+            readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>>;
+    }>;
+}>, Schema.Struct<{
+    readonly snapshot: Schema.Struct<{
+        readonly await: Schema.suspend<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+            readonly menu: Schema.suspend<Schema.Struct<{
+                readonly construct: Schema.String;
+                readonly default: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly document: Schema.String;
+                readonly id: Schema.String;
+                readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+                    readonly exit: Schema.Boolean;
+                    readonly id: Schema.String;
+                    readonly once: Schema.Boolean;
+                    readonly verdict: Schema.String;
+                }>>>;
+                readonly position: Schema.String;
+                readonly presentation: Schema.Int;
+                readonly prompt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly timeout: Schema.optionalKey<Schema.NullOr<Schema.Int>>;
+            }>>;
+            readonly request: Schema.Int;
+            readonly type: Schema.Literal<"awaitChoice">;
+        }>, Schema.Struct<{
+            readonly document: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.String>;
+            readonly position: Schema.String;
+            readonly request: Schema.Int;
+            readonly tag: Schema.String;
+            readonly type: Schema.Literal<"awaitBridge">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"idle">;
+        }>, Schema.Struct<{
+            readonly reason: Schema.String;
+            readonly type: Schema.Literal<"ended">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly message: Schema.String;
+            readonly site: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly type: Schema.Literal<"halted">;
+        }>]>>;
+        readonly continuation: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+            readonly answers: Schema.$Array<Schema.suspend<Schema.Union<readonly [Schema.Struct<{
+                readonly choice: Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly option: Schema.String;
+                }>;
+            }>, Schema.Struct<{
+                readonly bridge: Schema.Struct<{
+                    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly tag: Schema.String;
+                }>;
+            }>]>>>;
+            readonly before: Schema.suspend<Schema.Struct<{
+                readonly accepts: Schema.$Array<Schema.String>;
+                readonly advanceCascadeDepth: Schema.Int;
+                readonly cadence: Schema.suspend<Schema.Struct<{
+                    readonly latched: Schema.$Record<Schema.String, Schema.NullOr<Schema.suspend<Schema.Struct<{
+                        readonly day: Schema.Int;
+                        readonly slot: Schema.Int;
+                    }>>>>;
+                    readonly live: Schema.$Record<Schema.String, Schema.Boolean>;
+                    readonly rearm: Schema.$Record<Schema.String, Schema.Boolean>;
+                    readonly spentSeason: Schema.UniqueArray<Schema.String>;
+                    readonly windows: Schema.UniqueArray<Schema.String>;
+                }>>;
+                readonly clockAdvancedByBeat: Schema.Boolean;
+                readonly deferBy: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly deferHandlers: Schema.Boolean;
+                readonly deferredHandlers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+                readonly derive: Schema.optionalKey<Schema.NullOr<Schema.Boolean>>;
+                readonly facts: Schema.UniqueArray<Schema.Tuple<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly failedObjectives: Schema.UniqueArray<Schema.String>;
+                readonly nextRunAccepts: Schema.$Array<Schema.String>;
+                readonly questInstances: Schema.$Record<Schema.String, Schema.Int>;
+                readonly quests: Schema.$Record<Schema.String, Schema.String>;
+                readonly shareSpentBy: Schema.$Record<Schema.String, Schema.String>;
+                readonly spentAt: Schema.$Record<Schema.String, Schema.suspend<Schema.Struct<{
+                    readonly day: Schema.Int;
+                    readonly slot: Schema.Int;
+                }>>>;
+                readonly spentRun: Schema.UniqueArray<Schema.String>;
+                readonly spentUser: Schema.UniqueArray<Schema.String>;
+                readonly stage: Schema.suspend<Schema.Struct<{
+                    readonly actors: Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly anchor: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly character: Schema.String;
+                        readonly costume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly emotion: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    }>>>;
+                    readonly bg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                        readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly location: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly time: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    }>>>>;
+                    readonly cg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                        readonly assetId: Schema.String;
+                        readonly layout: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    }>>>>;
+                    readonly music: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                        readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly mood: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly playback: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly volume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    }>>>>;
+                    readonly video: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                        readonly assetId: Schema.String;
+                    }>>>>;
+                }>>;
+                readonly state: Schema.$Record<Schema.String, Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"bool">;
+                    readonly value: Schema.Boolean;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"int">;
+                    readonly value: Schema.Int;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"double">;
+                    readonly value: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"str">;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"unknown">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"error">;
+                    readonly value: Schema.String;
+                }>]>>>;
+                readonly visited: Schema.UniqueArray<Schema.String>;
+            }>>;
+            readonly delivered: Schema.Int;
+            readonly input: Schema.suspend<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+                readonly occasion: Schema.String;
+                readonly payload: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly pick: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly beat: Schema.String;
+                }>]>>>>;
+                readonly target: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly type: Schema.Literal<"raiseOccasion">;
+                readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                    readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                        readonly path: Schema.String;
+                        readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>>>>;
+                }>>>;
+            }>, Schema.Struct<{
+                readonly request: Schema.Int;
+                readonly type: Schema.Literal<"timeout">;
+            }>, Schema.Struct<{
+                readonly option: Schema.String;
+                readonly request: Schema.Int;
+                readonly type: Schema.Literal<"choose">;
+            }>, Schema.Struct<{
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly request: Schema.Int;
+                readonly type: Schema.Literal<"bridgeResult">;
+            }>, Schema.Struct<{
+                readonly by: Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Struct<{
+                    readonly to: Schema.String;
+                }>, Schema.Struct<{
+                    readonly to: Schema.suspend<Schema.Struct<{
+                        readonly slot: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly weekday: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    }>>;
+                }>]>>;
+                readonly pick: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly beat: Schema.String;
+                }>]>>>>;
+                readonly type: Schema.Literal<"advanceClock">;
+                readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                    readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                        readonly path: Schema.String;
+                        readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>>>>;
+                }>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"hostWrite">;
+                readonly writes: Schema.suspend<Schema.Struct<{
+                    readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                        readonly path: Schema.String;
+                        readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>>>>;
+                }>>;
+            }>, Schema.Struct<{
+                readonly name: Schema.String;
+                readonly type: Schema.Literal<"worldEvent">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"newRun">;
+                readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                    readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                        readonly path: Schema.String;
+                        readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>>>>;
+                }>>>;
+            }>]>>;
+            readonly pending: Schema.suspend<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+                readonly menu: Schema.suspend<Schema.Struct<{
+                    readonly construct: Schema.String;
+                    readonly default: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly document: Schema.String;
+                    readonly id: Schema.String;
+                    readonly options: Schema.$Array<Schema.suspend<Schema.Struct<{
+                        readonly exit: Schema.Boolean;
+                        readonly id: Schema.String;
+                        readonly once: Schema.Boolean;
+                        readonly verdict: Schema.String;
+                    }>>>;
+                    readonly position: Schema.String;
+                    readonly presentation: Schema.Int;
+                    readonly prompt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly timeout: Schema.optionalKey<Schema.NullOr<Schema.Int>>;
+                }>>;
+                readonly request: Schema.Int;
+                readonly type: Schema.Literal<"awaitChoice">;
+            }>, Schema.Struct<{
+                readonly document: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.String>;
+                readonly position: Schema.String;
+                readonly request: Schema.Int;
+                readonly tag: Schema.String;
+                readonly type: Schema.Literal<"awaitBridge">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"idle">;
+            }>, Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly type: Schema.Literal<"ended">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly message: Schema.String;
+                readonly site: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly type: Schema.Literal<"halted">;
+            }>]>>;
+            readonly stage: Schema.suspend<Schema.Struct<{
+                readonly actors: Schema.$Array<Schema.suspend<Schema.Struct<{
+                    readonly anchor: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly character: Schema.String;
+                    readonly costume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly emotion: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>;
+                readonly bg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly location: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly time: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly cg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.String;
+                    readonly layout: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly music: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly mood: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly playback: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly volume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly video: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.String;
+                }>>>>;
+            }>>;
+        }>>>>;
+        readonly project: Schema.String;
+        readonly request: Schema.Int;
+        readonly snapshotVersion: Schema.String;
+        readonly world: Schema.suspend<Schema.Struct<{
+            readonly accepts: Schema.$Array<Schema.String>;
+            readonly advanceCascadeDepth: Schema.Int;
+            readonly cadence: Schema.suspend<Schema.Struct<{
+                readonly latched: Schema.$Record<Schema.String, Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly day: Schema.Int;
+                    readonly slot: Schema.Int;
+                }>>>>;
+                readonly live: Schema.$Record<Schema.String, Schema.Boolean>;
+                readonly rearm: Schema.$Record<Schema.String, Schema.Boolean>;
+                readonly spentSeason: Schema.UniqueArray<Schema.String>;
+                readonly windows: Schema.UniqueArray<Schema.String>;
+            }>>;
+            readonly clockAdvancedByBeat: Schema.Boolean;
+            readonly deferBy: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly deferHandlers: Schema.Boolean;
+            readonly deferredHandlers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+            readonly derive: Schema.optionalKey<Schema.NullOr<Schema.Boolean>>;
+            readonly facts: Schema.UniqueArray<Schema.Tuple<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly failedObjectives: Schema.UniqueArray<Schema.String>;
+            readonly nextRunAccepts: Schema.$Array<Schema.String>;
+            readonly questInstances: Schema.$Record<Schema.String, Schema.Int>;
+            readonly quests: Schema.$Record<Schema.String, Schema.String>;
+            readonly shareSpentBy: Schema.$Record<Schema.String, Schema.String>;
+            readonly spentAt: Schema.$Record<Schema.String, Schema.suspend<Schema.Struct<{
+                readonly day: Schema.Int;
+                readonly slot: Schema.Int;
+            }>>>;
+            readonly spentRun: Schema.UniqueArray<Schema.String>;
+            readonly spentUser: Schema.UniqueArray<Schema.String>;
+            readonly stage: Schema.suspend<Schema.Struct<{
+                readonly actors: Schema.$Array<Schema.suspend<Schema.Struct<{
+                    readonly anchor: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly character: Schema.String;
+                    readonly costume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly emotion: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>;
+                readonly bg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly location: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly time: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly cg: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.String;
+                    readonly layout: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly music: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly mood: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly playback: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly volume: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>>;
+                readonly video: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Struct<{
+                    readonly assetId: Schema.String;
+                }>>>>;
+            }>>;
+            readonly state: Schema.$Record<Schema.String, Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"bool">;
+                readonly value: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"int">;
+                readonly value: Schema.Int;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"double">;
+                readonly value: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"str">;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"unknown">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"error">;
+                readonly value: Schema.String;
+            }>]>>>;
+            readonly visited: Schema.UniqueArray<Schema.String>;
+        }>>;
+    }>;
+}>, Schema.Struct<{
+    readonly input: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly occasion: Schema.String;
+        readonly payload: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly pick: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly beat: Schema.String;
+        }>]>>>>;
+        readonly target: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly type: Schema.Literal<"raiseOccasion">;
+        readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                readonly path: Schema.String;
+                readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>>>;
+        }>>>;
+    }>, Schema.Struct<{
+        readonly request: Schema.Int;
+        readonly type: Schema.Literal<"timeout">;
+    }>, Schema.Struct<{
+        readonly option: Schema.String;
+        readonly request: Schema.Int;
+        readonly type: Schema.Literal<"choose">;
+    }>, Schema.Struct<{
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly request: Schema.Int;
+        readonly type: Schema.Literal<"bridgeResult">;
+    }>, Schema.Struct<{
+        readonly by: Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Struct<{
+            readonly to: Schema.String;
+        }>, Schema.Struct<{
+            readonly to: Schema.suspend<Schema.Struct<{
+                readonly slot: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly weekday: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            }>>;
+        }>]>>;
+        readonly pick: Schema.optionalKey<Schema.NullOr<Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly beat: Schema.String;
+        }>]>>>>;
+        readonly type: Schema.Literal<"advanceClock">;
+        readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                readonly path: Schema.String;
+                readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>>>;
+        }>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"hostWrite">;
+        readonly writes: Schema.suspend<Schema.Struct<{
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                readonly path: Schema.String;
+                readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>>>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly name: Schema.String;
+        readonly type: Schema.Literal<"worldEvent">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"newRun">;
+        readonly writes: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly facts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly retract: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly state: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+                readonly add: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                readonly path: Schema.String;
+                readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>>>;
+        }>>>;
+    }>]>;
+}>]>;
+export type LogEntry = typeof LogEntry.Type;
+declare const InputLog_base: Context.ServiceClass<InputLog, "@lute-lang/runtime/InputLog", {
+    /** Start a new log with its `seed` or `snapshot` entry. */
+    readonly reset: (start: LogEntry) => Effect.Effect<void, InputLogError>;
+    /** Record an accepted input. */
+    readonly append: (entry: LogEntry) => Effect.Effect<void, InputLogError>;
+    readonly entries: Effect.Effect<ReadonlyArray<LogEntry>, InputLogError>;
+}>;
+export declare class InputLog extends InputLog_base {
+}
+/** A log held in memory for the session's lifetime. */
+export declare const memory: Layer.Layer<InputLog>;
+/** A log persisted under `key` in a `KeyValueStore` (e.g. `localStorage`). */
+export declare const keyValueStore: (key: string) => Layer.Layer<InputLog, never, KeyValueStore.KeyValueStore>;
+export {};