@lemmabase/lemma-engine 0.8.12 → 0.8.14

package/README.md

@@ -7,7 +7,7 @@ Pricing tiers, tax brackets, leave entitlement, eligibility checks, discount sta
 ```lemma
 spec pricing 2026-01-01
 
-data money: scale
+data money: quantity
   -> unit eur 1.00
   -> decimals 2
 
@@ -30,7 +30,7 @@ import { Lemma } from '@lemmabase/lemma-engine';
 const engine = await Lemma();
 await engine.load(pricing, 'pricing.lemma');
 
-const response = engine.run('pricing', [], { quantity: 50, is_vip: false }, null);
+const response = engine.run(null, 'pricing', [], { quantity: 50, is_vip: false }, null);
 // response.results.unit_price → 16 eur
 // response.results.total      → 800 eur
 ```
@@ -42,7 +42,7 @@ The `Response` carries every rule's value (or `veto` if no result could be compu
 - **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.
 - **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, scale-family mismatches - all caught at `load()` time. Bad specs never reach `run()`.
+- **Statically checked.** Type errors, missing data, cycles, quantity-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.
 - **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.
 
@@ -112,13 +112,31 @@ 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[]`. |
-| `list()` | All loaded specs with metadata and an inlined `SpecSchema`. |
-| `schema(spec, effective?)` | `SpecSchema` for the spec at the given effective date. |
-| `run(spec, rules, data, effective?)` | Evaluate. `rules: []` runs everything; pass an array to filter. Returns a `Response`. |
+| `load_batch(sources, dependency?)` | Load many sources in one planning pass (see `lemma.d.ts`). |
+| `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 si`. |
+| `format_repository(repo)` | Canonical Lemma source for a loaded repository, formatted from the in-engine AST. Use `"lemma"` for the embedded SI stdlib. |
+| `schema(repo, name, effective?)` | `SpecSchema`; `repo` null for workspace. |
+| `run(repo, name, ruleNames, data, effective?)` | Evaluate. `rules: []` runs everything; pass an array to filter. Returns a `Response`. |
 | `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:
+
+```javascript
+import { Lemma } from '@lemmabase/lemma-engine';
+
+const engine = await Lemma();
+const { source, id } = await engine.fetch('@lemma/std');
+await engine.load_batch({ '': source }, id);
+await engine.load(sourceThatUsesStd, 'app.lemma');
+```
+
+In the browser, the registry must allow your origin (CORS). Use `https` or `http://localhost` when using `fetch`.
+
 ## Status
 
 Lemma is in early development. Expect breaking changes between minor versions; **don't put it in front of paying customers yet**. Production-readiness tracking lives in the [main repo](https://github.com/lemma/lemma).

package/lemma.bindings.d.ts

@@ -6,46 +6,63 @@
  * *This API requires the following crate features to be activated: `ReadableStreamType`*
  */
 
-type ReadableStreamType = "bytes";
+export type ReadableStreamType = "bytes";
 
 export class Engine {
     free(): void;
     [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.
+     */
+    fetch(name: string): Promise<any>;
     /**
      * Returns formatted source string on success; throws with error message on failure.
      */
     format(code: string, attribute?: string | null): any;
+    /**
+     * Canonical Lemma source for `repository`, formatted from the in-engine AST (e.g. `"lemma"`).
+     */
+    format_repository(repository: string): string;
     invert(_spec_name: string, _rule_name: string, _target_json: string, _provided_values_json: string): any;
     /**
-     * Loaded specs, each paired with its planning schema.
-     *
-     * Each entry has `{ name, effective_from, effective_to, schema }`. The
-     * pair describes a half-open `[effective_from, effective_to)` validity
-     * range; `effective_from` is `null` when the first version has no
-     * declared start, and `effective_to` is `null` for the latest version of
-     * a name (no successor). Order matches [`Engine::list_specs_with_ranges`].
-     *
-     * `schema` is the same envelope returned by [`WasmEngine::schema`] for
-     * `(name, effective_from)`; shipping it inline saves the N+1 round-trip
-     * every consumer (playground, dashboards, docs) was doing.
+     * Same data as [`Engine::list`]: grouped [`ResolvedRepository`] JSON without planning.
      */
     list(): any;
     /**
-     * Load Lemma source. Resolves with `undefined` on success; rejects with an array of
-     * serialized errors (same shape as `EngineError` in `engine/packages/npm/lemma.d.ts`).
+     * 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`].
      *
-     * Breaking: previously rejected with an array of strings.
+     * `dependency`: when non-empty after trim, sources are tagged as that dependency id.
+     *
+     * Throws with an array of `JsError` on failure.
      */
-    load(code: string, attribute: string): Promise<any>;
+    load_batch(sources: any, dependency?: string | null): void;
     constructor();
+    /**
+     * Loaded repositories (workspace and dependencies): `{ name, dependency }`.
+     */
+    repositories(): any;
     /**
      * 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(spec: string, rule_names: any, data_values: any, effective?: string | null): any;
+    run(repository: string | null | undefined, spec: string, rule_names: any, data_values: any, rule_result_units: any, effective?: string | 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`]).
      */
-    schema(spec: string, effective?: string | null): any;
+    schema(repository: string | null | undefined, spec: string, effective?: string | null): any;
 }
 
 export class IntoUnderlyingByteSource {
@@ -109,16 +126,20 @@ export interface InitOutput {
     readonly intounderlyingsource_cancel: (a: number) => void;
     readonly intounderlyingsource_pull: (a: number, b: number) => number;
     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_invert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly wasmengine_list: (a: number, b: number) => void;
-    readonly wasmengine_load: (a: number, b: number, c: number, d: number, e: number) => number;
+    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_new: () => number;
-    readonly wasmengine_run: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
-    readonly wasmengine_schema: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly __wasm_bindgen_func_elem_10686: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2761: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_10704: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmengine_repositories: (a: number, b: 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_11787: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2722: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_11799: (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;