@ff-labs/fff-node 0.10.4-nightly.e2cad2f → 0.10.5-dev.774d6bc

package/dist/index.cjs

@@ -0,0 +1,1533 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  ok: () => ok,
+  getTriple: () => getTriple,
+  getNpmPackageName: () => getNpmPackageName,
+  getLibFilename: () => getLibFilename,
+  getLibExtension: () => getLibExtension,
+  findBinary: () => findBinary,
+  err: () => err,
+  closeLibrary: () => closeLibrary,
+  binaryExists: () => binaryExists,
+  FileFinder: () => FileFinder
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/binary.ts
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+
+// src/platform.ts
+var import_node_child_process = require("node:child_process");
+function getTriple() {
+  const platform = process.platform;
+  const arch = process.arch;
+  let osName;
+  if (platform === "darwin") {
+    osName = "apple-darwin";
+  } else if (platform === "android") {
+    osName = "linux-android";
+  } else if (platform === "linux") {
+    osName = detectLinuxLibc();
+  } else if (platform === "win32") {
+    osName = "pc-windows-msvc";
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  const archName = normalizeArch(arch);
+  return `${archName}-${osName}`;
+}
+function detectLinuxLibc() {
+  let output = "";
+  try {
+    output = import_node_child_process.execSync("ldd --version 2>&1", {
+      encoding: "utf-8",
+      timeout: 5000
+    });
+  } catch (e) {
+    const err = e;
+    output = String(err?.stdout ?? "") + String(err?.stderr ?? "");
+  }
+  if (output.toLowerCase().includes("musl")) {
+    return "unknown-linux-musl";
+  }
+  return "unknown-linux-gnu";
+}
+function normalizeArch(arch) {
+  switch (arch) {
+    case "x64":
+    case "amd64":
+      return "x86_64";
+    case "arm64":
+      return "aarch64";
+    case "arm":
+      return "arm";
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+}
+function getLibExtension() {
+  switch (process.platform) {
+    case "darwin":
+      return "dylib";
+    case "win32":
+      return "dll";
+    default:
+      return "so";
+  }
+}
+function getLibPrefix() {
+  return process.platform === "win32" ? "" : "lib";
+}
+function getLibFilename() {
+  const prefix = getLibPrefix();
+  const ext = getLibExtension();
+  return `${prefix}fff_c.${ext}`;
+}
+var TRIPLE_TO_NPM_PACKAGE = {
+  "aarch64-apple-darwin": "@ff-labs/fff-bin-darwin-arm64",
+  "x86_64-apple-darwin": "@ff-labs/fff-bin-darwin-x64",
+  "x86_64-unknown-linux-gnu": "@ff-labs/fff-bin-linux-x64-gnu",
+  "aarch64-unknown-linux-gnu": "@ff-labs/fff-bin-linux-arm64-gnu",
+  "x86_64-unknown-linux-musl": "@ff-labs/fff-bin-linux-x64-musl",
+  "aarch64-unknown-linux-musl": "@ff-labs/fff-bin-linux-arm64-musl",
+  "x86_64-pc-windows-msvc": "@ff-labs/fff-bin-win32-x64",
+  "aarch64-pc-windows-msvc": "@ff-labs/fff-bin-win32-arm64",
+  "aarch64-linux-android": "@ff-labs/fff-bin-android-arm64"
+};
+function getNpmPackageName() {
+  const triple = getTriple();
+  const packageName = TRIPLE_TO_NPM_PACKAGE[triple];
+  if (!packageName) {
+    throw new Error(`No npm package available for platform: ${triple}`);
+  }
+  return packageName;
+}
+
+// src/binary.ts
+var __dirname = "/home/runner/work/fff/fff/packages/fff-node/src";
+function getCurrentDir() {
+  if (typeof __dirname !== "undefined")
+    return __dirname;
+  const url = "file:///home/runner/work/fff/fff/packages/fff-node/src/binary.ts";
+  if (url.startsWith("file://")) {
+    return import_node_path.dirname(import_node_url.fileURLToPath(url));
+  }
+  return import_node_path.dirname(url);
+}
+function getPackageDir() {
+  const currentDir = getCurrentDir();
+  let dir = currentDir;
+  for (let i = 0;i < 5; i++) {
+    if (import_node_fs.existsSync(import_node_path.join(dir, "package.json"))) {
+      try {
+        const pkg = JSON.parse(import_node_fs.readFileSync(import_node_path.join(dir, "package.json"), "utf-8"));
+        if (pkg.name === "@ff-labs/fff-node") {
+          return dir;
+        }
+      } catch {}
+    }
+    dir = import_node_path.dirname(dir);
+  }
+  return import_node_path.dirname(currentDir);
+}
+function binaryExists() {
+  return findBinary() !== null;
+}
+function resolveFromNpmPackage() {
+  const packageName = getNpmPackageName();
+  try {
+    const require2 = import_node_module.createRequire(import_node_path.join(getPackageDir(), "package.json"));
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const packageDir = import_node_path.dirname(packageJsonPath);
+    const binaryPath = import_node_path.join(packageDir, getLibFilename());
+    if (import_node_fs.existsSync(binaryPath)) {
+      return binaryPath;
+    }
+  } catch {}
+  return null;
+}
+function getDevBinaryPath() {
+  const packageDir = getPackageDir();
+  const workspaceRoot = import_node_path.join(packageDir, "..", "..");
+  const possiblePaths = [
+    import_node_path.join(workspaceRoot, "target", "release", getLibFilename()),
+    import_node_path.join(workspaceRoot, "target", "debug", getLibFilename())
+  ];
+  for (const path of possiblePaths) {
+    if (import_node_fs.existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function isDevWorkspace() {
+  const packageDir = getPackageDir();
+  const workspaceRoot = import_node_path.join(packageDir, "..", "..");
+  return import_node_fs.existsSync(import_node_path.join(workspaceRoot, "Cargo.toml"));
+}
+function findBinary() {
+  if (isDevWorkspace()) {
+    const binPath = import_node_path.join(getPackageDir(), "bin", getLibFilename());
+    if (import_node_fs.existsSync(binPath))
+      return binPath;
+    const devPath = getDevBinaryPath();
+    if (devPath)
+      return devPath;
+    const npmPath2 = resolveFromNpmPackage();
+    if (npmPath2)
+      return npmPath2;
+    return null;
+  }
+  const npmPath = resolveFromNpmPackage();
+  if (npmPath)
+    return npmPath;
+  return getDevBinaryPath();
+}
+// src/ffi.ts
+var import_ffi_rs = require("ffi-rs");
+
+// src/fff-api.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function createGrepCursor(offset) {
+  return { __brand: "GrepCursor", _offset: offset };
+}
+
+// src/ffi.ts
+var LIBRARY_KEY = "fff_c";
+var FFF_CREATE_OPTIONS_STRUCT = {
+  version: import_ffi_rs.DataType.U32,
+  base_path: import_ffi_rs.DataType.String,
+  frecency_db_path: import_ffi_rs.DataType.String,
+  history_db_path: import_ffi_rs.DataType.String,
+  enable_mmap_cache: import_ffi_rs.DataType.U8,
+  enable_content_indexing: import_ffi_rs.DataType.U8,
+  watch: import_ffi_rs.DataType.U8,
+  ai_mode: import_ffi_rs.DataType.U8,
+  log_file_path: import_ffi_rs.DataType.String,
+  log_level: import_ffi_rs.DataType.String,
+  cache_budget_max_files: import_ffi_rs.DataType.U64,
+  cache_budget_max_bytes: import_ffi_rs.DataType.U64,
+  cache_budget_max_file_size: import_ffi_rs.DataType.U64,
+  enable_fs_root_scanning: import_ffi_rs.DataType.U8,
+  enable_home_dir_scanning: import_ffi_rs.DataType.U8,
+  follow_symlinks: import_ffi_rs.DataType.U8
+};
+var FFF_CREATE_OPTIONS_VERSION = 2;
+var GREP_MODE_PLAIN = 0;
+var GREP_MODE_REGEX = 1;
+var GREP_MODE_FUZZY = 2;
+function grepModeToU8(mode) {
+  switch (mode) {
+    case "regex":
+      return GREP_MODE_REGEX;
+    case "fuzzy":
+      return GREP_MODE_FUZZY;
+    default:
+      return GREP_MODE_PLAIN;
+  }
+}
+var isLoaded = false;
+var FFF_RESULT_STRUCT = {
+  success: import_ffi_rs.DataType.U8,
+  error: import_ffi_rs.DataType.External,
+  handle: import_ffi_rs.DataType.External,
+  int_value: import_ffi_rs.DataType.I64
+};
+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`");
+  }
+  import_ffi_rs.open({ library: LIBRARY_KEY, path: binaryPath });
+  isLoaded = true;
+}
+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;
+}
+function readCString(ptr) {
+  if (import_ffi_rs.isNullPointer(ptr))
+    return null;
+  try {
+    const [str] = import_ffi_rs.restorePointer({
+      retType: [import_ffi_rs.DataType.String],
+      paramsValue: import_ffi_rs.wrapPointer([ptr])
+    });
+    return str;
+  } catch {
+    return null;
+  }
+}
+function callRaw(funcName, paramsType, paramsValue) {
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName,
+    retType: import_ffi_rs.DataType.External,
+    paramsType,
+    paramsValue,
+    freeResultMemory: false
+  });
+  const [structData] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  return { rawPtr, struct: structData };
+}
+function freeResult(resultPtr) {
+  try {
+    import_ffi_rs.load({
+      library: LIBRARY_KEY,
+      funcName: "fff_free_result",
+      retType: import_ffi_rs.DataType.Void,
+      paramsType: [import_ffi_rs.DataType.External],
+      paramsValue: [resultPtr]
+    });
+  } catch {}
+}
+function readResultEnvelope(funcName, paramsType, paramsValue) {
+  loadLibrary();
+  const { rawPtr, struct: structData } = callRaw(funcName, paramsType, paramsValue);
+  if (structData.success === 0) {
+    const errorStr = readCString(structData.error);
+    freeResult(rawPtr);
+    return err(errorStr || "Unknown error");
+  }
+  return { rawPtr, struct: structData };
+}
+function callVoidResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res)
+    return res;
+  freeResult(res.rawPtr);
+  return { ok: true, value: undefined };
+}
+function callIntResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res)
+    return res;
+  const value = Number(res.struct.int_value);
+  freeResult(res.rawPtr);
+  return { ok: true, value };
+}
+function callBoolResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res)
+    return res;
+  const value = Number(res.struct.int_value) !== 0;
+  freeResult(res.rawPtr);
+  return { ok: true, value };
+}
+function callStringResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res)
+    return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr))
+    return { ok: true, value: null };
+  const str = readCString(handlePtr);
+  freeString(handlePtr);
+  return { ok: true, value: str };
+}
+function callJsonResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res)
+    return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr))
+    return { ok: true, value: undefined };
+  const jsonStr = readCString(handlePtr);
+  freeString(handlePtr);
+  if (jsonStr === null || jsonStr === "")
+    return { ok: true, value: undefined };
+  try {
+    return { ok: true, value: snakeToCamel(JSON.parse(jsonStr)) };
+  } catch {
+    return { ok: true, value: jsonStr };
+  }
+}
+function freeString(ptr) {
+  try {
+    import_ffi_rs.load({
+      library: LIBRARY_KEY,
+      funcName: "fff_free_string",
+      retType: import_ffi_rs.DataType.Void,
+      paramsType: [import_ffi_rs.DataType.External],
+      paramsValue: [ptr]
+    });
+  } catch {}
+}
+function ffiCreate(basePath, frecencyDbPath, historyDbPath, _useUnsafeNoLock, enableMmapCache, enableContentIndexing, watch, aiMode, logFilePath, logLevel, cacheBudgetMaxFiles, cacheBudgetMaxBytes, cacheBudgetMaxFileSize, enableFsRootScanning, enableHomeDirScanning, followSymlinks) {
+  loadLibrary();
+  const optsValue = {
+    version: FFF_CREATE_OPTIONS_VERSION,
+    base_path: basePath,
+    frecency_db_path: frecencyDbPath,
+    history_db_path: historyDbPath,
+    enable_mmap_cache: enableMmapCache ? 1 : 0,
+    enable_content_indexing: enableContentIndexing ? 1 : 0,
+    watch: watch ? 1 : 0,
+    ai_mode: aiMode ? 1 : 0,
+    log_file_path: logFilePath,
+    log_level: logLevel,
+    cache_budget_max_files: cacheBudgetMaxFiles,
+    cache_budget_max_bytes: cacheBudgetMaxBytes,
+    cache_budget_max_file_size: cacheBudgetMaxFileSize,
+    enable_fs_root_scanning: enableFsRootScanning ? 1 : 0,
+    enable_home_dir_scanning: enableHomeDirScanning ? 1 : 0,
+    follow_symlinks: followSymlinks ? 1 : 0
+  };
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_create_instance_with",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [FFF_CREATE_OPTIONS_STRUCT],
+    paramsValue: [optsValue],
+    freeResultMemory: false
+  });
+  const [structData] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  const success = structData.success !== 0;
+  try {
+    if (success) {
+      const handle = structData.handle;
+      if (import_ffi_rs.isNullPointer(handle)) {
+        return err("fff_create_instance_with returned null handle");
+      }
+      return { ok: true, value: handle };
+    } else {
+      const errorStr = readCString(structData.error);
+      return err(errorStr || "Unknown error");
+    }
+  } finally {
+    freeResult(rawPtr);
+  }
+}
+function ffiDestroy(handle) {
+  loadLibrary();
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_destroy",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handle]
+  });
+}
+var FFF_FILE_ITEM_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  file_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  is_binary: import_ffi_rs.DataType.U8
+};
+var FFF_SCORE_STRUCT = {
+  total: import_ffi_rs.DataType.I32,
+  base_score: import_ffi_rs.DataType.I32,
+  filename_bonus: import_ffi_rs.DataType.I32,
+  special_filename_bonus: import_ffi_rs.DataType.I32,
+  frecency_boost: import_ffi_rs.DataType.I32,
+  distance_penalty: import_ffi_rs.DataType.I32,
+  current_file_penalty: import_ffi_rs.DataType.I32,
+  combo_match_boost: import_ffi_rs.DataType.I32,
+  exact_match: import_ffi_rs.DataType.U8,
+  match_type: import_ffi_rs.DataType.External
+};
+var FFF_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  location_tag: import_ffi_rs.DataType.U8,
+  location_line: import_ffi_rs.DataType.I32,
+  location_col: import_ffi_rs.DataType.I32,
+  location_end_line: import_ffi_rs.DataType.I32,
+  location_end_col: import_ffi_rs.DataType.I32
+};
+var FFF_DIR_ITEM_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  dir_name: import_ffi_rs.DataType.External,
+  max_access_frecency: import_ffi_rs.DataType.I32
+};
+var FFF_DIR_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_dirs: import_ffi_rs.DataType.U32
+};
+var FFF_MIXED_ITEM_STRUCT = {
+  item_type: import_ffi_rs.DataType.U8,
+  relative_path: import_ffi_rs.DataType.External,
+  display_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  is_binary: import_ffi_rs.DataType.U8
+};
+var FFF_MIXED_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  total_dirs: import_ffi_rs.DataType.U32,
+  location_tag: import_ffi_rs.DataType.U8,
+  location_line: import_ffi_rs.DataType.I32,
+  location_col: import_ffi_rs.DataType.I32,
+  location_end_line: import_ffi_rs.DataType.I32,
+  location_end_col: import_ffi_rs.DataType.I32
+};
+var FFF_GREP_MATCH_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  file_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  line_content: import_ffi_rs.DataType.External,
+  match_ranges: import_ffi_rs.DataType.External,
+  context_before: import_ffi_rs.DataType.External,
+  context_after: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  line_number: import_ffi_rs.DataType.U64,
+  byte_offset: import_ffi_rs.DataType.U64,
+  col: import_ffi_rs.DataType.U32,
+  match_ranges_count: import_ffi_rs.DataType.U32,
+  context_before_count: import_ffi_rs.DataType.U32,
+  context_after_count: import_ffi_rs.DataType.U32,
+  fuzzy_score: import_ffi_rs.DataType.U32,
+  has_fuzzy_score: import_ffi_rs.DataType.U8,
+  is_binary: import_ffi_rs.DataType.U8,
+  is_definition: import_ffi_rs.DataType.U8
+};
+var FFF_GREP_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files_searched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  filtered_file_count: import_ffi_rs.DataType.U32,
+  next_file_offset: import_ffi_rs.DataType.U32,
+  regex_fallback_error: import_ffi_rs.DataType.External
+};
+var FFF_MATCH_RANGE_STRUCT = {
+  start: import_ffi_rs.DataType.U32,
+  end: import_ffi_rs.DataType.U32
+};
+function readFileItemFromRaw(raw) {
+  return {
+    relativePath: readCString(raw.relative_path) ?? "",
+    fileName: readCString(raw.file_name) ?? "",
+    gitStatus: readCString(raw.git_status) ?? "",
+    size: Number(raw.size),
+    modified: Number(raw.modified),
+    accessFrecencyScore: Number(raw.access_frecency_score),
+    modificationFrecencyScore: Number(raw.modification_frecency_score),
+    totalFrecencyScore: Number(raw.total_frecency_score)
+  };
+}
+function readScoreFromRaw(raw) {
+  return {
+    total: raw.total,
+    baseScore: raw.base_score,
+    filenameBonus: raw.filename_bonus,
+    specialFilenameBonus: raw.special_filename_bonus,
+    frecencyBoost: raw.frecency_boost,
+    distancePenalty: raw.distance_penalty,
+    currentFilePenalty: raw.current_file_penalty,
+    comboMatchBoost: raw.combo_match_boost,
+    exactMatch: raw.exact_match !== 0,
+    matchType: readCString(raw.match_type) ?? ""
+  };
+}
+function readDirItemFromRaw(raw) {
+  return {
+    relativePath: readCString(raw.relative_path) ?? "",
+    dirName: readCString(raw.dir_name) ?? "",
+    maxAccessFrecency: raw.max_access_frecency
+  };
+}
+function readMixedItemFromRaw(raw) {
+  if (raw.item_type === 1) {
+    return {
+      type: "directory",
+      item: {
+        relativePath: readCString(raw.relative_path) ?? "",
+        dirName: readCString(raw.display_name) ?? "",
+        maxAccessFrecency: Number(raw.access_frecency_score)
+      }
+    };
+  }
+  return {
+    type: "file",
+    item: {
+      relativePath: readCString(raw.relative_path) ?? "",
+      fileName: readCString(raw.display_name) ?? "",
+      gitStatus: readCString(raw.git_status) ?? "",
+      size: Number(raw.size),
+      modified: Number(raw.modified),
+      accessFrecencyScore: Number(raw.access_frecency_score),
+      modificationFrecencyScore: Number(raw.modification_frecency_score),
+      totalFrecencyScore: Number(raw.total_frecency_score)
+    }
+  };
+}
+function callAccessor(funcName, resultPtr, index, structDef) {
+  loadLibrary();
+  const elemPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName,
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+    paramsValue: [resultPtr, index]
+  });
+  const [raw] = import_ffi_rs.restorePointer({
+    retType: [structDef],
+    paramsValue: import_ffi_rs.wrapPointer([elemPtr])
+  });
+  return raw;
+}
+function ptrOffset(base, bytes) {
+  return import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_ptr_offset",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    paramsValue: [base, bytes]
+  });
+}
+function readCStringArray(ptrArray, count) {
+  if (count === 0 || import_ffi_rs.isNullPointer(ptrArray))
+    return [];
+  const result = [];
+  for (let i = 0;i < count; i++) {
+    const elemPtr = ptrOffset(ptrArray, i * 8);
+    const [charPtr] = import_ffi_rs.restorePointer({
+      retType: [import_ffi_rs.DataType.External],
+      paramsValue: [elemPtr]
+    });
+    result.push(readCString(charPtr) ?? "");
+  }
+  return result;
+}
+function readGrepMatchFromRaw(raw) {
+  const matchRanges = [];
+  for (let i = 0;i < raw.match_ranges_count; i++) {
+    const rangePtr = ptrOffset(raw.match_ranges, i * 8);
+    const [rangeRaw] = import_ffi_rs.restorePointer({
+      retType: [FFF_MATCH_RANGE_STRUCT],
+      paramsValue: import_ffi_rs.wrapPointer([rangePtr])
+    });
+    matchRanges.push([rangeRaw.start, rangeRaw.end]);
+  }
+  const match = {
+    relativePath: readCString(raw.relative_path) ?? "",
+    fileName: readCString(raw.file_name) ?? "",
+    gitStatus: readCString(raw.git_status) ?? "",
+    lineContent: readCString(raw.line_content) ?? "",
+    size: Number(raw.size),
+    modified: Number(raw.modified),
+    totalFrecencyScore: Number(raw.total_frecency_score),
+    accessFrecencyScore: Number(raw.access_frecency_score),
+    modificationFrecencyScore: Number(raw.modification_frecency_score),
+    isBinary: raw.is_binary !== 0,
+    lineNumber: Number(raw.line_number),
+    col: raw.col,
+    byteOffset: Number(raw.byte_offset),
+    matchRanges
+  };
+  if (raw.has_fuzzy_score !== 0) {
+    match.fuzzyScore = raw.fuzzy_score;
+  }
+  if (raw.context_before_count > 0) {
+    match.contextBefore = readCStringArray(raw.context_before, raw.context_before_count);
+  }
+  if (raw.context_after_count > 0) {
+    match.contextAfter = readCStringArray(raw.context_after, raw.context_after_count);
+  }
+  if (raw.is_definition !== 0) {
+    match.isDefinition = true;
+  }
+  return match;
+}
+function parseGrepResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr)) {
+    return err("grep returned null result");
+  }
+  const [gr] = import_ffi_rs.restorePointer({
+    retType: [FFF_GREP_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([handlePtr])
+  });
+  const count = gr.count;
+  const regexFallbackError = readCString(gr.regex_fallback_error) ?? undefined;
+  const items = [];
+  for (let i = 0;i < count; i++) {
+    const rawMatch = callAccessor("fff_grep_result_get_match", handlePtr, i, FFF_GREP_MATCH_STRUCT);
+    items.push(readGrepMatchFromRaw(rawMatch));
+  }
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_grep_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const grepResult = {
+    items,
+    totalMatched: gr.total_matched,
+    totalFilesSearched: gr.total_files_searched,
+    totalFiles: gr.total_files,
+    filteredFileCount: gr.filtered_file_count,
+    nextCursor: gr.next_file_offset > 0 ? createGrepCursor(gr.next_file_offset) : null
+  };
+  if (regexFallbackError) {
+    grepResult.regexFallbackError = regexFallbackError;
+  }
+  return { ok: true, value: grepResult };
+}
+function parseSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr)) {
+    return err("fff_search returned null search result");
+  }
+  const [sr] = import_ffi_rs.restorePointer({
+    retType: [FFF_SEARCH_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([handlePtr])
+  });
+  const count = sr.count;
+  let location;
+  if (sr.location_tag === 1) {
+    location = { type: "line", line: sr.location_line };
+  } else if (sr.location_tag === 2) {
+    location = {
+      type: "position",
+      line: sr.location_line,
+      col: sr.location_col
+    };
+  } else if (sr.location_tag === 3) {
+    location = {
+      type: "range",
+      start: { line: sr.location_line, col: sr.location_col },
+      end: { line: sr.location_end_line, col: sr.location_end_col }
+    };
+  }
+  const items = [];
+  const scores = [];
+  for (let i = 0;i < count; i++) {
+    const rawItem = callAccessor("fff_search_result_get_item", handlePtr, i, FFF_FILE_ITEM_STRUCT);
+    items.push(readFileItemFromRaw(rawItem));
+    const rawScore = callAccessor("fff_search_result_get_score", handlePtr, i, FFF_SCORE_STRUCT);
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const result = {
+    items,
+    scores,
+    totalMatched: sr.total_matched,
+    totalFiles: sr.total_files
+  };
+  if (location) {
+    result.location = location;
+  }
+  return { ok: true, value: result };
+}
+function parseDirSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr)) {
+    return err("fff_search_directories returned null search result");
+  }
+  const [sr] = import_ffi_rs.restorePointer({
+    retType: [FFF_DIR_SEARCH_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([handlePtr])
+  });
+  const count = sr.count;
+  const items = [];
+  const scores = [];
+  for (let i = 0;i < count; i++) {
+    const rawItem = callAccessor("fff_dir_search_result_get_item", handlePtr, i, FFF_DIR_ITEM_STRUCT);
+    items.push(readDirItemFromRaw(rawItem));
+    const rawScore = callAccessor("fff_dir_search_result_get_score", handlePtr, i, FFF_SCORE_STRUCT);
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_dir_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  return {
+    ok: true,
+    value: {
+      items,
+      scores,
+      totalMatched: sr.total_matched,
+      totalDirs: sr.total_dirs
+    }
+  };
+}
+function parseMixedSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = import_ffi_rs.restorePointer({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr)) {
+    return err("fff_search_mixed returned null search result");
+  }
+  const [sr] = import_ffi_rs.restorePointer({
+    retType: [FFF_MIXED_SEARCH_RESULT_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([handlePtr])
+  });
+  const count = sr.count;
+  let location;
+  if (sr.location_tag === 1) {
+    location = { type: "line", line: sr.location_line };
+  } else if (sr.location_tag === 2) {
+    location = {
+      type: "position",
+      line: sr.location_line,
+      col: sr.location_col
+    };
+  } else if (sr.location_tag === 3) {
+    location = {
+      type: "range",
+      start: { line: sr.location_line, col: sr.location_col },
+      end: { line: sr.location_end_line, col: sr.location_end_col }
+    };
+  }
+  const items = [];
+  const scores = [];
+  for (let i = 0;i < count; i++) {
+    const rawItem = callAccessor("fff_mixed_search_result_get_item", handlePtr, i, FFF_MIXED_ITEM_STRUCT);
+    items.push(readMixedItemFromRaw(rawItem));
+    const rawScore = callAccessor("fff_mixed_search_result_get_score", handlePtr, i, FFF_SCORE_STRUCT);
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_mixed_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const result = {
+    items,
+    scores,
+    totalMatched: sr.total_matched,
+    totalFiles: sr.total_files,
+    totalDirs: sr.total_dirs
+  };
+  if (location) {
+    result.location = location;
+  }
+  return { ok: true, value: result };
+}
+function ffiSearch(handle, query, currentFile, maxThreads, pageIndex, pageSize, comboBoostMultiplier, minComboCount) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_search",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.I32,
+      import_ffi_rs.DataType.U32
+    ],
+    paramsValue: [
+      handle,
+      query,
+      currentFile,
+      maxThreads,
+      pageIndex,
+      pageSize,
+      comboBoostMultiplier,
+      minComboCount
+    ],
+    freeResultMemory: false
+  });
+  return parseSearchResult(rawPtr);
+}
+function ffiGlob(handle, pattern, currentFile, maxThreads, pageIndex, pageSize) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_glob",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32
+    ],
+    paramsValue: [handle, pattern, currentFile, maxThreads, pageIndex, pageSize],
+    freeResultMemory: false
+  });
+  return parseSearchResult(rawPtr);
+}
+function ffiSearchDirectories(handle, query, currentFile, maxThreads, pageIndex, pageSize) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_search_directories",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32
+    ],
+    paramsValue: [handle, query, currentFile ?? "", maxThreads, pageIndex, pageSize],
+    freeResultMemory: false
+  });
+  return parseDirSearchResult(rawPtr);
+}
+function ffiSearchMixed(handle, query, currentFile, maxThreads, pageIndex, pageSize, comboBoostMultiplier, minComboCount) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_search_mixed",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.I32,
+      import_ffi_rs.DataType.U32
+    ],
+    paramsValue: [
+      handle,
+      query,
+      currentFile,
+      maxThreads,
+      pageIndex,
+      pageSize,
+      comboBoostMultiplier,
+      minComboCount
+    ],
+    freeResultMemory: false
+  });
+  return parseMixedSearchResult(rawPtr);
+}
+function ffiLiveGrep(handle, query, mode, maxFileSize, maxMatchesPerFile, smartCase, fileOffset, pageLimit, timeBudgetMs, beforeContext, afterContext, classifyDefinitions) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_live_grep",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U8,
+      import_ffi_rs.DataType.U64,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.Boolean,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U64,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.Boolean
+    ],
+    paramsValue: [
+      handle,
+      query,
+      grepModeToU8(mode),
+      maxFileSize,
+      maxMatchesPerFile,
+      smartCase,
+      fileOffset,
+      pageLimit,
+      timeBudgetMs,
+      beforeContext,
+      afterContext,
+      classifyDefinitions
+    ],
+    freeResultMemory: false
+  });
+  return parseGrepResult(rawPtr);
+}
+function ffiMultiGrep(handle, patternsJoined, constraints, maxFileSize, maxMatchesPerFile, smartCase, fileOffset, pageLimit, timeBudgetMs, beforeContext, afterContext, classifyDefinitions) {
+  loadLibrary();
+  const rawPtr = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_multi_grep",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.String,
+      import_ffi_rs.DataType.U64,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.Boolean,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U64,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.U32,
+      import_ffi_rs.DataType.Boolean
+    ],
+    paramsValue: [
+      handle,
+      patternsJoined,
+      constraints,
+      maxFileSize,
+      maxMatchesPerFile,
+      smartCase,
+      fileOffset,
+      pageLimit,
+      timeBudgetMs,
+      beforeContext,
+      afterContext,
+      classifyDefinitions
+    ],
+    freeResultMemory: false
+  });
+  return parseGrepResult(rawPtr);
+}
+function ffiScanFiles(handle) {
+  return callVoidResult("fff_scan_files", [import_ffi_rs.DataType.External], [handle]);
+}
+function ffiIsScanning(handle) {
+  loadLibrary();
+  return import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_is_scanning",
+    retType: import_ffi_rs.DataType.Boolean,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handle]
+  });
+}
+function ffiGetBasePath(handle) {
+  return callStringResult("fff_get_base_path", [import_ffi_rs.DataType.External], [handle]);
+}
+var FFF_SCAN_PROGRESS_STRUCT = {
+  scanned_files_count: import_ffi_rs.DataType.U64,
+  is_scanning: import_ffi_rs.DataType.U8,
+  is_watcher_ready: import_ffi_rs.DataType.U8,
+  is_warmup_complete: import_ffi_rs.DataType.U8
+};
+function ffiGetScanProgress(handle) {
+  loadLibrary();
+  const res = readResultEnvelope("fff_get_scan_progress", [import_ffi_rs.DataType.External], [handle]);
+  if ("ok" in res)
+    return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if (import_ffi_rs.isNullPointer(handlePtr))
+    return err("scan progress returned null");
+  const [sp] = import_ffi_rs.restorePointer({
+    retType: [FFF_SCAN_PROGRESS_STRUCT],
+    paramsValue: import_ffi_rs.wrapPointer([handlePtr])
+  });
+  const result = {
+    scannedFilesCount: Number(sp.scanned_files_count),
+    isScanning: sp.is_scanning !== 0,
+    isWatcherReady: sp.is_watcher_ready !== 0,
+    isWarmupComplete: sp.is_warmup_complete !== 0
+  };
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_scan_progress",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  return { ok: true, value: result };
+}
+function ffiWaitForScan(handle, timeoutMs) {
+  return callBoolResult("fff_wait_for_scan", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64], [handle, timeoutMs]);
+}
+function ffiRestartIndex(handle, newPath) {
+  return callVoidResult("fff_restart_index", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String], [handle, newPath]);
+}
+function ffiRefreshGitStatus(handle) {
+  return callIntResult("fff_refresh_git_status", [import_ffi_rs.DataType.External], [handle]);
+}
+function ffiTrackQuery(handle, query, filePath) {
+  return callBoolResult("fff_track_query", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String, import_ffi_rs.DataType.String], [handle, query, filePath]);
+}
+function ffiGetHistoricalQuery(handle, offset) {
+  return callStringResult("fff_get_historical_query", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64], [handle, offset]);
+}
+function watchKindFromU8(kind) {
+  switch (kind) {
+    case 0:
+      return "created";
+    case 1:
+      return "modified";
+    case 2:
+      return "removed";
+    default:
+      return "rescan";
+  }
+}
+var WATCH_TRAMPOLINE_TYPE = import_ffi_rs.funcConstructor({
+  paramsType: [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64],
+  retType: import_ffi_rs.DataType.Void
+});
+var watchHandlers = new Map;
+var watchInstances = new Set;
+var watchTrampoline = null;
+function addressToExternal(address) {
+  return import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_ptr_offset",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64],
+    paramsValue: [address, 0]
+  });
+}
+function consumeWatchBatch(address) {
+  const batchPtr = addressToExternal(address);
+  const count = import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_watch_events_count",
+    retType: import_ffi_rs.DataType.U32,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [batchPtr]
+  });
+  const events = [];
+  for (let i = 0;i < count; i++) {
+    const path = import_ffi_rs.load({
+      library: LIBRARY_KEY,
+      funcName: "fff_watch_events_get_path",
+      retType: import_ffi_rs.DataType.External,
+      paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+      paramsValue: [batchPtr, i]
+    });
+    const kind = import_ffi_rs.load({
+      library: LIBRARY_KEY,
+      funcName: "fff_watch_events_get_kind",
+      retType: import_ffi_rs.DataType.U8,
+      paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+      paramsValue: [batchPtr, i]
+    });
+    events.push({
+      path: readCString(path) ?? "",
+      kind: watchKindFromU8(kind)
+    });
+  }
+  import_ffi_rs.load({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_watch_events",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.U64],
+    paramsValue: [address]
+  });
+  return events;
+}
+function watchTrampolineImpl(watchId, batchAddress, _userData) {
+  const events = consumeWatchBatch(batchAddress);
+  const handler = watchHandlers.get(Number(watchId));
+  if (handler === undefined || events.length === 0)
+    return;
+  try {
+    handler(events);
+  } catch {}
+}
+function ensureWatchTrampoline() {
+  if (watchTrampoline === null) {
+    watchTrampoline = import_ffi_rs.createPointer({
+      paramsType: [WATCH_TRAMPOLINE_TYPE],
+      paramsValue: [watchTrampolineImpl]
+    });
+  }
+  return import_ffi_rs.unwrapPointer(watchTrampoline)[0];
+}
+function ensureWatchCallbackRegistered(handle) {
+  if (watchInstances.has(handle))
+    return { ok: true, value: undefined };
+  const trampoline = ensureWatchTrampoline();
+  const registered = callVoidResult("fff_set_watch_callback", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64], [handle, trampoline, 0]);
+  if (registered.ok)
+    watchInstances.add(handle);
+  return registered;
+}
+function releaseWatchTrampolineIfIdle() {
+  if (watchHandlers.size > 0 || watchInstances.size > 0 || watchTrampoline === null)
+    return;
+  import_ffi_rs.freePointer({
+    paramsType: [WATCH_TRAMPOLINE_TYPE],
+    paramsValue: watchTrampoline,
+    pointerType: import_ffi_rs.PointerType.RsPointer
+  });
+  watchTrampoline = null;
+}
+function ffiWatch(handle, pattern, ignore, callback) {
+  loadLibrary();
+  const registered = ensureWatchCallbackRegistered(handle);
+  if (!registered.ok)
+    return registered;
+  const created = callIntResult("fff_watch_args", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String, import_ffi_rs.DataType.StringArray, import_ffi_rs.DataType.U32], [handle, pattern, ignore, ignore.length]);
+  if (!created.ok)
+    return created;
+  watchHandlers.set(created.value, callback);
+  return created;
+}
+function ffiUnwatch(handle, watchId) {
+  const result = callBoolResult("fff_unwatch", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64], [handle, watchId]);
+  watchHandlers.delete(watchId);
+  return result;
+}
+function ffiWatchCleanupAfterDestroy(handle, watchIds) {
+  for (const id of watchIds) {
+    watchHandlers.delete(id);
+  }
+  watchInstances.delete(handle);
+  releaseWatchTrampolineIfIdle();
+}
+function ffiHealthCheck(handle, testPath) {
+  if (handle === null) {
+    return callJsonResult("fff_health_check", [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.String], [0, testPath]);
+  }
+  return callJsonResult("fff_health_check", [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String], [handle, testPath]);
+}
+function ensureLoaded() {
+  loadLibrary();
+}
+function isAvailable() {
+  try {
+    loadLibrary();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function closeLibrary() {
+  if (isLoaded) {
+    import_ffi_rs.close(LIBRARY_KEY);
+    isLoaded = false;
+  }
+}
+// src/finder.ts
+class FileFinder {
+  handle;
+  watchers = new Set;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  static create(options) {
+    const result = ffiCreate(options.basePath, options.frecencyDbPath ?? "", options.historyDbPath ?? "", options.useUnsafeNoLock ?? false, !(options.disableMmapCache ?? false), !(options.disableContentIndexing ?? options.disableMmapCache ?? false), !(options.disableWatch ?? false), options.aiMode ?? false, options.logFilePath ?? "", options.logLevel ?? "", options.cacheBudgetMaxFiles ?? 0, options.cacheBudgetMaxBytes ?? 0, options.cacheBudgetMaxFileSize ?? 0, options.enableFsRootScanning ?? false, options.enableHomeDirScanning ?? false, options.followSymlinks ?? false);
+    if (!result.ok) {
+      return result;
+    }
+    return { ok: true, value: new FileFinder(result.value) };
+  }
+  destroy() {
+    if (this.handle !== null) {
+      const handle = this.handle;
+      ffiDestroy(handle);
+      this.handle = null;
+      ffiWatchCleanupAfterDestroy(handle, this.watchers);
+      this.watchers.clear();
+    }
+  }
+  get isDestroyed() {
+    return this.handle === null;
+  }
+  ensureAlive() {
+    if (this.handle === null) {
+      return err("FileFinder instance has been destroyed.");
+    }
+    return { ok: true, value: this.handle };
+  }
+  fileSearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiSearch(guard.value, query, options?.currentFile ?? "", options?.maxThreads ?? 0, options?.pageIndex ?? 0, options?.pageSize ?? 0, options?.comboBoostMultiplier ?? 0, options?.minComboCount ?? 0);
+  }
+  glob(pattern, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiGlob(guard.value, pattern, options?.currentFile ?? "", options?.maxThreads ?? 0, options?.pageIndex ?? 0, options?.pageSize ?? 0);
+  }
+  directorySearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiSearchDirectories(guard.value, query, options?.currentFile ?? null, options?.maxThreads ?? 0, options?.pageIndex ?? 0, options?.pageSize ?? 0);
+  }
+  mixedSearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiSearchMixed(guard.value, query, options?.currentFile ?? "", options?.maxThreads ?? 0, options?.pageIndex ?? 0, options?.pageSize ?? 0, options?.comboBoostMultiplier ?? 0, options?.minComboCount ?? 0);
+  }
+  grep(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiLiveGrep(guard.value, query, options?.mode ?? "plain", options?.maxFileSize ?? 0, options?.maxMatchesPerFile ?? 0, options?.smartCase ?? true, options?.cursor?._offset ?? 0, options?.pageSize ?? 0, options?.timeBudgetMs ?? 0, options?.beforeContext ?? 0, options?.afterContext ?? 0, options?.classifyDefinitions ?? false);
+  }
+  multiGrep(options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    if (!options.patterns || options.patterns.length === 0) {
+      return err("patterns array must have at least 1 element");
+    }
+    return ffiMultiGrep(guard.value, options.patterns.join(`
+`), options.constraints ?? "", options.maxFileSize ?? 0, options.maxMatchesPerFile ?? 0, options.smartCase ?? true, options.cursor?._offset ?? 0, options.pageSize ?? 0, options.timeBudgetMs ?? 0, options.beforeContext ?? 0, options.afterContext ?? 0, options.classifyDefinitions ?? false);
+  }
+  scanFiles() {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiScanFiles(guard.value);
+  }
+  isScanning() {
+    if (this.handle === null)
+      return false;
+    return ffiIsScanning(this.handle);
+  }
+  getBasePath() {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiGetBasePath(guard.value);
+  }
+  getScanProgress() {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiGetScanProgress(guard.value);
+  }
+  async waitForScan(timeoutMs = 5000) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    const deadline = Date.now() + timeoutMs;
+    while (this.isScanning()) {
+      if (Date.now() >= deadline) {
+        return { ok: true, value: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return { ok: true, value: true };
+  }
+  waitForScanBlocking(timeoutMs = 5000) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiWaitForScan(guard.value, timeoutMs);
+  }
+  async waitForIndexReady(timeoutMs = 5000) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const progress = this.getScanProgress();
+      if (!progress.ok)
+        return progress;
+      if (!progress.value.isScanning && progress.value.isWarmupComplete) {
+        return { ok: true, value: true };
+      }
+      if (Date.now() >= deadline) {
+        return { ok: true, value: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+  reindex(newPath) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiRestartIndex(guard.value, newPath);
+  }
+  refreshGitStatus() {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiRefreshGitStatus(guard.value);
+  }
+  trackQuery(query, selectedFilePath) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiTrackQuery(guard.value, query, selectedFilePath);
+  }
+  getHistoricalQuery(offset) {
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    return ffiGetHistoricalQuery(guard.value, offset);
+  }
+  watch(patternOrCallback, callbackOrOptions, maybeOptions) {
+    const noPattern = typeof patternOrCallback === "function";
+    const pattern = noPattern ? "" : patternOrCallback;
+    const callback = noPattern ? patternOrCallback : callbackOrOptions;
+    const options = noPattern ? callbackOrOptions : maybeOptions;
+    if (typeof callback !== "function") {
+      return err("watch callback must be a function");
+    }
+    const guard = this.ensureAlive();
+    if (!guard.ok)
+      return guard;
+    const created = ffiWatch(guard.value, pattern, options?.ignore ?? [], callback);
+    if (!created.ok)
+      return created;
+    const watchId = created.value;
+    this.watchers.add(watchId);
+    return {
+      ok: true,
+      value: () => {
+        if (!this.watchers.delete(watchId))
+          return;
+        if (this.handle !== null)
+          ffiUnwatch(this.handle, watchId);
+      }
+    };
+  }
+  healthCheck(testPath) {
+    return ffiHealthCheck(this.handle, testPath || "");
+  }
+  static isAvailable() {
+    return isAvailable();
+  }
+  static ensureLoaded() {
+    ensureLoaded();
+  }
+  static healthCheckStatic(testPath) {
+    return ffiHealthCheck(null, testPath || "");
+  }
+}
+
+//# debugId=A462FE346ED11F3D64756E2164756E21