@sanbus/galley-wasm 0.0.1

package/dist/ffi.js

@@ -0,0 +1,1115 @@
+/**
+ * WebAssembly adapter for the Galley JavaScript bindings: a `WasmPort`
+ * implementing the core `FfiPort` over a WASI reactor module built from
+ * `bindings/c/galley.h` (`zig build -Dwasm`, see `build.mjs`).
+ *
+ * Zero npm dependencies. The module is instantiated with a minimal
+ * in-TS `wasi_snapshot_preview1` stub (real `random_get`/`clock_time_get`,
+ * filesystem calls report unavailable — the parse path never touches the
+ * filesystem) plus an `env.galley_js_dispatch_id` import that forwards
+ * procedure-hook IDs to the core registry. All memory copying and integer
+ * normalization live here; all session logic lives in `@sanbus/galley-core`.
+ *
+ * Initialization is async (`await init()`), except under Node where the
+ * file can be read and instantiated synchronously — `Session` and the
+ * module-level queries auto-initialize there, so Node demos stay
+ * synchronous. Elsewhere (browsers) the gate throws `NeedInitError` until
+ * `await init()` completes. Views into wasm memory are never cached:
+ * `malloc` may grow memory and detach old views.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { GalleyError, dispatchProcedure, resolveArtifact, wasmArtifactFileName } from "@sanbus/galley-core";
+const LIBRARY_BASE = "galley-js-wasm";
+const WASI_NOSYS = 52;
+const WASI_BADF = 8;
+export class NeedInitError extends Error {
+    constructor(libraryPath) {
+        super(`galley-wasm: WebAssembly module${libraryPath ? ` for ${libraryPath}` : ""} is not initialized. ` +
+            `Call "await init()" (or "await init({ url })" / "init({ bytes })" in browsers) first.`);
+        this.name = "NeedInitError";
+    }
+}
+// --- instance cache (one module per grammar file) --------------------------
+const ports = new Map();
+let seededDefault = null;
+function isNode() {
+    return (typeof process !== "undefined" &&
+        typeof process.versions?.node === "string");
+}
+// --- library discovery (mirrors the Node adapter, `.wasm` names) -----------
+// One place, named up front: an explicit path or GALLEY_LIBRARY_PATH.
+// Anything else is a loud error, never a search.
+const BUILD_HINT = `Build it first: npx galley-js-wasm <language-dir>\n` +
+    `or set GALLEY_LIBRARY_PATH=/path/to/${wasmFileName()}`;
+export function wasmFileName(base = LIBRARY_BASE) {
+    return wasmArtifactFileName(base);
+}
+function exists(localPath) {
+    try {
+        fs.accessSync(localPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function findLibrary(explicit) {
+    return resolveArtifact(explicit, {
+        getEnv: (name) => process.env[name],
+        resolvePath: (candidate) => path.resolve(candidate),
+        existsSync: exists,
+        buildHint: BUILD_HINT,
+    });
+}
+// --- minimal WASI stub ------------------------------------------------------
+// Real entropy and clocks; filesystem calls report unavailable. The parse
+// path never touches the filesystem (`parseFile` is served by the host
+// reading the file into a buffer first).
+function makeWasiStub(getMemory) {
+    const view = () => new DataView(getMemory());
+    const bytes = () => new Uint8Array(getMemory());
+    const fail = () => WASI_NOSYS;
+    return {
+        random_get: (ptr, len) => {
+            crypto.getRandomValues(bytes().subarray(ptr, ptr + len));
+            return 0;
+        },
+        clock_res_get: (_id, resPtr) => {
+            view().setBigUint64(resPtr, 1n, true);
+            return 0;
+        },
+        clock_time_get: (_id, _precision, timePtr) => {
+            view().setBigUint64(timePtr, BigInt(Date.now()) * 1000000n, true);
+            return 0;
+        },
+        fd_write: (fd, iovs, iovsLen, nwrittenPtr) => {
+            try {
+                const dataView = view();
+                let written = 0;
+                const chunks = [];
+                for (let i = 0; i < iovsLen; i++) {
+                    const base = dataView.getUint32(iovs + i * 8, true);
+                    const len = dataView.getUint32(iovs + i * 8 + 4, true);
+                    chunks.push(bytes().slice(base, base + len));
+                    written += len;
+                }
+                if (fd === 1 || fd === 2) {
+                    const text = chunks.map((c) => new TextDecoder().decode(c)).join("");
+                    if (isNode()) {
+                        (fd === 1 ? process.stdout : process.stderr).write(text);
+                    }
+                    else {
+                        console.log(text);
+                    }
+                }
+                dataView.setUint32(nwrittenPtr, written, true);
+                return 0;
+            }
+            catch {
+                return WASI_NOSYS;
+            }
+        },
+        proc_exit: (code) => {
+            throw new Error(`galley-wasm: guest called proc_exit(${code})`);
+        },
+        // No preopened directories: BADF ends the preopen scan (NOSYS aborts libc init).
+        fd_prestat_get: () => WASI_BADF,
+        fd_fdstat_get: fail,
+        fd_filestat_get: fail,
+        fd_filestat_set_size: fail,
+        fd_filestat_set_times: fail,
+        fd_pread: fail,
+        fd_prestat_dir_name: fail,
+        fd_pwrite: fail,
+        fd_read: fail,
+        fd_seek: fail,
+        path_create_directory: fail,
+        path_filestat_get: fail,
+        path_filestat_set_times: fail,
+        path_link: fail,
+        path_open: fail,
+        path_readlink: fail,
+        path_remove_directory: fail,
+        path_rename: fail,
+        path_symlink: fail,
+        path_unlink_file: fail,
+        poll_oneoff: fail,
+        fd_sync: fail,
+        fd_readdir: fail,
+        fd_close: fail,
+    };
+}
+function makeImports(pending) {
+    return {
+        wasi_snapshot_preview1: makeWasiStub(() => {
+            if (pending.memory === null)
+                throw new Error("galley-wasm: memory unavailable");
+            return pending.memory;
+        }),
+        env: {
+            // Current builds import the ID entry; older modules import the
+            // name-carrying one. Both are always provided so either links.
+            galley_js_dispatch_id: (id, argsPtr) => {
+                const port = pending.port;
+                if (port === null)
+                    return;
+                port.dispatchFromGuestById(id, argsPtr);
+            },
+            galley_js_dispatch: (namePtr, nameLen, argsPtr) => {
+                const port = pending.port;
+                if (port === null)
+                    return;
+                port.dispatchFromGuest(namePtr, nameLen, argsPtr);
+            },
+        },
+    };
+}
+function adoptInstance(instance, wasmPath, pending) {
+    pending.memory = instance.exports.memory.buffer;
+    if (typeof instance.exports._initialize === "function") {
+        instance.exports._initialize();
+    }
+    const port = new WasmPort(instance.exports, wasmPath);
+    pending.port = port;
+    ports.set(wasmPath, port);
+    return port;
+}
+function instantiate(bytes, wasmPath) {
+    const pending = { port: null, memory: null };
+    const instance = new WebAssembly.Instance(new WebAssembly.Module(bytes), makeImports(pending));
+    return adoptInstance(instance, wasmPath, pending);
+}
+function loadBytesSync(options) {
+    if (options.bytes) {
+        return {
+            bytes: Uint8Array.from(options.bytes),
+            wasmPath: options.libraryPath ?? seededDefault ?? "<bytes>",
+        };
+    }
+    if (options.url !== undefined) {
+        throw new NeedInitError(options.libraryPath);
+    }
+    if (!isNode())
+        throw new NeedInitError(options.libraryPath);
+    // findLibrary throws MissingArtifactError naming the exact place.
+    const wasmPath = options.libraryPath ?? seededDefault ?? findLibrary();
+    return { bytes: Uint8Array.from(new Uint8Array(fs.readFileSync(wasmPath))), wasmPath };
+}
+/** Async entry point; the only way to initialize in browsers. */
+export async function init(options = {}) {
+    if (options.bytes) {
+        const wasmPath = options.libraryPath ?? seededDefault ?? "<bytes>";
+        instantiate(Uint8Array.from(options.bytes), wasmPath);
+        if (options.libraryPath === undefined)
+            seededDefault = wasmPath;
+        return;
+    }
+    if (options.url !== undefined) {
+        const response = await fetch(options.url);
+        if (!response.ok)
+            throw new Error(`galley-wasm: failed to fetch ${options.url}: ${response.status}`);
+        const wasmPath = options.libraryPath ?? seededDefault ?? String(options.url);
+        instantiate(new Uint8Array(await response.arrayBuffer()), wasmPath);
+        if (options.libraryPath === undefined)
+            seededDefault = wasmPath;
+        return;
+    }
+    if (!isNode())
+        throw new NeedInitError(options.libraryPath);
+    const { bytes, wasmPath } = loadBytesSync(options);
+    // Asynchronous compile for streaming-friendly startup; semantics match initSync.
+    const pending = { port: null, memory: null };
+    const instance = await WebAssembly.instantiate(await WebAssembly.compile(bytes), makeImports(pending));
+    adoptInstance(instance, wasmPath, pending);
+}
+/** Synchronous entry point; Node only (file read + `WebAssembly.Module`). */
+export function initSync(options = {}) {
+    const { bytes, wasmPath } = loadBytesSync(options);
+    instantiate(bytes, wasmPath);
+    if (options.libraryPath === undefined)
+        seededDefault = wasmPath;
+}
+/** Seed the default cache key (used by `init({ bytes })` without a path). */
+export function seedDefault(wasmPath) {
+    seededDefault = wasmPath;
+}
+function resolveKey(explicit) {
+    if (explicit)
+        return explicit;
+    if (seededDefault !== null)
+        return seededDefault;
+    if (!isNode())
+        throw new NeedInitError();
+    return findLibrary();
+}
+/**
+ * Single gate for every consumer: returns the initialized port for a
+ * grammar, auto-initializing synchronously under Node. Throws
+ * `NeedInitError` anywhere synchronous initialization is impossible.
+ */
+export function getWasmPort(libraryPath) {
+    const key = libraryPath ?? resolveKey();
+    const cached = ports.get(key);
+    if (cached)
+        return cached;
+    if (!isNode())
+        throw new NeedInitError(libraryPath);
+    const resolved = libraryPath ?? findLibrary();
+    const direct = ports.get(resolved);
+    if (direct)
+        return direct;
+    initSync(libraryPath ? { libraryPath: resolved } : {});
+    const port = ports.get(resolved) ?? ports.get(key);
+    if (!port)
+        throw new NeedInitError(libraryPath);
+    return port;
+}
+// --- helpers ----------------------------------------------------------------
+function isNegative(status) {
+    return status < 0n;
+}
+function toNumber(value) {
+    return Number(value);
+}
+/** Reinterpret a guest i64 as an unsigned u64 address (INVALID_NODE survives). */
+function asAddress(value) {
+    return BigInt.asUintN(64, value);
+}
+/** Encode a u64 address (possibly INVALID_NODE) as a guest i64. */
+function asI64(value) {
+    return BigInt.asIntN(64, value);
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+/**
+ * The wasm `FfiPort`: normalizes the reactor module's i32/i64 boundary
+ * into the structured values the core expects. Memory is allocated with
+ * the guest's `galley_js_malloc`/`galley_js_free`; every view is fresh
+ * because allocation may grow (and detach) memory.
+ */
+export class WasmPort {
+    wasm;
+    libraryPath;
+    constructor(wasm, libraryPath) {
+        this.wasm = wasm;
+        this.libraryPath = libraryPath;
+    }
+    /** Guest hook entry: decode the name and forward to the core registry. */
+    dispatchFromGuest(namePtr, nameLen, argsPtr) {
+        let name;
+        try {
+            name = textDecoder.decode(this.readBytes(namePtr, nameLen));
+        }
+        catch (error) {
+            console.error("galley procedure dispatch: failed to decode name", error);
+            return;
+        }
+        dispatchProcedure(name, argsPtr, this);
+    }
+    /** Guest hook entry (current builds): integer hook ID, no strings cross. */
+    dispatchFromGuestById(id, argsPtr) {
+        const name = this.procedureNames()[id];
+        if (name === undefined)
+            return;
+        dispatchProcedure(name, argsPtr, this);
+    }
+    #procedureNameTable = null;
+    procedureNames() {
+        if (this.#procedureNameTable !== null)
+            return this.#procedureNameTable;
+        const table = [];
+        if (typeof this.wasm.galley_js_procedure_count === "function" &&
+            typeof this.wasm.galley_js_procedure_name_ptr === "function" &&
+            typeof this.wasm.galley_js_procedure_name_len === "function") {
+            const n = this.wasm.galley_js_procedure_count();
+            for (let i = 0; i < n; i++) {
+                const ptrValue = this.wasm.galley_js_procedure_name_ptr(i);
+                if (ptrValue === 0)
+                    break;
+                table.push(textDecoder.decode(this.readBytes(ptrValue, this.wasm.galley_js_procedure_name_len(i))));
+            }
+        }
+        this.#procedureNameTable = table;
+        return table;
+    }
+    // -- memory -------------------------------------------------------------
+    memoryBytes() {
+        return new Uint8Array(this.wasm.memory.buffer);
+    }
+    dataView() {
+        return new DataView(this.wasm.memory.buffer);
+    }
+    malloc(len) {
+        const ptr = this.wasm.galley_js_malloc(len);
+        if (ptr === 0)
+            throw new Error("galley-wasm: out of memory");
+        return ptr;
+    }
+    free(ptr, len) {
+        if (len === 0)
+            return;
+        this.wasm.galley_js_free(ptr, len);
+    }
+    /** Copy guest bytes out (owned copy, valid after the next call). */
+    readBytes(ptr, len) {
+        if (ptr === 0 || len === 0)
+            return new Uint8Array(0);
+        return this.memoryBytes().slice(ptr, ptr + len);
+    }
+    readCString(ptr) {
+        if (ptr === 0)
+            return "";
+        const memory = this.memoryBytes();
+        let end = ptr;
+        while (memory[end] !== 0)
+            end++;
+        return textDecoder.decode(memory.subarray(ptr, end));
+    }
+    /** Copy host bytes in; zero-length inputs still get a non-null slot. */
+    writeBytes(data) {
+        const len = data.length;
+        const ptr = this.malloc(Math.max(len, 1));
+        if (len > 0)
+            this.memoryBytes().set(data, ptr);
+        return { ptr, len };
+    }
+    // -- module-level queries -----------------------------------------------
+    version() {
+        return this.readCString(this.wasm.galley_version());
+    }
+    parserType() {
+        return toNumber(this.wasm.galley_parser_type());
+    }
+    errorRecoveryMode() {
+        return toNumber(this.wasm.galley_error_recovery_mode());
+    }
+    hasAst() {
+        return this.wasm.galley_has_ast() !== 0;
+    }
+    hasProcedures() {
+        return this.wasm.galley_has_procedures() !== 0;
+    }
+    allowsNoAstTreeProcedures() {
+        return this.wasm.galley_allows_no_ast_tree_procedures() !== 0;
+    }
+    sourceRetentionEnabled() {
+        return this.wasm.galley_source_retention_enabled() !== 0;
+    }
+    hasPositionTracking() {
+        return this.wasm.galley_has_position_tracking() !== 0;
+    }
+    hasInputStreaming() {
+        return this.wasm.galley_has_input_streaming() !== 0;
+    }
+    usesVerbatim() {
+        return this.wasm.galley_uses_verbatim() !== 0;
+    }
+    stackOverflowRecoveryAvailable() {
+        return this.wasm.galley_stack_overflow_recovery_available() !== 0;
+    }
+    symbolCount() {
+        return toNumber(this.wasm.galley_symbol_count());
+    }
+    variableCount() {
+        return toNumber(this.wasm.galley_variable_count());
+    }
+    statusString(status) {
+        const ptr = this.wasm.galley_status_string(BigInt(status));
+        if (ptr === 0)
+            return null;
+        return this.readCString(ptr);
+    }
+    // -- sessions ------------------------------------------------------------
+    createSession(options) {
+        if (options === null) {
+            const handle = this.wasm.galley_session_create();
+            if (handle === 0)
+                return null;
+            return handle;
+        }
+        // GalleyCOptions layout (wasm32, little-endian): 5x i32/u32, pad, f64, u64.
+        const ptr = this.malloc(40);
+        try {
+            const view = this.dataView();
+            view.setInt32(ptr, options.maxErrors, true);
+            view.setInt32(ptr + 4, options.recoveryWindow, true);
+            view.setInt32(ptr + 8, options.stackOverflowRecovery, true);
+            view.setUint32(ptr + 12, options.syntaxErrorStackDepth, true);
+            view.setInt32(ptr + 16, options.verbosity, true);
+            view.setFloat64(ptr + 24, options.astPreallocationRatio, true);
+            view.setBigUint64(ptr + 32, options.astPreallocationCap, true);
+            const handle = this.wasm.galley_session_create_ex(ptr);
+            if (handle === 0)
+                return null;
+            return handle;
+        }
+        finally {
+            this.free(ptr, 40);
+        }
+    }
+    destroySession(handle) {
+        this.wasm.galley_session_destroy(handle);
+    }
+    setMessageOverride(handle, name, message) {
+        const nameBytes = textEncoder.encode(textDecoder.decode(name));
+        const messageBytes = textEncoder.encode(textDecoder.decode(message));
+        const nameSlot = this.writeBytes(nameBytes);
+        const messageSlot = this.writeBytes(messageBytes);
+        try {
+            return toNumber(this.wasm.galley_session_set_message_override(handle, nameSlot.ptr, nameSlot.len, messageSlot.ptr, messageSlot.len));
+        }
+        finally {
+            this.free(nameSlot.ptr, Math.max(nameSlot.len, 1));
+            this.free(messageSlot.ptr, Math.max(messageSlot.len, 1));
+        }
+    }
+    // -- parsing --------------------------------------------------------------
+    parse(handle, data) {
+        const slot = this.writeBytes(data);
+        try {
+            return toNumber(this.wasm.galley_parse(handle, slot.ptr, slot.len));
+        }
+        finally {
+            this.free(slot.ptr, Math.max(slot.len, 1));
+        }
+    }
+    parseFile(handle, filePath) {
+        // No guest filesystem: the host reads the file, then parses bytes.
+        // Mirrors the native `galley_error_io` (-11) contract on read failure.
+        let data;
+        try {
+            data = new Uint8Array(fs.readFileSync(filePath));
+        }
+        catch {
+            return -11;
+        }
+        return this.parse(handle, data);
+    }
+    lastPosition(handle) {
+        const out = this.malloc(8);
+        try {
+            const status = this.wasm.galley_last_position(handle, out, out + 4);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    // -- arena and navigation ---------------------------------------------------
+    nodeCount(handle) {
+        return toNumber(this.wasm.galley_node_count(handle));
+    }
+    reserveNodes(handle, capacity) {
+        return toNumber(this.wasm.galley_reserve_nodes(handle, asI64(capacity)));
+    }
+    nodeCapacity(handle) {
+        return toNumber(this.wasm.galley_node_capacity(handle));
+    }
+    rootNode(handle) {
+        return asAddress(this.wasm.galley_root_node(handle));
+    }
+    nodeValid(handle, node) {
+        return this.wasm.galley_node_is_valid(handle, asI64(node)) !== 0;
+    }
+    childCount(handle, node) {
+        return this.wasm.galley_node_child_count(handle, asI64(node));
+    }
+    firstChild(handle, node) {
+        return asAddress(this.wasm.galley_node_first_child(handle, asI64(node)));
+    }
+    lastChild(handle, node) {
+        return asAddress(this.wasm.galley_node_last_child(handle, asI64(node)));
+    }
+    nextSibling(handle, node) {
+        return asAddress(this.wasm.galley_node_next_sibling(handle, asI64(node)));
+    }
+    priorSibling(handle, node) {
+        return asAddress(this.wasm.galley_node_prior_sibling(handle, asI64(node)));
+    }
+    parent(handle, node) {
+        return asAddress(this.wasm.galley_node_parent(handle, asI64(node)));
+    }
+    treeSnapshot(handle) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const count = this.nodeCount(handle);
+            const empty = {
+                count,
+                parent: new BigUint64Array(0),
+                firstChild: new BigUint64Array(0),
+                next: new BigUint64Array(0),
+                childCount: new Uint32Array(0),
+                variable: new BigInt64Array(0),
+                spanStart: new BigUint64Array(0),
+                spanLen: new BigUint64Array(0),
+            };
+            if (count === 0)
+                return empty;
+            // Eight-byte columns first (parent, firstChild, next, spanStart,
+            // spanLen, variable), then the u32 childCount tail: every column
+            // stays naturally aligned for bulk typed-array copies.
+            const stride = count * 8;
+            const offParent = 0;
+            const offFirst = stride;
+            const offNext = stride * 2;
+            const offSpanStart = stride * 3;
+            const offSpanLen = stride * 4;
+            const offVariable = stride * 5;
+            const offChildCount = stride * 6;
+            const total = offChildCount + count * 4;
+            const base = this.malloc(total);
+            try {
+                const status = this.wasm.galley_tree_snapshot(handle, base + offParent, base + offFirst, base + offNext, base + offChildCount, base + offVariable, base + offSpanStart, base + offSpanLen, BigInt(count));
+                if (isNegative(status))
+                    throw new GalleyError("galley_tree_snapshot failed", Number(status));
+                if (status !== BigInt(count))
+                    continue;
+                const memory = this.memoryBytes();
+                const column64 = (offset) => new BigUint64Array(memory.buffer, memory.byteOffset + base + offset, count);
+                const parent = new BigUint64Array(count);
+                parent.set(column64(offParent));
+                const firstChild = new BigUint64Array(count);
+                firstChild.set(column64(offFirst));
+                const next = new BigUint64Array(count);
+                next.set(column64(offNext));
+                const spanStart = new BigUint64Array(count);
+                spanStart.set(column64(offSpanStart));
+                const spanLen = new BigUint64Array(count);
+                spanLen.set(column64(offSpanLen));
+                const variable = new BigInt64Array(count);
+                variable.set(new BigInt64Array(memory.buffer, memory.byteOffset + base + offVariable, count));
+                const childCount = new Uint32Array(count);
+                childCount.set(new Uint32Array(memory.buffer, memory.byteOffset + base + offChildCount, count));
+                return { count, parent, firstChild, next, childCount, variable, spanStart, spanLen };
+            }
+            finally {
+                this.free(base, total);
+            }
+        }
+        throw new GalleyError("node count changed during galley_tree_snapshot", -8);
+    }
+    // -- walker -------------------------------------------------------------------
+    walkerCreate(handle, node, skipSemanticErrors) {
+        const walker = this.wasm.galley_walker_create(handle, asI64(node), skipSemanticErrors ? 1 : 0);
+        if (walker === 0)
+            return null;
+        return walker;
+    }
+    walkerNext(walker) {
+        const out = this.malloc(16);
+        try {
+            const yielded = this.wasm.galley_walker_next(walker, out, out + 8, out + 12);
+            if (yielded === 0)
+                return null;
+            const view = this.dataView();
+            return {
+                node: view.getBigUint64(out, true),
+                depth: view.getUint32(out + 8, true),
+                isSemanticError: view.getInt32(out + 12, true) !== 0,
+            };
+        }
+        finally {
+            this.free(out, 16);
+        }
+    }
+    walkerSkipChildren(walker) {
+        this.wasm.galley_walker_skip_children(walker);
+    }
+    walkerDestroy(walker) {
+        this.wasm.galley_walker_destroy(walker);
+    }
+    // -- node accessors ------------------------------------------------------------
+    /** Read a guest `(data, len)` byte pair; null on negative status. */
+    tryCopyBytes(call) {
+        const out = this.malloc(8);
+        try {
+            const status = call(out, out + 4);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            const ptr = view.getUint32(out, true);
+            const len = view.getUint32(out + 4, true);
+            if (ptr === 0)
+                return null;
+            return this.readBytes(ptr, len);
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    readSemanticPair(call) {
+        const out = this.malloc(16);
+        try {
+            const status = call(out, out + 4, out + 8, out + 12);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            const variablePtr = view.getUint32(out, true);
+            const variableLen = view.getUint32(out + 4, true);
+            const messagePtr = view.getUint32(out + 8, true);
+            const messageLen = view.getUint32(out + 12, true);
+            if (variablePtr === 0 || messagePtr === 0)
+                return null;
+            return [
+                textDecoder.decode(this.readBytes(variablePtr, variableLen)),
+                textDecoder.decode(this.readBytes(messagePtr, messageLen)),
+            ];
+        }
+        finally {
+            this.free(out, 16);
+        }
+    }
+    nodeSymbolName(handle, node) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_node_symbol_name(session, asI64(node), data, len));
+    }
+    nodeText(handle, node) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_node_text(session, asI64(node), data, len));
+    }
+    nodeSpan(handle, node) {
+        const out = this.malloc(16);
+        try {
+            const status = this.wasm.galley_node_span(handle, asI64(node), out, out + 8);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            return [view.getBigUint64(out, true), view.getBigUint64(out + 8, true)];
+        }
+        finally {
+            this.free(out, 16);
+        }
+    }
+    nodeLineColumn(handle, node) {
+        const out = this.malloc(8);
+        try {
+            const status = this.wasm.galley_node_line_column(handle, asI64(node), out, out + 4);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    nodeVariableIndex(handle, node) {
+        return toNumber(this.wasm.galley_node_variable_index(handle, asI64(node)));
+    }
+    symbolNameAt(handle, index) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_symbol_name(session, BigInt(index), data, len));
+    }
+    symbolIsTerminal(handle, index) {
+        return this.wasm.galley_symbol_is_terminal(handle, BigInt(index)) !== 0;
+    }
+    variableNameAt(handle, index) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_variable_name(session, BigInt(index), data, len));
+    }
+    // -- diagnostics ------------------------------------------------------------------
+    hasDiagnostic(handle) {
+        return this.wasm.galley_has_diagnostic(handle) !== 0;
+    }
+    diagnosticKind(handle) {
+        return toNumber(this.wasm.galley_diagnostic_kind(handle));
+    }
+    diagnosticMessage(handle) {
+        const out = this.malloc(4);
+        try {
+            if (this.wasm.galley_diagnostic_message(handle, out) !== 0n)
+                return null;
+            return this.readCString(this.dataView().getUint32(out, true));
+        }
+        finally {
+            this.free(out, 4);
+        }
+    }
+    diagnosticMessageAnsi(handle) {
+        const out = this.malloc(4);
+        try {
+            if (this.wasm.galley_diagnostic_message_ansi(handle, out) !== 0n)
+                return null;
+            return this.readCString(this.dataView().getUint32(out, true));
+        }
+        finally {
+            this.free(out, 4);
+        }
+    }
+    diagnosticPosition(handle) {
+        const out = this.malloc(8);
+        try {
+            if (isNegative(this.wasm.galley_diagnostic_position(handle, out, out + 4)))
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    diagnosticUnexpectedToken(handle) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_diagnostic_unexpected_token(session, data, len));
+    }
+    diagnosticExpectedCount(handle) {
+        return toNumber(this.wasm.galley_diagnostic_expected_count(handle));
+    }
+    diagnosticExpectedAt(handle, index) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_diagnostic_expected_at(session, BigInt(index), data, len));
+    }
+    diagnosticContextCount(handle) {
+        return toNumber(this.wasm.galley_diagnostic_context_count(handle));
+    }
+    diagnosticContextAt(handle, index) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_diagnostic_context_at(session, BigInt(index), data, len));
+    }
+    syntaxErrorCount(handle) {
+        return toNumber(this.wasm.galley_syntax_error_count(handle));
+    }
+    semanticErrorCount(handle) {
+        return toNumber(this.wasm.galley_semantic_error_count(handle));
+    }
+    diagnosticSemantic(handle) {
+        const session = handle;
+        return this.readSemanticPair((variable, variableLen, message, messageLen) => this.wasm.galley_diagnostic_semantic(session, variable, variableLen, message, messageLen));
+    }
+    diagnosticIndentation(handle) {
+        const out = this.malloc(8);
+        try {
+            if (toNumber(this.wasm.galley_diagnostic_indentation(handle, out, out + 4)) !== 0)
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    diagnosticRecoveryKind(handle) {
+        return toNumber(this.wasm.galley_diagnostic_recovery_kind(handle));
+    }
+    diagnosticRecoveryTerminal(handle) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_diagnostic_recovery_terminal(session, data, len));
+    }
+    diagnosticRecoveryResume(handle) {
+        const out = this.malloc(8);
+        try {
+            if (toNumber(this.wasm.galley_diagnostic_recovery_resume(handle, out)) !== 0)
+                return null;
+            return toNumber(this.dataView().getBigInt64(out, true));
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    diagnosticRecoveryLhsVariable(handle) {
+        const session = handle;
+        const out = this.malloc(8);
+        try {
+            const status = this.wasm.galley_diagnostic_recovery_lhs_variable(session, out, out + 4);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            const ptr = view.getUint32(out, true);
+            if (ptr === 0)
+                return null;
+            return textDecoder.decode(this.readBytes(ptr, view.getUint32(out + 4, true)));
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    diagnosticRecoveryProduction(handle) {
+        const out = this.malloc(12);
+        try {
+            if (toNumber(this.wasm.galley_diagnostic_recovery_production(handle, out, out + 4, out + 8)) !==
+                0)
+                return null;
+            const view = this.dataView();
+            return [
+                textDecoder.decode(this.readBytes(view.getUint32(out, true), view.getUint32(out + 4, true))),
+                view.getUint32(out + 8, true),
+            ];
+        }
+        finally {
+            this.free(out, 12);
+        }
+    }
+    diagnosticRecoveryOccurrence(handle) {
+        const out = this.malloc(24);
+        try {
+            if (toNumber(this.wasm.galley_diagnostic_recovery_occurrence(handle, out, out + 4, out + 8, out + 12, out + 16, out + 20)) !== 0)
+                return null;
+            const view = this.dataView();
+            return [
+                textDecoder.decode(this.readBytes(view.getUint32(out, true), view.getUint32(out + 4, true))),
+                view.getUint32(out + 8, true),
+                view.getUint32(out + 12, true),
+                textDecoder.decode(this.readBytes(view.getUint32(out + 16, true), view.getUint32(out + 20, true))),
+            ];
+        }
+        finally {
+            this.free(out, 24);
+        }
+    }
+    recordedDiagnosticCount(handle) {
+        return toNumber(this.wasm.galley_recorded_diagnostic_count(handle));
+    }
+    recordedDiagnosticKind(handle, diagIndex) {
+        return toNumber(this.wasm.galley_recorded_diagnostic_kind(handle, BigInt(diagIndex)));
+    }
+    recordedDiagnosticPosition(handle, diagIndex) {
+        const out = this.malloc(8);
+        try {
+            if (isNegative(this.wasm.galley_recorded_diagnostic_position(handle, BigInt(diagIndex), out, out + 4)))
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    recordedUnexpectedToken(handle, diagIndex) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_recorded_unexpected_token(session, BigInt(diagIndex), data, len));
+    }
+    recordedDiagnosticMessage(handle, diagIndex) {
+        const out = this.malloc(4);
+        try {
+            if (toNumber(this.wasm.galley_recorded_diagnostic_message(handle, BigInt(diagIndex), out)) !== 0)
+                return null;
+            return this.readCString(this.dataView().getUint32(out, true));
+        }
+        finally {
+            this.free(out, 4);
+        }
+    }
+    recordedIndentation(handle, diagIndex) {
+        const out = this.malloc(8);
+        try {
+            if (toNumber(this.wasm.galley_recorded_indentation(handle, BigInt(diagIndex), out, out + 4)) !== 0)
+                return null;
+            const view = this.dataView();
+            return [view.getUint32(out, true), view.getUint32(out + 4, true)];
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    recordedSemantic(handle, diagIndex) {
+        const session = handle;
+        return this.readSemanticPair((variable, variableLen, message, messageLen) => this.wasm.galley_recorded_semantic(session, BigInt(diagIndex), variable, variableLen, message, messageLen));
+    }
+    recordedExpectedCount(handle, diagIndex) {
+        return toNumber(this.wasm.galley_recorded_expected_count(handle, BigInt(diagIndex)));
+    }
+    recordedExpectedToken(handle, diagIndex, tokenIndex) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_recorded_expected_token(session, BigInt(diagIndex), BigInt(tokenIndex), data, len));
+    }
+    recordedContextCount(handle, diagIndex) {
+        return toNumber(this.wasm.galley_recorded_context_count(handle, BigInt(diagIndex)));
+    }
+    recordedContextName(handle, diagIndex, contextIndex) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_recorded_context_name(session, BigInt(diagIndex), BigInt(contextIndex), data, len));
+    }
+    recordedRecoveryKind(handle, diagIndex) {
+        return toNumber(this.wasm.galley_recorded_diagnostic_recovery_kind(handle, BigInt(diagIndex)));
+    }
+    recordedRecoveryTerminal(handle, diagIndex) {
+        const session = handle;
+        return this.tryCopyBytes((data, len) => this.wasm.galley_recorded_recovery_terminal(session, BigInt(diagIndex), data, len));
+    }
+    recordedRecoveryResume(handle, diagIndex) {
+        const out = this.malloc(8);
+        try {
+            if (toNumber(this.wasm.galley_recorded_recovery_resume(handle, BigInt(diagIndex), out)) !== 0)
+                return null;
+            return toNumber(this.dataView().getBigInt64(out, true));
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    recordedRecoveryLhsVariable(handle, diagIndex) {
+        const session = handle;
+        const out = this.malloc(8);
+        try {
+            const status = this.wasm.galley_recorded_recovery_lhs_variable(session, BigInt(diagIndex), out, out + 4);
+            if (isNegative(status))
+                return null;
+            const view = this.dataView();
+            const ptr = view.getUint32(out, true);
+            if (ptr === 0)
+                return null;
+            return textDecoder.decode(this.readBytes(ptr, view.getUint32(out + 4, true)));
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    recordedRecoveryProduction(handle, diagIndex) {
+        const out = this.malloc(12);
+        try {
+            if (toNumber(this.wasm.galley_recorded_recovery_production(handle, BigInt(diagIndex), out, out + 4, out + 8)) !== 0)
+                return null;
+            const view = this.dataView();
+            return [
+                textDecoder.decode(this.readBytes(view.getUint32(out, true), view.getUint32(out + 4, true))),
+                view.getUint32(out + 8, true),
+            ];
+        }
+        finally {
+            this.free(out, 12);
+        }
+    }
+    recordedRecoveryOccurrence(handle, diagIndex) {
+        const out = this.malloc(24);
+        try {
+            if (toNumber(this.wasm.galley_recorded_recovery_occurrence(handle, BigInt(diagIndex), out, out + 4, out + 8, out + 12, out + 16, out + 20)) !== 0)
+                return null;
+            const view = this.dataView();
+            return [
+                textDecoder.decode(this.readBytes(view.getUint32(out, true), view.getUint32(out + 4, true))),
+                view.getUint32(out + 8, true),
+                view.getUint32(out + 12, true),
+                textDecoder.decode(this.readBytes(view.getUint32(out + 16, true), view.getUint32(out + 20, true))),
+            ];
+        }
+        finally {
+            this.free(out, 24);
+        }
+    }
+    // -- tree editing --------------------------------------------------------------------
+    treeAppendChildren(handle, parent, first) {
+        return toNumber(this.wasm.galley_tree_append_children(handle, asI64(parent), asI64(first)));
+    }
+    treeInsertBefore(handle, target, first) {
+        return toNumber(this.wasm.galley_tree_insert_before(handle, asI64(target), asI64(first)));
+    }
+    treeInsertAfter(handle, target, first) {
+        return toNumber(this.wasm.galley_tree_insert_after(handle, asI64(target), asI64(first)));
+    }
+    treeRemoveSiblings(handle, node, count) {
+        const out = this.malloc(8);
+        try {
+            const status = toNumber(this.wasm.galley_tree_remove_siblings(handle, asI64(node), count, out));
+            return { status, head: this.dataView().getBigUint64(out, true) };
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    treeRemoveSelf(handle, node) {
+        const out = this.malloc(8);
+        try {
+            const status = toNumber(this.wasm.galley_tree_remove_self(handle, asI64(node), out));
+            return { status, head: this.dataView().getBigUint64(out, true) };
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    treePromoteChildrenOverWrapper(handle, wrapper) {
+        const out = this.malloc(8);
+        try {
+            const status = toNumber(this.wasm.galley_tree_promote_children_over_wrapper(handle, asI64(wrapper), out));
+            return { status, head: this.dataView().getBigUint64(out, true) };
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    treeCleanChildren(handle, node) {
+        const out = this.malloc(8);
+        try {
+            const status = toNumber(this.wasm.galley_tree_clean_children(handle, asI64(node), out));
+            return { status, head: this.dataView().getBigUint64(out, true) };
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    treeUnlinkWrapper(handle, wrapper) {
+        return toNumber(this.wasm.galley_tree_unlink_wrapper(handle, asI64(wrapper)));
+    }
+    treeInsertChildrenAt(handle, parent, index, first) {
+        return toNumber(this.wasm.galley_tree_insert_children_at(handle, asI64(parent), index, asI64(first)));
+    }
+    treeRemoveChildrenAt(handle, parent, index, count) {
+        const out = this.malloc(8);
+        try {
+            const status = toNumber(this.wasm.galley_tree_remove_children_at(handle, asI64(parent), index, count, out));
+            return { status, head: this.dataView().getBigUint64(out, true) };
+        }
+        finally {
+            this.free(out, 8);
+        }
+    }
+    // -- procedure hooks (parse-time state) ---------------------------------------------------
+    procCurrentNode(args) {
+        return asAddress(this.wasm.galley_procedure_current_node(args));
+    }
+    procSetCurrentNode(args, node) {
+        this.wasm.galley_procedure_set_current_node(args, asI64(node));
+    }
+    procDropSelf(args) {
+        return toNumber(this.wasm.galley_procedure_drop_self(args));
+    }
+    procDropChildren(args) {
+        return toNumber(this.wasm.galley_procedure_drop_children(args));
+    }
+    procDropIfEmpty(args) {
+        return toNumber(this.wasm.galley_procedure_drop_if_empty(args));
+    }
+    procReplaceWithChildren(args) {
+        return toNumber(this.wasm.galley_procedure_replace_with_children(args));
+    }
+    procContextLine(args) {
+        return this.wasm.galley_procedure_context_line(args);
+    }
+    procContextColumn(args) {
+        return this.wasm.galley_procedure_context_column(args);
+    }
+    procReportSemanticError(args, message) {
+        const bytes = textEncoder.encode(textDecoder.decode(message));
+        const slot = this.writeBytes(bytes);
+        try {
+            return toNumber(this.wasm.galley_procedure_report_semantic_error(args, slot.ptr, slot.len));
+        }
+        finally {
+            this.free(slot.ptr, Math.max(slot.len, 1));
+        }
+    }
+    syncProcedures(names) {
+        if (typeof this.wasm.galley_js_procedure_clear !== "function")
+            return;
+        if (typeof this.wasm.galley_js_procedure_enable !== "function")
+            return;
+        this.wasm.galley_js_procedure_clear();
+        for (const name of names) {
+            const bytes = textEncoder.encode(name);
+            const slot = this.writeBytes(bytes);
+            try {
+                this.wasm.galley_js_procedure_enable(slot.ptr, slot.len);
+            }
+            finally {
+                this.free(slot.ptr, Math.max(slot.len, 1));
+            }
+        }
+        // Warm the ID table outside any parse so the hot path never queries
+        // (querying would re-enter the guest mid-parse).
+        this.procedureNames();
+    }
+}
+//# sourceMappingURL=ffi.js.map