@lute-lang/runtime 0.39.0 → 0.41.0

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 §5–§6, 0.41.0 §6). 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";

package/dist/index.js

@@ -1,40 +1,53 @@
 import {
-  LogEntry,
   __export,
-  exports_Bundle,
+  projectIndex,
+  exports_Ir,
+  exports_Errors,
   exports_BundleSource,
   exports_Contract,
-  exports_Errors,
+  LogEntry,
   exports_InputLog,
-  exports_LuteRuntime,
   exports_LuteWasm,
   exports_Program,
+  exports_LuteRuntime,
   exports_Session
-} from "./index-eqt12qy0.js";
+} from "./index-tecmws3f.js";
+
+// src/Bundle.ts
+var exports_Bundle = {};
+__export(exports_Bundle, {
+  Bundle: () => Bundle
+});
+import { Schema } from "effect";
+var Bundle = Schema.Struct({
+  index: projectIndex,
+  artifacts: Schema.Record(Schema.String, Schema.Json)
+});
 // src/Replay.ts
 var exports_Replay = {};
 __export(exports_Replay, {
-  run: () => run,
-  parseLog: () => parseLog
+  parseLog: () => parseLog,
+  run: () => run
 });
-import { Effect, Schema, Stream } from "effect";
-var decodeLine = Schema.decodeUnknownEffect(Schema.fromJsonString(LogEntry));
+import { Effect, Schema as Schema2, Stream } from "effect";
+var decodeLine = Schema2.decodeUnknownEffect(Schema2.fromJsonString(LogEntry));
 var parseLog = (text) => Effect.forEach(text.split(`
 `).filter((line) => line.trim().length > 0), (line) => decodeLine(line));
 var run = (program, entries) => {
   const [start, ...inputs] = entries;
   const begun = start === undefined || "input" in start ? Effect.die(new Error("an input log starts with a seed or a snapshot")) : ("seed" in start) ? Effect.map(program.begin(start.seed), ({ state, output }) => ({ state, outputs: [output] })) : Effect.map(program.restore(start.snapshot), (state) => ({ state, outputs: [] }));
-  return Stream.unwrap(Effect.map(begun, ({ state, outputs }) => Stream.fromIterable(inputs).pipe(Stream.mapAccumEffect(() => state, (state2, entry) => ("input" in entry) ? Effect.map(program.step(state2, entry.input), (step) => [step.state, [step.output]]) : Effect.die(new Error("an input log has one seed or snapshot, at its start"))), Stream.prepend(outputs))));
+  return Stream.unwrap(Effect.map(begun, ({ state, outputs }) => Stream.fromIterable(inputs).pipe(Stream.mapAccumEffect(() => state, (state, entry) => ("input" in entry) ? Effect.map(program.step(state, entry.input), (step) => [step.state, [step.output]]) : Effect.die(new Error("an input log has one seed or snapshot, at its start"))), Stream.prepend(outputs))));
 };
 export {
-  exports_Session as Session,
-  exports_Replay as Replay,
-  exports_Program as Program,
-  exports_LuteWasm as LuteWasm,
-  exports_LuteRuntime as LuteRuntime,
-  exports_InputLog as InputLog,
-  exports_Errors as Errors,
-  exports_Contract as Contract,
+  exports_Bundle as Bundle,
   exports_BundleSource as BundleSource,
-  exports_Bundle as Bundle
+  exports_Contract as Contract,
+  exports_Errors as Errors,
+  exports_InputLog as InputLog,
+  exports_Ir as Ir,
+  exports_LuteRuntime as LuteRuntime,
+  exports_LuteWasm as LuteWasm,
+  exports_Program as Program,
+  exports_Replay as Replay,
+  exports_Session as Session
 };

package/dist/wasm/lute_runtime_wasm.d.ts

@@ -33,10 +33,28 @@ export class Program {
      * The clock position, as `ClockAt` JSON or `null` without a clock.
      */
     clock(state: State): string;
+    /**
+     * Evaluate the bundle's def `name` over the state, its parameters bound
+     * to `args` (a JSON array of scalars, one per declared parameter;
+     * absent = `[]`), as `Evaluation` JSON; an unknown def, an argument
+     * fault or an evaluation error is rejected.
+     */
+    def(state: State, name: string, args?: string | null): QueryResult;
     /**
      * The verdict of `beat` (for `member`), as `Candidate` JSON or `null`.
      */
     eligibility(state: State, beat: string, member?: string | null): string;
+    /**
+     * Evaluate an IR `exprNode` (JSON) over the state, as `Evaluation`
+     * JSON; a malformed expression or an evaluation error is rejected.
+     */
+    evaluate(state: State, expr: string): QueryResult;
+    /**
+     * Whether a `raiseOccasion` of `occasion` (for `target`) with no writes
+     * would pass the seam now, as `Gate` JSON; an occasion the bundle does
+     * not declare is rejected.
+     */
+    gate(state: State, occasion: string, target?: string | null): QueryResult;
     /**
      * Load a `project.index.json` and an object mapping artifact paths to IR.
      *
@@ -53,6 +71,10 @@ export class Program {
      * contract's canonical form).
      */
     snapshot(state: State): string;
+    /**
+     * The persistent presentation stage as canonical JSON.
+     */
+    stage(state: State): string;
     /**
      * Apply a JSON input without invalidating the supplied state handle.
      */
@@ -68,6 +90,19 @@ export class Program {
     readonly fingerprint: string;
 }
 
+/**
+ * The result of a query (`evaluate`, `def`, `gate`): its answer JSON
+ * (`Evaluation`, `Gate`) or a rejection.
+ */
+export class QueryResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly ok: boolean;
+    readonly rejected: string | undefined;
+    readonly value: string | undefined;
+}
+
 /**
  * The result of restoring a snapshot.
  */
@@ -108,6 +143,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_loadresult_free: (a: number, b: number) => void;
     readonly __wbg_program_free: (a: number, b: number) => void;
+    readonly __wbg_queryresult_free: (a: number, b: number) => void;
     readonly __wbg_restoreresult_free: (a: number, b: number) => void;
     readonly __wbg_state_free: (a: number, b: number) => void;
     readonly __wbg_stepresult_free: (a: number, b: number) => void;
@@ -117,14 +153,21 @@ export interface InitOutput {
     readonly program_begin: (a: number, b: number, c: number) => number;
     readonly program_candidates: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly program_clock: (a: number, b: number) => [number, number];
+    readonly program_def: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly program_eligibility: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly program_evaluate: (a: number, b: number, c: number, d: number) => number;
     readonly program_fingerprint: (a: number) => [number, number];
+    readonly program_gate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly program_load: (a: number, b: number, c: number, d: number) => number;
     readonly program_restore: (a: number, b: number, c: number) => number;
     readonly program_snapshot: (a: number, b: number) => [number, number];
+    readonly program_stage: (a: number, b: number) => [number, number];
     readonly program_step: (a: number, b: number, c: number, d: number) => number;
     readonly program_terminal: (a: number, b: number) => number;
     readonly program_view: (a: number, b: number, c: number) => [number, number];
+    readonly queryresult_ok: (a: number) => number;
+    readonly queryresult_rejected: (a: number) => [number, number];
+    readonly queryresult_value: (a: number) => [number, number];
     readonly restoreresult_ok: (a: number) => number;
     readonly restoreresult_rejected: (a: number) => [number, number];
     readonly restoreresult_state: (a: number) => number;

package/dist/wasm/lute_runtime_wasm.js

@@ -123,6 +123,25 @@ export class Program {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Evaluate the bundle's def `name` over the state, its parameters bound
+     * to `args` (a JSON array of scalars, one per declared parameter;
+     * absent = `[]`), as `Evaluation` JSON; an unknown def, an argument
+     * fault or an evaluation error is rejected.
+     * @param {State} state
+     * @param {string} name
+     * @param {string | null} [args]
+     * @returns {QueryResult}
+     */
+    def(state, name, args) {
+        _assertClass(state, State);
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(args) ? 0 : passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.program_def(this.__wbg_ptr, state.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return QueryResult.__wrap(ret);
+    }
     /**
      * The verdict of `beat` (for `member`), as `Candidate` JSON or `null`.
      * @param {State} state
@@ -147,6 +166,20 @@ export class Program {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Evaluate an IR `exprNode` (JSON) over the state, as `Evaluation`
+     * JSON; a malformed expression or an evaluation error is rejected.
+     * @param {State} state
+     * @param {string} expr
+     * @returns {QueryResult}
+     */
+    evaluate(state, expr) {
+        _assertClass(state, State);
+        const ptr0 = passStringToWasm0(expr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.program_evaluate(this.__wbg_ptr, state.__wbg_ptr, ptr0, len0);
+        return QueryResult.__wrap(ret);
+    }
     /**
      * @returns {string}
      */
@@ -162,6 +195,24 @@ export class Program {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Whether a `raiseOccasion` of `occasion` (for `target`) with no writes
+     * would pass the seam now, as `Gate` JSON; an occasion the bundle does
+     * not declare is rejected.
+     * @param {State} state
+     * @param {string} occasion
+     * @param {string | null} [target]
+     * @returns {QueryResult}
+     */
+    gate(state, occasion, target) {
+        _assertClass(state, State);
+        const ptr0 = passStringToWasm0(occasion, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(target) ? 0 : passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.program_gate(this.__wbg_ptr, state.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return QueryResult.__wrap(ret);
+    }
     /**
      * Load a `project.index.json` and an object mapping artifact paths to IR.
      *
@@ -209,6 +260,24 @@ export class Program {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The persistent presentation stage as canonical JSON.
+     * @param {State} state
+     * @returns {string}
+     */
+    stage(state) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            _assertClass(state, State);
+            const ret = wasm.program_stage(this.__wbg_ptr, state.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Apply a JSON input without invalidating the supplied state handle.
      * @param {State} state
@@ -254,6 +323,61 @@ export class Program {
 }
 if (Symbol.dispose) Program.prototype[Symbol.dispose] = Program.prototype.free;
 
+/**
+ * The result of a query (`evaluate`, `def`, `gate`): its answer JSON
+ * (`Evaluation`, `Gate`) or a rejection.
+ */
+export class QueryResult {
+    static __wrap(ptr) {
+        const obj = Object.create(QueryResult.prototype);
+        obj.__wbg_ptr = ptr;
+        QueryResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QueryResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_queryresult_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get ok() {
+        const ret = wasm.queryresult_ok(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get rejected() {
+        const ret = wasm.queryresult_rejected(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get value() {
+        const ret = wasm.queryresult_value(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) QueryResult.prototype[Symbol.dispose] = QueryResult.prototype.free;
+
 /**
  * The result of restoring a snapshot.
  */
@@ -414,6 +538,9 @@ const LoadResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const ProgramFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_program_free(ptr, 1));
+const QueryResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_queryresult_free(ptr, 1));
 const RestoreResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_restoreresult_free(ptr, 1));

package/dist/wasm/lute_runtime_wasm_bg.wasm.d.ts

@@ -3,6 +3,7 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_loadresult_free: (a: number, b: number) => void;
 export const __wbg_program_free: (a: number, b: number) => void;
+export const __wbg_queryresult_free: (a: number, b: number) => void;
 export const __wbg_restoreresult_free: (a: number, b: number) => void;
 export const __wbg_state_free: (a: number, b: number) => void;
 export const __wbg_stepresult_free: (a: number, b: number) => void;
@@ -12,14 +13,21 @@ export const loadresult_rejected: (a: number) => [number, number];
 export const program_begin: (a: number, b: number, c: number) => number;
 export const program_candidates: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const program_clock: (a: number, b: number) => [number, number];
+export const program_def: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const program_eligibility: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const program_evaluate: (a: number, b: number, c: number, d: number) => number;
 export const program_fingerprint: (a: number) => [number, number];
+export const program_gate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const program_load: (a: number, b: number, c: number, d: number) => number;
 export const program_restore: (a: number, b: number, c: number) => number;
 export const program_snapshot: (a: number, b: number) => [number, number];
+export const program_stage: (a: number, b: number) => [number, number];
 export const program_step: (a: number, b: number, c: number, d: number) => number;
 export const program_terminal: (a: number, b: number) => number;
 export const program_view: (a: number, b: number, c: number) => [number, number];
+export const queryresult_ok: (a: number) => number;
+export const queryresult_rejected: (a: number) => [number, number];
+export const queryresult_value: (a: number) => [number, number];
 export const restoreresult_ok: (a: number) => number;
 export const restoreresult_rejected: (a: number) => [number, number];
 export const restoreresult_state: (a: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lute-lang/runtime",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "description": "The Lute runtime for TypeScript hosts, in Effect: load a compiled Lute bundle, drive the resumable step function, replay input logs (Bun and browsers).",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
     "test": "bunx --bun vitest run",
     "test:browser": "bunx --bun vitest run --config vitest.browser.config.ts",
     "contract:gen": "bun scripts/contract-codegen.ts",
-    "contract:check": "cargo run -q -p lute-runtime --features json-schema --bin lute-contract-schema && bun scripts/contract-codegen.ts && git diff --exit-code -- ../../schemas src/generated"
+    "contract:check": "cargo run -q -p lute-runtime --features json-schema --bin lute-contract-schema && bun scripts/contract-codegen.ts && git diff --exit-code -- ../../schemas src/generated ../player/src/bindings/schema.ts"
   },
   "peerDependencies": {
     "effect": "4.0.2",