@lemmabase/lemma-engine 0.8.11

package/lemma.js

@@ -0,0 +1,23 @@
+/**
+ * @lemmabase/lemma-engine — public entry.
+ * Glue: lemma.bindings.js (wasm-pack output, renamed by build).
+ */
+import initWasm, * as bindings from './lemma.bindings.js';
+
+let wasmReady = null;
+
+export async function init() {
+  if (wasmReady === null) wasmReady = initWasm();
+  return wasmReady;
+}
+
+export function initSync(module) {
+  return bindings.initSync(module);
+}
+
+export async function Lemma() {
+  await init();
+  return new bindings.Engine();
+}
+
+export const Engine = bindings.Engine;

package/lemma_bg.wasm.d.ts

@@ -0,0 +1,36 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_serverconfig_free: (a: number, b: number) => void;
+export const serve: (a: number) => number;
+export const serverconfig_new: (a: number, b: number) => number;
+export const __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+export const __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+export const __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+export const intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+export const intounderlyingbytesource_cancel: (a: number) => void;
+export const intounderlyingbytesource_pull: (a: number, b: number) => number;
+export const intounderlyingbytesource_start: (a: number, b: number) => void;
+export const intounderlyingbytesource_type: (a: number) => number;
+export const intounderlyingsink_abort: (a: number, b: number) => number;
+export const intounderlyingsink_close: (a: number) => number;
+export const intounderlyingsink_write: (a: number, b: number) => number;
+export const intounderlyingsource_cancel: (a: number) => void;
+export const intounderlyingsource_pull: (a: number, b: number) => number;
+export const __wbg_engine_free: (a: number, b: number) => void;
+export const wasmengine_format: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmengine_invert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+export const wasmengine_list: (a: number, b: number) => void;
+export const wasmengine_load: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmengine_new: () => number;
+export const wasmengine_run: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const wasmengine_schema: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const __wasm_bindgen_func_elem_10702: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2761: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_10709: (a: number, b: number, c: number, d: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_export5: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;

package/lsp-client.js

@@ -0,0 +1,325 @@
+/**
+ * LSP client for the Lemma WASM playground.
+ *
+ * Handles LSP JSON-RPC protocol framing (Content-Length headers),
+ * stream plumbing for the WASM LSP server, and Monaco marker updates.
+ */
+
+import { serve, ServerConfig } from './lsp.js';
+
+// ---------------------------------------------------------------------------
+// Async channel: a simple queue that backs an AsyncIterator for the server.
+// ---------------------------------------------------------------------------
+
+/**
+ * Queue-backed channel that implements AsyncIterable (Symbol.asyncIterator)
+ * so Rust js_sys::AsyncIterator can consume it. Yields Uint8Array chunks.
+ */
+function createChannel() {
+    const queue = [];
+    let waiting = null;
+    let closed = false;
+
+    const channel = {
+        send(data) {
+            if (closed) return;
+            if (waiting) {
+                const resolve = waiting;
+                waiting = null;
+                resolve({ value: data, done: false });
+            } else {
+                queue.push(data);
+            }
+        },
+        close() {
+            closed = true;
+            if (waiting) {
+                const resolve = waiting;
+                waiting = null;
+                resolve({ value: undefined, done: true });
+            }
+        },
+        next() {
+            if (queue.length > 0) {
+                return Promise.resolve({ value: queue.shift(), done: false });
+            }
+            if (closed) {
+                return Promise.resolve({ value: undefined, done: true });
+            }
+            return new Promise(function (resolve) { waiting = resolve; });
+        },
+    };
+    channel[Symbol.asyncIterator] = function () { return this; };
+    return channel;
+}
+
+// ---------------------------------------------------------------------------
+// LSP protocol framing
+// ---------------------------------------------------------------------------
+
+const HEADER_SEPARATOR = '\r\n\r\n';
+const CONTENT_LENGTH_RE = /Content-Length:\s*(\d+)/i;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+function encodeMessage(json) {
+    const body = JSON.stringify(json);
+    const bodyBytes = encoder.encode(body);
+    const header = 'Content-Length: ' + bodyBytes.byteLength + HEADER_SEPARATOR;
+    const headerBytes = encoder.encode(header);
+    const frame = new Uint8Array(headerBytes.byteLength + bodyBytes.byteLength);
+    frame.set(headerBytes, 0);
+    frame.set(bodyBytes, headerBytes.byteLength);
+    return frame;
+}
+
+// ---------------------------------------------------------------------------
+// LSP Client
+// ---------------------------------------------------------------------------
+
+export class LspClient {
+    /**
+     * @param {object} monacoInstance  The `monaco` global (for setModelMarkers)
+     */
+    constructor(monacoInstance) {
+        this._monaco = monacoInstance;
+        this._nextId = 1;
+        this._pending = new Map();
+        this._diagnosticsCallback = null;
+        this._channel = null;
+        this._receiveBuffer = new Uint8Array(0);
+        this._running = false;
+    }
+
+    /**
+     * Launch the WASM LSP server. Uses bundled serve/ServerConfig unless overridden.
+     * @param {Function} [serveFn]  Optional; defaults to bundled LSP serve
+     * @param {Function} [ServerConfigCls]  Optional; defaults to bundled ServerConfig
+     */
+    async start(serveFn, ServerConfigCls) {
+        const runServe = serveFn ?? serve;
+        const RunConfig = ServerConfigCls ?? ServerConfig;
+
+        this._channel = createChannel();
+
+        const self = this;
+
+        const serverToClient = new WritableStream({
+            write(chunk) {
+                if (chunk instanceof Uint8Array) {
+                    self._onServerBytes(chunk);
+                }
+            },
+        });
+
+        const config = new RunConfig(this._channel, serverToClient);
+        this._running = true;
+
+        runServe(config).then(function () {
+            self._running = false;
+        }).catch(function (err) {
+            console.error('LSP server stopped:', err);
+            self._running = false;
+        });
+    }
+
+    /**
+     * Send the LSP initialize request and the initialized notification.
+     */
+    async initialize() {
+        await this.sendRequest('initialize', {
+            processId: null,
+            capabilities: {},
+            rootUri: null,
+        });
+        this.sendNotification('initialized', {});
+    }
+
+    /**
+     * Notify the server that a file was opened.
+     */
+    didOpen(uri, languageId, version, text) {
+        this.sendNotification('textDocument/didOpen', {
+            textDocument: { uri: uri, languageId: languageId, version: version, text: text },
+        });
+    }
+
+    /**
+     * Notify the server that a file changed (full sync).
+     */
+    didChange(uri, version, text) {
+        this.sendNotification('textDocument/didChange', {
+            textDocument: { uri: uri, version: version },
+            contentChanges: [{ text: text }],
+        });
+    }
+
+    /**
+     * Request textDocument/formatting from the server.
+     * Returns an array of TextEdit.
+     */
+    async formatting(uri, tabSize, insertSpaces) {
+        return this.sendRequest('textDocument/formatting', {
+            textDocument: { uri: uri },
+            options: { tabSize: tabSize, insertSpaces: insertSpaces },
+        });
+    }
+
+    /**
+     * Request textDocument/semanticTokens/full from the server.
+     * Returns { data: number[] } or null.
+     */
+    async semanticTokensFull(uri) {
+        return this.sendRequest('textDocument/semanticTokens/full', {
+            textDocument: { uri: uri },
+        });
+    }
+
+    /**
+     * Register a callback for textDocument/publishDiagnostics notifications.
+     * @param {Function} callback  Receives (uri, diagnostics)
+     */
+    onDiagnostics(callback) {
+        this._diagnosticsCallback = callback;
+    }
+
+    /**
+     * Send a JSON-RPC request and return a Promise for the result.
+     */
+    sendRequest(method, params) {
+        const id = this._nextId++;
+        const msg = { jsonrpc: '2.0', id: id, method: method, params: params };
+        this._send(msg);
+        const pending = this._pending;
+        return new Promise(function (resolve, reject) {
+            pending.set(id, { resolve: resolve, reject: reject });
+        });
+    }
+
+    /**
+     * Send a JSON-RPC notification (no response expected).
+     */
+    sendNotification(method, params) {
+        const msg = { jsonrpc: '2.0', method: method, params: params };
+        this._send(msg);
+    }
+
+    /**
+     * Stop the LSP server by closing the input channel.
+     */
+    stop() {
+        if (this._channel) {
+            this._channel.close();
+        }
+        this._running = false;
+    }
+
+    // -- internals --
+
+    _send(json) {
+        if (!this._channel) return;
+        this._channel.send(encodeMessage(json));
+    }
+
+    _onServerBytes(chunk) {
+        const merged = new Uint8Array(this._receiveBuffer.byteLength + chunk.byteLength);
+        merged.set(this._receiveBuffer, 0);
+        merged.set(chunk, this._receiveBuffer.byteLength);
+        this._receiveBuffer = merged;
+
+        this._drainFrames();
+    }
+
+    _drainFrames() {
+        while (true) {
+            const buf = this._receiveBuffer;
+            const text = decoder.decode(buf);
+
+            const sepIndex = text.indexOf(HEADER_SEPARATOR);
+            if (sepIndex === -1) break;
+
+            const headerPart = text.substring(0, sepIndex);
+            const match = CONTENT_LENGTH_RE.exec(headerPart);
+            if (!match) {
+                console.error('LSP: missing Content-Length in header:', headerPart);
+                break;
+            }
+            const contentLength = parseInt(match[1], 10);
+
+            const headerByteLength = encoder.encode(headerPart + HEADER_SEPARATOR).byteLength;
+            const totalNeeded = headerByteLength + contentLength;
+
+            if (buf.byteLength < totalNeeded) break;
+
+            const bodyBytes = buf.slice(headerByteLength, totalNeeded);
+            this._receiveBuffer = buf.slice(totalNeeded);
+
+            const bodyText = decoder.decode(bodyBytes);
+            let json;
+            try {
+                json = JSON.parse(bodyText);
+            } catch (e) {
+                console.error('LSP: failed to parse JSON body:', bodyText, e);
+                continue;
+            }
+
+            this._handleMessage(json);
+        }
+    }
+
+    _handleMessage(msg) {
+        if (msg.id !== undefined && msg.id !== null && this._pending.has(msg.id)) {
+            const entry = this._pending.get(msg.id);
+            this._pending.delete(msg.id);
+            if (msg.error) {
+                entry.reject(msg.error);
+            } else {
+                entry.resolve(msg.result);
+            }
+            return;
+        }
+
+        if (msg.method === 'textDocument/publishDiagnostics' && msg.params) {
+            if (this._diagnosticsCallback) {
+                this._diagnosticsCallback(msg.params.uri, msg.params.diagnostics || []);
+            }
+            return;
+        }
+    }
+
+    // -- Monaco integration --
+
+    /**
+     * Convert LSP diagnostics to Monaco markers and set them on the given model.
+     *
+     * @param {object} model       Monaco editor model
+     * @param {Array}  diagnostics LSP Diagnostic[]
+     */
+    setMonacoMarkers(model, diagnostics) {
+        const monaco = this._monaco;
+        if (!monaco) return;
+
+        const markers = diagnostics.map(function (d) {
+            return {
+                startLineNumber: d.range.start.line + 1,
+                startColumn: d.range.start.character + 1,
+                endLineNumber: d.range.end.line + 1,
+                endColumn: d.range.end.character + 1,
+                message: d.message,
+                severity: lspSeverityToMonaco(monaco, d.severity),
+            };
+        });
+
+        monaco.editor.setModelMarkers(model, 'lemma-lsp', markers);
+    }
+}
+
+function lspSeverityToMonaco(monaco, severity) {
+    switch (severity) {
+        case 1: return monaco.MarkerSeverity.Error;
+        case 2: return monaco.MarkerSeverity.Warning;
+        case 3: return monaco.MarkerSeverity.Info;
+        case 4: return monaco.MarkerSeverity.Hint;
+        default: return monaco.MarkerSeverity.Error;
+    }
+}

package/lsp.d.ts

@@ -0,0 +1 @@
+export { serve, ServerConfig } from './lemma.bindings.js';

package/lsp.js

@@ -0,0 +1,4 @@
+/**
+ * Browser LSP (streams). Call init() from package root first.
+ */
+export { serve, ServerConfig } from './lemma.bindings.js';

package/monaco.js

@@ -0,0 +1,80 @@
+/**
+ * Monaco Editor language registration for Lemma.
+ * Syntax highlighting is provided by the Rust LSP via semantic tokens.
+ */
+
+export const SEMANTIC_TOKEN_TYPES = [
+  'keyword',
+  'type',
+  'function',
+  'variable',
+  'number',
+  'string',
+  'comment',
+  'operator',
+  'enumMember',
+  'property',
+];
+
+export function registerLemmaLanguage(monaco) {
+  monaco.languages.register({ id: 'lemma' });
+
+  monaco.languages.setLanguageConfiguration('lemma', {
+    comments: { blockComment: ['"""', '"""'] },
+    brackets: [['(', ')'], ['[', ']']],
+    autoClosingPairs: [
+      { open: '(', close: ')' },
+      { open: '[', close: ']' },
+      { open: '"', close: '"' },
+    ],
+    surroundingPairs: [
+      { open: '(', close: ')' },
+      { open: '[', close: ']' },
+      { open: '"', close: '"' },
+    ],
+  });
+}
+
+/**
+ * Register LSP-backed providers for semantic tokens and formatting.
+ * Call after the LspClient has been initialized and didOpen sent.
+ * URI for each request is derived from model.uri (multi-file support).
+ *
+ * @param {object} monaco     The monaco-editor API object
+ * @param {object} lspClient  An initialized LspClient instance
+ */
+export function registerLspProviders(monaco, lspClient) {
+  monaco.languages.registerDocumentSemanticTokensProvider('lemma', {
+    getLegend() {
+      return { tokenTypes: SEMANTIC_TOKEN_TYPES, tokenModifiers: [] };
+    },
+    async provideDocumentSemanticTokens(model) {
+      const uri = model.uri.toString();
+      const result = await lspClient.semanticTokensFull(uri);
+      if (!result || !result.data) return null;
+      return { data: new Uint32Array(result.data) };
+    },
+    releaseDocumentSemanticTokens() {},
+  });
+
+  monaco.languages.registerDocumentFormattingEditProvider('lemma', {
+    async provideDocumentFormattingEdits(model) {
+      const uri = model.uri.toString();
+      const edits = await lspClient.formatting(
+        uri,
+        model.getOptions().tabSize,
+        model.getOptions().insertSpaces,
+      );
+      if (!Array.isArray(edits)) return [];
+      return edits.map(function (edit) {
+        return {
+          range: new monaco.Range(
+            edit.range.start.line + 1, edit.range.start.character + 1,
+            edit.range.end.line + 1, edit.range.end.character + 1,
+          ),
+          text: edit.newText,
+        };
+      });
+    },
+  });
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@lemmabase/lemma-engine",
+  "version": "0.8.11",
+  "description": "A language that means business. Also in the browser.",
+  "type": "module",
+  "main": "lemma.js",
+  "types": "lemma.d.ts",
+  "files": [
+    "lemma_bg.wasm",
+    "lemma.bindings.js",
+    "lemma.bindings.d.ts",
+    "lemma.js",
+    "lemma.d.ts",
+    "lsp.js",
+    "lsp.d.ts",
+    "lemma_bg.wasm.d.ts",
+    "lsp-client.js",
+    "monaco.js",
+    "esbuild.js",
+    "lemma.iife.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./lemma.js",
+    "./lsp": "./lsp.js",
+    "./lsp-client": "./lsp-client.js",
+    "./monaco": "./monaco.js",
+    "./iife": "./lemma.iife.js",
+    "./esbuild": "./esbuild.js"
+  },
+  "keywords": [
+    "lemma",
+    "rules-engine",
+    "business-rules",
+    "policy-engine",
+    "declarative",
+    "dsl",
+    "typed",
+    "wasm",
+    "webassembly",
+    "lsp",
+    "language-server",
+    "monaco-editor"
+  ],
+  "author": "Ben Rogmans <ben@amrai.nl>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lemma/lemma"
+  },
+  "homepage": "https://github.com/lemma/lemma",
+  "bugs": {
+    "url": "https://github.com/lemma/lemma/issues"
+  }
+}