@lute-lang/runtime 0.39.0 → 0.40.0

package/dist/{index-eqt12qy0.js → index-wshk3yvw.js}

@@ -16,8 +16,8 @@ var __export = (target, all) => {
 // src/Bundle.ts
 var exports_Bundle = {};
 __export(exports_Bundle, {
-  IndexDocuments: () => IndexDocuments,
-  Bundle: () => Bundle
+  Bundle: () => Bundle,
+  IndexDocuments: () => IndexDocuments
 });
 import { Schema } from "effect";
 var Bundle = Schema.Struct({
@@ -31,21 +31,22 @@ var IndexDocuments = Schema.Struct({
 // src/Errors.ts
 var exports_Errors = {};
 __export(exports_Errors, {
-  fromRejected: () => fromRejected,
-  WasmLoadError: () => WasmLoadError,
-  SnapshotVersionMismatch: () => SnapshotVersionMismatch,
-  SnapshotProjectMismatch: () => SnapshotProjectMismatch,
-  RuntimeHalted: () => RuntimeHalted,
-  RuntimeBusy: () => RuntimeBusy,
-  RequestMismatch: () => RequestMismatch,
-  OptionUnavailable: () => OptionUnavailable,
-  IrVersionMismatch: () => IrVersionMismatch,
-  InvalidInput: () => InvalidInput,
-  InputLogError: () => InputLogError,
-  BundleUnreadable: () => BundleUnreadable,
-  BundleNotFound: () => BundleNotFound,
+  BridgeShapeMismatch: () => BridgeShapeMismatch,
   BundleMalformed: () => BundleMalformed,
-  BridgeShapeMismatch: () => BridgeShapeMismatch
+  BundleNotFound: () => BundleNotFound,
+  BundleUnreadable: () => BundleUnreadable,
+  InputLogError: () => InputLogError,
+  InvalidInput: () => InvalidInput,
+  IrVersionMismatch: () => IrVersionMismatch,
+  OptionUnavailable: () => OptionUnavailable,
+  RequestMismatch: () => RequestMismatch,
+  RuntimeBusy: () => RuntimeBusy,
+  RuntimeHalted: () => RuntimeHalted,
+  SnapshotProjectMismatch: () => SnapshotProjectMismatch,
+  SnapshotVersionMismatch: () => SnapshotVersionMismatch,
+  TimeoutUnavailable: () => TimeoutUnavailable,
+  WasmLoadError: () => WasmLoadError,
+  fromRejected: () => fromRejected
 });
 import { Effect, Schema as Schema2 } from "effect";
 
@@ -55,6 +56,12 @@ class RuntimeBusy extends Schema2.TaggedError()("RuntimeBusy", {
 }) {
 }
 
+class TimeoutUnavailable extends Schema2.TaggedError()("TimeoutUnavailable", {
+  code: Schema2.Literal("E-RUNTIME-TIMEOUT"),
+  message: Schema2.String
+}) {
+}
+
 class RequestMismatch extends Schema2.TaggedError()("RequestMismatch", {
   code: Schema2.Literal("E-RUNTIME-REQUEST"),
   message: Schema2.String
@@ -101,6 +108,7 @@ var byCode = {
   "E-RUNTIME-REQUEST": (message) => new RequestMismatch({ code: "E-RUNTIME-REQUEST", message }),
   "E-RUNTIME-OPTION": (message) => new OptionUnavailable({ code: "E-RUNTIME-OPTION", message }),
   "E-RUNTIME-BRIDGE-SHAPE": (message) => new BridgeShapeMismatch({ code: "E-RUNTIME-BRIDGE-SHAPE", message }),
+  "E-RUNTIME-TIMEOUT": (message) => new TimeoutUnavailable({ code: "E-RUNTIME-TIMEOUT", message }),
   "E-RUNTIME-INPUT": (message) => new InvalidInput({ code: "E-RUNTIME-INPUT", message }),
   "E-RUNTIME-HALTED": (message) => new RuntimeHalted({ code: "E-RUNTIME-HALTED", message }),
   "E-RUNTIME-IR-VERSION": (message) => new IrVersionMismatch({ code: "E-RUNTIME-IR-VERSION", message }),
@@ -143,10 +151,10 @@ class InputLogError extends Schema2.TaggedError()("InputLogError", {
 // src/BundleSource.ts
 var exports_BundleSource = {};
 __export(exports_BundleSource, {
-  value: () => value,
-  url: () => url,
+  BundleSource: () => BundleSource,
   directory: () => directory,
-  BundleSource: () => BundleSource
+  url: () => url,
+  value: () => value
 });
 import { Context, Effect as Effect2, FileSystem, Layer, Path, Schema as Schema3 } from "effect";
 import * as HttpClient from "effect/http/HttpClient";
@@ -184,38 +192,44 @@ var url = (base) => Layer.effect(BundleSource, Effect2.gen(function* () {
 // src/generated/Contract.ts
 var exports_Contract = {};
 __export(exports_Contract, {
-  parseOptions: () => parseOptions,
-  WritesInput: () => WritesInput,
-  WorldView: () => WorldView,
-  World: () => World,
-  Verdict: () => Verdict,
-  Value: () => Value,
-  StreamLine: () => StreamLine,
-  StateWrite: () => StateWrite,
-  Snapshot: () => Snapshot,
-  Seed: () => Seed,
-  SaveInput: () => SaveInput,
-  Rejected: () => Rejected,
-  Premise: () => Premise,
-  PickInput: () => PickInput,
-  Output: () => Output,
-  MenuOptionAwait: () => MenuOptionAwait,
-  MenuAwait: () => MenuAwait,
-  Input: () => Input,
-  GuardRead: () => GuardRead,
-  Event: () => Event,
-  Continuation: () => Continuation,
-  ClockView: () => ClockView,
-  ClockPosition: () => ClockPosition,
-  ClockAt: () => ClockAt,
-  Candidate: () => Candidate,
-  Cadence: () => Cadence,
-  BeatOnce: () => BeatOnce,
-  BeatKind: () => BeatKind,
-  Await: () => Await,
-  Atom: () => Atom,
+  AdvanceBy: () => AdvanceBy,
   Answer: () => Answer,
-  AdvanceBy: () => AdvanceBy
+  Atom: () => Atom,
+  Await: () => Await,
+  BeatKind: () => BeatKind,
+  BeatOnce: () => BeatOnce,
+  Cadence: () => Cadence,
+  Candidate: () => Candidate,
+  ClockAt: () => ClockAt,
+  ClockPosition: () => ClockPosition,
+  ClockView: () => ClockView,
+  Continuation: () => Continuation,
+  Event: () => Event,
+  GuardRead: () => GuardRead,
+  Input: () => Input,
+  MenuAwait: () => MenuAwait,
+  MenuOptionAwait: () => MenuOptionAwait,
+  Output: () => Output,
+  PickInput: () => PickInput,
+  Premise: () => Premise,
+  Rejected: () => Rejected,
+  SaveInput: () => SaveInput,
+  Seed: () => Seed,
+  Snapshot: () => Snapshot,
+  Stage: () => Stage,
+  StageActor: () => StageActor,
+  StageBackground: () => StageBackground,
+  StageCg: () => StageCg,
+  StageMusic: () => StageMusic,
+  StageVideo: () => StageVideo,
+  StateWrite: () => StateWrite,
+  StreamLine: () => StreamLine,
+  Value: () => Value,
+  Verdict: () => Verdict,
+  World: () => World,
+  WorldView: () => WorldView,
+  WritesInput: () => WritesInput,
+  parseOptions: () => parseOptions
 });
 import * as Schema4 from "effect/Schema";
 var parseOptions = { onExcessProperty: "error" };
@@ -378,6 +392,10 @@ var Input = Schema4.Union([
     type: Schema4.Literal("raiseOccasion"),
     writes: Schema4.optionalKey(Schema4.suspend(() => WritesInput))
   }),
+  Schema4.Struct({
+    request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
+    type: Schema4.Literal("timeout")
+  }),
   Schema4.Struct({
     option: Schema4.String,
     request: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
@@ -409,13 +427,14 @@ var Input = Schema4.Union([
 ]).pipe(Schema4.toTaggedUnion("type"));
 var MenuAwait = Schema4.Struct({
   construct: Schema4.String,
+  default: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
   document: Schema4.String,
   id: Schema4.String,
   options: Schema4.Array(Schema4.suspend(() => MenuOptionAwait)),
   position: Schema4.String,
   presentation: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
   prompt: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
-  timeout: Schema4.optionalKey(Schema4.NullOr(Schema4.Number))
+  timeout: Schema4.optionalKey(Schema4.NullOr(Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0)))))
 });
 var MenuOptionAwait = Schema4.Struct({
   exit: Schema4.Boolean,
@@ -582,7 +601,39 @@ var Continuation = Schema4.Struct({
   before: Schema4.suspend(() => World),
   delivered: Schema4.Int.pipe(Schema4.check(Schema4.isGreaterThanOrEqualTo(0))),
   input: Schema4.suspend(() => Input),
-  pending: Schema4.suspend(() => Await)
+  pending: Schema4.suspend(() => Await),
+  stage: Schema4.suspend(() => Stage)
+});
+var Stage = Schema4.Struct({
+  actors: Schema4.Array(Schema4.suspend(() => StageActor)),
+  bg: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageBackground))),
+  cg: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageCg))),
+  music: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageMusic))),
+  video: Schema4.optionalKey(Schema4.NullOr(Schema4.suspend(() => StageVideo)))
+});
+var StageActor = Schema4.Struct({
+  anchor: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  character: Schema4.String,
+  costume: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  emotion: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageBackground = Schema4.Struct({
+  assetId: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  location: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  time: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageCg = Schema4.Struct({
+  assetId: Schema4.String,
+  layout: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageMusic = Schema4.Struct({
+  assetId: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  mood: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  playback: Schema4.optionalKey(Schema4.NullOr(Schema4.String)),
+  volume: Schema4.optionalKey(Schema4.NullOr(Schema4.String))
+});
+var StageVideo = Schema4.Struct({
+  assetId: Schema4.String
 });
 var World = Schema4.Struct({
   accepts: Schema4.Array(Schema4.String),
@@ -608,6 +659,7 @@ var World = Schema4.Struct({
   spentAt: Schema4.Record(Schema4.String, Schema4.suspend(() => ClockAt)),
   spentRun: Schema4.UniqueArray(Schema4.String),
   spentUser: Schema4.UniqueArray(Schema4.String),
+  stage: Schema4.suspend(() => Stage),
   state: Schema4.Record(Schema4.String, Schema4.suspend(() => Value)),
   visited: Schema4.UniqueArray(Schema4.String)
 });
@@ -623,10 +675,10 @@ var Snapshot = Schema4.Struct({
 // src/InputLog.ts
 var exports_InputLog = {};
 __export(exports_InputLog, {
-  memory: () => memory,
-  keyValueStore: () => keyValueStore,
+  InputLog: () => InputLog,
   LogEntry: () => LogEntry,
-  InputLog: () => InputLog
+  keyValueStore: () => keyValueStore,
+  memory: () => memory
 });
 import { Context as Context2, Effect as Effect3, Layer as Layer2, Option, Ref, Schema as Schema5 } from "effect";
 import * as KeyValueStore from "effect/persistence/KeyValueStore";
@@ -656,14 +708,14 @@ var keyValueStore = (key) => Layer2.effect(InputLog, Effect3.gen(function* () {
 // src/LuteWasm.ts
 var exports_LuteWasm = {};
 __export(exports_LuteWasm, {
-  layerFromBytes: () => layerFromBytes,
+  LuteWasm: () => LuteWasm2,
   fromBytes: () => fromBytes,
-  LuteWasm: () => LuteWasm
+  layerFromBytes: () => layerFromBytes
 });
 import { Context as Context3, Effect as Effect4, Layer as Layer3 } from "effect";
 import * as Glue from "./wasm/lute_runtime_wasm.js";
 
-class LuteWasm extends Context3.Service()("@lute-lang/runtime/LuteWasm") {
+class LuteWasm2 extends Context3.Service()("@lute-lang/runtime/LuteWasm") {
 }
 var fromBytes = (bytes) => Effect4.try({
   try: () => {
@@ -675,13 +727,13 @@ var fromBytes = (bytes) => Effect4.try({
   },
   catch: (cause) => new WasmLoadError({ message: `cannot instantiate the runtime binding: ${String(cause)}` })
 });
-var layerFromBytes = (bytes) => Layer3.effect(LuteWasm, fromBytes(bytes));
+var layerFromBytes = (bytes) => Layer3.effect(LuteWasm2, fromBytes(bytes));
 
 // src/Program.ts
 var exports_Program = {};
 __export(exports_Program, {
-  rejection: () => rejection,
-  make: () => make
+  make: () => make,
+  rejection: () => rejection
 });
 import { Effect as Effect5, Option as Option2, Schema as Schema6 } from "effect";
 var TypeId = "~@lute-lang/runtime/RuntimeState";
@@ -701,13 +753,14 @@ var fromBinding = (schema) => {
 };
 var toBinding = (schema) => {
   const encode = Schema6.encodeEffect(Schema6.fromJsonString(schema), parseOptions);
-  return (value2) => Effect5.orDie(encode(value2));
+  return (value) => Effect5.orDie(encode(value));
 };
 var decodeOutput = fromBinding(Output);
 var decodeRejected = fromBinding(Rejected);
 var decodeSnapshot = fromBinding(Snapshot);
 var decodeCandidates = fromBinding(Schema6.Array(Candidate));
 var decodeCandidate = fromBinding(Schema6.NullOr(Candidate));
+var decodeStage = fromBinding(Stage);
 var decodeClock = fromBinding(Schema6.NullOr(ClockAt));
 var decodeView = fromBinding(WorldView);
 var encodeSeed = toBinding(Seed);
@@ -724,7 +777,7 @@ var settle = (result, success) => Effect5.suspend(() => {
 }).pipe(Effect5.ensuring(Effect5.sync(() => result.free())));
 var stepOf = (result) => settle(result, () => {
   const { state, output } = result;
-  return state === undefined || output === undefined ? Effect5.die(new Error("the runtime binding accepted an input without a state and output")) : Effect5.map(decodeOutput(output), (output2) => ({ state: wrap(state), output: output2 }));
+  return state === undefined || output === undefined ? Effect5.die(new Error("the runtime binding accepted an input without a state and output")) : Effect5.map(decodeOutput(output), (output) => ({ state: wrap(state), output }));
 });
 var make = (raw) => ({
   fingerprint: raw.fingerprint,
@@ -767,6 +820,10 @@ var make = (raw) => ({
     const handle = yield* handleOf(state);
     return raw.terminal(handle);
   }),
+  stage: Effect5.fn("Lute.Program.stage")(function* (state) {
+    const handle = yield* handleOf(state);
+    return yield* decodeStage(raw.stage(handle));
+  }),
   view: Effect5.fn("Lute.Program.view")(function* (state, options) {
     const handle = yield* handleOf(state);
     return yield* decodeView(raw.view(handle, options?.facts === true));
@@ -777,14 +834,14 @@ var make = (raw) => ({
 // src/LuteRuntime.ts
 var exports_LuteRuntime = {};
 __export(exports_LuteRuntime, {
-  layer: () => layer,
-  LuteRuntime: () => LuteRuntime
+  LuteRuntime: () => LuteRuntime,
+  layer: () => layer
 });
 import { Context as Context4, Effect as Effect6, Layer as Layer4 } from "effect";
 class LuteRuntime extends Context4.Service()("@lute-lang/runtime/LuteRuntime") {
 }
 var layer = Layer4.effect(LuteRuntime, Effect6.gen(function* () {
-  const wasm = yield* LuteWasm;
+  const wasm = yield* LuteWasm2;
   const acquire = Effect6.fn("Lute.LuteRuntime.load")(function* (bundle) {
     const result = wasm.Program.load(JSON.stringify(bundle.index), JSON.stringify(bundle.artifacts));
     const { ok, program, rejected } = result;
@@ -803,8 +860,8 @@ var layer = Layer4.effect(LuteRuntime, Effect6.gen(function* () {
 // src/Session.ts
 var exports_Session = {};
 __export(exports_Session, {
-  layer: () => layer2,
-  Session: () => Session
+  Session: () => Session,
+  layer: () => layer2
 });
 import { Context as Context5, Effect as Effect7, Layer as Layer5, PubSub, Semaphore, Stream, SubscriptionRef } from "effect";
 class Session extends Context5.Service()("@lute-lang/runtime/Session") {
@@ -818,9 +875,11 @@ var layer2 = (options) => Layer5.effect(Session, Effect7.gen(function* () {
     state: yield* program.restore(options.snapshot),
     output: { eventVersion: options.snapshot.snapshotVersion, events: [], await: options.snapshot.await }
   };
+  const stage = yield* program.stage(started.state);
   yield* log.reset(options);
   const current = yield* SubscriptionRef.make({
     state: started.state,
+    stage,
     await: started.output.await
   });
   const events = yield* PubSub.unbounded();
@@ -831,15 +890,17 @@ var layer2 = (options) => Layer5.effect(Session, Effect7.gen(function* () {
     const { state } = yield* SubscriptionRef.get(current);
     const step = yield* program.step(state, input);
     yield* log.append({ input });
-    yield* SubscriptionRef.set(current, { state: step.state, await: step.output.await });
+    const stage = yield* program.stage(step.state);
+    yield* SubscriptionRef.set(current, { state: step.state, stage, await: step.output.await });
     yield* PubSub.publishAll(events, step.output.events);
     yield* PubSub.publish(awaits, step.output.await);
     return step.output;
   });
   const restore = Effect7.fn("Lute.Session.restore")(function* (snapshot) {
     const state = yield* program.restore(snapshot);
+    const stage = yield* program.stage(state);
     yield* log.reset({ snapshot });
-    yield* SubscriptionRef.set(current, { state, await: snapshot.await });
+    yield* SubscriptionRef.set(current, { state, stage, await: snapshot.await });
     yield* PubSub.publish(awaits, snapshot.await);
   });
   return {
@@ -854,4 +915,4 @@ var layer2 = (options) => Layer5.effect(Session, Effect7.gen(function* () {
   };
 }));
 
-export { __export, exports_Bundle, WasmLoadError, exports_Errors, directory, url, exports_BundleSource, exports_Contract, LogEntry, memory, keyValueStore, exports_InputLog, LuteWasm, fromBytes, exports_LuteWasm, exports_Program, layer, exports_LuteRuntime, layer2 as layer1, exports_Session };
+export { __export, exports_Bundle, WasmLoadError, exports_Errors, directory, url, exports_BundleSource, exports_Contract, LogEntry, memory, keyValueStore, exports_InputLog, LuteWasm2, fromBytes, exports_LuteWasm, exports_Program, layer, exports_LuteRuntime, layer2, exports_Session };

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 /**
  * `@lute-lang/runtime` — the Lute runtime for TypeScript hosts, in Effect
- * (spec 0.39.0). Platform layers live in `@lute-lang/runtime/bun` and
+ * (spec 0.40.0). Platform layers live in `@lute-lang/runtime/bun` and
  * `@lute-lang/runtime/browser`.
  */
 export * as Bundle from "./Bundle.js";
 export * as BundleSource from "./BundleSource.js";
 export * as Contract from "./generated/Contract.js";
+export * as Ir from "./generated/Ir.js";
 export * as Errors from "./Errors.js";
 export * as InputLog from "./InputLog.js";
 export * as LuteRuntime from "./LuteRuntime.js";