@lemmabase/lemma-engine 0.9.9 → 0.9.10

package/README.md

@@ -111,13 +111,13 @@ A pre-wired Monaco adapter ships at `@lemmabase/lemma-engine/monaco`.
 
 | Method | Description |
 |--------|-------------|
-| `load(code)` | Load inline Lemma source as a volatile workspace source |
+| `load(code)` | Load inline Lemma source as a volatile source in the default repository |
 | `load(sources)` | Load multiple sources in one planning pass (`Record<label, text>` or `[label, code][]`; object keys keep insertion order; `@org/pkg` keys tag LemmaBase repositories) |
 | `Engine.withLimits(limits)` | Static: create engine with named limit overrides (unknown keys throw) |
 | `Engine.fromSnapshot(bytes)` | Static: restore engine from `snapshot()` bytes (`Uint8Array`) |
 | `install(name)` | Download a repository from LemmaBase; resolves with `{ source, id }`. Does not load. Rejects with `EngineError[]`. |
 | `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. |
+| `show(repo, name, effective?)` | Spec interface + temporal window; `repo` null for the default repository. |
 | `source(repo, spec?, effective?)` | Canonical Lemma source text. Omit `spec` for whole repository. |
 | `run({ spec, repository?, effective?, data?, rules?, explain? })` | Evaluate. Omit `rules` 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. |

package/lemma.bindings.d.ts

@@ -35,7 +35,7 @@ export class Engine {
     /**
      * Load Lemma source(s).
      *
-     * - string → one volatile workspace source
+     * - string → one volatile source in the default repository
      * - plain object or `[label, code][]` → labeled sources in one planning pass
      *
      * Throws with an array of serialized errors on failure. `null` / `undefined` are rejected.
@@ -158,10 +158,10 @@ export interface InitOutput {
     readonly engine_source: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_update: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_withLimits: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_13544: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_13706: (a: number, b: number, c: number, d: number) => void;
     readonly __wasm_bindgen_func_elem_2736: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_13550: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_7929: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_13712: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_7982: (a: number, b: 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

@@ -117,7 +117,7 @@ export class Engine {
     /**
      * Load Lemma source(s).
      *
-     * - string → one volatile workspace source
+     * - string → one volatile source in the default repository
      * - plain object or `[label, code][]` → labeled sources in one planning pass
      *
      * Throws with an array of serialized errors on failure. `null` / `undefined` are rejected.
@@ -803,7 +803,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_13550(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_13712(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -943,8 +943,8 @@ 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: 1470, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_13544);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1510, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_13706);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
@@ -953,8 +953,8 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 913, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_7929);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 910, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_7982);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0) {
@@ -991,14 +991,14 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_7929(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_7929(arg0, arg1);
+function __wasm_bindgen_func_elem_7982(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_7982(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_13544(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_13706(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_13544(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_13706(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1023,8 +1023,8 @@ function __wasm_bindgen_func_elem_2736(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_13550(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_13550(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_13712(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_13712(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 

package/lemma.d.ts

@@ -20,7 +20,7 @@ declare module './lemma.bindings.js' {
   interface Engine {
     /**
      * Load Lemma source(s).
-     * - string → volatile workspace source
+     * - string → volatile source in the default repository
      * - object → labeled sources (key insertion order); `[label, code][]` → labeled sources (array order)
      * Throws `EngineError[]` on failure. `null`/`undefined` rejected.
      */
@@ -36,7 +36,7 @@ declare module './lemma.bindings.js' {
 
     /**
      * JSON serialization of `Vec<ResolvedRepository>` from [`Engine::list`]:
-     * each item has `repository` (name or null for workspace) and `specs`
+     * each item has `repository` (name, or omitted for the default repository) and `specs`
      * (`ListedSpec` rows: name, effective_from, effective_to).
      */
     list(): ResolvedRepository[];
@@ -109,7 +109,7 @@ declare module './lemma.bindings.js' {
 export interface RunOptions {
   /** Spec name (required). */
   spec: string;
-  /** Repository qualifier (e.g. `@org/repo`), or omit for workspace. */
+  /** Repository qualifier (e.g. `@org/repo`), or omit for the default repository. */
   repository?: string | null;
   /** ISO datetime for temporal resolution, or omit for now. */
   effective?: string | null;
@@ -455,6 +455,112 @@ export type LiteralValue =
   | { boolean: "true" | "false" | "yes" | "no" }
   | { range: [LiteralValue, LiteralValue] };
 
+/** Conversion target on a Show `as` expression. */
+export type ShowConversionTarget =
+  | {
+      type:
+        | "boolean"
+        | "measure"
+        | "measure_range"
+        | "number"
+        | "number_range"
+        | "ratio"
+        | "ratio_range"
+        | "text"
+        | "date"
+        | "date_range"
+        | "time"
+        | "time_range";
+    }
+  | { unit: { unit_name: string } };
+
+/** Resolved expression on a Show rule branch (tagged by `type`). */
+export type ShowExpression =
+  | ({ type: "literal" } & RuleResultValue)
+  | { type: "data"; name: string }
+  | { type: "rule"; name: string }
+  | { type: "and"; left: ShowExpression; right: ShowExpression }
+  | { type: "not"; operand: ShowExpression }
+  | {
+      type: "arithmetic";
+      op: "add" | "subtract" | "multiply" | "divide" | "modulo" | "power";
+      left: ShowExpression;
+      right: ShowExpression;
+    }
+  | {
+      type: "comparison";
+      op:
+        | "greater_than"
+        | "less_than"
+        | "greater_than_or_equal"
+        | "less_than_or_equal"
+        | "is"
+        | "is_not";
+      left: ShowExpression;
+      right: ShowExpression;
+    }
+  | {
+      type: "unit_conversion";
+      operand: ShowExpression;
+      target: ShowConversionTarget;
+    }
+  | {
+      type: "math";
+      op:
+        | "sqrt"
+        | "sin"
+        | "cos"
+        | "tan"
+        | "asin"
+        | "acos"
+        | "atan"
+        | "log"
+        | "exp"
+        | "abs"
+        | "floor"
+        | "ceil"
+        | "round";
+      operand: ShowExpression;
+    }
+  | { type: "veto"; message?: string }
+  | { type: "now" }
+  | {
+      type: "date_relative";
+      kind: "in_past" | "in_future";
+      operand: ShowExpression;
+    }
+  | {
+      type: "date_calendar";
+      kind: "current" | "past" | "future" | "not_in";
+      unit: "year" | "month" | "week";
+      operand: ShowExpression;
+    }
+  | { type: "range_literal"; from: ShowExpression; to: ShowExpression }
+  | {
+      type: "past_future_range";
+      kind: "in_past" | "in_future";
+      operand: ShowExpression;
+    }
+  | {
+      type: "range_containment";
+      value: ShowExpression;
+      range: ShowExpression;
+    }
+  | { type: "is_veto"; operand: ShowExpression };
+
+/** One arm of a rule's flat last-match table. Default arm omits condition. */
+export interface ShowBranch {
+  condition?: ShowExpression;
+  result: ShowExpression;
+}
+
+/** Local rule on Show: result type, branches, stored depends_on_rules. */
+export interface ShowRule {
+  type: LemmaType;
+  branches: ShowBranch[];
+  depends_on_rules: string[];
+}
+
 /** Return shape of {@link Engine.show}. */
 export interface Show {
   spec: string;
@@ -465,8 +571,8 @@ export interface Show {
   source_type?: SourceType;
   versions?: ShowVersion[];
   data: Record<string, ShowData>;
-  /** Rule result types; measure and ratio entries expose `units[]` like their data counterparts. */
-  rules: Record<string, LemmaType>;
+  /** Local rule graph; measure/ratio units live under `type.units`. */
+  rules: Record<string, ShowRule>;
   meta: Record<string, LiteralValue>;
 }
 
@@ -479,7 +585,7 @@ export interface ListedSpec {
 
 /** Rust `ResolvedRepository` (engine `list`). */
 export interface ResolvedRepository {
-  /** Absent for the local workspace group (only real repositories carry a name). */
+  /** Absent for the default unnamed repository (only named repositories carry a name). */
   repository?: string;
   specs: ListedSpec[];
 }