@edgerules/web 0.0.0-alpha.202607061957 → 0.0.0-alpha.202607071338

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

@@ -22,6 +22,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;
@@ -35,4 +37,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.
      *
@@ -79,6 +111,8 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_decisionservicewasm_free: (a: number, b: number) => void;
+    readonly decisionservicewasm_completions: (a: number, b: number, c: number, d: number) => void;
+    readonly decisionservicewasm_diagnostics: (a: number, b: number, c: number) => void;
     readonly decisionservicewasm_execute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly decisionservicewasm_from_code: (a: number, b: number, c: number) => void;
     readonly decisionservicewasm_from_portable: (a: number, b: number, c: number) => void;

package/dist/wasm/dev/edgerules_wasm.js

@@ -22,6 +22,93 @@ export 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/web",
-  "version": "0.0.0-alpha.202607061957",
+  "version": "0.0.0-alpha.202607071338",
   "type": "module",
   "description": "EdgeRules decision service for the browser.",
   "dependencies": {
-    "@edgerules/portable": "0.0.0-alpha.202607061957"
+    "@edgerules/portable": "0.0.0-alpha.202607071338"
   },
   "devDependencies": {
     "@edgerules/core": "*",