@benrogmans/lemma-engine 0.6.9 → 0.7.4

package/README.md

@@ -46,12 +46,12 @@ const engine = new WasmEngine();
 
 ### Core Methods
 
-#### `addLemmaCode(code: string, filename: string): string`
+#### `addLemmaFile(code: string, filename: string): string`
 
 Adds a Lemma document to the engine.
 
 ```javascript
-const result = engine.addLemmaCode(`
+const result = engine.addLemmaFile(`
   doc employee_contract
 
   fact salary = 5000 eur
@@ -78,7 +78,7 @@ Evaluates a document with optional runtime facts.
 // Evaluate with default facts
 const result1 = engine.evaluate('employee_contract', '{}');
 
-// Evaluate with runtime fact overrides (as JSON object)
+// Evaluate with runtime fact values (as JSON object)
 const result2 = engine.evaluate('employee_contract', JSON.stringify({
   salary: 6000,
   vacation_days: 30
@@ -162,7 +162,7 @@ async function calculatePricing() {
 
   // Load the document
   const loadResult = JSON.parse(
-    engine.addLemmaCode(pricingDoc, 'pricing.lemma')
+    engine.addLemmaFile(pricingDoc, 'pricing.lemma')
   );
 
   if (!loadResult.success) {
@@ -222,7 +222,7 @@ interface EvaluationResponse {
     document: string;
     rules: {
       [ruleName: string]: {
-        value: any;  // The computed value (e.g., {Number: "100"}, {Unit: "50 EUR"})
+        value: any;  // The computed value (e.g., {Number: "100"})
         veto?: string;  // Present if rule was vetoed
         missing_facts?: string[];  // Present if rule couldn't be evaluated
         operations?: Array<{  // Operation records (always present if rule was evaluated)
@@ -254,8 +254,6 @@ async function typedExample() {
 
   if (result.success && result.data) {
     const price = result.data.rules.final_price?.value;
-    // price might be {Unit: "100 USD"} or {Number: "100"}
-    // depending on the rule's result type
   }
 }
 ```
@@ -265,7 +263,7 @@ async function typedExample() {
 ```javascript
 try {
   const result = JSON.parse(
-    engine.addLemmaCode('invalid syntax', 'bad.lemma')
+    engine.addLemmaFile('invalid syntax', 'bad.lemma')
   );
 
   if (!result.success) {

package/lemma.d.ts

@@ -1,49 +1,182 @@
 /* tslint:disable */
 /* eslint-disable */
+
+type ReadableStreamReaderMode = "byob";
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: any): Promise<any>;
+    start(controller: any): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: any;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: any): Promise<any>;
+}
+
+/**
+ * Raw options for [`pipeTo()`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/pipeTo).
+ */
+export class PipeOptions {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly preventAbort: boolean;
+    readonly preventCancel: boolean;
+    readonly preventClose: boolean;
+    readonly signal: AbortSignal | undefined;
+}
+
+export class QueuingStrategy {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly highWaterMark: number;
+}
+
+/**
+ * Raw options for [`getReader()`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/getReader).
+ */
+export class ReadableStreamGetReaderOptions {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly mode: ReadableStreamReaderMode;
+}
+
+export class ServerConfig {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(into_server: AsyncIterator<any>, from_server: WritableStream);
+}
+
 export class WasmEngine {
-  free(): void;
-  [Symbol.dispose](): void;
-  addLemmaCode(code: string, source: string): string;
-  listDocuments(): string;
-  constructor();
-  invert(doc_name: string, rule_name: string, target_json: string, given_facts_json: string): string;
-  evaluate(doc_name: string, fact_values_json: string): string;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add Lemma source (e.g. file contents). Returns a Promise that resolves to a JSON string result.
+     */
+    addLemmaFile(code: string, source: string): Promise<any>;
+    /**
+     * Evaluate rules in a document.
+     *
+     * Pass `rule_names_json` as `"[]"` or `""` to evaluate all rules.
+     * Pass a JSON array like `'["total","discount"]'` to evaluate specific rules.
+     */
+    evaluate(doc_name: string, rule_names_json: string, fact_values_json: string): string;
+    /**
+     * Format Lemma source code. Returns a JSON string: `{ "success": true, "formatted": "..." }`
+     * or `{ "success": false, "error": "..." }`. Only formats if the source parses successfully.
+     * Call from JS (e.g. Monaco playground) to implement "Format" without an LSP; there is no on-save in the browser.
+     */
+    formatSource(code: string, source_attribute: string): string;
+    /**
+     * Return the full document schema: all facts and rules with their types.
+     *
+     * Returns the `DocumentSchema` used by all Lemma interfaces, serialized as
+     * JSON. Use `getSchema` with specific rule names to get only the facts
+     * required by those rules.
+     */
+    getSchema(doc_name: string, rule_names_json: string): string;
+    invert(_doc_name: string, _rule_name: string, _target_json: string, _provided_values_json: string): string;
+    /**
+     * List all loaded documents with their full schemas.
+     *
+     * Returns `{ success: true, documents: [DocumentSchema, ...] }` sorted by
+     * document name, consistent with the HTTP and MCP interfaces.
+     */
+    listDocuments(): string;
+    constructor();
 }
 
+/**
+ * Run the Lemma LSP over the given streams. Call from JS after creating
+ * an AsyncIterator (client → server messages) and a WritableStream (server → client).
+ */
+export function serve(config: ServerConfig): Promise<void>;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_wasmengine_free: (a: number, b: number) => void;
-  readonly wasmengine_addLemmaCode: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-  readonly wasmengine_evaluate: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-  readonly wasmengine_invert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
-  readonly wasmengine_listDocuments: (a: number) => [number, number];
-  readonly wasmengine_new: () => number;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_export_3: WebAssembly.Table;
-  readonly __wbindgen_start: () => void;
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_serverconfig_free: (a: number, b: number) => void;
+    readonly serve: (a: number) => number;
+    readonly serverconfig_new: (a: number, b: number) => number;
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly __wbg_pipeoptions_free: (a: number, b: number) => void;
+    readonly __wbg_queuingstrategy_free: (a: number, b: number) => void;
+    readonly __wbg_readablestreamgetreaderoptions_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: number) => number;
+    readonly intounderlyingbytesource_start: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly intounderlyingsink_abort: (a: number, b: number) => number;
+    readonly intounderlyingsink_close: (a: number) => number;
+    readonly intounderlyingsink_write: (a: number, b: number) => number;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: number) => number;
+    readonly pipeoptions_preventAbort: (a: number) => number;
+    readonly pipeoptions_preventCancel: (a: number) => number;
+    readonly pipeoptions_preventClose: (a: number) => number;
+    readonly pipeoptions_signal: (a: number) => number;
+    readonly queuingstrategy_highWaterMark: (a: number) => number;
+    readonly readablestreamgetreaderoptions_mode: (a: number) => number;
+    readonly __wbg_wasmengine_free: (a: number, b: number) => void;
+    readonly wasmengine_addLemmaFile: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmengine_evaluate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly wasmengine_formatSource: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmengine_getSchema: (a: number, b: number, c: number, d: number, e: number, f: 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_listDocuments: (a: number, b: number) => void;
+    readonly wasmengine_new: () => number;
+    readonly __wasm_bindgen_func_elem_8774: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_9930: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_8789: (a: number, b: number, c: 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;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;
+
 /**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
 export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
 
 /**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
-*
-* @returns {Promise<InitOutput>}
-*/
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
 export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;