@lemmabase/lemma-engine 0.9.4 → 0.9.6

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 Lemma engine for JavaScript and TypeScript** — browser, 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.
 
@@ -8,7 +8,7 @@ Pricing tiers, tax brackets, leave entitlement, eligibility checks, discount sta
 spec pricing 2026-01-01
 
 data money: measure
-  -> unit eur 1.00
+  -> unit eur: 1.00
   -> decimals 2
 
 data quantity : number
@@ -35,7 +35,7 @@ const response = engine.run({ spec: 'pricing', data: { quantity: 50, is_vip: fal
 // response.results.total      → 800 eur
 ```
 
-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.
+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?
 
@@ -62,7 +62,7 @@ const engine = await Lemma();
 
 `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 the engine module as a separate asset, use the inlined entry — everything ships in one 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';
@@ -145,7 +145,7 @@ Lemma is pre-1.0. The JavaScript API is stable for most use cases, but breaking
 
 ### Runtime traps (internal bugs)
 
-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.
+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

@@ -148,9 +148,9 @@ 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, i: number, j: number, k: number, l: number) => void;
     readonly engine_withLimits: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_12532: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2733: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_12539: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_12566: (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_12574: (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

@@ -770,7 +770,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_12539(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_12574(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -929,13 +929,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: 1404, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12532);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1415, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12566);
             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_2733);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2732);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -972,10 +972,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_12532(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_12566(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_12532(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_12566(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -986,10 +986,10 @@ function __wasm_bindgen_func_elem_12532(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_2733(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_2733(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) {
@@ -1000,8 +1000,8 @@ function __wasm_bindgen_func_elem_2733(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_12539(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_12539(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_12574(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_12574(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }