@edgerules/node 0.0.0-alpha.202607061133 → 0.0.0-alpha.202607071338

package/README.md

@@ -0,0 +1,199 @@
+# @edgerules/node
+
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=rimvydasb_edgerules&metric=alert_status&token=98a392e505393c255f7de845e8b74a32911f2435)](https://sonarcloud.io/summary/new_code?id=rimvydasb_edgerules)
+[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=rimvydasb_edgerules&metric=bugs&token=98a392e505393c255f7de845e8b74a32911f2435)](https://sonarcloud.io/summary/new_code?id=rimvydasb_edgerules)
+[![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=rimvydasb_edgerules&metric=code_smells&token=98a392e505393c255f7de845e8b74a32911f2435)](https://sonarcloud.io/summary/new_code?id=rimvydasb_edgerules)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=rimvydasb_edgerules&metric=coverage&token=98a392e505393c255f7de845e8b74a32911f2435)](https://sonarcloud.io/summary/new_code?id=rimvydasb_edgerules)
+[![Duplicated Lines](https://sonarcloud.io/api/project_badges/measure?project=rimvydasb_edgerules&metric=duplicated_lines_density&token=98a392e505393c255f7de845e8b74a32911f2435)](https://sonarcloud.io/summary/new_code?id=rimvydasb_edgerules)
+
+EdgeRules decision service for **Node.js**. Ships two builds:
+
+| Export | Description |
+|---|---|
+| `@edgerules/node` | Production build — execution only (`DecisionService`) |
+| `@edgerules/node/mutable` | Development build — execution + CRUD (`MutableDecisionService`) |
+
+---
+
+## Installation
+
+```sh
+npm install @edgerules/node @edgerules/portable
+```
+
+> Requires Node.js 18 or later (ESM only).
+
+---
+
+## Production Usage
+
+### Load from an EdgeRules DSL string
+
+```typescript
+import { DecisionService } from '@edgerules/node';
+
+const service = new DecisionService(`{
+    applicant: {
+        age:    <number, required: true>
+        income: <number, default: 0>
+    }
+    isEligible: applicant.age >= 18 and applicant.income >= 1000
+}`);
+
+// Execute the whole model — inputs are bound via a model-shaped request object
+const result = service.execute('*', { applicant: { age: 25, income: 2500 } });
+// { applicant: { age: 25, income: 2500 }, isEligible: true }
+```
+
+### Load from a Portable JSON model
+
+```typescript
+import { DecisionService } from '@edgerules/node';
+import type { PortableRootContext } from '@edgerules/portable';
+
+const model: PortableRootContext = {
+  '@version': '1.0',
+  '@model-name': 'Tax Calculator',
+  taxRate: 0.21,
+  calculateTax: {
+    '@kind': 'function',
+    '@parameters': { amount: 'number' },
+    '@body': {
+      '@kind': 'context',
+      result: 'amount * taxRate',
+    },
+  },
+};
+
+const service = new DecisionService(model);
+
+// Execute a specific function — pass its arguments as request bindings
+const tax = service.execute('calculateTax', { amount: 100 });
+// { result: 21 }
+```
+
+### Executing a ruleset
+
+```typescript
+const service = new DecisionService(`{
+    ruleset risk(age: number, income: number): {
+        hitPolicy: "first-match"
+        rules: [
+            { when: { age: 18..25, income: < 30000 }, then: { level: "high",   limit: 1000  } }
+            { when: { age: 18..25, income: >= 30000 }, then: { level: "medium", limit: 5000  } }
+            { when: { age: > 25 },                     then: { level: "low",    limit: 20000 } }
+        ]
+        default: { level: "none", limit: 0 }
+    }
+    decision: risk(age: applicant.age, income: applicant.income)
+}`);
+
+const result = service.execute('decision', { applicant: { age: 23, income: 25000 } });
+// { level: "high", limit: 1000 }
+```
+
+### Error handling
+
+Every execution or model error is a structured `PortableError` — never a plain string.
+
+```typescript
+import { DecisionService } from '@edgerules/node';
+import type { PortableError } from '@edgerules/portable';
+
+try {
+  service.execute('unknownField');
+} catch (err) {
+  const error = err as PortableError;
+  console.error(error.type);     // "EntryNotFound"
+  console.error(error.message);  // human-readable, safe to surface
+  console.error(error.path);     // "unknownField"
+}
+```
+
+| `error.type` | Meaning |
+|---|---|
+| `EntryNotFound` | Path does not exist in the model |
+| `WrongFieldPath` | Invalid path, out-of-bounds array index |
+| `Parse` | Expression string failed to parse |
+| `Linking` | Type mismatch or broken reference |
+| `Execution` | Runtime error during evaluation |
+
+---
+
+## Mutable / Development Usage
+
+Use the `./mutable` subpath import to access `MutableDecisionService`, which adds CRUD operations on top of execution.
+This build is intended for IDEs, rule editors, and test tooling — **not** for production traffic.
+
+```typescript
+import { MutableDecisionService } from '@edgerules/node/mutable';
+
+const service = new MutableDecisionService(`{
+    taxRate: 0.21
+    tax: amount * taxRate
+}`);
+
+// Read a node enriched with linked type information
+const node = service.get('taxRate');
+// { "@kind": "expression", "expression": 0.21, "type": "number", "readOnly": true }
+
+// Update a field at runtime — the engine relinks lazily on the next execute
+service.set('taxRate', 0.25);
+
+// Read the entire model snapshot
+const model = service.get('*');
+
+// Add a new typed input
+service.set('amount', { '@kind': 'type', type: 'number', required: true });
+
+// Remove a field
+service.remove('taxRate');
+
+// Rename a field
+service.rename('tax', 'vat');
+```
+
+### `get` filters
+
+```typescript
+// Default FIELDS view — returns expressions, typed holes, and function schemas
+service.get('isEligible');
+
+// Full function definition (body included)
+service.get('isEligible', 'FUNCTION_DEFINITIONS');
+
+// Type definition
+service.get('Customer', 'TYPE_DEFINITIONS');
+
+// Everything at once
+service.get('*', 'ALL');
+```
+
+---
+
+## API Reference
+
+### `DecisionService`
+
+| Method | Description |
+|---|---|
+| `new DecisionService(model)` | Create from DSL string or `PortableRootContext` |
+| `execute(method, args?)` | Evaluate `method` (field path, function, or `"*"`) against optional request bindings |
+
+### `MutableDecisionService` (dev build)
+
+Inherits `execute` and adds:
+
+| Method | Description |
+|---|---|
+| `get(path, filter?)` | Read a node enriched with inferred types |
+| `set(path, node)` | Write an expression, typed hole, function, type, or context |
+| `remove(path)` | Delete an entry |
+| `rename(oldPath, newPath)` | Rename an entry within its context |
+
+---
+
+## Related packages
+
+- [`@edgerules/web`](https://www.npmjs.com/package/@edgerules/web) — same API for the browser
+- [`@edgerules/portable`](https://www.npmjs.com/package/@edgerules/portable) — Portable JSON type definitions

package/dist/_core/completions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One completion option from the dev WASM build's `completions()` export.
+ *
+ * A structural superset of `@codemirror/autocomplete`'s `Completion`: `label` is the text to
+ * insert, `type` the icon category CodeMirror renders, and `detail` an optional short hint shown
+ * after the label (a built-in's signature, a member's declared type).
+ */
+export interface EditorCompletion {
+    label: string;
+    type: 'variable' | 'function' | 'type' | 'keyword' | 'property' | 'constant';
+    detail?: string;
+}
+/**
+ * A completion query result, directly usable as a CodeMirror `CompletionResult`.
+ *
+ * `from`/`to` delimit the identifier prefix being typed (UTF-16 code units into the document,
+ * already converted from the engine's UTF-8 byte offsets), so CodeMirror replaces the right range;
+ * an empty range at the cursor means no prefix. `options` are rank-ordered — user-scope names,
+ * then built-ins, then keywords — and unfiltered: CodeMirror's own fuzzy matcher filters by the
+ * typed prefix.
+ */
+export interface EditorCompletionResult {
+    from: number;
+    to: number;
+    options: EditorCompletion[];
+}
+/**
+ * Parses the raw JSON emitted by the WASM `completions()` export and converts the replace range
+ * from UTF-8 byte offsets to UTF-16 code-unit offsets against the same `code` string, keeping
+ * `from <= to` and both within the document.
+ */
+export declare function toEditorCompletions(rawJson: string, code: string): EditorCompletionResult;

package/dist/_core/completions.js

@@ -0,0 +1,13 @@
+import { byteToUtf16Mapper } from './offsets.js';
+/**
+ * Parses the raw JSON emitted by the WASM `completions()` export and converts the replace range
+ * from UTF-8 byte offsets to UTF-16 code-unit offsets against the same `code` string, keeping
+ * `from <= to` and both within the document.
+ */
+export function toEditorCompletions(rawJson, code) {
+    const raw = JSON.parse(rawJson);
+    const toUtf16 = byteToUtf16Mapper(code);
+    const from = toUtf16(raw.from);
+    const to = Math.max(from, toUtf16(raw.to));
+    return { from, to, options: raw.options };
+}

package/dist/_core/diagnostics.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A structured diagnostic from the dev WASM build's `diagnostics()` export.
+ *
+ * The shape is a structural superset of `@codemirror/lint`'s `Diagnostic`, so an editor can pass
+ * these straight to a CodeMirror linter callback: `from`/`to` are document positions in UTF-16
+ * code units (already converted from the engine's UTF-8 byte offsets and clamped to the document),
+ * `severity` matches CodeMirror's union, and `source`/`code` fill the optional fields of the same
+ * names. A diagnostic whose location could not be resolved (a linker error with no span) arrives
+ * as `from = to = 0` — render it document-wide or as a gutter marker.
+ */
+export interface EditorDiagnostic {
+    from: number;
+    to: number;
+    severity: 'error';
+    source: 'parser' | 'linker';
+    /** Stable machine code: a `ParseErrorKind` name (`"UnexpectedToken"`) or a linker `Exxx` code. */
+    code?: string;
+    message: string;
+}
+/**
+ * Parses the raw JSON emitted by the WASM `diagnostics()` export and converts every span from
+ * UTF-8 byte offsets to UTF-16 code-unit offsets against the same `code` string, keeping
+ * `from <= to` and both within the document.
+ */
+export declare function toEditorDiagnostics(rawJson: string, code: string): EditorDiagnostic[];

package/dist/_core/diagnostics.js

@@ -0,0 +1,15 @@
+import { byteToUtf16Mapper } from './offsets.js';
+/**
+ * Parses the raw JSON emitted by the WASM `diagnostics()` export and converts every span from
+ * UTF-8 byte offsets to UTF-16 code-unit offsets against the same `code` string, keeping
+ * `from <= to` and both within the document.
+ */
+export function toEditorDiagnostics(rawJson, code) {
+    const raw = JSON.parse(rawJson);
+    const toUtf16 = byteToUtf16Mapper(code);
+    return raw.map((diagnostic) => {
+        const from = toUtf16(diagnostic.from);
+        const to = Math.max(from, toUtf16(diagnostic.to));
+        return { ...diagnostic, from, to };
+    });
+}

package/dist/_core/mutable-service.d.ts

@@ -1,5 +1,7 @@
 import type { PortableError, PortableNode, PortableRootContext } from '@edgerules/portable';
-import type { DecisionServiceWasmCtor, MutableDecisionServiceWasmInstance } from './wasm-types.js';
+import type { MutableDecisionServiceWasmCtor, MutableDecisionServiceWasmInstance } from './wasm-types.js';
+import { type EditorDiagnostic } from './diagnostics.js';
+import { type EditorCompletionResult } from './completions.js';
 /**
  * Binds `MutableDecisionService` to a specific platform's dev wasm-pack class. Mirrors
  * `createDecisionService` (Clarification 8) but for the CRUD-enabled dev WASM build.
@@ -8,7 +10,7 @@ import type { DecisionServiceWasmCtor, MutableDecisionServiceWasmInstance } from
  * deliberately non-generic (see Clarification 14) — inheriting them unmodified would construct a base
  * `DecisionService`, not a `MutableDecisionService`, losing `set`/`remove`/`rename` at runtime.
  */
-export declare function createMutableDecisionService<TInstance extends MutableDecisionServiceWasmInstance>(WasmClass: DecisionServiceWasmCtor<TInstance>): {
+export declare function createMutableDecisionService<TInstance extends MutableDecisionServiceWasmInstance>(WasmClass: MutableDecisionServiceWasmCtor<TInstance>): {
     new (wasm: TInstance): {
         set(path: string, node: PortableNode): PortableNode | PortableError;
         remove(path: string): void | PortableError;
@@ -29,6 +31,19 @@ export declare function createMutableDecisionService<TInstance extends MutableDe
         toPortable(): PortableRootContext;
         [Symbol.dispose](): void;
     };
+    /**
+     * Parses and links `code` without constructing a service, returning structured,
+     * CodeMirror-compatible diagnostics (empty when the source is valid). Positions are
+     * UTF-16 code units into `code`, ready to use as editor document offsets.
+     */
+    diagnostics(code: string): EditorDiagnostic[];
+    /**
+     * Computes completion options for the cursor at UTF-16 document position `pos` in `code`,
+     * in the shape of `@codemirror/autocomplete`'s `CompletionResult`. Works on syntactically
+     * broken source (the engine parses leniently) and never throws for arbitrary input; the
+     * worst case is an empty `options` list.
+     */
+    completions(code: string, pos: number): EditorCompletionResult;
     fromPortable(model: PortableRootContext): {
         set(path: string, node: PortableNode): PortableNode | PortableError;
         remove(path: string): void | PortableError;

package/dist/_core/mutable-service.js

@@ -1,5 +1,8 @@
 import { createDecisionService } from './decision-service.js';
 import { toPortableError } from './errors.js';
+import { toEditorDiagnostics } from './diagnostics.js';
+import { toEditorCompletions } from './completions.js';
+import { utf16ToByteOffset } from './offsets.js';
 /**
  * Binds `MutableDecisionService` to a specific platform's dev wasm-pack class. Mirrors
  * `createDecisionService` (Clarification 8) but for the CRUD-enabled dev WASM build.
@@ -14,6 +17,23 @@ export function createMutableDecisionService(WasmClass) {
         static fromCode(code) {
             return new MutableDecisionService(WasmClass.from_code(code));
         }
+        /**
+         * Parses and links `code` without constructing a service, returning structured,
+         * CodeMirror-compatible diagnostics (empty when the source is valid). Positions are
+         * UTF-16 code units into `code`, ready to use as editor document offsets.
+         */
+        static diagnostics(code) {
+            return toEditorDiagnostics(WasmClass.diagnostics(code), code);
+        }
+        /**
+         * Computes completion options for the cursor at UTF-16 document position `pos` in `code`,
+         * in the shape of `@codemirror/autocomplete`'s `CompletionResult`. Works on syntactically
+         * broken source (the engine parses leniently) and never throws for arbitrary input; the
+         * worst case is an empty `options` list.
+         */
+        static completions(code, pos) {
+            return toEditorCompletions(WasmClass.completions(code, utf16ToByteOffset(code, pos)), code);
+        }
         static fromPortable(model) {
             return new MutableDecisionService(WasmClass.from_portable(JSON.stringify(model)));
         }

package/dist/_core/offsets.d.ts

@@ -0,0 +1,21 @@
+/**
+ * UTF-8 byte offset ↔ UTF-16 code unit conversion for editor positions.
+ *
+ * The engine reports source ranges as byte offsets into the UTF-8 source; CodeMirror document
+ * positions are UTF-16 code units. For ASCII sources the two coincide and conversion is a clamp.
+ */
+/**
+ * Builds a UTF-8-byte-offset → UTF-16-code-unit-offset mapper for `code`.
+ *
+ * For non-ASCII sources a per-code-point offset table is built once and each lookup binary-searches
+ * it. Offsets that fall inside a multi-byte sequence (impossible for well-formed engine spans) or
+ * past the end resolve to the nearest boundary.
+ */
+export declare function byteToUtf16Mapper(code: string): (byteOffset: number) => number;
+/**
+ * Converts a single UTF-16 code-unit position in `code` to a UTF-8 byte offset — the reverse
+ * direction of {@link byteToUtf16Mapper}, as a one-shot walk (completion sends one position per
+ * request, so no table is needed). Positions inside a surrogate pair or past the end resolve to
+ * the nearest code-point boundary.
+ */
+export declare function utf16ToByteOffset(code: string, position: number): number;

package/dist/_core/offsets.js

@@ -0,0 +1,73 @@
+/**
+ * UTF-8 byte offset ↔ UTF-16 code unit conversion for editor positions.
+ *
+ * The engine reports source ranges as byte offsets into the UTF-8 source; CodeMirror document
+ * positions are UTF-16 code units. For ASCII sources the two coincide and conversion is a clamp.
+ */
+/**
+ * Builds a UTF-8-byte-offset → UTF-16-code-unit-offset mapper for `code`.
+ *
+ * For non-ASCII sources a per-code-point offset table is built once and each lookup binary-searches
+ * it. Offsets that fall inside a multi-byte sequence (impossible for well-formed engine spans) or
+ * past the end resolve to the nearest boundary.
+ */
+export function byteToUtf16Mapper(code) {
+    // eslint-disable-next-line no-control-regex
+    if (!/[^\x00-\x7f]/.test(code)) {
+        return (byteOffset) => Math.max(0, Math.min(byteOffset, code.length));
+    }
+    const byteStarts = [];
+    const utf16Starts = [];
+    let byteOffset = 0;
+    let utf16Offset = 0;
+    for (const char of code) {
+        byteStarts.push(byteOffset);
+        utf16Starts.push(utf16Offset);
+        const codePoint = char.codePointAt(0) ?? 0;
+        byteOffset += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
+        utf16Offset += char.length;
+    }
+    byteStarts.push(byteOffset);
+    utf16Starts.push(utf16Offset);
+    return (target) => {
+        let low = 0;
+        let high = byteStarts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if (byteStarts[mid] <= target) {
+                low = mid;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return utf16Starts[low];
+    };
+}
+/**
+ * Converts a single UTF-16 code-unit position in `code` to a UTF-8 byte offset — the reverse
+ * direction of {@link byteToUtf16Mapper}, as a one-shot walk (completion sends one position per
+ * request, so no table is needed). Positions inside a surrogate pair or past the end resolve to
+ * the nearest code-point boundary.
+ */
+export function utf16ToByteOffset(code, position) {
+    // eslint-disable-next-line no-control-regex
+    if (!/[^\x00-\x7f]/.test(code)) {
+        return Math.max(0, Math.min(position, code.length));
+    }
+    const clamped = Math.max(0, Math.min(position, code.length));
+    let byteOffset = 0;
+    let utf16Offset = 0;
+    for (const char of code) {
+        if (utf16Offset + char.length > clamped) {
+            break;
+        }
+        const codePoint = char.codePointAt(0) ?? 0;
+        byteOffset += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
+        utf16Offset += char.length;
+        if (utf16Offset === clamped) {
+            break;
+        }
+    }
+    return byteOffset;
+}

package/dist/_core/wasm-types.d.ts

@@ -18,3 +18,12 @@ export interface DecisionServiceWasmCtor<TInstance extends DecisionServiceWasmIn
     from_code(code: string): TInstance;
     from_portable(json: string): TInstance;
 }
+/**
+ * Ctor surface of the dev (`mutable_ds` + `analyzer`) WASM builds, which additionally export the
+ * static `diagnostics` and `completions` language-tooling entry points. Production builds
+ * deliberately lack both.
+ */
+export interface MutableDecisionServiceWasmCtor<TInstance extends MutableDecisionServiceWasmInstance> extends DecisionServiceWasmCtor<TInstance> {
+    diagnostics(code: string): string;
+    completions(code: string, offset: number): string;
+}

package/dist/mutable.d.ts

@@ -20,6 +20,8 @@ export declare const MutableDecisionService: {
         toPortable(): import("@edgerules/portable").PortableRootContext;
         [Symbol.dispose](): void;
     };
+    diagnostics(code: string): import("./mutable.js").EditorDiagnostic[];
+    completions(code: string, pos: number): import("./mutable.js").EditorCompletionResult;
     fromPortable(model: import("@edgerules/portable").PortableRootContext): {
         set(path: string, node: import("@edgerules/portable").PortableNode): import("@edgerules/portable").PortableNode | import("@edgerules/portable").PortableError;
         remove(path: string): void | import("@edgerules/portable").PortableError;
@@ -33,4 +35,6 @@ export declare const MutableDecisionService: {
 };
 export type MutableDecisionService = InstanceType<typeof MutableDecisionService>;
 export type { GetFilter } from './_core/decision-service.js';
+export type { EditorDiagnostic } from './_core/diagnostics.js';
+export type { EditorCompletion, EditorCompletionResult } from './_core/completions.js';
 export type { PortableError, PortableNode, PortableRootContext } from '@edgerules/portable';

package/dist/wasm/dev/edgerules_wasm.d.ts

@@ -8,6 +8,38 @@ export class DecisionServiceWASM {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Computes code-completion options for the cursor at UTF-8 byte `offset`
+     * into `code`, returning JSON `{from, to, options: [{label, type,
+     * detail?}]}` — the shape of `@codemirror/autocomplete`'s
+     * `CompletionResult`. `from`/`to` delimit the identifier prefix being
+     * typed (byte offsets; the JS wrapper converts to UTF-16) and `options`
+     * are rank-ordered: user-scope names, then built-ins, then keywords.
+     *
+     * Works on syntactically broken source (lenient parse) and never throws
+     * for arbitrary input; the worst case is an empty options list.
+     *
+     * Dev/IDE builds only (`analyzer`): production packages stay
+     * execution-only and never link this code in.
+     */
+    static completions(code: string, offset: number): string;
+    /**
+     * Parses and links `code`, returning a JSON array of structured
+     * diagnostics — empty when the source is valid.
+     *
+     * Each diagnostic is `{severity, source, code?, message, from, to}` with
+     * `from`/`to` as UTF-8 byte offsets into `code` (start/end exclusive).
+     * Parse failures report every collected `ParseError` with its own span;
+     * a link failure reports the single `LinkerError`, resolved to the
+     * offending definition's span via `EdgeRulesModel::span_of(node_id)`.
+     * Errors that carry no `node_id` (or an id allocated outside the parser)
+     * degrade to `from = to = 0` — the editor maps that to a whole-document
+     * diagnostic.
+     *
+     * Dev/IDE builds only (`analyzer`): production packages stay
+     * execution-only and never link this code in.
+     */
+    static diagnostics(code: string): string;
     /**
      * Executes a function defined in the model, or evaluates a field by path.
      *

package/dist/wasm/dev/edgerules_wasm.js

@@ -21,6 +21,93 @@ class DecisionServiceWASM {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_decisionservicewasm_free(ptr, 0);
     }
+    /**
+     * Computes code-completion options for the cursor at UTF-8 byte `offset`
+     * into `code`, returning JSON `{from, to, options: [{label, type,
+     * detail?}]}` — the shape of `@codemirror/autocomplete`'s
+     * `CompletionResult`. `from`/`to` delimit the identifier prefix being
+     * typed (byte offsets; the JS wrapper converts to UTF-16) and `options`
+     * are rank-ordered: user-scope names, then built-ins, then keywords.
+     *
+     * Works on syntactically broken source (lenient parse) and never throws
+     * for arbitrary input; the worst case is an empty options list.
+     *
+     * Dev/IDE builds only (`analyzer`): production packages stay
+     * execution-only and never link this code in.
+     * @param {string} code
+     * @param {number} offset
+     * @returns {string}
+     */
+    static completions(code, offset) {
+        let deferred3_0;
+        let deferred3_1;
+        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;
+            wasm.decisionservicewasm_completions(retptr, ptr0, len0, offset);
+            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);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Parses and links `code`, returning a JSON array of structured
+     * diagnostics — empty when the source is valid.
+     *
+     * Each diagnostic is `{severity, source, code?, message, from, to}` with
+     * `from`/`to` as UTF-8 byte offsets into `code` (start/end exclusive).
+     * Parse failures report every collected `ParseError` with its own span;
+     * a link failure reports the single `LinkerError`, resolved to the
+     * offending definition's span via `EdgeRulesModel::span_of(node_id)`.
+     * Errors that carry no `node_id` (or an id allocated outside the parser)
+     * degrade to `from = to = 0` — the editor maps that to a whole-document
+     * diagnostic.
+     *
+     * Dev/IDE builds only (`analyzer`): production packages stay
+     * execution-only and never link this code in.
+     * @param {string} code
+     * @returns {string}
+     */
+    static diagnostics(code) {
+        let deferred3_0;
+        let deferred3_1;
+        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;
+            wasm.decisionservicewasm_diagnostics(retptr, ptr0, len0);
+            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);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Executes a function defined in the model, or evaluates a field by path.
      *

package/dist/wasm/dev/edgerules_wasm_bg.wasm.d.ts

@@ -2,6 +2,8 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_decisionservicewasm_free: (a: number, b: number) => void;
+export const decisionservicewasm_completions: (a: number, b: number, c: number, d: number) => void;
+export const decisionservicewasm_diagnostics: (a: number, b: number, c: number) => void;
 export const decisionservicewasm_execute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const decisionservicewasm_from_code: (a: number, b: number, c: number) => void;
 export const decisionservicewasm_from_portable: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@edgerules/node",
-  "version": "0.0.0-alpha.202607061133",
+  "version": "0.0.0-alpha.202607071338",
   "type": "module",
   "description": "EdgeRules decision service for Node.js.",
   "dependencies": {
-    "@edgerules/portable": "0.0.0-alpha.202607061133"
+    "@edgerules/portable": "0.0.0-alpha.202607071338"
   },
   "devDependencies": {
     "@edgerules/core": "*",