@lute-lang/runtime 0.39.0 → 0.41.0

package/dist/Program.d.ts

@@ -1,11 +1,12 @@
 /**
- * A loaded bundle and the runtime's step function over it (spec 0.39.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;
@@ -34,9 +40,32 @@ export interface Program {
     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 stage: (state: RuntimeState) => Effect.Effect<Contract.Stage>;
     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/Replay.d.ts

@@ -1,5 +1,5 @@
 /**
- * Replaying a recorded input log (spec 0.39.0 §5.4). Against the bundle
+ * Replaying a recorded input log (spec 0.40.0 §5.4). Against the bundle
  * that recorded it, a log reproduces every output.
  */
 import { Effect, Schema, Stream } from "effect";

package/dist/Session.d.ts

@@ -1,23 +1,32 @@
 /**
- * One running playthrough (spec 0.39.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";
 import type { BundleError, InputLogError, RuntimeRejection } from "./Errors.js";
-import type { Await, Event, Input, Output, Seed, Snapshot } from "./generated/Contract.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";
-/** Where the session stands: its state and what it waits for. */
+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;
     /**
@@ -38,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

@@ -1,28 +1,28 @@
 import {
-  LuteWasm,
   WasmLoadError,
-  fromBytes,
+  url,
+  memory,
   keyValueStore,
+  LuteWasm2,
+  fromBytes,
   layer,
-  layer1 as layer2,
-  memory,
-  url
-} from "./index-eqt12qy0.js";
+  layer2
+} from "./index-tecmws3f.js";
 
 // src/browser.ts
 import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";
 import { Effect, Layer } from "effect";
 import * as FetchHttpClient from "effect/http/FetchHttpClient";
 import * as HttpClient from "effect/http/HttpClient";
-var wasm = (url2) => Layer.effect(LuteWasm, HttpClient.get(url2).pipe(Effect.flatMap((response) => response.arrayBuffer), Effect.mapError((error) => new WasmLoadError({ message: `cannot fetch the runtime binding: ${error.message}` })), Effect.flatMap(fromBytes))).pipe(Layer.provide(FetchHttpClient.layer));
-var runtime = (url2) => layer.pipe(Layer.provide(wasm(url2)));
+var wasm = (url) => Layer.effect(LuteWasm2, HttpClient.get(url).pipe(Effect.flatMap((response) => response.arrayBuffer), Effect.mapError((error) => new WasmLoadError({ message: `cannot fetch the runtime binding: ${error.message}` })), Effect.flatMap(fromBytes))).pipe(Layer.provide(FetchHttpClient.layer));
+var runtime = (url) => layer.pipe(Layer.provide(wasm(url)));
 var bundle = (base) => url(base).pipe(Layer.provide(FetchHttpClient.layer));
 var inputLog = (key) => keyValueStore(key).pipe(Layer.provide(BrowserKeyValueStore.layerLocalStorage));
 var session = (options) => layer2(options).pipe(Layer.provide(Layer.mergeAll(runtime(options.wasm), bundle(options.bundle), options.log === undefined ? memory : inputLog(options.log))));
 export {
-  wasm,
-  session,
-  runtime,
+  bundle,
   inputLog,
-  bundle
+  runtime,
+  session,
+  wasm
 };

package/dist/bun.js

@@ -1,17 +1,17 @@
 import {
-  LuteWasm,
   WasmLoadError,
   directory,
+  memory,
+  LuteWasm2,
   fromBytes,
   layer,
-  layer1 as layer2,
-  memory
-} from "./index-eqt12qy0.js";
+  layer2
+} from "./index-tecmws3f.js";
 
 // src/bun.ts
 import * as BunServices from "@effect/platform-bun/BunServices";
 import { Effect, FileSystem, Layer, Path } from "effect";
-var wasm = Layer.effect(LuteWasm, Effect.gen(function* () {
+var wasm = Layer.effect(LuteWasm2, Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const bytes = yield* path.fromFileUrl(new URL("./wasm/lute_runtime_wasm_bg.wasm", import.meta.url)).pipe(Effect.flatMap(fs.readFile), Effect.mapError((error) => new WasmLoadError({ message: `cannot read the runtime binding: ${error.message}` })));
@@ -21,8 +21,8 @@ var runtime = layer.pipe(Layer.provide(wasm));
 var bundle = (directory2) => directory(directory2).pipe(Layer.provide(BunServices.layer));
 var session = (options) => layer2(options).pipe(Layer.provide(Layer.mergeAll(runtime, bundle(options.bundle), options.log ?? memory)));
 export {
-  wasm,
-  session,
+  bundle,
   runtime,
-  bundle
+  session,
+  wasm
 };