@lute-lang/runtime 0.0.0-stage → 0.40.0

package/dist/LuteRuntime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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";
+import type { Bundle } from "./Bundle.js";
+import type * as Errors from "./Errors.js";
+import { LuteWasm } from "./LuteWasm.js";
+import * as Program from "./Program.js";
+declare const LuteRuntime_base: Context.ServiceClass<LuteRuntime, "@lute-lang/runtime/LuteRuntime", {
+    /**
+     * Load a bundle. `IrVersionMismatch` when the runtime does not execute
+     * it (another IR line, an unknown command kind, not a bundle).
+     */
+    readonly load: (bundle: Bundle) => Effect.Effect<Program.Program, Errors.RuntimeRejection, Scope.Scope>;
+}>;
+export declare class LuteRuntime extends LuteRuntime_base {
+}
+export declare const layer: Layer.Layer<LuteRuntime, never, LuteWasm>;
+export {};

package/dist/LuteWasm.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The instantiated wasm binding (`crates/lute-runtime-wasm`) as a service.
+ *
+ * Platform layers (`@lute-lang/runtime/bun`, `@lute-lang/runtime/browser`)
+ * obtain the module's bytes and instantiate it through {@link fromBytes};
+ * nothing else in the package touches the glue's module state.
+ */
+import { Context, Effect, Layer } from "effect";
+import { WasmLoadError } from "./Errors.js";
+import * as Glue from "./wasm/lute_runtime_wasm.js";
+/** The binding's entry point: `Program.load` and the result classes it returns. */
+export interface LuteWasmShape {
+    readonly Program: typeof Glue.Program;
+}
+declare const LuteWasm_base: Context.ServiceClass<LuteWasm, "@lute-lang/runtime/LuteWasm", LuteWasmShape>;
+export declare class LuteWasm extends LuteWasm_base {
+}
+/**
+ * Instantiate the binding from the `.wasm` bytes. Bytes backed by a
+ * `SharedArrayBuffer` are refused: WebAssembly compiles from an
+ * `ArrayBuffer`.
+ */
+export declare const fromBytes: (bytes: Uint8Array | ArrayBuffer) => Effect.Effect<LuteWasmShape, WasmLoadError>;
+/** The binding instantiated from bytes the host already holds. */
+export declare const layerFromBytes: (bytes: Uint8Array | ArrayBuffer) => Layer.Layer<LuteWasm, WasmLoadError>;
+export {};

package/dist/Program.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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
+ * not decode is contract drift — a defect.
+ */
+import { Effect, Option } 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";
+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}.
+ */
+export interface RuntimeState {
+    readonly [TypeId]: typeof TypeId;
+}
+/** One accepted input: the state it produced and the runtime's output. */
+export interface Step {
+    readonly state: RuntimeState;
+    readonly output: Contract.Output;
+}
+export interface Program {
+    /** The bundle's identity, which snapshots carry. */
+    readonly fingerprint: string;
+    readonly begin: (seed: Contract.Seed) => Effect.Effect<Step, Errors.RuntimeRejection>;
+    readonly step: (state: RuntimeState, input: Contract.Input) => Effect.Effect<Step, Errors.RuntimeRejection>;
+    readonly snapshot: (state: RuntimeState) => Effect.Effect<Contract.Snapshot>;
+    readonly restore: (snapshot: Contract.Snapshot) => Effect.Effect<RuntimeState, Errors.RuntimeRejection>;
+    readonly candidates: (state: RuntimeState, occasion: string, target?: string) => Effect.Effect<ReadonlyArray<Contract.Candidate>>;
+    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>;
+}
+/** Fail with a rejection the binding returned as JSON. */
+export declare const rejection: (json: string) => Effect.Effect<never, Errors.RuntimeRejection>;
+/** Wrap a program the binding loaded. The caller owns its lifetime ({@link free}). */
+export declare const make: (raw: Glue.Program) => Program & {
+    readonly free: Effect.Effect<void>;
+};
+export {};

package/dist/Replay.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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";
+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,56 @@
+/**
+ * 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, 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, 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 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 {
+  WasmLoadError,
+  url,
+  memory,
+  keyValueStore,
+  LuteWasm2,
+  fromBytes,
+  layer,
+  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 = (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 {
+  bundle,
+  inputLog,
+  runtime,
+  session,
+  wasm
+};

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 {
+  WasmLoadError,
+  directory,
+  memory,
+  LuteWasm2,
+  fromBytes,
+  layer,
+  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(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}` })));
+  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 {
+  bundle,
+  runtime,
+  session,
+  wasm
+};