@ff-labs/fff-node 0.1.0-nightly.28ebf7a

package/dist/src/binary.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Binary resolution utilities for fff-node
+ *
+ * Resolves the native library from:
+ * 1. Platform-specific npm package (e.g. @ff-labs/fff-bin-darwin-arm64)
+ * 2. Local dev build (target/release or target/debug)
+ */
+/**
+ * Check if the binary exists in any known location
+ */
+export declare function binaryExists(): boolean;
+/**
+ * Find the native library binary.
+ *
+ * Resolution order:
+ * - Dev workspace: local dev build first, then npm package
+ * - Production: npm package first, then dev build
+ *
+ * @returns Absolute path to the library, or null if not found
+ */
+export declare function findBinary(): string | null;
+//# sourceMappingURL=binary.d.ts.map

package/dist/src/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../src/binary.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8CH;;GAEG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AA0DD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAuB1C"}

package/dist/src/binary.js

@@ -0,0 +1,135 @@
+/**
+ * Binary resolution utilities for fff-node
+ *
+ * Resolves the native library from:
+ * 1. Platform-specific npm package (e.g. @ff-labs/fff-bin-darwin-arm64)
+ * 2. Local dev build (target/release or target/debug)
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLibFilename, getNpmPackageName } from "./platform.js";
+/**
+ * Get the current file's directory
+ */
+function getCurrentDir() {
+    const url = import.meta.url;
+    if (url.startsWith("file://")) {
+        return dirname(fileURLToPath(url));
+    }
+    return dirname(url);
+}
+/**
+ * Get the package root directory
+ */
+function getPackageDir() {
+    const currentDir = getCurrentDir();
+    // In dev: src/ -> package root
+    // In dist: dist/src/ -> package root
+    // We look for package.json to find the actual root
+    let dir = currentDir;
+    for (let i = 0; i < 5; i++) {
+        if (existsSync(join(dir, "package.json"))) {
+            try {
+                const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+                if (pkg.name === "@ff-labs/fff-node") {
+                    return dir;
+                }
+            }
+            catch {
+                // Not our package.json, keep going up
+            }
+        }
+        dir = dirname(dir);
+    }
+    // Fallback: assume we're one level deep in src/
+    return dirname(currentDir);
+}
+/**
+ * Check if the binary exists in any known location
+ */
+export function binaryExists() {
+    return findBinary() !== null;
+}
+/**
+ * Try to resolve the binary from the platform-specific npm package.
+ *
+ * When users install @ff-labs/fff-node, npm automatically installs the matching
+ * optionalDependency (e.g. @ff-labs/fff-bin-darwin-arm64). We resolve the binary
+ * path by requiring that package's package.json and looking for the binary
+ * in the same directory.
+ */
+function resolveFromNpmPackage() {
+    const packageName = getNpmPackageName();
+    try {
+        // Use createRequire to resolve the platform package's location
+        const require = createRequire(join(getPackageDir(), "package.json"));
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
+        const packageDir = dirname(packageJsonPath);
+        const binaryPath = join(packageDir, getLibFilename());
+        if (existsSync(binaryPath)) {
+            return binaryPath;
+        }
+    }
+    catch {
+        // Package not installed - this is expected on unsupported platforms
+        // or when installed without optional dependencies
+    }
+    return null;
+}
+/**
+ * Get the development binary path (for local development)
+ */
+function getDevBinaryPath() {
+    const packageDir = getPackageDir();
+    const workspaceRoot = join(packageDir, "..", "..");
+    const possiblePaths = [
+        join(workspaceRoot, "target", "release", getLibFilename()),
+        join(workspaceRoot, "target", "debug", getLibFilename()),
+    ];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+function isDevWorkspace() {
+    const packageDir = getPackageDir();
+    const workspaceRoot = join(packageDir, "..", "..");
+    return existsSync(join(workspaceRoot, "Cargo.toml"));
+}
+/**
+ * Find the native library binary.
+ *
+ * Resolution order:
+ * - Dev workspace: local dev build first, then npm package
+ * - Production: npm package first, then dev build
+ *
+ * @returns Absolute path to the library, or null if not found
+ */
+export function findBinary() {
+    if (isDevWorkspace()) {
+        // 1. Local bin/ directory (populated by `make prepare-node`)
+        const binPath = join(getPackageDir(), "bin", getLibFilename());
+        if (existsSync(binPath))
+            return binPath;
+        // 2. Local dev build (target/release or target/debug)
+        const devPath = getDevBinaryPath();
+        if (devPath)
+            return devPath;
+        // 3. Fallback to npm package
+        const npmPath = resolveFromNpmPackage();
+        if (npmPath)
+            return npmPath;
+        return null;
+    }
+    // Production: npm package first
+    const npmPath = resolveFromNpmPackage();
+    if (npmPath)
+        return npmPath;
+    // Fallback: local dev build (e.g. user built from source)
+    return getDevBinaryPath();
+}
+//# sourceMappingURL=binary.js.map

package/dist/src/binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sourceRoot":"","sources":["../../src/binary.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElE;;GAEG;AACH,SAAS,aAAa;IACpB,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;IAE5B,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,OAAO,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,SAAS,aAAa;IACpB,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;IACnC,+BAA+B;IAC/B,qCAAqC;IACrC,mDAAmD;IACnD,IAAI,GAAG,GAAG,UAAU,CAAC;IACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;gBACzE,IAAI,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;oBACrC,OAAO,GAAG,CAAC;gBACb,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,sCAAsC;YACxC,CAAC;QACH,CAAC;QACD,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,gDAAgD;IAChD,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,UAAU,EAAE,KAAK,IAAI,CAAC;AAC/B,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,qBAAqB;IAC5B,MAAM,WAAW,GAAG,iBAAiB,EAAE,CAAC;IAExC,IAAI,CAAC;QACH,+DAA+D;QAC/D,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC;QACrE,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,WAAW,eAAe,CAAC,CAAC;QACvE,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,cAAc,EAAE,CAAC,CAAC;QAEtD,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;YAC3B,OAAO,UAAU,CAAC;QACpB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,oEAAoE;QACpE,kDAAkD;IACpD,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB;IACvB,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;IACnC,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAEnD,MAAM,aAAa,GAAG;QACpB,IAAI,CAAC,aAAa,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;QAC1D,IAAI,CAAC,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;KACzD,CAAC;IAEF,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;QACjC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,cAAc;IACrB,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;IACnC,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACnD,OAAO,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU;IACxB,IAAI,cAAc,EAAE,EAAE,CAAC;QACrB,6DAA6D;QAC7D,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;QAC/D,IAAI,UAAU,CAAC,OAAO,CAAC;YAAE,OAAO,OAAO,CAAC;QAExC,sDAAsD;QACtD,MAAM,OAAO,GAAG,gBAAgB,EAAE,CAAC;QACnC,IAAI,OAAO;YAAE,OAAO,OAAO,CAAC;QAE5B,6BAA6B;QAC7B,MAAM,OAAO,GAAG,qBAAqB,EAAE,CAAC;QACxC,IAAI,OAAO;YAAE,OAAO,OAAO,CAAC;QAE5B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gCAAgC;IAChC,MAAM,OAAO,GAAG,qBAAqB,EAAE,CAAC;IACxC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAE5B,0DAA0D;IAC1D,OAAO,gBAAgB,EAAE,CAAC;AAC5B,CAAC"}

package/dist/src/ffi.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Node.js FFI bindings for the fff-c native library using ffi-rs
+ *
+ * This module uses ffi-rs to call into the Rust C library.
+ * All functions follow the Result pattern for error handling.
+ *
+ * The API is instance-based: `ffiCreate` returns an opaque handle that must
+ * be passed to all subsequent calls and freed with `ffiDestroy`.
+ *
+ * ## Memory management
+ *
+ * Every `fff_*` function returning `*mut FffResult` allocates with Rust's Box.
+ * We MUST call `fff_free_result` to properly deallocate (not libc::free).
+ *
+ * ## FffResult struct reading
+ *
+ * The FffResult struct layout (#[repr(C)]):
+ *   offset  0: success (bool, 1 byte + 7 padding)
+ *   offset  8: data pointer (8 bytes) - *mut c_char (JSON string or null)
+ *   offset 16: error pointer (8 bytes) - *mut c_char (error message or null)
+ *   offset 24: handle pointer (8 bytes) - *mut c_void (instance handle or null)
+ *
+ * ## Two-step approach for reading + freeing
+ *
+ * ffi-rs auto-dereferences struct retType pointers, losing the original pointer.
+ * We solve this by:
+ * 1. Calling the C function with `retType: DataType.External` to get the raw pointer
+ * 2. Using `restorePointer` to read the struct fields from the raw pointer
+ * 3. Calling `fff_free_result` with the original raw pointer
+ *
+ * ## Null pointer detection
+ *
+ * `isNullPointer` from ffi-rs correctly detects null C pointers wrapped as
+ * V8 External objects. We use this instead of truthy checks.
+ */
+import { type JsExternal } from "ffi-rs";
+import type { Result } from "./types.js";
+/**
+ * Opaque native handle type. Callers must not inspect or modify this value.
+ */
+export type NativeHandle = JsExternal;
+/**
+ * Create a new file finder instance.
+ *
+ * Returns the opaque native handle on success. The handle must be passed to
+ * all subsequent FFI calls and freed with `ffiDestroy`.
+ */
+export declare function ffiCreate(optsJson: string): Result<NativeHandle>;
+/**
+ * Destroy and clean up an instance.
+ */
+export declare function ffiDestroy(handle: NativeHandle): void;
+/**
+ * Perform fuzzy search.
+ */
+export declare function ffiSearch(handle: NativeHandle, query: string, optsJson: string): Result<unknown>;
+/**
+ * Trigger file scan.
+ */
+export declare function ffiScanFiles(handle: NativeHandle): Result<void>;
+/**
+ * Check if scanning.
+ */
+export declare function ffiIsScanning(handle: NativeHandle): boolean;
+/**
+ * Get scan progress.
+ */
+export declare function ffiGetScanProgress(handle: NativeHandle): Result<unknown>;
+/**
+ * Wait for a tree scan to complete.
+ */
+export declare function ffiWaitForScan(handle: NativeHandle, timeoutMs: number): Result<boolean>;
+/**
+ * Restart index in new path.
+ */
+export declare function ffiRestartIndex(handle: NativeHandle, newPath: string): Result<void>;
+/**
+ * Refresh git status.
+ */
+export declare function ffiRefreshGitStatus(handle: NativeHandle): Result<number>;
+/**
+ * Track query completion.
+ */
+export declare function ffiTrackQuery(handle: NativeHandle, query: string, filePath: string): Result<boolean>;
+/**
+ * Get historical query.
+ */
+export declare function ffiGetHistoricalQuery(handle: NativeHandle, offset: number): Result<string | null>;
+/**
+ * Health check.
+ *
+ * `handle` can be null for a limited check (version + git only).
+ * When null, we pass DataType.U64 with value 0 as a null pointer workaround
+ * since ffi-rs does not accept `null` for External parameters.
+ */
+export declare function ffiHealthCheck(handle: NativeHandle | null, testPath: string): Result<unknown>;
+/**
+ * Live grep - search file contents.
+ */
+export declare function ffiLiveGrep(handle: NativeHandle, query: string, optsJson: string): Result<unknown>;
+/**
+ * Multi-pattern grep - Aho-Corasick multi-needle search.
+ */
+export declare function ffiMultiGrep(handle: NativeHandle, optsJson: string): Result<unknown>;
+/**
+ * Ensure the library is loaded.
+ *
+ * Loads the native library from the platform-specific npm package
+ * or a local dev build. Throws if the binary is not found.
+ */
+export declare function ensureLoaded(): void;
+/**
+ * Check if the library is available.
+ */
+export declare function isAvailable(): boolean;
+/**
+ * Close the library and release ffi-rs resources.
+ * Call this when completely done with the library.
+ */
+export declare function closeLibrary(): void;
+//# sourceMappingURL=ffi.d.ts.map

package/dist/src/ffi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ffi.d.ts","sourceRoot":"","sources":["../../src/ffi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAIL,KAAK,UAAU,EAKhB,MAAM,QAAQ,CAAC;AAEhB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAmLzC;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,CAyBhE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CASrD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,OAAO,CAAC,CAMjB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,CAE/D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAS3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,CAExE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAQvF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAMnF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,CAcxE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,OAAO,CAAC,CAQjB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CASvB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,OAAO,CAAC,CA8CjB;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,OAAO,CAAC,CAMjB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAMpF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAOrC;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAKnC"}

package/dist/src/ffi.js

@@ -0,0 +1,398 @@
+/**
+ * Node.js FFI bindings for the fff-c native library using ffi-rs
+ *
+ * This module uses ffi-rs to call into the Rust C library.
+ * All functions follow the Result pattern for error handling.
+ *
+ * The API is instance-based: `ffiCreate` returns an opaque handle that must
+ * be passed to all subsequent calls and freed with `ffiDestroy`.
+ *
+ * ## Memory management
+ *
+ * Every `fff_*` function returning `*mut FffResult` allocates with Rust's Box.
+ * We MUST call `fff_free_result` to properly deallocate (not libc::free).
+ *
+ * ## FffResult struct reading
+ *
+ * The FffResult struct layout (#[repr(C)]):
+ *   offset  0: success (bool, 1 byte + 7 padding)
+ *   offset  8: data pointer (8 bytes) - *mut c_char (JSON string or null)
+ *   offset 16: error pointer (8 bytes) - *mut c_char (error message or null)
+ *   offset 24: handle pointer (8 bytes) - *mut c_void (instance handle or null)
+ *
+ * ## Two-step approach for reading + freeing
+ *
+ * ffi-rs auto-dereferences struct retType pointers, losing the original pointer.
+ * We solve this by:
+ * 1. Calling the C function with `retType: DataType.External` to get the raw pointer
+ * 2. Using `restorePointer` to read the struct fields from the raw pointer
+ * 3. Calling `fff_free_result` with the original raw pointer
+ *
+ * ## Null pointer detection
+ *
+ * `isNullPointer` from ffi-rs correctly detects null C pointers wrapped as
+ * V8 External objects. We use this instead of truthy checks.
+ */
+import { close, DataType, isNullPointer, load, open, restorePointer, wrapPointer, } from "ffi-rs";
+import { findBinary } from "./binary.js";
+import { err } from "./types.js";
+const LIBRARY_KEY = "fff_c";
+// Track whether the library is loaded
+let isLoaded = false;
+/**
+ * Struct type definition for FffResult used with restorePointer.
+ *
+ * Uses U8 for the bool success field (correct alignment with ffi-rs).
+ * Uses External for ALL pointer fields to avoid hangs on null char* pointers
+ * (ffi-rs hangs when trying to read DataType.String from null char*).
+ */
+const FFF_RESULT_STRUCT = {
+    success: DataType.U8,
+    data: DataType.External,
+    error: DataType.External,
+    handle: DataType.External,
+};
+/**
+ * Load the native library using ffi-rs
+ */
+function loadLibrary() {
+    if (isLoaded)
+        return;
+    const binaryPath = findBinary();
+    if (!binaryPath) {
+        throw new Error("fff native library not found. Run `npx @ff-labs/fff-node download` or build from source with `cargo build --release -p fff-c`");
+    }
+    open({ library: LIBRARY_KEY, path: binaryPath });
+    isLoaded = true;
+}
+/**
+ * Convert snake_case keys to camelCase recursively
+ */
+function snakeToCamel(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(snakeToCamel);
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        result[camelKey] = snakeToCamel(value);
+    }
+    return result;
+}
+/**
+ * Read a C string (char*) from an ffi-rs External pointer.
+ *
+ * Uses restorePointer + wrapPointer to dereference the char* and read the
+ * null-terminated string. Returns null if the pointer is null.
+ */
+function readCString(ptr) {
+    if (isNullPointer(ptr))
+        return null;
+    try {
+        const [str] = restorePointer({
+            retType: [DataType.String],
+            paramsValue: wrapPointer([ptr]),
+        });
+        return str;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Call a C function that returns `*mut FffResult` and get both the raw pointer
+ * (for freeing) and the parsed struct fields.
+ *
+ * Step 1: Call function with `DataType.External` retType → raw pointer
+ * Step 2: Use `restorePointer` to read struct fields from the raw pointer
+ */
+function callRaw(funcName, paramsType, paramsValue) {
+    const rawPtr = load({
+        library: LIBRARY_KEY,
+        funcName,
+        retType: DataType.External,
+        paramsType,
+        paramsValue,
+        freeResultMemory: false,
+    });
+    const [structData] = restorePointer({
+        retType: [FFF_RESULT_STRUCT],
+        paramsValue: wrapPointer([rawPtr]),
+    });
+    return { rawPtr, struct: structData };
+}
+/**
+ * Free a FffResult pointer by calling fff_free_result.
+ *
+ * This frees the FffResult struct and its data/error strings using Rust's
+ * Box::from_raw and CString::from_raw. The handle field is NOT freed.
+ */
+function freeResult(resultPtr) {
+    try {
+        load({
+            library: LIBRARY_KEY,
+            funcName: "fff_free_result",
+            retType: DataType.Void,
+            paramsType: [DataType.External],
+            paramsValue: [resultPtr],
+        });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Call a fff C function that returns *mut FffResult, parse the result,
+ * free the native memory, and return a typed Result<T>.
+ *
+ * Strategy:
+ * 1. Call the C function with External retType to get the raw pointer
+ * 2. Read struct fields via restorePointer
+ * 3. Based on success flag, read the data or error string
+ * 4. Call fff_free_result with the original raw pointer to free Rust memory
+ * 5. Parse JSON data and convert snake_case to camelCase
+ */
+function callFfiResult(funcName, paramsType, paramsValue) {
+    loadLibrary();
+    const { rawPtr, struct: structData } = callRaw(funcName, paramsType, paramsValue);
+    const success = structData.success !== 0;
+    try {
+        if (success) {
+            const dataStr = readCString(structData.data);
+            if (dataStr === null || dataStr === "") {
+                return { ok: true, value: undefined };
+            }
+            try {
+                const parsed = JSON.parse(dataStr);
+                const transformed = snakeToCamel(parsed);
+                return { ok: true, value: transformed };
+            }
+            catch {
+                // For simple values like "true" or numbers
+                return { ok: true, value: dataStr };
+            }
+        }
+        else {
+            const errorStr = readCString(structData.error);
+            return err(errorStr || "Unknown error");
+        }
+    }
+    finally {
+        freeResult(rawPtr);
+    }
+}
+/**
+ * Create a new file finder instance.
+ *
+ * Returns the opaque native handle on success. The handle must be passed to
+ * all subsequent FFI calls and freed with `ffiDestroy`.
+ */
+export function ffiCreate(optsJson) {
+    loadLibrary();
+    const { rawPtr, struct: structData } = callRaw("fff_create", [DataType.String], [optsJson]);
+    const success = structData.success !== 0;
+    try {
+        if (success) {
+            const handle = structData.handle;
+            if (isNullPointer(handle)) {
+                return err("fff_create returned null handle");
+            }
+            return { ok: true, value: handle };
+        }
+        else {
+            const errorStr = readCString(structData.error);
+            return err(errorStr || "Unknown error");
+        }
+    }
+    finally {
+        freeResult(rawPtr);
+    }
+}
+/**
+ * Destroy and clean up an instance.
+ */
+export function ffiDestroy(handle) {
+    loadLibrary();
+    load({
+        library: LIBRARY_KEY,
+        funcName: "fff_destroy",
+        retType: DataType.Void,
+        paramsType: [DataType.External],
+        paramsValue: [handle],
+    });
+}
+/**
+ * Perform fuzzy search.
+ */
+export function ffiSearch(handle, query, optsJson) {
+    return callFfiResult("fff_search", [DataType.External, DataType.String, DataType.String], [handle, query, optsJson]);
+}
+/**
+ * Trigger file scan.
+ */
+export function ffiScanFiles(handle) {
+    return callFfiResult("fff_scan_files", [DataType.External], [handle]);
+}
+/**
+ * Check if scanning.
+ */
+export function ffiIsScanning(handle) {
+    loadLibrary();
+    return load({
+        library: LIBRARY_KEY,
+        funcName: "fff_is_scanning",
+        retType: DataType.Boolean,
+        paramsType: [DataType.External],
+        paramsValue: [handle],
+    });
+}
+/**
+ * Get scan progress.
+ */
+export function ffiGetScanProgress(handle) {
+    return callFfiResult("fff_get_scan_progress", [DataType.External], [handle]);
+}
+/**
+ * Wait for a tree scan to complete.
+ */
+export function ffiWaitForScan(handle, timeoutMs) {
+    const result = callFfiResult("fff_wait_for_scan", [DataType.External, DataType.U64], [handle, timeoutMs]);
+    if (!result.ok)
+        return result;
+    return { ok: true, value: result.value === true || result.value === "true" };
+}
+/**
+ * Restart index in new path.
+ */
+export function ffiRestartIndex(handle, newPath) {
+    return callFfiResult("fff_restart_index", [DataType.External, DataType.String], [handle, newPath]);
+}
+/**
+ * Refresh git status.
+ */
+export function ffiRefreshGitStatus(handle) {
+    const result = callFfiResult("fff_refresh_git_status", [DataType.External], [handle]);
+    if (!result.ok)
+        return result;
+    return {
+        ok: true,
+        value: typeof result.value === "number"
+            ? result.value
+            : parseInt(result.value, 10),
+    };
+}
+/**
+ * Track query completion.
+ */
+export function ffiTrackQuery(handle, query, filePath) {
+    const result = callFfiResult("fff_track_query", [DataType.External, DataType.String, DataType.String], [handle, query, filePath]);
+    if (!result.ok)
+        return result;
+    return { ok: true, value: result.value === true || result.value === "true" };
+}
+/**
+ * Get historical query.
+ */
+export function ffiGetHistoricalQuery(handle, offset) {
+    const result = callFfiResult("fff_get_historical_query", [DataType.External, DataType.U64], [handle, offset]);
+    if (!result.ok)
+        return result;
+    if (result.value === null || result.value === "null")
+        return { ok: true, value: null };
+    return result;
+}
+/**
+ * Health check.
+ *
+ * `handle` can be null for a limited check (version + git only).
+ * When null, we pass DataType.U64 with value 0 as a null pointer workaround
+ * since ffi-rs does not accept `null` for External parameters.
+ */
+export function ffiHealthCheck(handle, testPath) {
+    loadLibrary();
+    if (handle === null) {
+        // Use U64(0) as a null pointer since ffi-rs rejects null for External params
+        const rawPtr = load({
+            library: LIBRARY_KEY,
+            funcName: "fff_health_check",
+            retType: DataType.External,
+            paramsType: [DataType.U64, DataType.String],
+            paramsValue: [0, testPath],
+            freeResultMemory: false,
+        });
+        const [structData] = restorePointer({
+            retType: [FFF_RESULT_STRUCT],
+            paramsValue: wrapPointer([rawPtr]),
+        });
+        const success = structData.success !== 0;
+        try {
+            if (success) {
+                const dataStr = readCString(structData.data);
+                if (dataStr === null || dataStr === "") {
+                    return { ok: true, value: undefined };
+                }
+                try {
+                    return { ok: true, value: snakeToCamel(JSON.parse(dataStr)) };
+                }
+                catch {
+                    return { ok: true, value: dataStr };
+                }
+            }
+            else {
+                const errorStr = readCString(structData.error);
+                return err(errorStr || "Unknown error");
+            }
+        }
+        finally {
+            freeResult(rawPtr);
+        }
+    }
+    return callFfiResult("fff_health_check", [DataType.External, DataType.String], [handle, testPath]);
+}
+/**
+ * Live grep - search file contents.
+ */
+export function ffiLiveGrep(handle, query, optsJson) {
+    return callFfiResult("fff_live_grep", [DataType.External, DataType.String, DataType.String], [handle, query, optsJson]);
+}
+/**
+ * Multi-pattern grep - Aho-Corasick multi-needle search.
+ */
+export function ffiMultiGrep(handle, optsJson) {
+    return callFfiResult("fff_multi_grep", [DataType.External, DataType.String], [handle, optsJson]);
+}
+/**
+ * Ensure the library is loaded.
+ *
+ * Loads the native library from the platform-specific npm package
+ * or a local dev build. Throws if the binary is not found.
+ */
+export function ensureLoaded() {
+    loadLibrary();
+}
+/**
+ * Check if the library is available.
+ */
+export function isAvailable() {
+    try {
+        loadLibrary();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Close the library and release ffi-rs resources.
+ * Call this when completely done with the library.
+ */
+export function closeLibrary() {
+    if (isLoaded) {
+        close(LIBRARY_KEY);
+        isLoaded = false;
+    }
+}
+//# sourceMappingURL=ffi.js.map