galley-js-wasm 0.0.1

package/README.md

@@ -0,0 +1,8 @@
+# JavaScript Bindings for WebAssembly
+
+`galley-js-core` over a WASI reactor module and `bindings/c/galley.h`. No
+native dependencies beyond the built parser module.
+
+See `docs/bindings_js_wasm.md` and `examples/js/wasm` for the consumer flow.
+
+One module embeds one parser; sessions are not thread-safe.

package/build.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * Builds a Galley parser and its WebAssembly module for a JavaScript consumer.
+ *
+ * Usage:
+ *   npx galley-js-wasm <language-dir>
+ *
+ * Thin wrapper over the shared gate (`galley-js-core/build/builder.mjs`),
+ * which documents the accepted grammar files and owns the build. For both
+ * legs at once, use the single entry instead: `galley build <language-dir>`
+ * from `@sanbus-org/galley`.
+ */
+
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildParserArtifact } from "galley-js-core/build/builder.mjs";
+
+const LIBRARY_NAME = "galley-js-wasm";
+
+function fatal(message) {
+  console.error(`galley-bindings: ${message}`);
+  process.exit(1);
+}
+
+async function main() {
+  if (process.argv.length !== 3) fatal("usage: npx galley-js-wasm <language-dir>");
+  await buildParserArtifact({
+    languageDirectory: process.argv[2],
+    libraryName: LIBRARY_NAME,
+    wasm: true,
+    posixOnly: false,
+    bindingsDirectory: path.dirname(fileURLToPath(import.meta.url)),
+    dependencyName: "galley-js-core",
+  });
+}
+
+main().catch((error) => fatal(error?.message ?? String(error)));

package/dist/dispatch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * WebAssembly procedure-dispatch setup.
+ *
+ * Unlike the native adapters there is nothing to install: the wasm module
+ * unconditionally imports `env.galley_js_dispatch_id`, which forwards every
+ * parser hook ID to the core registry (unregistered names are no-ops there,
+ * matching native semantics). This module only owns the `require()`-based
+ * auto-scan of `procedures.*` in the language directory, mirroring the Node
+ * adapter. Outside Node (browsers) the scan is skipped — register hooks
+ * explicitly with `installProcedures` from `galley-js-core`.
+ */
+export declare function ensureDispatch(wasmPath?: string): void;

package/dist/dispatch.js

@@ -0,0 +1,62 @@
+/**
+ * WebAssembly procedure-dispatch setup.
+ *
+ * Unlike the native adapters there is nothing to install: the wasm module
+ * unconditionally imports `env.galley_js_dispatch_id`, which forwards every
+ * parser hook ID to the core registry (unregistered names are no-ops there,
+ * matching native semantics). This module only owns the `require()`-based
+ * auto-scan of `procedures.*` in the language directory, mirroring the Node
+ * adapter. Outside Node (browsers) the scan is skipped — register hooks
+ * explicitly with `installProcedures` from `galley-js-core`.
+ */
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { installProcedures, listProcedures } from "galley-js-core";
+let autoAttempted = false;
+function isProcedureName(name) {
+    return name === "reduction" || name.startsWith("reduction_") || name.startsWith("hook_");
+}
+function isNode() {
+    return (typeof process !== "undefined" &&
+        typeof process.versions?.node === "string");
+}
+export function ensureDispatch(wasmPath) {
+    if (listProcedures().length > 0 || autoAttempted)
+        return;
+    autoAttempted = true;
+    if (!isNode())
+        return;
+    const require = createRequire(import.meta.url);
+    const tryLoadModule = (modulePath) => {
+        try {
+            const loadedModule = require(modulePath);
+            let hasHook = false;
+            for (const [name, value] of Object.entries(loadedModule)) {
+                if (typeof value !== "function" || !isProcedureName(name))
+                    continue;
+                hasHook = true;
+                break;
+            }
+            if (hasHook)
+                return installProcedures(loadedModule) > 0;
+            const defaultExport = loadedModule.default;
+            if (defaultExport && typeof defaultExport === "object") {
+                return installProcedures(defaultExport) > 0;
+            }
+        }
+        catch { }
+        return false;
+    };
+    // One place: the directory holding the loaded module. Anything found
+    // there belongs to this grammar; nothing else is even looked at.
+    // Byte-fed modules ("<bytes>") have no directory: nothing to scan.
+    if (!wasmPath || wasmPath === "<bytes>")
+        return;
+    const baseDirectory = path.dirname(path.resolve(wasmPath));
+    const extensions = ["", ".js", ".ts"];
+    for (const extension of extensions) {
+        if (tryLoadModule(path.join(baseDirectory, `procedures${extension}`)))
+            return;
+    }
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEnE,IAAI,aAAa,GAAG,KAAK,CAAC;AAE1B,SAAS,eAAe,CAAC,IAAY;IACnC,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AAC3F,CAAC;AAED,SAAS,MAAM;IACb,OAAO,CACL,OAAO,OAAO,KAAK,WAAW;QAC9B,OAAQ,OAAuD,CAAC,QAAQ,EAAE,IAAI,KAAK,QAAQ,CAC5F,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,QAAiB;IAC9C,IAAI,cAAc,EAAE,CAAC,MAAM,GAAG,CAAC,IAAI,aAAa;QAAE,OAAO;IACzD,aAAa,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,MAAM,EAAE;QAAE,OAAO;IACtB,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,aAAa,GAAG,CAAC,UAAkB,EAAW,EAAE;QACpD,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAA4B,CAAC;YACpE,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;gBACzD,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;oBAAE,SAAS;gBACpE,OAAO,GAAG,IAAI,CAAC;gBACf,MAAM;YACR,CAAC;YACD,IAAI,OAAO;gBAAE,OAAO,iBAAiB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YACxD,MAAM,aAAa,GAAI,YAAwC,CAAC,OAEnD,CAAC;YACd,IAAI,aAAa,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;gBACvD,OAAO,iBAAiB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAAC,MAAM,CAAC,CAAA,CAAC;QACV,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,qEAAqE;IACrE,iEAAiE;IACjE,mEAAmE;IACnE,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO;IAChD,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3D,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACtC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,aAAa,SAAS,EAAE,CAAC,CAAC;YAAE,OAAO;IAChF,CAAC;AACH,CAAC"}

package/dist/ffi.d.ts

@@ -0,0 +1,303 @@
+/**
+ * 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 `galley-js-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 type { FfiPort, Handle, SessionCOptions, TreeSnapshot, WalkedStep } from "galley-js-core";
+export declare class NeedInitError extends Error {
+    constructor(libraryPath?: string);
+}
+/** Callable view of the wasm exports (wasm32: pointers/i32 are `number`, i64/u64 are `bigint`). */
+interface GalleyWasmExports {
+    memory: WebAssembly.Memory;
+    _initialize?: unknown;
+    galley_js_malloc(len: number): number;
+    galley_js_free(ptr: number, len: number): void;
+    galley_version(): number;
+    galley_parser_type(): bigint;
+    galley_error_recovery_mode(): bigint;
+    galley_has_ast(): number;
+    galley_has_procedures(): number;
+    galley_allows_no_ast_tree_procedures(): number;
+    galley_source_retention_enabled(): number;
+    galley_has_position_tracking(): number;
+    galley_has_input_streaming(): number;
+    galley_uses_verbatim(): number;
+    galley_stack_overflow_recovery_available(): number;
+    galley_symbol_count(): bigint;
+    galley_variable_count(): bigint;
+    galley_status_string(status: bigint): number;
+    galley_symbol_name(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_symbol_is_terminal(session: number, index: bigint): number;
+    galley_variable_name(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_session_create(): number;
+    galley_session_create_ex(options: number): number;
+    galley_session_destroy(session: number): void;
+    galley_session_set_message_override(session: number, name: number, nameLen: number, message: number, messageLen: number): bigint;
+    galley_parse(session: number, data: number, len: number): bigint;
+    galley_node_count(session: number): bigint;
+    galley_reserve_nodes(session: number, capacity: bigint): bigint;
+    galley_node_capacity(session: number): bigint;
+    galley_root_node(session: number): bigint;
+    galley_node_is_valid(session: number, node: bigint): number;
+    galley_node_child_count(session: number, node: bigint): number;
+    galley_node_first_child(session: number, node: bigint): bigint;
+    galley_node_last_child(session: number, node: bigint): bigint;
+    galley_node_next_sibling(session: number, node: bigint): bigint;
+    galley_node_prior_sibling(session: number, node: bigint): bigint;
+    galley_node_parent(session: number, node: bigint): bigint;
+    galley_tree_snapshot(session: number, outParent: number, outFirstChild: number, outNext: number, outChildCount: number, outVariable: number, outSpanStart: number, outSpanLen: number, capacity: bigint): bigint;
+    galley_walker_create(session: number, node: bigint, skipSemanticErrors: number): number;
+    galley_walker_next(walker: number, outNode: number, outDepth: number, outFlag: number): number;
+    galley_walker_skip_children(walker: number): void;
+    galley_walker_destroy(walker: number): void;
+    galley_node_symbol_name(session: number, node: bigint, outData: number, outLen: number): bigint;
+    galley_node_text(session: number, node: bigint, outData: number, outLen: number): bigint;
+    galley_node_span(session: number, node: bigint, outStart: number, outLen: number): bigint;
+    galley_node_line_column(session: number, node: bigint, outLine: number, outCol: number): bigint;
+    galley_node_variable_index(session: number, node: bigint): bigint;
+    galley_last_position(session: number, outLine: number, outCol: number): bigint;
+    galley_has_diagnostic(session: number): number;
+    galley_diagnostic_kind(session: number): bigint;
+    galley_diagnostic_message(session: number, out: number): bigint;
+    galley_diagnostic_message_ansi(session: number, out: number): bigint;
+    galley_diagnostic_position(session: number, outLine: number, outCol: number): bigint;
+    galley_diagnostic_unexpected_token(session: number, outData: number, outLen: number): bigint;
+    galley_diagnostic_expected_count(session: number): bigint;
+    galley_diagnostic_expected_at(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_diagnostic_context_count(session: number): bigint;
+    galley_diagnostic_context_at(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_diagnostic_indentation(session: number, outSpaces: number, outWidth: number): bigint;
+    galley_syntax_error_count(session: number): bigint;
+    galley_semantic_error_count(session: number): bigint;
+    galley_diagnostic_semantic(session: number, outVariable: number, outVariableLen: number, outMessage: number, outMessageLen: number): bigint;
+    galley_diagnostic_recovery_kind(session: number): bigint;
+    galley_diagnostic_recovery_terminal(session: number, outData: number, outLen: number): bigint;
+    galley_diagnostic_recovery_resume(session: number, out: number): bigint;
+    galley_diagnostic_recovery_lhs_variable(session: number, outData: number, outLen: number): bigint;
+    galley_diagnostic_recovery_production(session: number, outVar: number, outLen: number, outIndex: number): bigint;
+    galley_diagnostic_recovery_occurrence(session: number, outParent: number, outParentLen: number, outRhs: number, outSym: number, outVar: number, outVarLen: number): bigint;
+    galley_recorded_diagnostic_count(session: number): bigint;
+    galley_recorded_diagnostic_kind(session: number, index: bigint): bigint;
+    galley_recorded_diagnostic_position(session: number, index: bigint, outLine: number, outCol: number): bigint;
+    galley_recorded_unexpected_token(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_recorded_diagnostic_message(session: number, index: bigint, out: number): bigint;
+    galley_recorded_indentation(session: number, index: bigint, outSpaces: number, outWidth: number): bigint;
+    galley_recorded_semantic(session: number, index: bigint, outVariable: number, outVariableLen: number, outMessage: number, outMessageLen: number): bigint;
+    galley_recorded_expected_count(session: number, index: bigint): bigint;
+    galley_recorded_expected_token(session: number, index: bigint, tokenIndex: bigint, outData: number, outLen: number): bigint;
+    galley_recorded_context_count(session: number, index: bigint): bigint;
+    galley_recorded_context_name(session: number, index: bigint, contextIndex: bigint, outData: number, outLen: number): bigint;
+    galley_recorded_diagnostic_recovery_kind(session: number, index: bigint): bigint;
+    galley_recorded_recovery_terminal(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_recorded_recovery_resume(session: number, index: bigint, out: number): bigint;
+    galley_recorded_recovery_lhs_variable(session: number, index: bigint, outData: number, outLen: number): bigint;
+    galley_recorded_recovery_production(session: number, index: bigint, outVar: number, outLen: number, outIdx: number): bigint;
+    galley_recorded_recovery_occurrence(session: number, index: bigint, outParent: number, outParentLen: number, outRhs: number, outSym: number, outVar: number, outVarLen: number): bigint;
+    galley_tree_append_children(session: number, parent: bigint, first: bigint): bigint;
+    galley_tree_insert_before(session: number, target: bigint, first: bigint): bigint;
+    galley_tree_insert_after(session: number, target: bigint, first: bigint): bigint;
+    galley_tree_remove_siblings(session: number, node: bigint, count: number, outHead: number): bigint;
+    galley_tree_remove_self(session: number, node: bigint, outHead: number): bigint;
+    galley_tree_promote_children_over_wrapper(session: number, wrapper: bigint, outHead: number): bigint;
+    galley_tree_clean_children(session: number, node: bigint, outHead: number): bigint;
+    galley_tree_unlink_wrapper(session: number, wrapper: bigint): bigint;
+    galley_tree_insert_children_at(session: number, parent: bigint, index: number, first: bigint): bigint;
+    galley_tree_remove_children_at(session: number, parent: bigint, index: number, count: number, outHead: number): bigint;
+    galley_procedure_current_node(args: number): bigint;
+    galley_procedure_set_current_node(args: number, node: bigint): void;
+    galley_procedure_drop_self(args: number): bigint;
+    galley_procedure_drop_children(args: number): bigint;
+    galley_procedure_drop_if_empty(args: number): bigint;
+    galley_procedure_replace_with_children(args: number): bigint;
+    galley_procedure_context_line(args: number): number;
+    galley_procedure_context_column(args: number): number;
+    galley_procedure_report_semantic_error(args: number, message: number, messageLen: number): bigint;
+    galley_js_procedure_count?(): number;
+    galley_js_procedure_name_ptr?(index: number): number;
+    galley_js_procedure_name_len?(index: number): number;
+    galley_js_procedure_enable?(namePtr: number, nameLen: number): number;
+    galley_js_procedure_clear?(): void;
+}
+export declare function wasmFileName(base?: string): string;
+export declare function findLibrary(explicit?: string): string;
+export interface InitOptions {
+    /** Grammar module path. Defaults to discovery (`findLibrary()` under Node). */
+    libraryPath?: string;
+    /** Raw module bytes (browsers, tests). Wins over `libraryPath`/`url`. */
+    bytes?: Uint8Array;
+    /** Module URL for `fetch` (browsers). Wins over `libraryPath`. */
+    url?: string | URL;
+}
+/** Async entry point; the only way to initialize in browsers. */
+export declare function init(options?: InitOptions): Promise<void>;
+/** Synchronous entry point; Node only (file read + `WebAssembly.Module`). */
+export declare function initSync(options?: InitOptions): void;
+/** Seed the default cache key (used by `init({ bytes })` without a path). */
+export declare function seedDefault(wasmPath: string): void;
+/**
+ * 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 declare function getWasmPort(libraryPath?: string): WasmPort;
+/**
+ * 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 declare class WasmPort implements FfiPort {
+    #private;
+    readonly wasm: GalleyWasmExports;
+    readonly libraryPath: string;
+    constructor(wasm: GalleyWasmExports, libraryPath: string);
+    /** Guest hook entry: decode the name and forward to the core registry. */
+    dispatchFromGuest(namePtr: number, nameLen: number, argsPtr: number): void;
+    /** Guest hook entry (current builds): integer hook ID, no strings cross. */
+    dispatchFromGuestById(id: number, argsPtr: number): void;
+    procedureNames(): string[];
+    private memoryBytes;
+    private dataView;
+    private malloc;
+    private free;
+    /** Copy guest bytes out (owned copy, valid after the next call). */
+    private readBytes;
+    private readCString;
+    /** Copy host bytes in; zero-length inputs still get a non-null slot. */
+    private writeBytes;
+    version(): string;
+    parserType(): number;
+    errorRecoveryMode(): number;
+    hasAst(): boolean;
+    hasProcedures(): boolean;
+    allowsNoAstTreeProcedures(): boolean;
+    sourceRetentionEnabled(): boolean;
+    hasPositionTracking(): boolean;
+    hasInputStreaming(): boolean;
+    usesVerbatim(): boolean;
+    stackOverflowRecoveryAvailable(): boolean;
+    symbolCount(): number;
+    variableCount(): number;
+    statusString(status: number): string | null;
+    createSession(options: SessionCOptions | null): Handle;
+    destroySession(handle: Handle): void;
+    setMessageOverride(handle: Handle, name: Uint8Array, message: Uint8Array): number;
+    parse(handle: Handle, data: Uint8Array): number;
+    parseFile(handle: Handle, filePath: string): number;
+    lastPosition(handle: Handle): [number, number] | null;
+    nodeCount(handle: Handle): number;
+    reserveNodes(handle: Handle, capacity: bigint): number;
+    nodeCapacity(handle: Handle): number;
+    rootNode(handle: Handle): bigint;
+    nodeValid(handle: Handle, node: bigint): boolean;
+    childCount(handle: Handle, node: bigint): number;
+    firstChild(handle: Handle, node: bigint): bigint;
+    lastChild(handle: Handle, node: bigint): bigint;
+    nextSibling(handle: Handle, node: bigint): bigint;
+    priorSibling(handle: Handle, node: bigint): bigint;
+    parent(handle: Handle, node: bigint): bigint;
+    treeSnapshot(handle: Handle): TreeSnapshot;
+    walkerCreate(handle: Handle, node: bigint, skipSemanticErrors: boolean): Handle | null;
+    walkerNext(walker: Handle): WalkedStep | null;
+    walkerSkipChildren(walker: Handle): void;
+    walkerDestroy(walker: Handle): void;
+    /** Read a guest `(data, len)` byte pair; null on negative status. */
+    private tryCopyBytes;
+    private readSemanticPair;
+    nodeSymbolName(handle: Handle, node: bigint): Uint8Array | null;
+    nodeText(handle: Handle, node: bigint): Uint8Array | null;
+    nodeSpan(handle: Handle, node: bigint): [bigint, bigint] | null;
+    nodeLineColumn(handle: Handle, node: bigint): [number, number] | null;
+    nodeVariableIndex(handle: Handle, node: bigint): number;
+    symbolNameAt(handle: Handle, index: number): Uint8Array | null;
+    symbolIsTerminal(handle: Handle, index: number): boolean;
+    variableNameAt(handle: Handle, index: number): Uint8Array | null;
+    hasDiagnostic(handle: Handle): boolean;
+    diagnosticKind(handle: Handle): number;
+    diagnosticMessage(handle: Handle): string | null;
+    diagnosticMessageAnsi(handle: Handle): string | null;
+    diagnosticPosition(handle: Handle): [number, number] | null;
+    diagnosticUnexpectedToken(handle: Handle): Uint8Array | null;
+    diagnosticExpectedCount(handle: Handle): number;
+    diagnosticExpectedAt(handle: Handle, index: number): Uint8Array | null;
+    diagnosticContextCount(handle: Handle): number;
+    diagnosticContextAt(handle: Handle, index: number): Uint8Array | null;
+    syntaxErrorCount(handle: Handle): number;
+    semanticErrorCount(handle: Handle): number;
+    diagnosticSemantic(handle: Handle): [string, string] | null;
+    diagnosticIndentation(handle: Handle): [number, number] | null;
+    diagnosticRecoveryKind(handle: Handle): number;
+    diagnosticRecoveryTerminal(handle: Handle): Uint8Array | null;
+    diagnosticRecoveryResume(handle: Handle): number | null;
+    diagnosticRecoveryLhsVariable(handle: Handle): string | null;
+    diagnosticRecoveryProduction(handle: Handle): [string, number] | null;
+    diagnosticRecoveryOccurrence(handle: Handle): [string, number, number, string] | null;
+    recordedDiagnosticCount(handle: Handle): number;
+    recordedDiagnosticKind(handle: Handle, diagIndex: number): number;
+    recordedDiagnosticPosition(handle: Handle, diagIndex: number): [number, number] | null;
+    recordedUnexpectedToken(handle: Handle, diagIndex: number): Uint8Array | null;
+    recordedDiagnosticMessage(handle: Handle, diagIndex: number): string | null;
+    recordedIndentation(handle: Handle, diagIndex: number): [number, number] | null;
+    recordedSemantic(handle: Handle, diagIndex: number): [string, string] | null;
+    recordedExpectedCount(handle: Handle, diagIndex: number): number;
+    recordedExpectedToken(handle: Handle, diagIndex: number, tokenIndex: number): Uint8Array | null;
+    recordedContextCount(handle: Handle, diagIndex: number): number;
+    recordedContextName(handle: Handle, diagIndex: number, contextIndex: number): Uint8Array | null;
+    recordedRecoveryKind(handle: Handle, diagIndex: number): number;
+    recordedRecoveryTerminal(handle: Handle, diagIndex: number): Uint8Array | null;
+    recordedRecoveryResume(handle: Handle, diagIndex: number): number | null;
+    recordedRecoveryLhsVariable(handle: Handle, diagIndex: number): string | null;
+    recordedRecoveryProduction(handle: Handle, diagIndex: number): [string, number] | null;
+    recordedRecoveryOccurrence(handle: Handle, diagIndex: number): [string, number, number, string] | null;
+    treeAppendChildren(handle: Handle, parent: bigint, first: bigint): number;
+    treeInsertBefore(handle: Handle, target: bigint, first: bigint): number;
+    treeInsertAfter(handle: Handle, target: bigint, first: bigint): number;
+    treeRemoveSiblings(handle: Handle, node: bigint, count: number): {
+        status: number;
+        head: bigint;
+    };
+    treeRemoveSelf(handle: Handle, node: bigint): {
+        status: number;
+        head: bigint;
+    };
+    treePromoteChildrenOverWrapper(handle: Handle, wrapper: bigint): {
+        status: number;
+        head: bigint;
+    };
+    treeCleanChildren(handle: Handle, node: bigint): {
+        status: number;
+        head: bigint;
+    };
+    treeUnlinkWrapper(handle: Handle, wrapper: bigint): number;
+    treeInsertChildrenAt(handle: Handle, parent: bigint, index: number, first: bigint): number;
+    treeRemoveChildrenAt(handle: Handle, parent: bigint, index: number, count: number): {
+        status: number;
+        head: bigint;
+    };
+    procCurrentNode(args: Handle): bigint;
+    procSetCurrentNode(args: Handle, node: bigint): void;
+    procDropSelf(args: Handle): number;
+    procDropChildren(args: Handle): number;
+    procDropIfEmpty(args: Handle): number;
+    procReplaceWithChildren(args: Handle): number;
+    procContextLine(args: Handle): number;
+    procContextColumn(args: Handle): number;
+    procReportSemanticError(args: Handle, message: Uint8Array): number;
+    syncProcedures(names: string[]): void;
+}
+export {};