@lute-lang/runtime 0.0.0-stage → 0.39.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.39.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,115 @@
+/**
+ * The typed failures of the runtime (spec 0.39.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 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 | 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,388 @@
+/**
+ * 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 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.Number>>;
+            }>>;
+            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 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 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 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.Number>>;
+                }>>;
+                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 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 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 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 {};

package/dist/LuteRuntime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Loads bundles into {@link Program}s (spec 0.39.0 §5.1). A program lives in
+ * the scope that loaded it and is freed when the scope closes.
+ */
+import { Context, Effect, Layer, Scope } from "effect";
+import type { Bundle } from "./Bundle.js";
+import type * as Errors from "./Errors.js";
+import { LuteWasm } from "./LuteWasm.js";
+import * as Program from "./Program.js";
+declare const LuteRuntime_base: Context.ServiceClass<LuteRuntime, "@lute-lang/runtime/LuteRuntime", {
+    /**
+     * Load a bundle. `IrVersionMismatch` when the runtime does not execute
+     * it (another IR line, an unknown command kind, not a bundle).
+     */
+    readonly load: (bundle: Bundle) => Effect.Effect<Program.Program, Errors.RuntimeRejection, Scope.Scope>;
+}>;
+export declare class LuteRuntime extends LuteRuntime_base {
+}
+export declare const layer: Layer.Layer<LuteRuntime, never, LuteWasm>;
+export {};

package/dist/LuteWasm.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The instantiated wasm binding (`crates/lute-runtime-wasm`) as a service.
+ *
+ * Platform layers (`@lute-lang/runtime/bun`, `@lute-lang/runtime/browser`)
+ * obtain the module's bytes and instantiate it through {@link fromBytes};
+ * nothing else in the package touches the glue's module state.
+ */
+import { Context, Effect, Layer } from "effect";
+import { WasmLoadError } from "./Errors.js";
+import * as Glue from "./wasm/lute_runtime_wasm.js";
+/** The binding's entry point: `Program.load` and the result classes it returns. */
+export interface LuteWasmShape {
+    readonly Program: typeof Glue.Program;
+}
+declare const LuteWasm_base: Context.ServiceClass<LuteWasm, "@lute-lang/runtime/LuteWasm", LuteWasmShape>;
+export declare class LuteWasm extends LuteWasm_base {
+}
+/**
+ * Instantiate the binding from the `.wasm` bytes. Bytes backed by a
+ * `SharedArrayBuffer` are refused: WebAssembly compiles from an
+ * `ArrayBuffer`.
+ */
+export declare const fromBytes: (bytes: Uint8Array | ArrayBuffer) => Effect.Effect<LuteWasmShape, WasmLoadError>;
+/** The binding instantiated from bytes the host already holds. */
+export declare const layerFromBytes: (bytes: Uint8Array | ArrayBuffer) => Layer.Layer<LuteWasm, WasmLoadError>;
+export {};

package/dist/Program.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A loaded bundle and the runtime's step function over it (spec 0.39.0 §5.1).
+ *
+ * Every value crossing the binding is encoded and decoded with the contract
+ * schemas generated from the Rust types. JSON the binding returns that does
+ * not decode is contract drift — a defect.
+ */
+import { Effect, Option } from "effect";
+import * as Errors from "./Errors.js";
+import * as Contract from "./generated/Contract.js";
+import type * as Glue from "./wasm/lute_runtime_wasm.js";
+declare const TypeId = "~@lute-lang/runtime/RuntimeState";
+/**
+ * An opaque, immutable runtime state. Stepping from it never invalidates it,
+ * so a host may keep earlier states (undo, branching). Its serialized form
+ * is {@link Program.snapshot}.
+ */
+export interface RuntimeState {
+    readonly [TypeId]: typeof TypeId;
+}
+/** One accepted input: the state it produced and the runtime's output. */
+export interface Step {
+    readonly state: RuntimeState;
+    readonly output: Contract.Output;
+}
+export interface Program {
+    /** The bundle's identity, which snapshots carry. */
+    readonly fingerprint: string;
+    readonly begin: (seed: Contract.Seed) => Effect.Effect<Step, Errors.RuntimeRejection>;
+    readonly step: (state: RuntimeState, input: Contract.Input) => Effect.Effect<Step, Errors.RuntimeRejection>;
+    readonly snapshot: (state: RuntimeState) => Effect.Effect<Contract.Snapshot>;
+    readonly restore: (snapshot: Contract.Snapshot) => Effect.Effect<RuntimeState, Errors.RuntimeRejection>;
+    readonly candidates: (state: RuntimeState, occasion: string, target?: string) => Effect.Effect<ReadonlyArray<Contract.Candidate>>;
+    readonly eligibility: (state: RuntimeState, beat: string, member?: string) => Effect.Effect<Option.Option<Contract.Candidate>>;
+    readonly clock: (state: RuntimeState) => Effect.Effect<Option.Option<Contract.ClockAt>>;
+    readonly terminal: (state: RuntimeState) => Effect.Effect<boolean>;
+    readonly view: (state: RuntimeState, options?: {
+        readonly facts?: boolean;
+    }) => Effect.Effect<Contract.WorldView>;
+}
+/** Fail with a rejection the binding returned as JSON. */
+export declare const rejection: (json: string) => Effect.Effect<never, Errors.RuntimeRejection>;
+/** Wrap a program the binding loaded. The caller owns its lifetime ({@link free}). */
+export declare const make: (raw: Glue.Program) => Program & {
+    readonly free: Effect.Effect<void>;
+};
+export {};