@sanbus/galley-deno 0.0.1

package/dist/ffi.js

@@ -0,0 +1,798 @@
+/**
+ * Deno adapter for the Galley JavaScript bindings: `Deno.dlopen` bindings
+ * over `bindings/c/galley.h`, implementing the core `FfiPort`.
+ *
+ * Zero dependencies: no npm packages, no build step for the adapter itself.
+ * The core (`@sanbus/galley-core`, resolved to its compiled `dist` via the
+ * package `deno.json` import map) owns all session logic; memory copying
+ * and integer normalization live here. Requires `--allow-ffi` (dlopen),
+ * `--allow-read` (library discovery, `parseFile`), and `--allow-env`
+ * (library discovery).
+ */
+import { GalleyError, resolveArtifact, artifactFileName } from "@sanbus/galley-core";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+// --- 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: deno task build in your language dir\n" +
+    `or set GALLEY_LIBRARY_PATH=/path/to/${libFileName()}`;
+export function libFileName(base = "galley-js-deno") {
+    return artifactFileName(base, Deno.build.os);
+}
+function exists(filePath) {
+    try {
+        Deno.statSync(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function findLibrary(explicit) {
+    // Deno reports the path it was given (no resolve step), as before.
+    return resolveArtifact(explicit, {
+        getEnv: (name) => Deno.env.get(name),
+        resolvePath: (candidate) => candidate,
+        existsSync: exists,
+        buildHint: BUILD_HINT,
+    });
+}
+// --- loader ------------------------------------------------------------
+const BASE_SYMBOLS = {
+    galley_version: { parameters: [], result: "pointer" },
+    galley_parser_type: { parameters: [], result: "i64" },
+    galley_error_recovery_mode: { parameters: [], result: "i64" },
+    galley_has_ast: { parameters: [], result: "i32" },
+    galley_has_procedures: { parameters: [], result: "i32" },
+    galley_allows_no_ast_tree_procedures: { parameters: [], result: "i32" },
+    galley_source_retention_enabled: { parameters: [], result: "i32" },
+    galley_has_position_tracking: { parameters: [], result: "i32" },
+    galley_has_input_streaming: { parameters: [], result: "i32" },
+    galley_uses_verbatim: { parameters: [], result: "i32" },
+    galley_stack_overflow_recovery_available: { parameters: [], result: "i32" },
+    galley_symbol_count: { parameters: [], result: "u64" },
+    galley_variable_count: { parameters: [], result: "u64" },
+    galley_status_string: { parameters: ["i64"], result: "pointer" },
+    galley_symbol_name: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_symbol_is_terminal: { parameters: ["pointer", "u64"], result: "i32" },
+    galley_variable_name: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_session_create: { parameters: [], result: "pointer" },
+    galley_session_create_ex: { parameters: ["buffer"], result: "pointer" },
+    galley_session_destroy: { parameters: ["pointer"], result: "void" },
+    galley_session_set_message_override: { parameters: ["pointer", "buffer", "usize", "buffer", "usize"], result: "i64" },
+    galley_parse: { parameters: ["pointer", "buffer", "usize"], result: "i64" },
+    galley_parse_file: { parameters: ["pointer", "buffer"], result: "i64" },
+    galley_last_position: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_node_count: { parameters: ["pointer"], result: "u64" },
+    galley_reserve_nodes: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_node_capacity: { parameters: ["pointer"], result: "u64" },
+    galley_root_node: { parameters: ["pointer"], result: "u64" },
+    galley_node_is_valid: { parameters: ["pointer", "u64"], result: "i32" },
+    galley_node_child_count: { parameters: ["pointer", "u64"], result: "u32" },
+    galley_node_first_child: { parameters: ["pointer", "u64"], result: "u64" },
+    galley_node_last_child: { parameters: ["pointer", "u64"], result: "u64" },
+    galley_node_next_sibling: { parameters: ["pointer", "u64"], result: "u64" },
+    galley_node_prior_sibling: { parameters: ["pointer", "u64"], result: "u64" },
+    galley_node_parent: { parameters: ["pointer", "u64"], result: "u64" },
+    galley_tree_snapshot: {
+        parameters: ["pointer", "buffer", "buffer", "buffer", "buffer", "buffer", "buffer", "buffer", "u64"],
+        result: "i64",
+    },
+    galley_walker_create: { parameters: ["pointer", "u64", "i32"], result: "pointer" },
+    galley_walker_next: { parameters: ["pointer", "buffer", "buffer", "buffer"], result: "i32" },
+    galley_walker_skip_children: { parameters: ["pointer"], result: "void" },
+    galley_walker_destroy: { parameters: ["pointer"], result: "void" },
+    galley_node_span: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_node_symbol_name: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_node_variable_index: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_node_text: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_node_line_column: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_has_diagnostic: { parameters: ["pointer"], result: "i32" },
+    galley_diagnostic_kind: { parameters: ["pointer"], result: "i64" },
+    galley_diagnostic_message: { parameters: ["pointer", "buffer"], result: "i64" },
+    galley_diagnostic_message_ansi: { parameters: ["pointer", "buffer"], result: "i64" },
+    galley_diagnostic_position: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_unexpected_token: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_expected_count: { parameters: ["pointer"], result: "i64" },
+    galley_diagnostic_expected_at: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_context_count: { parameters: ["pointer"], result: "i64" },
+    galley_diagnostic_context_at: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_indentation: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_syntax_error_count: { parameters: ["pointer"], result: "i64" },
+    galley_semantic_error_count: { parameters: ["pointer"], result: "i64" },
+    galley_diagnostic_semantic: { parameters: ["pointer", "buffer", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_recovery_kind: { parameters: ["pointer"], result: "i64" },
+    galley_diagnostic_recovery_terminal: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_recovery_resume: { parameters: ["pointer", "buffer"], result: "i64" },
+    galley_diagnostic_recovery_lhs_variable: { parameters: ["pointer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_recovery_production: { parameters: ["pointer", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_diagnostic_recovery_occurrence: { parameters: ["pointer", "buffer", "buffer", "buffer", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_recorded_diagnostic_count: { parameters: ["pointer"], result: "i64" },
+    galley_recorded_diagnostic_kind: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_recorded_diagnostic_position: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_unexpected_token: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_diagnostic_message: { parameters: ["pointer", "u64", "buffer"], result: "i64" },
+    galley_recorded_indentation: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_semantic: { parameters: ["pointer", "u64", "buffer", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_recorded_expected_count: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_recorded_expected_token: { parameters: ["pointer", "u64", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_context_count: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_recorded_context_name: { parameters: ["pointer", "u64", "u64", "buffer", "buffer"], result: "i64" },
+    // NB: the implementation exports galley_recorded_diagnostic_recovery_kind
+    // (the header's shorter name is stale); `name` maps to the true symbol.
+    galley_recorded_recovery_kind: { name: "galley_recorded_diagnostic_recovery_kind", parameters: ["pointer", "u64"], result: "i64" },
+    galley_recorded_recovery_terminal: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_recovery_resume: { parameters: ["pointer", "u64", "buffer"], result: "i64" },
+    galley_recorded_recovery_lhs_variable: { parameters: ["pointer", "u64", "buffer", "buffer"], result: "i64" },
+    galley_recorded_recovery_production: { parameters: ["pointer", "u64", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_recorded_recovery_occurrence: { parameters: ["pointer", "u64", "buffer", "buffer", "buffer", "buffer", "buffer", "buffer"], result: "i64" },
+    galley_tree_append_children: { parameters: ["pointer", "u64", "u64"], result: "i64" },
+    galley_tree_insert_before: { parameters: ["pointer", "u64", "u64"], result: "i64" },
+    galley_tree_insert_after: { parameters: ["pointer", "u64", "u64"], result: "i64" },
+    galley_tree_remove_siblings: { parameters: ["pointer", "u64", "usize", "buffer"], result: "i64" },
+    galley_tree_remove_self: { parameters: ["pointer", "u64", "buffer"], result: "i64" },
+    galley_tree_promote_children_over_wrapper: { parameters: ["pointer", "u64", "buffer"], result: "i64" },
+    galley_tree_clean_children: { parameters: ["pointer", "u64", "buffer"], result: "i64" },
+    galley_tree_unlink_wrapper: { parameters: ["pointer", "u64"], result: "i64" },
+    galley_tree_insert_children_at: { parameters: ["pointer", "u64", "usize", "u64"], result: "i64" },
+    galley_tree_remove_children_at: { parameters: ["pointer", "u64", "usize", "usize", "buffer"], result: "i64" },
+    galley_procedure_session: { parameters: ["pointer"], result: "pointer" },
+    galley_procedure_current_node: { parameters: ["pointer"], result: "u64" },
+    galley_procedure_set_current_node: { parameters: ["pointer", "u64"], result: "void" },
+    galley_procedure_drop_self: { parameters: ["pointer"], result: "i64" },
+    galley_procedure_drop_children: { parameters: ["pointer"], result: "i64" },
+    galley_procedure_drop_if_empty: { parameters: ["pointer"], result: "i64" },
+    galley_procedure_replace_with_children: { parameters: ["pointer"], result: "i64" },
+    galley_procedure_context_line: { parameters: ["pointer"], result: "u32" },
+    galley_procedure_context_column: { parameters: ["pointer"], result: "u32" },
+    galley_procedure_report_semantic_error: { parameters: ["pointer", "buffer", "usize"], result: "i64" },
+};
+const DISPATCH_SYMBOL = {
+    galley_install_js_dispatch: { parameters: ["function"], result: "void" },
+};
+const ID_DISPATCH_SYMBOL = {
+    galley_install_js_dispatch_id: { parameters: ["function"], result: "void" },
+    galley_js_procedure_count: { parameters: [], result: "u32" },
+    galley_js_procedure_name_ptr: { parameters: ["u32"], result: "u64" },
+    galley_js_procedure_name_len: { parameters: ["u32"], result: "u64" },
+};
+const SELECTIVE_SYMBOL = {
+    galley_js_procedure_enable: { parameters: ["buffer", "usize"], result: "i32" },
+    galley_js_procedure_clear: { parameters: [], result: "void" },
+};
+function openNative(libPath, level) {
+    const symbols = 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 Deno.dlopen(libPath, symbols);
+}
+// --- read helpers ----------------------------------------------------------
+function readBytes(addr, len) {
+    if (addr === 0n || len === 0n)
+        return new Uint8Array(0);
+    const ptr = Deno.UnsafePointer.create(addr);
+    if (ptr === null)
+        return new Uint8Array(0);
+    const view = new Deno.UnsafePointerView(ptr);
+    // slice(0) copies: the native memory dies on the next parse.
+    return new Uint8Array(view.getArrayBuffer(Number(len)).slice(0));
+}
+function readCString(ptr) {
+    if (ptr === null)
+        return null;
+    return new Deno.UnsafePointerView(ptr).getCString();
+}
+function ptrOut() {
+    return new BigUint64Array(1);
+}
+function lenOut() {
+    return new BigUint64Array(1);
+}
+function u32Out() {
+    return new Uint32Array(1);
+}
+function i64Out() {
+    return new BigInt64Array(1);
+}
+// --- FfiPort implementation ----------------------------------------------
+export class DenoPort {
+    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();
+        for (const name of names) {
+            this.native.galley_js_procedure_enable(textEncoder.encode(name), name.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 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(textDecoder.decode(readBytes(ptrValue, len)));
+            }
+        }
+        this.#procedureNameTable = table;
+        return table;
+    }
+    // -- module-level queries --------------------------------------------
+    version() {
+        return readCString(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) {
+        return readCString(this.native.galley_status_string(BigInt(status)));
+    }
+    // -- 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(new Uint8Array(buf));
+        }
+        if (handle === null)
+            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, name, name.length, message, message.length));
+    }
+    // -- parsing ----------------------------------------------------------
+    parse(handle, data) {
+        return Number(this.native.galley_parse(handle, data, data.length));
+    }
+    parseFile(handle, filePath) {
+        const bytes = textEncoder.encode(filePath);
+        const nul = new Uint8Array(bytes.length + 1);
+        nul.set(bytes);
+        return Number(this.native.galley_parse_file(handle, nul));
+    }
+    lastPosition(handle) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_last_position(handle, outLine, 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, parent, firstChild, next, childCount, variable, spanStart, 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 === null)
+            return null;
+        return walker;
+    }
+    walkerNext(walker) {
+        const outNode = lenOut();
+        const outDepth = u32Out();
+        const outFlag = u32Out();
+        if (this.native.galley_walker_next(walker, outNode, outDepth, 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 = ptrOut();
+        const outLen = lenOut();
+        if (fn(outData, outLen) < 0n)
+            return null;
+        if (outData[0] === 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    #readSemanticPair(fn) {
+        const outVariable = ptrOut();
+        const outVariableLen = lenOut();
+        const outMessage = ptrOut();
+        const outMessageLen = lenOut();
+        if (fn(outVariable, outVariableLen, outMessage, outMessageLen) < 0n)
+            return null;
+        if (outVariable[0] === 0n || outMessage[0] === 0n)
+            return null;
+        return [
+            textDecoder.decode(readBytes(outVariable[0], outVariableLen[0])),
+            textDecoder.decode(readBytes(outMessage[0], outMessageLen[0])),
+        ];
+    }
+    nodeSymbolName(handle, node) {
+        const h = handle;
+        const outData = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_node_symbol_name(h, node, outData, outLen) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    nodeText(handle, node) {
+        const h = handle;
+        const outData = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_node_text(h, node, outData, outLen) < 0n)
+            return null;
+        return readBytes(outData[0], outLen[0]);
+    }
+    nodeSpan(handle, node) {
+        const outStart = lenOut();
+        const outLen = lenOut();
+        if (this.native.galley_node_span(handle, node, outStart, 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, outLine, 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 = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_symbol_name(h, BigInt(index), outData, 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 = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_variable_name(h, BigInt(index), outData, 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 = ptrOut();
+        if (this.native.galley_diagnostic_message(handle, out) !== 0n)
+            return null;
+        return readCString(Deno.UnsafePointer.create(out[0]));
+    }
+    diagnosticMessageAnsi(handle) {
+        const out = ptrOut();
+        if (this.native.galley_diagnostic_message_ansi(handle, out) !== 0n)
+            return null;
+        return readCString(Deno.UnsafePointer.create(out[0]));
+    }
+    diagnosticPosition(handle) {
+        const outLine = u32Out();
+        const outCol = u32Out();
+        if (this.native.galley_diagnostic_position(handle, outLine, 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, od, 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), od, 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), od, 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, ov, ovl, om, oml));
+    }
+    diagnosticIndentation(handle) {
+        const outSpaces = u32Out();
+        const outWidth = u32Out();
+        if (this.native.galley_diagnostic_indentation(handle, outSpaces, 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, od, ol));
+    }
+    diagnosticRecoveryResume(handle) {
+        const out = i64Out();
+        if (this.native.galley_diagnostic_recovery_resume(handle, out) !== 0n)
+            return null;
+        return Number(out[0]);
+    }
+    diagnosticRecoveryLhsVariable(handle) {
+        const h = handle;
+        const outData = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_diagnostic_recovery_lhs_variable(h, outData, outLen) < 0n || outData[0] === 0n)
+            return null;
+        return textDecoder.decode(readBytes(outData[0], outLen[0]));
+    }
+    diagnosticRecoveryProduction(handle) {
+        const h = handle;
+        const outVar = ptrOut();
+        const outLen = lenOut();
+        const outIdx = u32Out();
+        if (this.native.galley_diagnostic_recovery_production(h, outVar, outLen, outIdx) !== 0n)
+            return null;
+        return [textDecoder.decode(readBytes(outVar[0], outLen[0])), outIdx[0]];
+    }
+    diagnosticRecoveryOccurrence(handle) {
+        const h = handle;
+        const outParent = ptrOut();
+        const outParentLen = lenOut();
+        const outRhs = u32Out();
+        const outSym = u32Out();
+        const outVar = ptrOut();
+        const outVarLen = lenOut();
+        if (this.native.galley_diagnostic_recovery_occurrence(h, outParent, outParentLen, outRhs, outSym, outVar, outVarLen) !== 0n)
+            return null;
+        return [
+            textDecoder.decode(readBytes(outParent[0], outParentLen[0])),
+            outRhs[0],
+            outSym[0],
+            textDecoder.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), outLine, 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, od, ol));
+    }
+    recordedDiagnosticMessage(handle, diagIndex) {
+        const out = ptrOut();
+        if (this.native.galley_recorded_diagnostic_message(handle, BigInt(diagIndex), out) !== 0n)
+            return null;
+        return readCString(Deno.UnsafePointer.create(out[0]));
+    }
+    recordedIndentation(handle, diagIndex) {
+        const outSpaces = u32Out();
+        const outWidth = u32Out();
+        if (this.native.galley_recorded_indentation(handle, BigInt(diagIndex), outSpaces, 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, ov, ovl, om, 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, od, 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, od, ol));
+    }
+    recordedRecoveryKind(handle, diagIndex) {
+        return Number(this.native.galley_recorded_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, od, ol));
+    }
+    recordedRecoveryResume(handle, diagIndex) {
+        const out = i64Out();
+        if (this.native.galley_recorded_recovery_resume(handle, BigInt(diagIndex), out) !== 0n)
+            return null;
+        return Number(out[0]);
+    }
+    recordedRecoveryLhsVariable(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outData = ptrOut();
+        const outLen = lenOut();
+        if (this.native.galley_recorded_recovery_lhs_variable(h, d, outData, outLen) < 0n || outData[0] === 0n)
+            return null;
+        return textDecoder.decode(readBytes(outData[0], outLen[0]));
+    }
+    recordedRecoveryProduction(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outVar = ptrOut();
+        const outLen = lenOut();
+        const outIdx = u32Out();
+        if (this.native.galley_recorded_recovery_production(h, d, outVar, outLen, outIdx) !== 0n)
+            return null;
+        return [textDecoder.decode(readBytes(outVar[0], outLen[0])), outIdx[0]];
+    }
+    recordedRecoveryOccurrence(handle, diagIndex) {
+        const h = handle;
+        const d = BigInt(diagIndex);
+        const outParent = ptrOut();
+        const outParentLen = lenOut();
+        const outRhs = u32Out();
+        const outSym = u32Out();
+        const outVar = ptrOut();
+        const outVarLen = lenOut();
+        if (this.native.galley_recorded_recovery_occurrence(h, d, outParent, outParentLen, outRhs, outSym, outVar, outVarLen) !== 0n)
+            return null;
+        return [
+            textDecoder.decode(readBytes(outParent[0], outParentLen[0])),
+            outRhs[0],
+            outSym[0],
+            textDecoder.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 = lenOut();
+        const st = this.native.galley_tree_remove_siblings(handle, node, count, outHead);
+        return { status: Number(st), head: outHead[0] };
+    }
+    treeRemoveSelf(handle, node) {
+        const outHead = lenOut();
+        const st = this.native.galley_tree_remove_self(handle, node, outHead);
+        return { status: Number(st), head: outHead[0] };
+    }
+    treePromoteChildrenOverWrapper(handle, wrapper) {
+        const outHead = lenOut();
+        const st = this.native.galley_tree_promote_children_over_wrapper(handle, wrapper, outHead);
+        return { status: Number(st), head: outHead[0] };
+    }
+    treeCleanChildren(handle, node) {
+        const outHead = lenOut();
+        const st = this.native.galley_tree_clean_children(handle, node, 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, index, first));
+    }
+    treeRemoveChildrenAt(handle, parent, index, count) {
+        const outHead = lenOut();
+        const st = this.native.galley_tree_remove_children_at(handle, parent, index, count, 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, message, message.length));
+    }
+}
+const portCache = new Map();
+/** Port for the library at `explicitPath` (or default discovery), cached per path. */
+export function getDenoPort(explicitPath) {
+    const libPath = findLibrary(explicitPath);
+    const cached = portCache.get(libPath);
+    if (cached)
+        return cached;
+    // Libraries built for C procedures lack the JS dispatch symbol; dlopen
+    // fails on missing symbols, so fall back to a dispatch-less table.
+    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 DenoPort(native, libPath, supportsDispatch);
+    portCache.set(libPath, port);
+    return port;
+}
+//# sourceMappingURL=ffi.js.map