@lute-lang/runtime 0.39.0 → 0.41.0

package/README.md

@@ -0,0 +1,64 @@
+# @lute-lang/runtime
+
+The Lute runtime for TypeScript hosts, in [Effect](https://effect.website) 4:
+load a bundle compiled by `lute compile --all`, drive the resumable step
+function, query the state (`view`, `evaluate`, `def`, `gate`, `candidates`, …),
+and replay input logs, on Bun and in browsers.
+
+```console
+bun add @lute-lang/runtime effect@4.0.2 @effect/platform-bun@4.0.2
+# or, for a browser application:
+bun add @lute-lang/runtime effect@4.0.2 @effect/platform-browser@4.0.2
+```
+
+The host guide — sessions, the `Program` API, errors, state interchangeability,
+replay, and local dogfooding with packed tarballs — is
+[`docs/runtime/typescript-runtime.md`](https://github.com/journeyWorker/lute/blob/main/docs/runtime/typescript-runtime.md).
+
+## Building from the repository
+
+The package wraps the wasm binding of `crates/lute-runtime-wasm`. In
+`packages/runtime`:
+
+```console
+bun install
+bun run wasm:build      # debug binding -> src/wasm/
+bun run build           # dist/: ESM entry points, declarations, the binding
+bun run typecheck
+bun run test            # builds the binding first (incremental)
+```
+
+`bun run wasm:build:release` builds the release binding and optimizes it with
+`wasm-opt -O`; a published package ships that one.
+
+### Tools
+
+`wasm:build` needs Rust with the `wasm32-unknown-unknown` target and
+**`wasm-bindgen` 0.2.126** — exactly the binding crate's `wasm-bindgen`
+version. The script resolves it in this order:
+
+1. `$WASM_BINDGEN`, a path to the binary;
+2. `wasm-bindgen` on `PATH`;
+3. the wasm-pack cache entry of the pinned version,
+   `<cache>/.wasm-pack/wasm-bindgen-cargo-install-0.2.126/wasm-bindgen`
+   (`wasm-bindgen.exe` on Windows), where `<cache>` is `~/Library/Caches` on
+   macOS, `$XDG_CACHE_HOME` or `~/.cache` on Linux, and `%LOCALAPPDATA%` on
+   Windows — wasm-pack leaves it there after any build of a crate pinned to
+   that version.
+
+When none resolves, or the binary cannot be run or reports another version,
+the script prints
+
+```text
+wasm-build: need wasm-bindgen 0.2.126 (set WASM_BINDGEN, put it on PATH, or cargo install --locked wasm-bindgen-cli --version 0.2.126)
+```
+
+and exits 1. Install it with
+`cargo install --locked wasm-bindgen-cli --version 0.2.126`.
+
+`wasm:build:release` also needs binaryen's `wasm-opt`, from `$WASM_OPT` or
+`PATH`.
+
+The contract schemas under `src/generated/` are generated from the Rust types:
+`bun run contract:gen` regenerates them and `bun run contract:check` fails on
+drift. Never edit them by hand.

package/dist/Bundle.d.ts

@@ -1,17 +1,230 @@
 /**
  * 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.
+ * (spec 0.38.0 §4.1). The index is typed by the generated `Ir.projectIndex`
+ * (spec 0.41.0 §4.4); the runtime validates the whole bundle on load.
  */
 import { Schema } from "effect";
+import * as Ir from "./generated/Ir.js";
 export declare const Bundle: Schema.Struct<{
-    readonly index: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly index: Schema.Struct<{
+        readonly beats: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly advances: Schema.optionalKey<Schema.Union<readonly [Schema.Literals<readonly ["slot", "day"]>, Schema.Int]>>;
+            readonly document: Schema.String;
+            readonly forKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly members: Schema.$Array<Schema.String>;
+            }>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["scene", "entry", "bundle"]>;
+            readonly on: Schema.String;
+            readonly once: Schema.optionalKey<Schema.String>;
+            readonly priority: Schema.Int;
+            readonly share: Schema.optionalKey<Schema.String>;
+            readonly spentBy: Schema.optionalKey<Schema.String>;
+            readonly target: Schema.optionalKey<Schema.String>;
+            readonly targetKind: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly prefix: Schema.String;
+                readonly members: Schema.$Array<Schema.String>;
+            }>>>;
+            readonly title: Schema.optionalKey<Schema.String>;
+            readonly when: Schema.optionalKey<Schema.String>;
+        }>>>>;
+        readonly bridgeResults: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<Ir.fieldType, Ir.fieldType, never, never>>>>>;
+        readonly capabilitySnapshot: Schema.String;
+        readonly cast: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly clock: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly day: Schema.String;
+            readonly slot: Schema.optionalKey<Schema.String>;
+            readonly slots: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly raise: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly slot: Schema.optionalKey<Schema.String>;
+                readonly dayStart: Schema.optionalKey<Schema.String>;
+                readonly dayEnd: Schema.optionalKey<Schema.String>;
+            }>]>>;
+            readonly raiseAtStart: Schema.optionalKey<Schema.Literal<true>>;
+            readonly week: Schema.optionalKey<Schema.Struct<{
+                readonly length: Schema.Int;
+                readonly first: Schema.Int;
+                readonly labels: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>>;
+            readonly last: Schema.optionalKey<Schema.Struct<{
+                readonly day: Schema.Int;
+                readonly slot: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly days: Schema.optionalKey<Schema.Int>;
+        }>>>;
+        readonly defs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Struct<{
+            readonly authored: Schema.optionalKey<Schema.String>;
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly host: Schema.optionalKey<Schema.Boolean>;
+            readonly params: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly type: Schema.suspend<Schema.Codec<Ir.fieldType, Ir.fieldType, never, never>>;
+            }>>>;
+        }>>>>;
+        readonly documents: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly artifact: Schema.String;
+            readonly key: Schema.String;
+            readonly kind: Schema.Literals<readonly ["scene", "quest", "lore"]>;
+            readonly path: Schema.String;
+        }>>>;
+        readonly entities: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly members: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly open: Schema.Boolean;
+            readonly labels: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly labelForms: Schema.optionalKey<Schema.suspend<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly start: Schema.optionalKey<Schema.String>;
+                readonly indefinite: Schema.optionalKey<Schema.String>;
+            }>>>>;
+        }>>>;
+        readonly entries: Schema.optionalKey<Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly category: Schema.optionalKey<Schema.String>;
+            readonly document: Schema.String;
+            readonly id: Schema.String;
+            readonly order: Schema.optionalKey<Schema.Int>;
+            readonly series: Schema.optionalKey<Schema.String>;
+            readonly target: Schema.optionalKey<Schema.String>;
+        }>>>>;
+        readonly enums: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+            readonly labels: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        }>>>;
+        readonly gates: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly occasion: Schema.String;
+            readonly raisedWhen: Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>>>;
+        readonly identityRenames: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly from: Schema.String;
+            readonly to: Schema.String;
+        }>>>;
+        readonly irVersion: Schema.String;
+        readonly occasions: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Struct<{
+            readonly judge: Schema.optionalKey<Schema.Literals<readonly ["after", "before"]>>;
+            readonly outsideRun: Schema.optionalKey<Schema.Boolean>;
+            readonly payload: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<Ir.fieldType, Ir.fieldType, never, never>>>>;
+            readonly select: Schema.Literals<readonly ["first", "all", "sequence"]>;
+            readonly target: Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
+                readonly entity: Schema.String;
+                readonly members: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly prefix: Schema.String;
+            }>]>;
+        }>>>>;
+        readonly outsideRun: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly prereqEdges: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly node: Schema.String;
+            readonly after: Schema.optionalKey<Schema.String>;
+            readonly follows: Schema.optionalKey<Schema.String>;
+            readonly formula: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+        readonly relations: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly tier: Schema.optionalKey<Schema.String>;
+            readonly derive: Schema.Boolean;
+            readonly reserved: Schema.Boolean;
+            readonly key: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+            readonly excludes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>>>;
+        readonly requiredSemantics: Schema.$Array<Schema.String>;
+        readonly rules: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly head: Schema.suspend<Schema.Struct<{
+                readonly relation: Schema.String;
+                readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"var">;
+                    readonly name: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"const">;
+                    readonly value: Schema.String;
+                }>]>>>;
+            }>>;
+            readonly body: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"atom">;
+                readonly atom: Schema.suspend<Schema.Struct<{
+                    readonly relation: Schema.String;
+                    readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"var">;
+                        readonly name: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"const">;
+                        readonly value: Schema.String;
+                    }>]>>>;
+                }>>;
+                readonly negated: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"guard">;
+                readonly cel: Schema.suspend<Schema.Struct<{
+                    readonly cel: Schema.String;
+                    readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly authored: Schema.optionalKey<Schema.String>;
+                }>>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"cmp">;
+                readonly lhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"var">;
+                    readonly name: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"const">;
+                    readonly value: Schema.String;
+                }>]>>;
+                readonly rhs: Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"var">;
+                    readonly name: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"const">;
+                    readonly value: Schema.String;
+                }>]>>;
+                readonly negated: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"count">;
+                readonly atom: Schema.suspend<Schema.Struct<{
+                    readonly relation: Schema.String;
+                    readonly terms: Schema.$Array<Schema.suspend<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"var">;
+                        readonly name: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"const">;
+                        readonly value: Schema.String;
+                    }>]>>>;
+                }>>;
+                readonly distinct: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly op: Schema.Literals<readonly ["==", "!=", "<", "<=", ">", ">="]>;
+                readonly n: Schema.Int;
+            }>]>>>;
+            readonly raw: Schema.String;
+        }>>>;
+        readonly seasons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly live: Schema.suspend<Schema.Struct<{
+                readonly cel: Schema.String;
+                readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly authored: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly name: Schema.String;
+        }>>>;
+        readonly seedFacts: Schema.$Array<Schema.suspend<Schema.Struct<{
+            readonly relation: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly stateDomains: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly members: Schema.$Array<Schema.String>;
+        }>>>>;
+        readonly terminal: Schema.optionalKey<Schema.suspend<Schema.Struct<{
+            readonly cel: Schema.String;
+            readonly expr: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly authored: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly terminalPersists: Schema.optionalKey<Schema.Boolean>;
+        readonly worldEvents: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
     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

@@ -1,11 +1,11 @@
 /**
- * Where a session's bundle comes from (spec 0.39.0 §5.1): a `lute compile
+ * 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 { 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>;

package/dist/Errors.d.ts

@@ -1,5 +1,5 @@
 /**
- * The typed failures of the runtime (spec 0.39.0 §5.3).
+ * The typed failures of the runtime (spec 0.40.0 §5.3, 0.41.0 §6.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
@@ -14,6 +14,13 @@ declare const RuntimeBusy_base: Schema.Class<RuntimeBusy, Schema.TaggedStruct<"R
 /** `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;
@@ -39,7 +46,7 @@ declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<
     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. */
+/** `E-RUNTIME-INPUT`: a seed, input or query names something the project lacks. */
 export declare class InvalidInput extends InvalidInput_base {
 }
 declare const RuntimeHalted_base: Schema.Class<RuntimeHalted, Schema.TaggedStruct<"RuntimeHalted", {
@@ -70,13 +77,47 @@ declare const SnapshotVersionMismatch_base: Schema.Class<SnapshotVersionMismatch
 /** `E-RUNTIME-SNAPSHOT-VERSION`: the snapshot is of another Event minor. */
 export declare class SnapshotVersionMismatch extends SnapshotVersionMismatch_base {
 }
+declare const OccasionGateClosed_base: Schema.Class<OccasionGateClosed, Schema.TaggedStruct<"OccasionGateClosed", {
+    readonly code: Schema.Literal<"E-OCCASION-GATE">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `E-OCCASION-GATE`: the engine would not make this raise — the occasion's
+ * `raisedWhen` is false, or the game is over and the occasion is not
+ * `outsideRun` (spec 0.41.0 §5.2). The state is unchanged, the input's own
+ * writes included; `Program.gate` answers the same rule beforehand.
+ */
+export declare class OccasionGateClosed extends OccasionGateClosed_base {
+}
 /** Every rejection the runtime returns. */
-export type RuntimeRejection = RuntimeBusy | RequestMismatch | OptionUnavailable | BridgeShapeMismatch | InvalidInput | RuntimeHalted | IrVersionMismatch | SnapshotProjectMismatch | SnapshotVersionMismatch;
+export type RuntimeRejection = RuntimeBusy | RequestMismatch | OptionUnavailable | BridgeShapeMismatch | InvalidInput | TimeoutUnavailable | RuntimeHalted | IrVersionMismatch | SnapshotProjectMismatch | SnapshotVersionMismatch | OccasionGateClosed;
 /**
  * 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 EvaluationError_base: Schema.Class<EvaluationError, Schema.TaggedStruct<"EvaluationError", {
+    readonly code: Schema.Literal<"E-RUNTIME-EVAL">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `E-RUNTIME-EVAL`: a queried condition evaluates to an error (spec 0.41.0 §5.1). */
+export declare class EvaluationError extends EvaluationError_base {
+}
+/**
+ * Every rejection a condition query (`Program.evaluate`, `Program.def`)
+ * returns: a malformed expression, an unknown def name or a misfit argument,
+ * or an evaluation error.
+ */
+export type QueryRejection = InvalidInput | EvaluationError;
+/**
+ * Fail with the typed error of a query rejection; any other code dies.
+ */
+export declare const fromQueryRejected: (rejected: Rejected) => Effect.Effect<never, QueryRejection>;
+/**
+ * Fail with the typed error of a `Program.gate` rejection (an occasion the
+ * bundle does not declare); any other code dies.
+ */
+export declare const fromGateRejected: (rejected: Rejected) => Effect.Effect<never, InvalidInput>;
 declare const BundleNotFound_base: Schema.Class<BundleNotFound, Schema.TaggedStruct<"BundleNotFound", {
     readonly path: Schema.String;
     readonly message: Schema.String;

package/dist/InputLog.d.ts

@@ -6,6 +6,7 @@
 import { Context, Effect, Layer, Schema } from "effect";
 import * as KeyValueStore from "effect/persistence/KeyValueStore";
 import { InputLogError } from "./Errors.js";
+import * as Contract from "./generated/Contract.js";
 export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
     readonly seed: Schema.Struct<{
         readonly derive: Schema.optionalKey<Schema.Boolean>;
@@ -28,6 +29,7 @@ export declare const LogEntry: Schema.Union<readonly [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<{
@@ -39,15 +41,16 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                 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 timeout: Schema.optionalKey<Schema.NullOr<Schema.Int>>;
             }>>;
             readonly request: Schema.Int;
             readonly type: Schema.Literal<"awaitChoice">;
         }>, Schema.Struct<{
+            readonly attrs: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
             readonly document: Schema.String;
-            readonly fields: Schema.$Record<Schema.String, Schema.String>;
             readonly position: Schema.String;
             readonly request: Schema.Int;
+            readonly results: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<Contract.fieldType, Contract.fieldType, never, never>>>;
             readonly tag: Schema.String;
             readonly type: Schema.Literal<"awaitBridge">;
         }>, Schema.Struct<{
@@ -71,6 +74,16 @@ export declare const LogEntry: Schema.Union<readonly [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 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 before: Schema.suspend<Schema.Struct<{
@@ -103,6 +116,32 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                 }>>>;
                 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;
@@ -142,6 +181,9 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                         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;
@@ -150,6 +192,16 @@ export declare const LogEntry: Schema.Union<readonly [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">;
+                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 by: Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Struct<{
                     readonly to: Schema.String;
@@ -204,6 +256,7 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
             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<{
@@ -215,15 +268,16 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                     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 timeout: Schema.optionalKey<Schema.NullOr<Schema.Int>>;
                 }>>;
                 readonly request: Schema.Int;
                 readonly type: Schema.Literal<"awaitChoice">;
             }>, Schema.Struct<{
+                readonly attrs: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
                 readonly document: Schema.String;
-                readonly fields: Schema.$Record<Schema.String, Schema.String>;
                 readonly position: Schema.String;
                 readonly request: Schema.Int;
+                readonly results: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<Contract.fieldType, Contract.fieldType, never, never>>>;
                 readonly tag: Schema.String;
                 readonly type: Schema.Literal<"awaitBridge">;
             }>, Schema.Struct<{
@@ -237,6 +291,32 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                 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;
@@ -271,6 +351,32 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
             }>>>;
             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;
@@ -311,6 +417,9 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                 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;
@@ -319,6 +428,16 @@ export declare const LogEntry: Schema.Union<readonly [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">;
+        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 by: Schema.suspend<Schema.Union<readonly [Schema.String, Schema.Int, Schema.Struct<{
             readonly to: Schema.String;

package/dist/LuteRuntime.d.ts

@@ -1,5 +1,5 @@
 /**
- * Loads bundles into {@link Program}s (spec 0.39.0 §5.1). A program lives in
+ * Loads bundles into {@link Program}s (spec 0.40.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";