@lute-lang/runtime 0.0.0-stage → 0.39.0

package/dist/Replay.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Replaying a recorded input log (spec 0.39.0 §5.4). Against the bundle
+ * that recorded it, a log reproduces every output.
+ */
+import { Effect, Schema, Stream } from "effect";
+import type { RuntimeRejection } from "./Errors.js";
+import type { Output } from "./generated/Contract.js";
+import { LogEntry } from "./InputLog.js";
+import type { Program } from "./Program.js";
+/** Parse an `inputs.jsonl` text: one log entry per non-empty line. */
+export declare const parseLog: (text: string) => Effect.Effect<ReadonlyArray<LogEntry>, Schema.SchemaError>;
+/**
+ * The outputs of a log: `begin` for a `seed` start (a `snapshot` start
+ * restores and emits nothing), then one output per `input`. A log that does
+ * not start with a seed or snapshot, or restarts midway, dies.
+ */
+export declare const run: (program: Program, entries: ReadonlyArray<LogEntry>) => Stream.Stream<Output, RuntimeRejection>;

package/dist/Session.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+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 { 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. */
+export interface SessionState {
+    readonly state: RuntimeState;
+    readonly await: Await;
+}
+declare const Session_base: Context.ServiceClass<Session, "@lute-lang/runtime/Session", {
+    /** The program's fingerprint (what snapshots carry). */
+    readonly fingerprint: string;
+    /** The output of `begin`; for a restored session, no events and the snapshot's await. */
+    readonly started: Output;
+    /**
+     * Apply one input. Inputs run one at a time, in call order. An accepted
+     * input is logged before its events are published; a rejected one
+     * changes nothing.
+     */
+    readonly send: (input: Input) => Effect.Effect<Output, RuntimeRejection | InputLogError>;
+    readonly current: SubscriptionRef.SubscriptionRef<SessionState>;
+    /**
+     * Subscribe to the events of every later output, in order. The
+     * subscription exists once this effect completes, so nothing published
+     * afterwards is missed; it ends with its scope or the session's.
+     */
+    readonly events: Effect.Effect<Stream.Stream<Event>, never, Scope.Scope>;
+    /** Subscribe to the await of every later output, like `events`. */
+    readonly awaits: Effect.Effect<Stream.Stream<Await>, never, Scope.Scope>;
+    readonly save: Effect.Effect<Snapshot>;
+    /** Continue from a snapshot; the input log restarts from it. */
+    readonly restore: (snapshot: Snapshot) => Effect.Effect<void, RuntimeRejection | InputLogError>;
+}>;
+export declare class Session extends Session_base {
+}
+/** How a session starts: from a seed, or from a snapshot. */
+export type SessionOptions = {
+    readonly seed: Seed;
+} | {
+    readonly snapshot: Snapshot;
+};
+/**
+ * A session over the bundle of `BundleSource`. The program it loads lives
+ * as long as the layer's scope; closing it ends `events` and `awaits`.
+ */
+export declare const layer: (options: SessionOptions) => Layer.Layer<Session, RuntimeRejection | BundleError | InputLogError, LuteRuntime | BundleSource | InputLog>;
+export {};

package/dist/browser.d.ts

@@ -0,0 +1,25 @@
+import { Layer } from "effect";
+import * as BundleSource from "./BundleSource.js";
+import { WasmLoadError } from "./Errors.js";
+import * as InputLog from "./InputLog.js";
+import * as LuteRuntime from "./LuteRuntime.js";
+import * as LuteWasm from "./LuteWasm.js";
+import * as Session from "./Session.js";
+/** The binding fetched from `url` (where the host serves `lute_runtime_wasm_bg.wasm`). */
+export declare const wasm: (url: string) => Layer.Layer<LuteWasm.LuteWasm, WasmLoadError>;
+/** `LuteRuntime` over the binding at `url`. */
+export declare const runtime: (url: string) => Layer.Layer<LuteRuntime.LuteRuntime, WasmLoadError>;
+/** The bundle served under `base` (a URL ending in `/`). */
+export declare const bundle: (base: string) => Layer.Layer<BundleSource.BundleSource>;
+/** An input log kept in `localStorage` under `key`. */
+export declare const inputLog: (key: string) => Layer.Layer<InputLog.InputLog>;
+/**
+ * A session over the bundle served under `bundle`, with the binding from
+ * `wasm`; inputs are logged in `localStorage` under `log` when given, in
+ * memory otherwise.
+ */
+export declare const session: (options: Session.SessionOptions & {
+    readonly wasm: string;
+    readonly bundle: string;
+    readonly log?: string;
+}) => Layer.Layer<Session.Session, import("./Errors.js").InputLogError | WasmLoadError | import("./Errors.js").BundleError | import("./Errors.js").RuntimeRejection, never>;

package/dist/browser.js

@@ -0,0 +1,28 @@
+import {
+  LuteWasm,
+  WasmLoadError,
+  fromBytes,
+  keyValueStore,
+  layer,
+  layer1 as layer2,
+  memory,
+  url
+} from "./index-eqt12qy0.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 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,
+  inputLog,
+  bundle
+};

package/dist/bun.d.ts

@@ -0,0 +1,21 @@
+import { Layer } from "effect";
+import * as BundleSource from "./BundleSource.js";
+import { WasmLoadError } from "./Errors.js";
+import * as InputLog from "./InputLog.js";
+import * as LuteRuntime from "./LuteRuntime.js";
+import * as LuteWasm from "./LuteWasm.js";
+import * as Session from "./Session.js";
+/** The binding shipped with this package, read from disk. */
+export declare const wasm: Layer.Layer<LuteWasm.LuteWasm, WasmLoadError>;
+/** `LuteRuntime` over the packaged binding. */
+export declare const runtime: Layer.Layer<LuteRuntime.LuteRuntime, WasmLoadError>;
+/** The bundle in a `lute compile --all` output directory. */
+export declare const bundle: (directory: string) => Layer.Layer<BundleSource.BundleSource>;
+/**
+ * A session over the bundle in `bundle` (a directory), logging inputs in
+ * memory unless `log` provides another `InputLog`.
+ */
+export declare const session: (options: Session.SessionOptions & {
+    readonly bundle: string;
+    readonly log?: Layer.Layer<InputLog.InputLog>;
+}) => Layer.Layer<Session.Session, import("./Errors.js").InputLogError | WasmLoadError | import("./Errors.js").BundleError | import("./Errors.js").RuntimeRejection, never>;

package/dist/bun.js

@@ -0,0 +1,28 @@
+import {
+  LuteWasm,
+  WasmLoadError,
+  directory,
+  fromBytes,
+  layer,
+  layer1 as layer2,
+  memory
+} from "./index-eqt12qy0.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* () {
+  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}` })));
+  return yield* fromBytes(bytes);
+})).pipe(Layer.provide(BunServices.layer));
+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,
+  runtime,
+  bundle
+};