@sanbus/galley-bun 0.0.1

package/dist/ffi.js

@@ -0,0 +1,794 @@
+/**
+ * Bun adapter for the Galley JavaScript bindings: `bun:ffi` bindings over
+ * `bindings/c/galley.h`, implementing the core `FfiPort`.
+ *
+ * Zero npm dependencies: `bun:ffi` is built into the runtime. The core
+ * (`@sanbus/galley-core`) owns all session logic; memory copying and integer
+ * normalization live here. Library discovery mirrors the Node adapter.
+ */
+import { Buffer } from "node:buffer";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { dlopen, FFIType, ptr, toArrayBuffer, CString } from "bun:ffi";
+import { GalleyError, resolveArtifact, artifactFileName } from "@sanbus/galley-core";
+// --- library discovery -------------------------------------------------
+// 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: bunx galley-js-bun <language-dir>\n` +
+    `or set GALLEY_LIBRARY_PATH=/path/to/${libFileName()}`;
+export function libFileName(base = "galley-js-bun") {
+    return artifactFileName(base, process.platform);
+}
+function exists(candidate) {
+    try {
+        fs.accessSync(candidate);
+        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,
+    });
+}
+// --- loader ------------------------------------------------------------
+const BASE_SYMBOLS = {
+    galley_version: { args: [], returns: FFIType.cstring },
+    galley_parser_type: { args: [], returns: FFIType.i64 },
+    galley_error_recovery_mode: { args: [], returns: FFIType.i64 },
+    galley_has_ast: { args: [], returns: FFIType.i32 },
+    galley_has_procedures: { args: [], returns: FFIType.i32 },
+    galley_allows_no_ast_tree_procedures: { args: [], returns: FFIType.i32 },
+    galley_source_retention_enabled: { args: [], returns: FFIType.i32 },
+    galley_has_position_tracking: { args: [], returns: FFIType.i32 },
+    galley_has_input_streaming: { args: [], returns: FFIType.i32 },
+    galley_uses_verbatim: { args: [], returns: FFIType.i32 },
+    galley_stack_overflow_recovery_available: { args: [], returns: FFIType.i32 },
+    galley_symbol_count: { args: [], returns: FFIType.u64 },
+    galley_variable_count: { args: [], returns: FFIType.u64 },
+    galley_status_string: { args: [FFIType.i64], returns: FFIType.cstring },
+    galley_symbol_name: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_symbol_is_terminal: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    galley_variable_name: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_session_create: { args: [], returns: FFIType.ptr },
+    galley_session_create_ex: { args: [FFIType.ptr], returns: FFIType.ptr },
+    galley_session_destroy: { args: [FFIType.ptr], returns: FFIType.void },
+    galley_session_set_message_override: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_parse: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_parse_file: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_last_position: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_node_count: { args: [FFIType.ptr], returns: FFIType.u64 },
+    galley_reserve_nodes: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_node_capacity: { args: [FFIType.ptr], returns: FFIType.u64 },
+    galley_root_node: { args: [FFIType.ptr], returns: FFIType.u64 },
+    galley_node_is_valid: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    galley_node_child_count: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u32 },
+    galley_node_first_child: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+    galley_node_last_child: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+    galley_node_next_sibling: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+    galley_node_prior_sibling: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+    galley_node_parent: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+    galley_tree_snapshot: {
+        args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u64],
+        returns: FFIType.i64,
+    },
+    galley_walker_create: { args: [FFIType.ptr, FFIType.u64, FFIType.i32], returns: FFIType.ptr },
+    galley_walker_next: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    galley_walker_skip_children: { args: [FFIType.ptr], returns: FFIType.void },
+    galley_walker_destroy: { args: [FFIType.ptr], returns: FFIType.void },
+    galley_node_span: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_node_symbol_name: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_node_variable_index: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_node_text: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_node_line_column: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_has_diagnostic: { args: [FFIType.ptr], returns: FFIType.i32 },
+    galley_diagnostic_kind: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_message: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_message_ansi: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_position: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_unexpected_token: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_expected_count: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_expected_at: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_context_count: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_context_at: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_indentation: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_syntax_error_count: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_semantic_error_count: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_semantic: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_kind: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_terminal: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_resume: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_lhs_variable: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_production: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_diagnostic_recovery_occurrence: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_diagnostic_count: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_diagnostic_kind: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_recorded_diagnostic_position: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_unexpected_token: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_diagnostic_message: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_indentation: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_semantic: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_expected_count: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_recorded_expected_token: { args: [FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_context_count: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_recorded_context_name: { args: [FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_diagnostic_recovery_kind: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_recorded_recovery_terminal: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_recovery_resume: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_recovery_lhs_variable: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_recovery_production: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_recorded_recovery_occurrence: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    galley_tree_append_children: { args: [FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.i64 },
+    galley_tree_insert_before: { args: [FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.i64 },
+    galley_tree_insert_after: { args: [FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.i64 },
+    galley_tree_remove_siblings: { args: [FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_tree_remove_self: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_tree_promote_children_over_wrapper: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_tree_clean_children: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_tree_unlink_wrapper: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+    galley_tree_insert_children_at: { args: [FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.u64], returns: FFIType.i64 },
+    galley_tree_remove_children_at: { args: [FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.ptr], returns: FFIType.i64 },
+    galley_procedure_session: { args: [FFIType.ptr], returns: FFIType.ptr },
+    galley_procedure_current_node: { args: [FFIType.ptr], returns: FFIType.u64 },
+    galley_procedure_set_current_node: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.void },
+    galley_procedure_drop_self: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_procedure_drop_children: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_procedure_drop_if_empty: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_procedure_replace_with_children: { args: [FFIType.ptr], returns: FFIType.i64 },
+    galley_procedure_context_line: { args: [FFIType.ptr], returns: FFIType.u32 },
+    galley_procedure_context_column: { args: [FFIType.ptr], returns: FFIType.u32 },
+    galley_procedure_report_semantic_error: { args: [FFIType.ptr, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+};
+const DISPATCH_SYMBOL = {
+    galley_install_js_dispatch: { args: [FFIType.function], returns: FFIType.void },
+};
+const ID_DISPATCH_SYMBOL = {
+    galley_install_js_dispatch_id: { args: [FFIType.function], returns: FFIType.void },
+    galley_js_procedure_count: { args: [], returns: FFIType.u32 },
+    galley_js_procedure_name_ptr: { args: [FFIType.u32], returns: FFIType.ptr },
+    galley_js_procedure_name_len: { args: [FFIType.u32], returns: FFIType.u64 },
+};
+const SELECTIVE_SYMBOL = {
+    galley_js_procedure_enable: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    galley_js_procedure_clear: { args: [], returns: FFIType.void },
+};
+function openNative(libPath, level) {
+    const table = level >= 3
+        ? { ...BASE_SYMBOLS, ...ID_DISPATCH_SYMBOL, ...SELECTIVE_SYMBOL }
+        : level >= 2
+            ? { ...BASE_SYMBOLS, ...DISPATCH_SYMBOL, ...SELECTIVE_SYMBOL }
+            : level >= 1
+                ? { ...BASE_SYMBOLS, ...DISPATCH_SYMBOL }
+                : BASE_SYMBOLS;
+    return dlopen(libPath, table);
+}
+// --- read helpers ----------------------------------------------------------
+/** Copy (addr,len) into a Uint8Array owning its bytes. */
+export function readBytes(addr, len) {
+    if (addr === 0n || len === 0n)
+        return new Uint8Array(0);
+    const view = toArrayBuffer(Number(addr), 0, Number(len));
+    return new Uint8Array(view.slice(0));
+}
+export function readCString(addr) {
+    return String(new CString(Number(addr)));
+}
+function ptrOut64() {
+    return new BigUint64Array(1);
+}
+function u32Out() {
+    return new Uint32Array(1);
+}
+function i64Out() {
+    return new BigInt64Array(1);
+}
+// --- FfiPort implementation ----------------------------------------------
+export class BunPort {
+    native;
+    libraryPath;
+    supportsDispatch;
+    constructor(native, libraryPath, supportsDispatch) {
+        this.native = native;
+        this.libraryPath = libraryPath;
+        this.supportsDispatch = supportsDispatch;
+    }
+    syncProcedures(names) {
+        if (typeof this.native.galley_js_procedure_clear !== "function")
+            return;
+        if (typeof this.native.galley_js_procedure_enable !== "function")
+            return;
+        this.native.galley_js_procedure_clear();
+        const encoder = new TextEncoder();
+        for (const name of names) {
+            const bytes = encoder.encode(name);
+            this.native.galley_js_procedure_enable(ptr(bytes), BigInt(bytes.length));
+        }
+        // Warm the ID table outside any parse so the hot path never queries.
+        this.procedureNames();
+    }
+    #procedureNameTable = null;
+    procedureNames() {
+        if (this.#procedureNameTable !== null)
+            return this.#procedureNameTable;
+        const table = [];
+        if (typeof this.native.galley_js_procedure_count === "function" &&
+            typeof this.native.galley_js_procedure_name_ptr === "function" &&
+            typeof this.native.galley_js_procedure_name_len === "function") {
+            const decoder = new TextDecoder();
+            const n = this.native.galley_js_procedure_count();
+            for (let i = 0; i < n; i++) {
+                const ptrValue = this.native.galley_js_procedure_name_ptr(i);
+                if (ptrValue === 0n)
+                    break;
+                const len = this.native.galley_js_procedure_name_len(i);
+                table.push(decoder.decode(readBytes(ptrValue, len)));
+            }
+        }
+        this.#procedureNameTable = table;
+        return table;
+    }
+    // -- module-level queries --------------------------------------------
+    version() {
+        return String(this.native.galley_version());
+    }
+    parserType() {
+        return Number(this.native.galley_parser_type());
+    }
+    errorRecoveryMode() {
+        return Number(this.native.galley_error_recovery_mode());
+    }
+    hasAst() {
+        return this.native.galley_has_ast() !== 0;
+    }
+    hasProcedures() {
+        return this.native.galley_has_procedures() !== 0;
+    }
+    allowsNoAstTreeProcedures() {
+        return this.native.galley_allows_no_ast_tree_procedures() !== 0;
+    }
+    sourceRetentionEnabled() {
+        return this.native.galley_source_retention_enabled() !== 0;
+    }
+    hasPositionTracking() {
+        return this.native.galley_has_position_tracking() !== 0;
+    }
+    hasInputStreaming() {
+        return this.native.galley_has_input_streaming() !== 0;
+    }
+    usesVerbatim() {
+        return this.native.galley_uses_verbatim() !== 0;
+    }
+    stackOverflowRecoveryAvailable() {
+        return this.native.galley_stack_overflow_recovery_available() !== 0;
+    }
+    symbolCount() {
+        return Number(this.native.galley_symbol_count());
+    }
+    variableCount() {
+        return Number(this.native.galley_variable_count());
+    }
+    statusString(status) {
+        // Native returns NULL for unknown codes; bun:ffi coerces that to "".
+        const rendered = String(this.native.galley_status_string(BigInt(status)));
+        return rendered === "" ? null : rendered;
+    }
+    // -- sessions ---------------------------------------------------------
+    createSession(options) {
+        let handle;
+        if (options === null) {
+            handle = this.native.galley_session_create();
+        }
+        else {
+            // GalleyCOptions layout: int32 x5, double, uint64 (40 bytes, LE).
+            const buf = new ArrayBuffer(40);
+            const view = new DataView(buf);
+            view.setInt32(0, options.maxErrors, true);
+            view.setInt32(4, options.recoveryWindow, true);
+            view.setInt32(8, options.stackOverflowRecovery, true);
+            view.setUint32(12, options.syntaxErrorStackDepth, true);
+            view.setInt32(16, options.verbosity, true);
+            view.setFloat64(24, options.astPreallocationRatio, true);
+            view.setBigUint64(32, options.astPreallocationCap, true);
+            handle = this.native.galley_session_create_ex(ptr(new Uint8Array(buf)));
+        }
+        if (handle === 0 || handle === null || handle === undefined)
+            return null;
+        return handle;
+    }
+    destroySession(handle) {
+        this.native.galley_session_destroy(handle);
+    }
+    setMessageOverride(handle, name, message) {
+        return Number(this.native.galley_session_set_message_override(handle, ptr(name), BigInt(name.length), ptr(message), BigInt(message.length)));
+    }
+    // -- parsing ----------------------------------------------------------
+    parse(handle, data) {
+        return Number(this.native.galley_parse(handle, ptr(data), BigInt(data.length)));
+    }
+    parseFile(handle, filePath) {
+        const bytes = Buffer.from(filePath, "utf-8");
+        const nul = Buffer.alloc(bytes.length + 1);
+        bytes.copy(nul);
+        return Number(this.native.galley_parse_file(handle, ptr(nul)));
+    }
+    lastPosition(handle) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_last_position(handle, ptr(outLine), ptr(outCol)) < 0n)
+            return null;
+        return [outLine[0], outCol[0]];
+    }
+    // -- arena and navigation ----------------------------------------------
+    nodeCount(handle) {
+        return Number(this.native.galley_node_count(handle));
+    }
+    reserveNodes(handle, capacity) {
+        return Number(this.native.galley_reserve_nodes(handle, capacity));
+    }
+    nodeCapacity(handle) {
+        return Number(this.native.galley_node_capacity(handle));
+    }
+    rootNode(handle) {
+        return this.native.galley_root_node(handle);
+    }
+    nodeValid(handle, node) {
+        return this.native.galley_node_is_valid(handle, node) !== 0;
+    }
+    childCount(handle, node) {
+        return this.native.galley_node_child_count(handle, node);
+    }
+    firstChild(handle, node) {
+        return this.native.galley_node_first_child(handle, node);
+    }
+    lastChild(handle, node) {
+        return this.native.galley_node_last_child(handle, node);
+    }
+    nextSibling(handle, node) {
+        return this.native.galley_node_next_sibling(handle, node);
+    }
+    priorSibling(handle, node) {
+        return this.native.galley_node_prior_sibling(handle, node);
+    }
+    parent(handle, node) {
+        return this.native.galley_node_parent(handle, node);
+    }
+    treeSnapshot(handle) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const count = this.nodeCount(handle);
+            const parent = new BigUint64Array(count);
+            const firstChild = new BigUint64Array(count);
+            const next = new BigUint64Array(count);
+            const childCount = new Uint32Array(count);
+            const variable = new BigInt64Array(count);
+            const spanStart = new BigUint64Array(count);
+            const spanLen = new BigUint64Array(count);
+            const total = this.native.galley_tree_snapshot(handle, ptr(parent), ptr(firstChild), ptr(next), ptr(childCount), ptr(variable), ptr(spanStart), ptr(spanLen), BigInt(count));
+            if (total < 0n)
+                throw new GalleyError("galley_tree_snapshot failed", Number(total));
+            if (total === BigInt(count)) {
+                return { count, parent, firstChild, next, childCount, variable, spanStart, spanLen };
+            }
+        }
+        throw new GalleyError("node count changed during galley_tree_snapshot", -8);
+    }
+    // -- walker ------------------------------------------------------------
+    walkerCreate(handle, node, skipSemanticErrors) {
+        const walker = this.native.galley_walker_create(handle, node, skipSemanticErrors ? 1 : 0);
+        if (walker === 0 || walker === null || walker === undefined)
+            return null;
+        return walker;
+    }
+    walkerNext(walker) {
+        const outNode = ptrOut64();
+        const outDepth = u32Out();
+        const outFlag = u32Out();
+        if (this.native.galley_walker_next(walker, ptr(outNode), ptr(outDepth), ptr(outFlag)) === 0)
+            return null;
+        return { node: outNode[0], depth: outDepth[0], isSemanticError: outFlag[0] !== 0 };
+    }
+    walkerSkipChildren(walker) {
+        this.native.galley_walker_skip_children(walker);
+    }
+    walkerDestroy(walker) {
+        this.native.galley_walker_destroy(walker);
+    }
+    // -- node accessors -----------------------------------------------------
+    #tryCopyBytes(fn) {
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (fn(outData, outLen) < 0n)
+            return null;
+        if (outData[0] === 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    #readSemanticPair(fn) {
+        const outVariable = ptrOut64();
+        const outVariableLen = ptrOut64();
+        const outMessage = ptrOut64();
+        const outMessageLen = ptrOut64();
+        if (fn(outVariable, outVariableLen, outMessage, outMessageLen) < 0n)
+            return null;
+        if (outVariable[0] === 0n || outMessage[0] === 0n)
+            return null;
+        const decoder = new TextDecoder();
+        return [
+            decoder.decode(readBytes(outVariable[0], outVariableLen[0])),
+            decoder.decode(readBytes(outMessage[0], outMessageLen[0])),
+        ];
+    }
+    nodeSymbolName(handle, node) {
+        const h = handle;
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_node_symbol_name(h, node, ptr(outData), ptr(outLen)) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    nodeText(handle, node) {
+        const h = handle;
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_node_text(h, node, ptr(outData), ptr(outLen)) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    nodeSpan(handle, node) {
+        const outStart = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_node_span(handle, node, ptr(outStart), ptr(outLen)) < 0n)
+            return null;
+        return [outStart[0], outLen[0]];
+    }
+    nodeLineColumn(handle, node) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_node_line_column(handle, node, ptr(outLine), ptr(outCol)) < 0n)
+            return null;
+        return [outLine[0], outCol[0]];
+    }
+    nodeVariableIndex(handle, node) {
+        return Number(this.native.galley_node_variable_index(handle, node));
+    }
+    symbolNameAt(handle, index) {
+        const h = handle;
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_symbol_name(h, BigInt(index), ptr(outData), ptr(outLen)) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    symbolIsTerminal(handle, index) {
+        return this.native.galley_symbol_is_terminal(handle, BigInt(index)) !== 0;
+    }
+    variableNameAt(handle, index) {
+        const h = handle;
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_variable_name(h, BigInt(index), ptr(outData), ptr(outLen)) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    // -- diagnostics ---------------------------------------------------------
+    hasDiagnostic(handle) {
+        return this.native.galley_has_diagnostic(handle) !== 0;
+    }
+    diagnosticKind(handle) {
+        return Number(this.native.galley_diagnostic_kind(handle));
+    }
+    diagnosticMessage(handle) {
+        const out = ptrOut64();
+        if (this.native.galley_diagnostic_message(handle, ptr(out)) !== 0n)
+            return null;
+        return readCString(out[0]);
+    }
+    diagnosticMessageAnsi(handle) {
+        const out = ptrOut64();
+        if (this.native.galley_diagnostic_message_ansi(handle, ptr(out)) !== 0n)
+            return null;
+        return readCString(out[0]);
+    }
+    diagnosticPosition(handle) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_diagnostic_position(handle, ptr(outLine), ptr(outCol)) < 0n)
+            return null;
+        return [outLine[0], outCol[0]];
+    }
+    diagnosticUnexpectedToken(handle) {
+        const h = handle;
+        return this.#tryCopyBytes((od, ol) => this.native.galley_diagnostic_unexpected_token(h, ptr(od), ptr(ol)));
+    }
+    diagnosticExpectedCount(handle) {
+        return Number(this.native.galley_diagnostic_expected_count(handle));
+    }
+    diagnosticExpectedAt(handle, index) {
+        const h = handle;
+        return this.#tryCopyBytes((od, ol) => this.native.galley_diagnostic_expected_at(h, BigInt(index), ptr(od), ptr(ol)));
+    }
+    diagnosticContextCount(handle) {
+        return Number(this.native.galley_diagnostic_context_count(handle));
+    }
+    diagnosticContextAt(handle, index) {
+        const h = handle;
+        return this.#tryCopyBytes((od, ol) => this.native.galley_diagnostic_context_at(h, BigInt(index), ptr(od), ptr(ol)));
+    }
+    syntaxErrorCount(handle) {
+        return Number(this.native.galley_syntax_error_count(handle));
+    }
+    semanticErrorCount(handle) {
+        return Number(this.native.galley_semantic_error_count(handle));
+    }
+    diagnosticSemantic(handle) {
+        const h = handle;
+        return this.#readSemanticPair((ov, ovl, om, oml) => this.native.galley_diagnostic_semantic(h, ptr(ov), ptr(ovl), ptr(om), ptr(oml)));
+    }
+    diagnosticIndentation(handle) {
+        const outSpaces = u32Out();
+        const outWidth = u32Out();
+        if (this.native.galley_diagnostic_indentation(handle, ptr(outSpaces), ptr(outWidth)) !== 0n)
+            return null;
+        return [outSpaces[0], outWidth[0]];
+    }
+    diagnosticRecoveryKind(handle) {
+        return Number(this.native.galley_diagnostic_recovery_kind(handle));
+    }
+    diagnosticRecoveryTerminal(handle) {
+        const h = handle;
+        return this.#tryCopyBytes((od, ol) => this.native.galley_diagnostic_recovery_terminal(h, ptr(od), ptr(ol)));
+    }
+    diagnosticRecoveryResume(handle) {
+        const out = i64Out();
+        if (this.native.galley_diagnostic_recovery_resume(handle, ptr(out)) !== 0n)
+            return null;
+        return Number(out[0]);
+    }
+    diagnosticRecoveryLhsVariable(handle) {
+        const h = handle;
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_diagnostic_recovery_lhs_variable(h, ptr(outData), ptr(outLen)) < 0n || outData[0] === 0n)
+            return null;
+        return new TextDecoder().decode(readBytes(outData[0], outLen[0]));
+    }
+    diagnosticRecoveryProduction(handle) {
+        const h = handle;
+        const outVar = ptrOut64();
+        const outLen = ptrOut64();
+        const outIdx = u32Out();
+        if (this.native.galley_diagnostic_recovery_production(h, ptr(outVar), ptr(outLen), ptr(outIdx)) !== 0n)
+            return null;
+        return [new TextDecoder().decode(readBytes(outVar[0], outLen[0])), outIdx[0]];
+    }
+    diagnosticRecoveryOccurrence(handle) {
+        const h = handle;
+        const outParent = ptrOut64();
+        const outParentLen = ptrOut64();
+        const outRhs = u32Out();
+        const outSym = u32Out();
+        const outVar = ptrOut64();
+        const outVarLen = ptrOut64();
+        if (this.native.galley_diagnostic_recovery_occurrence(h, ptr(outParent), ptr(outParentLen), ptr(outRhs), ptr(outSym), ptr(outVar), ptr(outVarLen)) !== 0n)
+            return null;
+        const decoder = new TextDecoder();
+        return [
+            decoder.decode(readBytes(outParent[0], outParentLen[0])),
+            outRhs[0],
+            outSym[0],
+            decoder.decode(readBytes(outVar[0], outVarLen[0])),
+        ];
+    }
+    recordedDiagnosticCount(handle) {
+        return Number(this.native.galley_recorded_diagnostic_count(handle));
+    }
+    recordedDiagnosticKind(handle, diagIndex) {
+        return Number(this.native.galley_recorded_diagnostic_kind(handle, BigInt(diagIndex)));
+    }
+    recordedDiagnosticPosition(handle, diagIndex) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_recorded_diagnostic_position(handle, BigInt(diagIndex), ptr(outLine), ptr(outCol)) < 0n)
+            return null;
+        return [outLine[0], outCol[0]];
+    }
+    recordedUnexpectedToken(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        return this.#tryCopyBytes((od, ol) => this.native.galley_recorded_unexpected_token(h, d, ptr(od), ptr(ol)));
+    }
+    recordedDiagnosticMessage(handle, diagIndex) {
+        const out = ptrOut64();
+        if (this.native.galley_recorded_diagnostic_message(handle, BigInt(diagIndex), ptr(out)) !== 0n)
+            return null;
+        return readCString(out[0]);
+    }
+    recordedIndentation(handle, diagIndex) {
+        const outSpaces = u32Out();
+        const outWidth = u32Out();
+        if (this.native.galley_recorded_indentation(handle, BigInt(diagIndex), ptr(outSpaces), ptr(outWidth)) !== 0n)
+            return null;
+        return [outSpaces[0], outWidth[0]];
+    }
+    recordedSemantic(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        return this.#readSemanticPair((ov, ovl, om, oml) => this.native.galley_recorded_semantic(h, d, ptr(ov), ptr(ovl), ptr(om), ptr(oml)));
+    }
+    recordedExpectedCount(handle, diagIndex) {
+        return Number(this.native.galley_recorded_expected_count(handle, BigInt(diagIndex)));
+    }
+    recordedExpectedToken(handle, diagIndex, tokenIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const t = BigInt(tokenIndex);
+        return this.#tryCopyBytes((od, ol) => this.native.galley_recorded_expected_token(h, d, t, ptr(od), ptr(ol)));
+    }
+    recordedContextCount(handle, diagIndex) {
+        return Number(this.native.galley_recorded_context_count(handle, BigInt(diagIndex)));
+    }
+    recordedContextName(handle, diagIndex, contextIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const c = BigInt(contextIndex);
+        return this.#tryCopyBytes((od, ol) => this.native.galley_recorded_context_name(h, d, c, ptr(od), ptr(ol)));
+    }
+    recordedRecoveryKind(handle, diagIndex) {
+        return Number(this.native.galley_recorded_diagnostic_recovery_kind(handle, BigInt(diagIndex)));
+    }
+    recordedRecoveryTerminal(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        return this.#tryCopyBytes((od, ol) => this.native.galley_recorded_recovery_terminal(h, d, ptr(od), ptr(ol)));
+    }
+    recordedRecoveryResume(handle, diagIndex) {
+        const out = i64Out();
+        if (this.native.galley_recorded_recovery_resume(handle, BigInt(diagIndex), ptr(out)) !== 0n)
+            return null;
+        return Number(out[0]);
+    }
+    recordedRecoveryLhsVariable(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outData = ptrOut64();
+        const outLen = ptrOut64();
+        if (this.native.galley_recorded_recovery_lhs_variable(h, d, ptr(outData), ptr(outLen)) < 0n || outData[0] === 0n)
+            return null;
+        return new TextDecoder().decode(readBytes(outData[0], outLen[0]));
+    }
+    recordedRecoveryProduction(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outVar = ptrOut64();
+        const outLen = ptrOut64();
+        const outIdx = u32Out();
+        if (this.native.galley_recorded_recovery_production(h, d, ptr(outVar), ptr(outLen), ptr(outIdx)) !== 0n)
+            return null;
+        return [new TextDecoder().decode(readBytes(outVar[0], outLen[0])), outIdx[0]];
+    }
+    recordedRecoveryOccurrence(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outParent = ptrOut64();
+        const outParentLen = ptrOut64();
+        const outRhs = u32Out();
+        const outSym = u32Out();
+        const outVar = ptrOut64();
+        const outVarLen = ptrOut64();
+        if (this.native.galley_recorded_recovery_occurrence(h, d, ptr(outParent), ptr(outParentLen), ptr(outRhs), ptr(outSym), ptr(outVar), ptr(outVarLen)) !== 0n)
+            return null;
+        const decoder = new TextDecoder();
+        return [
+            decoder.decode(readBytes(outParent[0], outParentLen[0])),
+            outRhs[0],
+            outSym[0],
+            decoder.decode(readBytes(outVar[0], outVarLen[0])),
+        ];
+    }
+    // -- tree editing ----------------------------------------------------------
+    treeAppendChildren(handle, parent, first) {
+        return Number(this.native.galley_tree_append_children(handle, parent, first));
+    }
+    treeInsertBefore(handle, target, first) {
+        return Number(this.native.galley_tree_insert_before(handle, target, first));
+    }
+    treeInsertAfter(handle, target, first) {
+        return Number(this.native.galley_tree_insert_after(handle, target, first));
+    }
+    treeRemoveSiblings(handle, node, count) {
+        const outHead = ptrOut64();
+        const st = this.native.galley_tree_remove_siblings(handle, node, BigInt(count), ptr(outHead));
+        return { status: Number(st), head: outHead[0] };
+    }
+    treeRemoveSelf(handle, node) {
+        const outHead = ptrOut64();
+        const st = this.native.galley_tree_remove_self(handle, node, ptr(outHead));
+        return { status: Number(st), head: outHead[0] };
+    }
+    treePromoteChildrenOverWrapper(handle, wrapper) {
+        const outHead = ptrOut64();
+        const st = this.native.galley_tree_promote_children_over_wrapper(handle, wrapper, ptr(outHead));
+        return { status: Number(st), head: outHead[0] };
+    }
+    treeCleanChildren(handle, node) {
+        const outHead = ptrOut64();
+        const st = this.native.galley_tree_clean_children(handle, node, ptr(outHead));
+        return { status: Number(st), head: outHead[0] };
+    }
+    treeUnlinkWrapper(handle, wrapper) {
+        return Number(this.native.galley_tree_unlink_wrapper(handle, wrapper));
+    }
+    treeInsertChildrenAt(handle, parent, index, first) {
+        return Number(this.native.galley_tree_insert_children_at(handle, parent, BigInt(index), first));
+    }
+    treeRemoveChildrenAt(handle, parent, index, count) {
+        const outHead = ptrOut64();
+        const st = this.native.galley_tree_remove_children_at(handle, parent, BigInt(index), BigInt(count), ptr(outHead));
+        return { status: Number(st), head: outHead[0] };
+    }
+    // -- procedure hooks ----------------------------------------------------------
+    procCurrentNode(args) {
+        return this.native.galley_procedure_current_node(args);
+    }
+    procSetCurrentNode(args, node) {
+        this.native.galley_procedure_set_current_node(args, node);
+    }
+    procDropSelf(args) {
+        return Number(this.native.galley_procedure_drop_self(args));
+    }
+    procDropChildren(args) {
+        return Number(this.native.galley_procedure_drop_children(args));
+    }
+    procDropIfEmpty(args) {
+        return Number(this.native.galley_procedure_drop_if_empty(args));
+    }
+    procReplaceWithChildren(args) {
+        return Number(this.native.galley_procedure_replace_with_children(args));
+    }
+    procContextLine(args) {
+        return this.native.galley_procedure_context_line(args);
+    }
+    procContextColumn(args) {
+        return this.native.galley_procedure_context_column(args);
+    }
+    procReportSemanticError(args, message) {
+        return Number(this.native.galley_procedure_report_semantic_error(args, ptr(message), BigInt(message.length)));
+    }
+}
+const portCache = new Map();
+/** Port for the library at `explicitPath` (or default discovery), cached per path. */
+export function getBunPort(explicitPath) {
+    const libPath = findLibrary(explicitPath);
+    const cached = portCache.get(libPath);
+    if (cached)
+        return cached;
+    // Libraries built for C procedures lack the JS dispatch symbol.
+    let native;
+    let supportsDispatch = true;
+    try {
+        native = openNative(libPath, 3).symbols;
+    }
+    catch {
+        try {
+            native = openNative(libPath, 2).symbols;
+        }
+        catch {
+            try {
+                native = openNative(libPath, 1).symbols;
+            }
+            catch {
+                native = openNative(libPath, 0).symbols;
+                supportsDispatch = false;
+            }
+        }
+    }
+    const port = new BunPort(native, libPath, supportsDispatch);
+    portCache.set(libPath, port);
+    return port;
+}
+//# sourceMappingURL=ffi.js.map