@lemmabase/lemma-engine 0.8.22 → 0.9.0

package/README.md

@@ -1,6 +1,6 @@
 # @lemmabase/lemma-engine
 
-> [Lemma](https://github.com/lemma/lemma) is a declarative language for business rules. **This package is the engine, compiled to WebAssembly** - runs in the browser, on Node, Bun, Deno, Cloudflare Workers, Vercel Edge, etc.
+> [Lemma](https://github.com/lemma/lemma) is a declarative language for business rules. **This package is the Lemma engine for JavaScript and TypeScript** — browser, Node, Bun, Deno, Cloudflare Workers, Vercel Edge, etc.
 
 Pricing tiers, tax brackets, leave entitlement, eligibility checks, discount stacks: the rules that change, that auditors ask about, that legal writes in PDFs and engineers re-implement in operational code... Lemma is a language built specifically for your business rules. It is readable by stakeholders, executable anywhere, and impossible to drift out of sync.
 
@@ -28,22 +28,22 @@ rule total:
 import { Lemma } from '@lemmabase/lemma-engine';
 
 const engine = await Lemma();
-await engine.load(pricing, 'pricing.lemma');
+await engine.load({ 'pricing.lemma': pricing });
 
-const response = engine.run(null, 'pricing', null, { quantity: 50, is_vip: false }, null);
+const response = engine.run(null, 'pricing', null, { quantity: 50, is_vip: false }, null, false);
 // response.results.unit_price → 16 eur
 // response.results.total      → 800 eur
 ```
 
-The `Response` carries every rule's value (or `veto` if no result could be computed), the input snapshot, and the source location of every rule that fired, allowing you to render an audit trail in your UI.
+The `Response` carries every rule's value (or `veto` if no result could be computed). When inputs are still unbound, that rule includes `missing_data` (`string[]` input keys). Types, prefilled literals, and suggestions are on `engine.show(...)` (`Show.data`) only — not on the evaluate response.
 
 ## Why use it from JavaScript?
 
 - **Deterministic.** `(spec, data, effective_date) → result`. No DB, no clock, no ambient state. Same inputs → same outputs, every time.
-- **Explainable.** The `Response` tells you which rules contributed and why; pair it with the [CLI](https://github.com/lemma/lemma) for a full reasoning trace.
+- **Explainable.** Pass `explain: true` (6th `run` argument) to get a per-rule explanation tree; see [explanation.v1.json](https://github.com/lemma/lemma/blob/main/documentation/schemas/explanation.v1.json). Pair with the [CLI](https://github.com/lemma/lemma) for human reasoning tables.
 - **Time-aware.** Multiple versions of the same spec coexist. Pass an `effective` date and the engine resolves the version in force on that day.
 - **Statically checked.** Type errors, missing data, cycles, measure-family mismatches - all caught at `load()` time. Bad specs never reach `run()`.
-- **Runs anywhere V8 does.** ~2 MB WASM, no native binary, no postinstall script.
+- **Runs anywhere JavaScript does.** ~2 MB package, no native binary, no postinstall script.
 - **Editor in a tab.** Includes an in-process language server and a Monaco adapter, so you can build a real Lemma editor experience client-side - diagnostics, completion, formatting... even without setting up a server.
 
 ## Install
@@ -60,9 +60,9 @@ import { Lemma } from '@lemmabase/lemma-engine';
 const engine = await Lemma();
 ```
 
-`Lemma()` initializes the WASM module once and returns an `Engine`. Serve over **http(s)**, not `file://`. For manual control: `init()` then `new Engine()`.
+`Lemma()` initializes the engine once and returns an `Engine`. Serve over **http(s)**, not `file://`. For manual control: `init()` then `new Engine()`.
 
-If your bundler emits IIFE, can't resolve `import.meta.url`, or refuses to ship `lemma_bg.wasm` as a separate asset, use the inlined entry - it embeds the wasm bytes in the JS bundle:
+If your bundler emits IIFE, can't resolve `import.meta.url`, or refuses to ship the engine module as a separate asset, use the inlined entry — everything ships in one JS bundle:
 
 ```javascript
 import { Lemma } from '@lemmabase/lemma-engine/iife';
@@ -86,7 +86,7 @@ import { Lemma } from '@lemmabase/lemma-engine';
 const engine = await Lemma();
 ```
 
-For zero-fetch startup with a preloaded module: `initSync({ module })` then `new Engine()`.
+For zero-fetch startup: `initSync({ module })` then `new Engine()`.
 
 ## In-process LSP + Monaco
 
@@ -111,39 +111,40 @@ A pre-wired Monaco adapter ships at `@lemmabase/lemma-engine/monaco`.
 
 | Method | Description |
 |--------|-------------|
-| `load(code, attribute?)` | Parse and validate a `.lemma` spec set. Resolves on success; rejects with `EngineError[]`. |
-| `load_batch(sources, dependency?)` | Load many sources in one planning pass (see `lemma.d.ts`). |
+| `load(code)` | Load inline Lemma source as a volatile workspace source |
+| `load(sources)` | Load multiple sources in one planning pass (`Record<label, text>` or `[label, code][]`; `@org/pkg` keys tag dependencies) |
 | `fetch(name)` | Download registry source only; resolves with `{ source, id }`. Does not load. Rejects with `EngineError[]`. |
-| `list()` | JSON array of `ResolvedRepository`: each has `repository` and `specs` (spec sets). Always includes embedded `lemma` / `spec units`. |
-| `format_repository(repo)` | Canonical Lemma source for a loaded repository, formatted from the in-engine AST. Use `"lemma"` for the embedded units stdlib. |
-| `schema(repo, name, effective?)` | `SpecSchema`; `repo` null for workspace. |
-| `run(repo, name, ruleNames, data, effective?, explain?)` | Evaluate. Omit/`null` `ruleNames` for all rules; pass a non-empty array to scope. `[]` errors. Returns a `Response`. |
+| `list()` | Slim catalog: `ResolvedRepository[]` with `repository` and temporal `specs` rows. Always includes embedded `lemma` / `spec units`. |
+| `show(repo, name, effective?)` | Spec interface + temporal window; `repo` null for workspace. |
+| `source(repo, spec?, effective?)` | Canonical Lemma source text. Omit `spec` for whole repository. |
+| `run(repo, name, effective?, data?, ruleNames?, explain?)` | Evaluate. Omit/`null` `ruleNames` for all rules; pass a non-empty array to scope. `[]` errors. Returns a `Response`. `explain: true` adds per-rule explanation trees. |
+| `remove(repo, name, effective?)` | Remove a temporal spec slice. |
+| `limits()` | Resource limits for this engine. |
 | `format(code, attribute?)` | Canonical formatting; throws `EngineError` on parse error. |
 
 Full TypeScript types are bundled - see `lemma.d.ts`.
 
 ### Registry dependencies
 
-Specs that reference `uses … @org/pkg` need that package available. `fetch` only downloads; call `load_batch` to load the dependency, then load your workspace:
+Specs that reference `uses … @org/pkg` need that package available. `fetch` only downloads; call `load` with the dependency id as the source label, then load your workspace:
 
 ```javascript
 import { Lemma } from '@lemmabase/lemma-engine';
 
 const engine = await Lemma();
 const { source, id } = await engine.fetch('@iso/countries');
-await engine.load_batch({ '': source }, id);
-await engine.load(sourceThatUsesStd, 'app.lemma');
+await engine.load({ [id]: source, 'app.lemma': sourceThatUsesStd });
 ```
 
 In the browser, the registry must allow your origin (CORS). Use `https` or `http://localhost` when using `fetch`.
 
 ## Status
 
-Lemma is pre-1.0. The WASM API is stable for most use cases, but breaking changes may occur between minor versions. Pin your dependency version and review the [changelog](https://github.com/lemma/lemma/blob/main/CHANGELOG.md) before upgrading.
+Lemma is pre-1.0. The JavaScript API is stable for most use cases, but breaking changes may occur between minor versions. Pin your dependency version and review the [changelog](https://github.com/lemma/lemma/blob/main/CHANGELOG.md) before upgrading.
 
-### WASM panic behavior
+### Runtime traps (internal bugs)
 
-Rust panics cannot unwind on the `wasm32` target, so an internal invariant violation (a bug) traps the WASM instance. The call throws a `RuntimeError` which you can catch with `try/catch` to fail gracefully, but the module's linear memory is poisoned — constructing a new `Engine()` from the same initialized module is not safe. To recover, re-initialize the WASM module (`init()` again) or, for robust containment, run the engine in a Web Worker and respawn the worker on trap. The panic message (prefixed `BUG: ...`) is logged to the console before the trap. All domain-level failures (invalid specs, bad data, impossible rules) are reported as `EngineError[]` or vetoes and never cause traps.
+An internal invariant violation (a bug in the engine) traps the runtime. The call throws a `RuntimeError` which you can catch with `try/catch`, but the loaded module is poisoned — constructing a new `Engine()` from the same initialization is not safe. To recover, call `init()` again or run the engine in a Web Worker and respawn the worker on trap. Domain failures (invalid specs, bad data, impossible rules) are reported as `EngineError[]` or vetoes and never cause traps.
 
 ## Related
 

package/lemma.bindings.d.ts

@@ -13,7 +13,7 @@ export class Engine {
     [Symbol.dispose](): void;
     /**
      * Download Lemma source for a registry identifier via [`crate::registry::LemmaBase`]. Returns `{ source, id }`.
-     * Does not load this [`WasmEngine`]; call [`Self::load_batch`], etc., yourself.
+     * Does not load this [`WasmEngine`]; call [`Self::load`] with `{ [id]: source }`.
      */
     fetch(name: string): Promise<any>;
     /**
@@ -21,43 +21,39 @@ export class Engine {
      */
     format(code: string, attribute?: string | null): any;
     /**
-     * Canonical Lemma source for `repository`, formatted from the in-engine AST (e.g. `"lemma"`).
+     * Resource limits configured for this engine.
      */
-    format_repository(repository: string): string;
+    limits(): any;
     /**
-     * Same data as [`Engine::list`]: grouped [`ResolvedRepository`] JSON without planning.
+     * Catalog of loaded repositories and specs (metadata only, no source).
      */
     list(): any;
     /**
-     * Load Lemma source. Throws with an array of serialized errors
-     * (same shape as `EngineError` in `engine/packages/npm/lemma.d.ts`).
-     */
-    load(code: string, attribute: string): void;
-    /**
-     * Load multiple Lemma sources in one planning pass (same as [`Engine::load_batch`]).
-     *
-     * `sources` is a plain object mapping path labels to source text. Labels become
-     * [`SourceType::Path`]; use `""` as a key for [`SourceType::Volatile`].
+     * Load Lemma source(s).
      *
-     * `dependency`: when non-empty after trim, sources are tagged as that dependency id.
+     * - string → one volatile workspace source
+     * - plain object or `[label, code][]` → labeled sources in one planning pass
      *
-     * Throws with an array of `JsError` on failure.
+     * Throws with an array of serialized errors on failure. `null` / `undefined` are rejected.
      */
-    load_batch(sources: any, dependency?: string | null): void;
+    load(sources: any): void;
     constructor();
+    /**
+     * Remove a temporal spec slice. `effective`: ISO datetime string or omit for now.
+     */
+    remove(repository: string | null | undefined, spec: string, effective?: string | null): void;
     /**
      * Evaluate spec. Returns [`crate::evaluation::Response`] as a JS object. Throws on planning/runtime error.
-     *
-     * `repository`: repository qualifier (`@org/pkg`), or `null`/empty for workspace (same as
-     * [`Engine::run`] `repo: None`).
      */
-    run(repository: string | null | undefined, spec: string, rule_names: any, data_values: any, effective?: string | null, explain?: boolean | null): any;
+    run(repository: string | null | undefined, spec: string, effective: string | null | undefined, data_values: any, rule_names: any, explain?: boolean | null): any;
     /**
-     * Planning schema for the spec ([`crate::planning::execution_plan::SpecSchema`]). Throws on error.
-     *
-     * `repository`: qualifier string or `null`/empty for workspace ([`Engine::schema`]).
+     * Spec interface and temporal window at `effective`. Lemma text is [`Self::source`].
+     */
+    show(repository: string | null | undefined, spec: string, effective?: string | null): any;
+    /**
+     * Formatted canonical Lemma source. Omit `spec` for whole-repository text.
      */
-    schema(repository: string | null | undefined, spec: string, effective?: string | null): any;
+    source(repository?: string | null, spec?: string | null, effective?: string | null): string;
 }
 
 export class IntoUnderlyingByteSource {
@@ -123,16 +119,17 @@ export interface InitOutput {
     readonly __wbg_engine_free: (a: number, b: number) => void;
     readonly wasmengine_fetch: (a: number, b: number, c: number) => number;
     readonly wasmengine_format: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly wasmengine_format_repository: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmengine_limits: (a: number, b: number) => void;
     readonly wasmengine_list: (a: number, b: number) => void;
-    readonly wasmengine_load: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly wasmengine_load_batch: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmengine_load: (a: number, b: number, c: number) => void;
     readonly wasmengine_new: () => number;
+    readonly wasmengine_remove: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly wasmengine_run: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
-    readonly wasmengine_schema: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
-    readonly __wasm_bindgen_func_elem_12297: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2740: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_12302: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmengine_show: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly wasmengine_source: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly __wasm_bindgen_func_elem_12266: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2732: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_12283: (a: number, b: number, c: number, d: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/lemma.bindings.js

@@ -13,7 +13,7 @@ export class Engine {
     }
     /**
      * Download Lemma source for a registry identifier via [`crate::registry::LemmaBase`]. Returns `{ source, id }`.
-     * Does not load this [`WasmEngine`]; call [`Self::load_batch`], etc., yourself.
+     * Does not load this [`WasmEngine`]; call [`Self::load`] with `{ [id]: source }`.
      * @param {string} name
      * @returns {Promise<any>}
      */
@@ -49,38 +49,26 @@ export class Engine {
         }
     }
     /**
-     * Canonical Lemma source for `repository`, formatted from the in-engine AST (e.g. `"lemma"`).
-     * @param {string} repository
-     * @returns {string}
+     * Resource limits configured for this engine.
+     * @returns {any}
      */
-    format_repository(repository) {
-        let deferred3_0;
-        let deferred3_1;
+    limits() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(repository, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.wasmengine_format_repository(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.wasmengine_limits(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            var ptr2 = r0;
-            var len2 = r1;
-            if (r3) {
-                ptr2 = 0; len2 = 0;
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
         }
     }
     /**
-     * Same data as [`Engine::list`]: grouped [`ResolvedRepository`] JSON without planning.
+     * Catalog of loaded repositories and specs (metadata only, no source).
      * @returns {any}
      */
     list() {
@@ -99,19 +87,18 @@ export class Engine {
         }
     }
     /**
-     * Load Lemma source. Throws with an array of serialized errors
-     * (same shape as `EngineError` in `engine/packages/npm/lemma.d.ts`).
-     * @param {string} code
-     * @param {string} attribute
+     * Load Lemma source(s).
+     *
+     * - string → one volatile workspace source
+     * - plain object or `[label, code][]` → labeled sources in one planning pass
+     *
+     * Throws with an array of serialized errors on failure. `null` / `undefined` are rejected.
+     * @param {any} sources
      */
-    load(code, attribute) {
+    load(sources) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(attribute, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.wasmengine_load(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            wasm.wasmengine_load(retptr, this.__wbg_ptr, addHeapObject(sources));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -121,24 +108,28 @@ export class Engine {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    constructor() {
+        const ret = wasm.wasmengine_new();
+        this.__wbg_ptr = ret;
+        EngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     /**
-     * Load multiple Lemma sources in one planning pass (same as [`Engine::load_batch`]).
-     *
-     * `sources` is a plain object mapping path labels to source text. Labels become
-     * [`SourceType::Path`]; use `""` as a key for [`SourceType::Volatile`].
-     *
-     * `dependency`: when non-empty after trim, sources are tagged as that dependency id.
-     *
-     * Throws with an array of `JsError` on failure.
-     * @param {any} sources
-     * @param {string | null} [dependency]
+     * Remove a temporal spec slice. `effective`: ISO datetime string or omit for now.
+     * @param {string | null | undefined} repository
+     * @param {string} spec
+     * @param {string | null} [effective]
      */
-    load_batch(sources, dependency) {
+    remove(repository, spec, effective) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = isLikeNone(dependency) ? 0 : passStringToWasm0(dependency, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var ptr0 = isLikeNone(repository) ? 0 : passStringToWasm0(repository, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             var len0 = WASM_VECTOR_LEN;
-            wasm.wasmengine_load_batch(retptr, this.__wbg_ptr, addHeapObject(sources), ptr0, len0);
+            const ptr1 = passStringToWasm0(spec, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(effective) ? 0 : passStringToWasm0(effective, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.wasmengine_remove(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -148,26 +139,17 @@ export class Engine {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    constructor() {
-        const ret = wasm.wasmengine_new();
-        this.__wbg_ptr = ret;
-        EngineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * Evaluate spec. Returns [`crate::evaluation::Response`] as a JS object. Throws on planning/runtime error.
-     *
-     * `repository`: repository qualifier (`@org/pkg`), or `null`/empty for workspace (same as
-     * [`Engine::run`] `repo: None`).
      * @param {string | null | undefined} repository
      * @param {string} spec
-     * @param {any} rule_names
+     * @param {string | null | undefined} effective
      * @param {any} data_values
-     * @param {string | null} [effective]
+     * @param {any} rule_names
      * @param {boolean | null} [explain]
      * @returns {any}
      */
-    run(repository, spec, rule_names, data_values, effective, explain) {
+    run(repository, spec, effective, data_values, rule_names, explain) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             var ptr0 = isLikeNone(repository) ? 0 : passStringToWasm0(repository, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -176,7 +158,7 @@ export class Engine {
             const len1 = WASM_VECTOR_LEN;
             var ptr2 = isLikeNone(effective) ? 0 : passStringToWasm0(effective, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             var len2 = WASM_VECTOR_LEN;
-            wasm.wasmengine_run(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(rule_names), addHeapObject(data_values), ptr2, len2, isLikeNone(explain) ? 0xFFFFFF : explain ? 1 : 0);
+            wasm.wasmengine_run(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, addHeapObject(data_values), addHeapObject(rule_names), isLikeNone(explain) ? 0xFFFFFF : explain ? 1 : 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -189,15 +171,13 @@ export class Engine {
         }
     }
     /**
-     * Planning schema for the spec ([`crate::planning::execution_plan::SpecSchema`]). Throws on error.
-     *
-     * `repository`: qualifier string or `null`/empty for workspace ([`Engine::schema`]).
+     * Spec interface and temporal window at `effective`. Lemma text is [`Self::source`].
      * @param {string | null | undefined} repository
      * @param {string} spec
      * @param {string | null} [effective]
      * @returns {any}
      */
-    schema(repository, spec, effective) {
+    show(repository, spec, effective) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             var ptr0 = isLikeNone(repository) ? 0 : passStringToWasm0(repository, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -206,7 +186,7 @@ export class Engine {
             const len1 = WASM_VECTOR_LEN;
             var ptr2 = isLikeNone(effective) ? 0 : passStringToWasm0(effective, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             var len2 = WASM_VECTOR_LEN;
-            wasm.wasmengine_schema(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            wasm.wasmengine_show(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -218,6 +198,43 @@ export class Engine {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Formatted canonical Lemma source. Omit `spec` for whole-repository text.
+     * @param {string | null} [repository]
+     * @param {string | null} [spec]
+     * @param {string | null} [effective]
+     * @returns {string}
+     */
+    source(repository, spec, effective) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(repository) ? 0 : passStringToWasm0(repository, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(spec) ? 0 : passStringToWasm0(spec, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(effective) ? 0 : passStringToWasm0(effective, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.wasmengine_source(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr4 = r0;
+            var len4 = r1;
+            if (r3) {
+                ptr4 = 0; len4 = 0;
+                throw takeObject(r2);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
+        }
+    }
 }
 if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
 
@@ -513,6 +530,10 @@ function __wbg_get_imports() {
             const ret = fetch(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_from_fa561fa561dc8031: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_getTime_09f1dd40a44edb30: function(arg0) {
             const ret = getObject(arg0).getTime();
             return ret;
@@ -587,6 +608,10 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_isArray_74b636a53056fecb: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
         __wbg_isArray_94898ed3aad6947b: function(arg0) {
             const ret = Array.isArray(getObject(arg0));
             return ret;
@@ -666,7 +691,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_12302(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_12283(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -825,13 +850,13 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1414, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12297);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1402, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12266);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IteratorResult<any>")], shim_idx: 7, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2740);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2732);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -868,10 +893,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_12297(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_12266(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_12297(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_12266(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -882,10 +907,10 @@ function __wasm_bindgen_func_elem_12297(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_2740(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_2732(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_2740(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_2732(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -896,8 +921,8 @@ function __wasm_bindgen_func_elem_2740(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_12302(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_12302(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_12283(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_12283(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }