@lute-lang/runtime 0.39.0 → 0.40.0

package/dist/BundleSource.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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.
  */

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).
  *
  * 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;
@@ -71,7 +78,7 @@ declare const SnapshotVersionMismatch_base: Schema.Class<SnapshotVersionMismatch
 export declare class SnapshotVersionMismatch extends SnapshotVersionMismatch_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;
 /**
  * Fail with the typed error of a runtime rejection; a code this package does
  * not know dies.

package/dist/InputLog.d.ts

@@ -28,6 +28,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,7 +40,7 @@ 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">;
@@ -103,6 +104,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 +169,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;
@@ -204,6 +234,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,7 +246,7 @@ 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">;
@@ -237,6 +268,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 +328,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 +394,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;

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";

package/dist/Program.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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).
  *
  * Every value crossing the binding is encoded and decoded with the contract
  * schemas generated from the Rust types. JSON the binding returns that does
@@ -34,6 +34,7 @@ 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>;

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,18 +1,19 @@
 /**
- * One running playthrough (spec 0.39.0 §5.2): the host sends inputs, watches
+ * 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.
  */
 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. */
+/** 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", {

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-wshk3yvw.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-wshk3yvw.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
 };