@lute-lang/runtime 0.40.0 → 0.41.1

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

@@ -5,7 +5,7 @@
  */
 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.40.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
@@ -46,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", {
@@ -77,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 | TimeoutUnavailable | 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>;
@@ -45,10 +46,11 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
             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<{
@@ -72,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<{
@@ -180,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;
@@ -251,10 +273,11 @@ export declare const LogEntry: Schema.Union<readonly [Schema.Struct<{
                 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<{
@@ -405,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/Program.d.ts

@@ -1,11 +1,12 @@
 /**
- * A loaded bundle and the runtime's step function over it (spec 0.40.0 §5.1).
+ * A loaded bundle and the runtime's step function over it (spec 0.40.0 §5.1,
+ * 0.41.0 §6).
  *
  * 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 { Effect, Option, Schema } 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";
@@ -14,6 +15,11 @@ 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}.
+ *
+ * A state is valid for every `Program` loaded from a bundle with the
+ * fingerprint of the program that created it (spec 0.41.0 §6.2): a host may
+ * query the state of a session it does not drive with its own program of
+ * that bundle. Handing it to a program of another fingerprint is a defect.
  */
 export interface RuntimeState {
     readonly [TypeId]: typeof TypeId;
@@ -38,6 +44,28 @@ export interface Program {
     readonly view: (state: RuntimeState, options?: {
         readonly facts?: boolean;
     }) => Effect.Effect<Contract.WorldView>;
+    /**
+     * Evaluate an IR `exprNode` — the `expr` of any `{cel, expr}` pair the IR
+     * carries, such as an objective's `visibleWhen.expr`, or the output of
+     * `lute expr` — over the state, as the runtime's walk reads a guard (spec
+     * 0.41.0 §5.1). A `param` node is not admitted: it is `InvalidInput`.
+     */
+    readonly evaluate: (state: RuntimeState, expr: Schema.Json) => Effect.Effect<Contract.Evaluation, Errors.QueryRejection>;
+    /**
+     * Evaluate the bundle's index def `name` over the state, binding its
+     * parameters to `args` in declaration order — one JSON scalar each, absent
+     * for a parameterless def (spec 0.41.0 §5.1). A wrong arity or an argument
+     * that does not fit its parameter type is `InvalidInput`.
+     */
+    readonly def: (state: RuntimeState, name: string, args?: ReadonlyArray<string | number | boolean>) => Effect.Effect<Contract.Evaluation, Errors.QueryRejection>;
+    /**
+     * Whether a `raiseOccasion` of `occasion` (for `target`) with no writes
+     * would pass the seam now (spec 0.41.0 §5.2): `open: false` without
+     * `unresolved` is decided closed (its `raisedWhen` is false, or the game
+     * is over and the occasion is not `outsideRun`); with `unresolved`, it is
+     * undecided. An occasion the bundle does not declare is `InvalidInput`.
+     */
+    readonly gate: (state: RuntimeState, occasion: string, target?: string) => Effect.Effect<Contract.Gate, Errors.InvalidInput>;
 }
 /** Fail with a rejection the binding returned as JSON. */
 export declare const rejection: (json: string) => Effect.Effect<never, Errors.RuntimeRejection>;

package/dist/Session.d.ts

@@ -1,7 +1,8 @@
 /**
- * One running playthrough (spec 0.40.0 §5.2): the host sends inputs, watches
- * the state, and subscribes to events and awaits. The session adds no game
- * policy — it answers nothing and paces nothing.
+ * One running playthrough (spec 0.40.0 §5.2, 0.41.0 §6.2): the host sends
+ * inputs, watches the state, subscribes to events and awaits, and queries the
+ * state through the session's program. The session adds no game policy — it
+ * answers nothing and paces nothing.
  */
 import { Context, Effect, Layer, Scope, Stream, SubscriptionRef } from "effect";
 import { BundleSource } from "./BundleSource.js";
@@ -9,16 +10,23 @@ import type { BundleError, InputLogError, RuntimeRejection } from "./Errors.js";
 import type { Await, Event, Input, Output, Seed, Snapshot, Stage } from "./generated/Contract.js";
 import { InputLog } from "./InputLog.js";
 import { LuteRuntime } from "./LuteRuntime.js";
-import type { RuntimeState } from "./Program.js";
+import type { Program, RuntimeState } from "./Program.js";
 /** Where the session stands: its state, stage, and what it waits for. */
 export interface SessionState {
     readonly state: RuntimeState;
     readonly stage: Stage;
     readonly await: Await;
 }
-declare const Session_base: Context.ServiceClass<Session, "@lute-lang/runtime/Session", {
+/** The session service. */
+export interface SessionShape {
     /** The program's fingerprint (what snapshots carry). */
     readonly fingerprint: string;
+    /**
+     * The program the layer loaded, valid for the session's scope: run
+     * `view`, `evaluate`, `def`, `gate`, `candidates` … over `current`'s state
+     * without loading the bundle a second time.
+     */
+    readonly program: Program;
     /** The output of `begin`; for a restored session, no events and the snapshot's await. */
     readonly started: Output;
     /**
@@ -39,7 +47,8 @@ declare const Session_base: Context.ServiceClass<Session, "@lute-lang/runtime/Se
     readonly save: Effect.Effect<Snapshot>;
     /** Continue from a snapshot; the input log restarts from it. */
     readonly restore: (snapshot: Snapshot) => Effect.Effect<void, RuntimeRejection | InputLogError>;
-}>;
+}
+declare const Session_base: Context.ServiceClass<Session, "@lute-lang/runtime/Session", SessionShape>;
 export declare class Session extends Session_base {
 }
 /** How a session starts: from a seed, or from a snapshot. */

package/dist/browser.js

@@ -7,7 +7,7 @@ import {
   fromBytes,
   layer,
   layer2
-} from "./index-wshk3yvw.js";
+} from "./index-tecmws3f.js";
 
 // src/browser.ts
 import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";

package/dist/bun.js

@@ -6,7 +6,7 @@ import {
   fromBytes,
   layer,
   layer2
-} from "./index-wshk3yvw.js";
+} from "./index-tecmws3f.js";
 
 // src/bun.ts
 import * as BunServices from "@effect/platform-bun/BunServices";