@ff-labs/fff-bun 0.2.4-nightly.d1d5d86 → 0.2.5-dev.14642b8

package/README.md

@@ -113,7 +113,7 @@ Track file access for frecency scoring.
 FileFinder.trackAccess("/path/to/file.ts");
 ```
 
-### `FileFinder.liveGrep(query, options?)`
+### `FileFinder.grep(query, options?)`
 
 Search file contents with SIMD-accelerated matching.
 
@@ -129,7 +129,7 @@ interface GrepOptions {
 }
 
 // Plain text search
-const result = FileFinder.liveGrep("TODO", { pageLimit: 20 });
+const result = FileFinder.grep("TODO", { pageLimit: 20 });
 if (result.ok) {
   for (const match of result.value.items) {
     console.log(`${match.relativePath}:${match.lineNumber}: ${match.lineContent}`);
@@ -137,22 +137,22 @@ if (result.ok) {
 }
 
 // Regex search
-const regexResult = FileFinder.liveGrep("fn\\s+\\w+", { mode: "regex" });
+const regexResult = FileFinder.grep("fn\\s+\\w+", { mode: "regex" });
 
 // Fuzzy search
-const fuzzyResult = FileFinder.liveGrep("imprt recat", { mode: "fuzzy" });
+const fuzzyResult = FileFinder.grep("imprt recat", { mode: "fuzzy" });
 
 // Pagination
-const page1 = FileFinder.liveGrep("error");
+const page1 = FileFinder.grep("error");
 if (page1.ok && page1.value.nextCursor) {
-  const page2 = FileFinder.liveGrep("error", {
+  const page2 = FileFinder.grep("error", {
     cursor: page1.value.nextCursor,
   });
 }
 
 // With file constraints
-const tsOnly = FileFinder.liveGrep("*.ts useState");
-const srcOnly = FileFinder.liveGrep("src/ handleClick");
+const tsOnly = FileFinder.grep("*.ts useState");
+const srcOnly = FileFinder.grep("src/ handleClick");
 ```
 
 ### `FileFinder.trackQuery(query, selectedFile)`
@@ -178,7 +178,7 @@ if (health.ok) {
 
 ### Other Methods
 
-- `FileFinder.liveGrep(query, options?)` - Search file contents
+- `FileFinder.grep(query, options?)` - Search file contents
 - `FileFinder.scanFiles()` - Trigger rescan
 - `FileFinder.isScanning()` - Check scan status
 - `FileFinder.getScanProgress()` - Get scan progress

package/examples/grep.ts

@@ -190,7 +190,7 @@ async function main() {
       }
 
       const searchStart = Date.now();
-      const result = finder.liveGrep(query, {
+      const result = finder.grep(query, {
         mode: currentMode,
         pageLimit: 30,
         timeBudgetMs: 5000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ff-labs/fff-bun",
-  "version": "0.2.4-nightly.d1d5d86",
+  "version": "0.2.5-dev.14642b8",
   "private": false,
   "description": "High-performance fuzzy file finder for Bun - perfect for LLM agent tools",
   "type": "module",
@@ -62,14 +62,14 @@
   },
   "homepage": "https://github.com/dmtrKovalenko/fff.nvim#readme",
   "optionalDependencies": {
-    "@ff-labs/fff-bin-darwin-arm64": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-darwin-x64": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-linux-x64-gnu": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-linux-arm64-gnu": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-linux-x64-musl": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-linux-arm64-musl": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-win32-x64": "0.2.4-nightly.d1d5d86",
-    "@ff-labs/fff-bin-win32-arm64": "0.2.4-nightly.d1d5d86"
+    "@ff-labs/fff-bin-darwin-arm64": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-darwin-x64": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-linux-x64-gnu": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-linux-arm64-gnu": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-linux-x64-musl": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-linux-arm64-musl": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-win32-x64": "0.2.5-dev.14642b8",
+    "@ff-labs/fff-bin-win32-arm64": "0.2.5-dev.14642b8"
   },
   "devDependencies": {
     "@types/bun": "^1.3.8",

package/src/ffi.ts

@@ -10,14 +10,44 @@
 
 import { CString, dlopen, FFIType, type Pointer, ptr, read } from "bun:ffi";
 import { findBinary } from "./download";
-import type { Result } from "./types";
-import { err } from "./types";
+import type {
+  FileItem,
+  GrepMatch,
+  GrepResult,
+  Location,
+  Result,
+  Score,
+  SearchResult,
+} from "./types";
+import { createGrepCursor, err } from "./types";
+
+/** Grep mode constants matching the C API (u8). */
+const GREP_MODE_PLAIN = 0;
+const GREP_MODE_REGEX = 1;
+const GREP_MODE_FUZZY = 2;
+
+/** Map string mode to u8 */
+function grepModeToU8(mode?: string): number {
+  switch (mode) {
+    case "regex":
+      return GREP_MODE_REGEX;
+    case "fuzzy":
+      return GREP_MODE_FUZZY;
+    default:
+      return GREP_MODE_PLAIN;
+  }
+}
 
-// Define the FFI symbols
 const ffiDefinition = {
-  // Lifecycle
-  fff_create: {
-    args: [FFIType.cstring],
+  fff_create_instance: {
+    args: [
+      FFIType.cstring, // base_path
+      FFIType.cstring, // frecency_db_path
+      FFIType.cstring, // history_db_path
+      FFIType.bool, // use_unsafe_no_lock
+      FFIType.bool, // warmup_mmap_cache
+      FFIType.bool, // ai_mode
+    ],
     returns: FFIType.ptr,
   },
   fff_destroy: {
@@ -27,19 +57,54 @@ const ffiDefinition = {
 
   // Search
   fff_search: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
+    args: [
+      FFIType.ptr, // handle
+      FFIType.cstring, // query
+      FFIType.cstring, // current_file
+      FFIType.u32, // max_threads
+      FFIType.u32, // page_index
+      FFIType.u32, // page_size
+      FFIType.i32, // combo_boost_multiplier
+      FFIType.u32, // min_combo_count
+    ],
     returns: FFIType.ptr,
   },
 
   // Live grep (content search)
   fff_live_grep: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
+    args: [
+      FFIType.ptr, // handle
+      FFIType.cstring, // query
+      FFIType.u8, // mode
+      FFIType.u64, // max_file_size
+      FFIType.u32, // max_matches_per_file
+      FFIType.bool, // smart_case
+      FFIType.u32, // file_offset
+      FFIType.u32, // page_limit
+      FFIType.u64, // time_budget_ms
+      FFIType.u32, // before_context
+      FFIType.u32, // after_context
+      FFIType.bool, // classify_definitions
+    ],
     returns: FFIType.ptr,
   },
 
   // Multi-pattern grep (Aho-Corasick)
   fff_multi_grep: {
-    args: [FFIType.ptr, FFIType.cstring],
+    args: [
+      FFIType.ptr, // handle
+      FFIType.cstring, // patterns_joined (\n-separated)
+      FFIType.cstring, // constraints
+      FFIType.u64, // max_file_size
+      FFIType.u32, // max_matches_per_file
+      FFIType.bool, // smart_case
+      FFIType.u32, // file_offset
+      FFIType.u32, // page_limit
+      FFIType.u64, // time_budget_ms
+      FFIType.u32, // before_context
+      FFIType.u32, // after_context
+      FFIType.bool, // classify_definitions
+    ],
     returns: FFIType.ptr,
   },
 
@@ -87,6 +152,30 @@ const ffiDefinition = {
     returns: FFIType.ptr,
   },
 
+  // Search result accessors / free
+  fff_free_search_result: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  fff_search_result_get_item: {
+    args: [FFIType.ptr, FFIType.u32],
+    returns: FFIType.ptr,
+  },
+  fff_search_result_get_score: {
+    args: [FFIType.ptr, FFIType.u32],
+    returns: FFIType.ptr,
+  },
+
+  // Grep result accessors / free
+  fff_free_grep_result: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  fff_grep_result_get_match: {
+    args: [FFIType.ptr, FFIType.u32],
+    returns: FFIType.ptr,
+  },
+
   // Memory management
   fff_free_result: {
     args: [FFIType.ptr],
@@ -96,6 +185,10 @@ const ffiDefinition = {
     args: [FFIType.ptr],
     returns: FFIType.void,
   },
+  fff_free_scan_progress: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
 } as const;
 
 type FFFLibrary = ReturnType<typeof dlopen<typeof ffiDefinition>>;
@@ -148,59 +241,100 @@ function snakeToCamel(obj: unknown): unknown {
 
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-    const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
+      letter.toUpperCase(),
+    );
     result[camelKey] = snakeToCamel(value);
   }
   return result;
 }
 
+// ---------------------------------------------------------------------------
+// FffResult byte offsets (must match #[repr(C)] layout on 64-bit)
+// { success: bool(1+7pad), error: *char(8), handle: *void(8), int_value: i64(8) }
+// ---------------------------------------------------------------------------
+const RES_SUCCESS   = 0;   // bool (1 + 7 padding)
+const RES_ERROR     = 8;   // *mut c_char (8)
+const RES_HANDLE    = 16;  // *mut c_void (8)
+const RES_INT_VALUE = 24;  // i64         (8)
+
 /**
- * Parse a FffResult from the FFI return value.
- *
- * The result is a pointer to a struct:
- *   { success: bool, data: *char, error: *char, handle: *void }
- *
- * Layout (with alignment padding):
- *   offset  0: success (bool, 1 byte + 7 padding)
- *   offset  8: data pointer (8 bytes)
- *   offset 16: error pointer (8 bytes)
- *   offset 24: handle pointer (8 bytes)
+ * Read the FffResult envelope: check success, extract payload, free envelope.
+ * On error returns a Result<never>. On success returns the raw handle pointer and int_value.
  */
-function parseResult<T>(resultPtr: Pointer | null): Result<T> {
+function readResultEnvelope(resultPtr: Pointer | null): { success: true; handlePtr: number; intValue: number } | Result<never> {
   if (resultPtr === null) {
     return err("FFI returned null pointer");
   }
 
-  const success = read.u8(resultPtr, 0) !== 0;
-  const dataPtr = read.ptr(resultPtr, 8);
-  const errorPtr = read.ptr(resultPtr, 16);
-
+  const success = read.u8(resultPtr, RES_SUCCESS) !== 0;
   const library = loadLibrary();
 
-  if (success) {
-    const data = readCString(dataPtr);
-    // Free the result
-    library.symbols.fff_free_result(resultPtr);
-
-    if (data === null || data === "") {
-      return { ok: true, value: undefined as T };
-    }
-
-    try {
-      const parsed = JSON.parse(data);
-      // Convert snake_case to camelCase for TypeScript consumers
-      const transformed = snakeToCamel(parsed) as T;
-      return { ok: true, value: transformed };
-    } catch {
-      // For simple values like "true" or numbers
-      return { ok: true, value: data as T };
-    }
-  } else {
+  if (!success) {
+    const errorPtr = read.ptr(resultPtr, RES_ERROR);
     const errorMsg = readCString(errorPtr) || "Unknown error";
-    // Free the result
     library.symbols.fff_free_result(resultPtr);
     return err(errorMsg);
   }
+
+  const handlePtr = read.ptr(resultPtr, RES_HANDLE);
+  const intValue = Number(read.i64(resultPtr, RES_INT_VALUE));
+  library.symbols.fff_free_result(resultPtr);
+  return { success: true, handlePtr, intValue };
+}
+
+/** Parse a FffResult that carries a bool in int_value (0 = false, nonzero = true). */
+function parseBoolResult(resultPtr: Pointer | null): Result<boolean> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+  return { ok: true, value: envelope.intValue !== 0 };
+}
+
+/** Parse a FffResult that carries an integer in int_value. */
+function parseIntResult(resultPtr: Pointer | null): Result<number> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+  return { ok: true, value: envelope.intValue };
+}
+
+/** Parse a FffResult that carries a string in handle (freed with fff_free_string). */
+function parseStringResult(resultPtr: Pointer | null): Result<string | null> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+
+  if (envelope.handlePtr === 0) return { ok: true, value: null };
+
+  const library = loadLibrary();
+  const str = readCString(envelope.handlePtr);
+  library.symbols.fff_free_string(asPtr(envelope.handlePtr));
+  return { ok: true, value: str };
+}
+
+/** Parse a FffResult that carries a JSON string in handle. */
+function parseJsonResult<T>(resultPtr: Pointer | null): Result<T> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+
+  if (envelope.handlePtr === 0) return { ok: true, value: undefined as T };
+
+  const library = loadLibrary();
+  const jsonStr = readCString(envelope.handlePtr);
+  library.symbols.fff_free_string(asPtr(envelope.handlePtr));
+
+  if (jsonStr === null || jsonStr === "") return { ok: true, value: undefined as T };
+
+  try {
+    return { ok: true, value: snakeToCamel(JSON.parse(jsonStr)) as T };
+  } catch {
+    return { ok: true, value: jsonStr as T };
+  }
+}
+
+/** Parse a FffResult with no payload (void, success/error only). */
+function parseVoidResult(resultPtr: Pointer | null): Result<void> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+  return { ok: true, value: undefined };
 }
 
 /**
@@ -210,28 +344,39 @@ export type NativeHandle = Pointer;
 
 /**
  * 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: string): Result<NativeHandle> {
+export function ffiCreate(
+  basePath: string,
+  frecencyDbPath: string,
+  historyDbPath: string,
+  useUnsafeNoLock: boolean,
+  warmupMmapCache: boolean,
+  aiMode: boolean,
+): Result<NativeHandle> {
   const library = loadLibrary();
-  const resultPtr = library.symbols.fff_create(ptr(encodeString(optsJson)));
+  const resultPtr = library.symbols.fff_create_instance(
+    ptr(encodeString(basePath)),
+    ptr(encodeString(frecencyDbPath)),
+    ptr(encodeString(historyDbPath)),
+    useUnsafeNoLock,
+    warmupMmapCache,
+    aiMode,
+  );
 
   if (resultPtr === null) {
     return err("FFI returned null pointer");
   }
 
-  const success = read.u8(resultPtr, 0) !== 0;
-  const errorPtr = read.ptr(resultPtr, 16);
-  const handlePtr = read.ptr(resultPtr, 24);
+  const success = read.u8(resultPtr, RES_SUCCESS) !== 0;
+  const errorPtr = read.ptr(resultPtr, RES_ERROR);
+  const handlePtr = read.ptr(resultPtr, RES_HANDLE);
 
   if (success) {
     const handle = handlePtr as unknown as Pointer;
     library.symbols.fff_free_result(resultPtr);
 
     if (!handle || handle === (0 as unknown as Pointer)) {
-      return err("fff_create returned null handle");
+      return err("fff_create_instance returned null handle");
     }
 
     return { ok: true, value: handle };
@@ -250,21 +395,415 @@ export function ffiDestroy(handle: NativeHandle): void {
   library.symbols.fff_destroy(handle);
 }
 
+// ---------------------------------------------------------------------------
+// Struct byte offsets (must match #[repr(C)] layout on 64-bit)
+// ---------------------------------------------------------------------------
+
+// FffSearchResult { items: *mut, scores: *mut, count: u32, total_matched: u32, total_files: u32, location: FffLocation }
+const SR_ITEMS = 0; // *mut FffFileItem (8)
+const SR_SCORES = 8; // *mut FffScore    (8)
+const SR_COUNT = 16; // u32              (4)
+const SR_MATCHED = 20; // u32              (4)
+const SR_TOTAL = 24; // u32              (4)
+// FffLocation is inlined at offset 28
+const SR_LOC_TAG = 28; // u8               (1 + 3 padding)
+const SR_LOC_LINE = 32; // i32              (4)
+const SR_LOC_COL = 36; // i32              (4)
+const SR_LOC_END_LINE = 40; // i32           (4)
+const SR_LOC_END_COL = 44; // i32           (4)
+
+// FffFileItem (80 bytes)
+const FI_PATH = 0; // *mut c_char (8)
+const FI_RELPATH = 8; // *mut c_char (8)
+const FI_FNAME = 16; // *mut c_char (8)
+const FI_GIT = 24; // *mut c_char (8)
+const FI_SIZE = 32; // u64         (8)
+const FI_MODIFIED = 40; // u64         (8)
+const FI_ACCESS = 48; // i64         (8)
+const FI_MODFR = 56; // i64         (8)
+const FI_TOTAL_FR = 64; // i64         (8)
+const _FI_BINARY = 72; // bool        (1 + 7 pad)
+const FI_SIZE_OF = 80;
+
+// FffScore (48 bytes)
+const SC_TOTAL = 0; // i32         (4)
+const SC_BASE = 4; // i32         (4)
+const SC_FNAME = 8; // i32         (4)
+const SC_SPECIAL = 12; // i32         (4)
+const SC_FREC = 16; // i32         (4)
+const SC_DIST = 20; // i32         (4)
+const SC_CURFILE = 24; // i32         (4)
+const SC_COMBO = 28; // i32         (4)
+const SC_EXACT = 32; // bool        (1 + 7 pad)
+const SC_MTYPE = 40; // *mut c_char (8)
+const SC_SIZE_OF = 48;
+
+/** Cast a number (raw address from pointer math) to Pointer for read.*. */
+function asPtr(n: number): Pointer {
+  return n as unknown as Pointer;
+}
+
+/**
+ * Read an FffFileItem struct at the given raw address.
+ */
+function readFileItemStruct(p: number): FileItem {
+  const pp = asPtr(p);
+  return {
+    path: readCString(read.ptr(pp, FI_PATH)) ?? "",
+    relativePath: readCString(read.ptr(pp, FI_RELPATH)) ?? "",
+    fileName: readCString(read.ptr(pp, FI_FNAME)) ?? "",
+    gitStatus: readCString(read.ptr(pp, FI_GIT)) ?? "",
+    size: Number(read.u64(pp, FI_SIZE)),
+    modified: Number(read.u64(pp, FI_MODIFIED)),
+    accessFrecencyScore: Number(read.i64(pp, FI_ACCESS)),
+    modificationFrecencyScore: Number(read.i64(pp, FI_MODFR)),
+    totalFrecencyScore: Number(read.i64(pp, FI_TOTAL_FR)),
+  };
+}
+
+/**
+ * Read an FffScore struct at the given raw address.
+ */
+function readScoreStruct(p: number): Score {
+  const pp = asPtr(p);
+  return {
+    total: read.i32(pp, SC_TOTAL),
+    baseScore: read.i32(pp, SC_BASE),
+    filenameBonus: read.i32(pp, SC_FNAME),
+    specialFilenameBonus: read.i32(pp, SC_SPECIAL),
+    frecencyBoost: read.i32(pp, SC_FREC),
+    distancePenalty: read.i32(pp, SC_DIST),
+    currentFilePenalty: read.i32(pp, SC_CURFILE),
+    comboMatchBoost: read.i32(pp, SC_COMBO),
+    exactMatch: read.u8(pp, SC_EXACT) !== 0,
+    matchType: readCString(read.ptr(pp, SC_MTYPE)) ?? "",
+  };
+}
+
+/**
+ * Parse an FffSearchResult from a raw pointer, then free native memory.
+ */
+function parseSearchResult(resultPtr: Pointer | null): Result<SearchResult> {
+  if (resultPtr === null) {
+    return err("FFI returned null pointer");
+  }
+
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+
+  if (envelope.handlePtr === 0) {
+    return err("fff_search returned null search result");
+  }
+
+  const hp = asPtr(envelope.handlePtr);
+  const count = read.u32(hp, SR_COUNT);
+  const totalMatched = read.u32(hp, SR_MATCHED);
+  const totalFiles = read.u32(hp, SR_TOTAL);
+  const itemsBase = read.ptr(hp, SR_ITEMS);
+  const scoresBase = read.ptr(hp, SR_SCORES);
+
+  // Read location
+  const locTag = read.u8(hp, SR_LOC_TAG);
+  let location: Location | undefined;
+  if (locTag === 1) {
+    location = { type: "line", line: read.i32(hp, SR_LOC_LINE) };
+  } else if (locTag === 2) {
+    location = {
+      type: "position",
+      line: read.i32(hp, SR_LOC_LINE),
+      col: read.i32(hp, SR_LOC_COL),
+    };
+  } else if (locTag === 3) {
+    location = {
+      type: "range",
+      start: { line: read.i32(hp, SR_LOC_LINE), col: read.i32(hp, SR_LOC_COL) },
+      end: {
+        line: read.i32(hp, SR_LOC_END_LINE),
+        col: read.i32(hp, SR_LOC_END_COL),
+      },
+    };
+  }
+
+  // Read items and scores arrays using pointer arithmetic
+  const items: FileItem[] = [];
+  const scores: Score[] = [];
+
+  for (let i = 0; i < count; i++) {
+    items.push(readFileItemStruct(itemsBase + i * FI_SIZE_OF));
+    scores.push(readScoreStruct(scoresBase + i * SC_SIZE_OF));
+  }
+
+  // Free native search result
+  loadLibrary().symbols.fff_free_search_result(hp);
+
+  const result: SearchResult = { items, scores, totalMatched, totalFiles };
+  if (location) {
+    result.location = location;
+  }
+  return { ok: true, value: result };
+}
+
+// ---------------------------------------------------------------------------
+// FffGrepMatch byte offsets (must match #[repr(C)] layout on 64-bit)
+// ---------------------------------------------------------------------------
+
+// Pointers (8 bytes each)
+const GM_PATH = 0;
+const GM_RELPATH = 8;
+const GM_FNAME = 16;
+const GM_GIT = 24;
+const GM_LINE_CONTENT = 32;
+const GM_MATCH_RANGES = 40;
+const GM_CTX_BEFORE = 48;
+const GM_CTX_AFTER = 56;
+
+// 8-byte numeric fields
+const GM_SIZE = 64;
+const GM_MODIFIED = 72;
+const GM_TOTAL_FR = 80;
+const GM_ACCESS_FR = 88;
+const GM_MOD_FR = 96;
+const GM_LINE_NUM = 104;
+const GM_BYTE_OFF = 112;
+
+// 4-byte fields
+const GM_COL = 120;
+const GM_MR_COUNT = 124;
+const GM_CTX_B_COUNT = 128;
+const GM_CTX_A_COUNT = 132;
+
+// 2-byte
+const GM_FUZZY_SCORE = 136;
+// 1-byte
+const GM_HAS_FUZZY = 138;
+const GM_IS_BINARY = 139;
+const _GM_IS_DEF = 140;
+
+// struct size: pad to 8-byte alignment → 144
+const GM_SIZE_OF = 144;
+
+// FffGrepResult
+const GR_ITEMS = 0; // *mut FffGrepMatch (8)
+const GR_COUNT = 8; // u32 (4)
+const GR_MATCHED = 12; // u32 (4)
+const GR_FILES_SEARCHED = 16; // u32 (4)
+const GR_TOTAL_FILES = 20; // u32 (4)
+const GR_FILTERED = 24; // u32 (4)
+const GR_NEXT_OFFSET = 28; // u32 (4)
+const GR_REGEX_ERR = 32; // *mut c_char (8)
+
+// FffMatchRange (8 bytes)
+const MR_START = 0;
+const MR_END = 4;
+const MR_SIZE = 8;
+
+/**
+ * Read a C string array (char**) at the given pointer, with `count` elements.
+ */
+function readCStringArray(base: number, count: number): string[] {
+  if (count === 0 || base === 0) return [];
+  const result: string[] = [];
+  const bp = asPtr(base);
+  for (let i = 0; i < count; i++) {
+    const strPtr = read.ptr(bp, i * 8); // each pointer is 8 bytes
+    result.push(readCString(strPtr) ?? "");
+  }
+  return result;
+}
+
+/**
+ * Read an FffGrepMatch struct at the given raw address.
+ */
+function readGrepMatchStruct(p: number): GrepMatch {
+  const pp = asPtr(p);
+  const matchRangesPtr = read.ptr(pp, GM_MATCH_RANGES);
+  const matchRangesCount = read.u32(pp, GM_MR_COUNT);
+  const matchRanges: [number, number][] = [];
+  for (let i = 0; i < matchRangesCount; i++) {
+    const base = matchRangesPtr + i * MR_SIZE;
+    const bp = asPtr(base);
+    matchRanges.push([read.u32(bp, MR_START), read.u32(bp, MR_END)]);
+  }
+
+  const hasFuzzy = read.u8(pp, GM_HAS_FUZZY) !== 0;
+  const ctxBeforeCount = read.u32(pp, GM_CTX_B_COUNT);
+  const ctxAfterCount = read.u32(pp, GM_CTX_A_COUNT);
+
+  const match: GrepMatch = {
+    path: readCString(read.ptr(pp, GM_PATH)) ?? "",
+    relativePath: readCString(read.ptr(pp, GM_RELPATH)) ?? "",
+    fileName: readCString(read.ptr(pp, GM_FNAME)) ?? "",
+    gitStatus: readCString(read.ptr(pp, GM_GIT)) ?? "",
+    lineContent: readCString(read.ptr(pp, GM_LINE_CONTENT)) ?? "",
+    size: Number(read.u64(pp, GM_SIZE)),
+    modified: Number(read.u64(pp, GM_MODIFIED)),
+    totalFrecencyScore: Number(read.i64(pp, GM_TOTAL_FR)),
+    accessFrecencyScore: Number(read.i64(pp, GM_ACCESS_FR)),
+    modificationFrecencyScore: Number(read.i64(pp, GM_MOD_FR)),
+    isBinary: read.u8(pp, GM_IS_BINARY) !== 0,
+    lineNumber: Number(read.u64(pp, GM_LINE_NUM)),
+    col: read.u32(pp, GM_COL),
+    byteOffset: Number(read.u64(pp, GM_BYTE_OFF)),
+    matchRanges,
+  };
+
+  if (hasFuzzy) {
+    match.fuzzyScore = read.u16(pp, GM_FUZZY_SCORE);
+  }
+  if (ctxBeforeCount > 0) {
+    match.contextBefore = readCStringArray(
+      read.ptr(pp, GM_CTX_BEFORE),
+      ctxBeforeCount,
+    );
+  }
+  if (ctxAfterCount > 0) {
+    match.contextAfter = readCStringArray(
+      read.ptr(pp, GM_CTX_AFTER),
+      ctxAfterCount,
+    );
+  }
+
+  return match;
+}
+
+/**
+ * Parse an FffGrepResult from a raw FffResult pointer, then free native memory.
+ */
+function parseGrepResult(resultPtr: Pointer | null): Result<GrepResult> {
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+
+  if (envelope.handlePtr === 0) {
+    return err("grep returned null result");
+  }
+
+  const hp = asPtr(envelope.handlePtr);
+  const count = read.u32(hp, GR_COUNT);
+  const totalMatched = read.u32(hp, GR_MATCHED);
+  const totalFilesSearched = read.u32(hp, GR_FILES_SEARCHED);
+  const totalFiles = read.u32(hp, GR_TOTAL_FILES);
+  const filteredFileCount = read.u32(hp, GR_FILTERED);
+  const nextFileOffset = read.u32(hp, GR_NEXT_OFFSET);
+  const regexErrPtr = read.ptr(hp, GR_REGEX_ERR);
+  const regexFallbackError = readCString(regexErrPtr) ?? undefined;
+  const itemsBase = read.ptr(hp, GR_ITEMS);
+
+  const items: GrepMatch[] = [];
+  for (let i = 0; i < count; i++) {
+    items.push(readGrepMatchStruct(itemsBase + i * GM_SIZE_OF));
+  }
+
+  loadLibrary().symbols.fff_free_grep_result(hp);
+
+  const grepResult: GrepResult = {
+    items,
+    totalMatched,
+    totalFilesSearched,
+    totalFiles,
+    filteredFileCount,
+    nextCursor: nextFileOffset > 0 ? createGrepCursor(nextFileOffset) : null,
+  };
+  if (regexFallbackError) {
+    grepResult.regexFallbackError = regexFallbackError;
+  }
+  return { ok: true, value: grepResult };
+}
+
 /**
  * Perform fuzzy search.
  */
 export function ffiSearch(
   handle: NativeHandle,
   query: string,
-  optsJson: string,
-): Result<unknown> {
+  currentFile: string,
+  maxThreads: number,
+  pageIndex: number,
+  pageSize: number,
+  comboBoostMultiplier: number,
+  minComboCount: number,
+): Result<SearchResult> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_search(
     handle,
     ptr(encodeString(query)),
-    ptr(encodeString(optsJson)),
+    ptr(encodeString(currentFile)),
+    maxThreads,
+    pageIndex,
+    pageSize,
+    comboBoostMultiplier,
+    minComboCount,
+  );
+  return parseSearchResult(resultPtr);
+}
+
+/**
+ * Live grep - search file contents.
+ */
+export function ffiLiveGrep(
+  handle: NativeHandle,
+  query: string,
+  mode: string,
+  maxFileSize: number,
+  maxMatchesPerFile: number,
+  smartCase: boolean,
+  fileOffset: number,
+  pageLimit: number,
+  timeBudgetMs: number,
+  beforeContext: number,
+  afterContext: number,
+  classifyDefinitions: boolean,
+): Result<GrepResult> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_live_grep(
+    handle,
+    ptr(encodeString(query)),
+    grepModeToU8(mode),
+    BigInt(maxFileSize),
+    maxMatchesPerFile,
+    smartCase,
+    fileOffset,
+    pageLimit,
+    BigInt(timeBudgetMs),
+    beforeContext,
+    afterContext,
+    classifyDefinitions,
+  );
+  return parseGrepResult(resultPtr);
+}
+
+/**
+ * Multi-pattern grep - Aho-Corasick multi-needle search.
+ */
+export function ffiMultiGrep(
+  handle: NativeHandle,
+  patternsJoined: string,
+  constraints: string,
+  maxFileSize: number,
+  maxMatchesPerFile: number,
+  smartCase: boolean,
+  fileOffset: number,
+  pageLimit: number,
+  timeBudgetMs: number,
+  beforeContext: number,
+  afterContext: number,
+  classifyDefinitions: boolean,
+): Result<GrepResult> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_multi_grep(
+    handle,
+    ptr(encodeString(patternsJoined)),
+    ptr(encodeString(constraints)),
+    BigInt(maxFileSize),
+    maxMatchesPerFile,
+    smartCase,
+    fileOffset,
+    pageLimit,
+    BigInt(timeBudgetMs),
+    beforeContext,
+    afterContext,
+    classifyDefinitions,
   );
-  return parseResult<unknown>(resultPtr);
+  return parseGrepResult(resultPtr);
 }
 
 /**
@@ -273,7 +812,7 @@ export function ffiSearch(
 export function ffiScanFiles(handle: NativeHandle): Result<void> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_scan_files(handle);
-  return parseResult<void>(resultPtr);
+  return parseVoidResult(resultPtr);
 }
 
 /**
@@ -284,35 +823,54 @@ export function ffiIsScanning(handle: NativeHandle): boolean {
   return library.symbols.fff_is_scanning(handle) as boolean;
 }
 
+// FffScanProgress { scanned_files_count: u64(8), is_scanning: bool(1+7pad) }
+const SP_COUNT    = 0;  // u64 (8)
+const SP_SCANNING = 8;  // bool (1 + 7 pad)
+
 /**
  * Get scan progress.
  */
-export function ffiGetScanProgress(handle: NativeHandle): Result<unknown> {
+export function ffiGetScanProgress(handle: NativeHandle): Result<{ scannedFilesCount: number; isScanning: boolean }> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_get_scan_progress(handle);
-  return parseResult<unknown>(resultPtr);
+  const envelope = readResultEnvelope(resultPtr);
+  if (!("success" in envelope)) return envelope;
+
+  if (envelope.handlePtr === 0) {
+    return err("scan progress returned null");
+  }
+
+  const hp = asPtr(envelope.handlePtr);
+  const result = {
+    scannedFilesCount: Number(read.u64(hp, SP_COUNT)),
+    isScanning: read.u8(hp, SP_SCANNING) !== 0,
+  };
+  library.symbols.fff_free_scan_progress(hp);
+  return { ok: true, value: result };
 }
 
 /**
  * Wait for scan to complete.
  */
-export function ffiWaitForScan(handle: NativeHandle, timeoutMs: number): Result<boolean> {
+export function ffiWaitForScan(
+  handle: NativeHandle,
+  timeoutMs: number,
+): Result<boolean> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_wait_for_scan(handle, BigInt(timeoutMs));
-  const result = parseResult<boolean | string>(resultPtr);
-  if (!result.ok) return result;
-  // JSON.parse("true") returns boolean true, but we also handle
-  // the string case defensively.
-  return { ok: true, value: result.value === true || result.value === "true" };
+  return parseBoolResult(resultPtr);
 }
 
 /**
  * Restart index in new path.
  */
-export function ffiRestartIndex(handle: NativeHandle, newPath: string): Result<void> {
+export function ffiRestartIndex(
+  handle: NativeHandle,
+  newPath: string,
+): Result<void> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_restart_index(handle, ptr(encodeString(newPath)));
-  return parseResult<void>(resultPtr);
+  return parseVoidResult(resultPtr);
 }
 
 /**
@@ -321,13 +879,7 @@ export function ffiRestartIndex(handle: NativeHandle, newPath: string): Result<v
 export function ffiRefreshGitStatus(handle: NativeHandle): Result<number> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_refresh_git_status(handle);
-  const result = parseResult<number | string>(resultPtr);
-  if (!result.ok) return result;
-  // JSON.parse("3") returns 3 (number), parseInt handles both
-  return {
-    ok: true,
-    value: typeof result.value === "number" ? result.value : parseInt(result.value, 10),
-  };
+  return parseIntResult(resultPtr);
 }
 
 /**
@@ -344,9 +896,7 @@ export function ffiTrackQuery(
     ptr(encodeString(query)),
     ptr(encodeString(filePath)),
   );
-  const result = parseResult<boolean | string>(resultPtr);
-  if (!result.ok) return result;
-  return { ok: true, value: result.value === true || result.value === "true" };
+  return parseBoolResult(resultPtr);
 }
 
 /**
@@ -358,10 +908,7 @@ export function ffiGetHistoricalQuery(
 ): Result<string | null> {
   const library = loadLibrary();
   const resultPtr = library.symbols.fff_get_historical_query(handle, BigInt(offset));
-  const result = parseResult<string | null>(resultPtr);
-  if (!result.ok) return result;
-  if (result.value === null || result.value === "null") return { ok: true, value: null };
-  return result as Result<string>;
+  return parseStringResult(resultPtr);
 }
 
 /**
@@ -378,42 +925,7 @@ export function ffiHealthCheck(
     handle ?? (0 as unknown as Pointer),
     ptr(encodeString(testPath)),
   );
-  return parseResult<unknown>(resultPtr);
-}
-
-/**
- * Detect workspace roots in the indexed directory.
- */
-export function ffiDetectWorkspaces(handle: NativeHandle): Result<unknown> {
-  const library = loadLibrary();
-  const resultPtr = library.symbols.fff_detect_workspaces(handle);
-  return parseResult<unknown>(resultPtr);
-}
-
-/**
- * Live grep - search file contents.
- */
-export function ffiLiveGrep(
-  handle: NativeHandle,
-  query: string,
-  optsJson: string,
-): Result<unknown> {
-  const library = loadLibrary();
-  const resultPtr = library.symbols.fff_live_grep(
-    handle,
-    ptr(encodeString(query)),
-    ptr(encodeString(optsJson)),
-  );
-  return parseResult<unknown>(resultPtr);
-}
-
-/**
- * Multi-pattern grep - Aho-Corasick multi-needle search.
- */
-export function ffiMultiGrep(handle: NativeHandle, optsJson: string): Result<unknown> {
-  const library = loadLibrary();
-  const resultPtr = library.symbols.fff_multi_grep(handle, ptr(encodeString(optsJson)));
-  return parseResult<unknown>(resultPtr);
+  return parseJsonResult<unknown>(resultPtr);
 }
 
 /**

package/src/finder.ts

@@ -40,14 +40,7 @@ import type {
   SearchResult,
 } from "./types";
 
-import {
-  createGrepCursor,
-  err,
-  toInternalGrepOptions,
-  toInternalInitOptions,
-  toInternalMultiGrepOptions,
-  toInternalSearchOptions,
-} from "./types";
+import { err } from "./types";
 
 /**
  * FileFinder - Fast file finder with fuzzy search
@@ -108,8 +101,14 @@ export class FileFinder {
    * ```
    */
   static create(options: InitOptions): Result<FileFinder> {
-    const internalOpts = toInternalInitOptions(options);
-    const result = ffiCreate(JSON.stringify(internalOpts));
+    const result = ffiCreate(
+      options.basePath,
+      options.frecencyDbPath ?? "",
+      options.historyDbPath ?? "",
+      options.useUnsafeNoLock ?? false,
+      options.warmupMmapCache ?? false,
+      options.aiMode ?? false,
+    );
 
     if (!result.ok) {
       return result;
@@ -177,14 +176,16 @@ export class FileFinder {
     const guard = this.ensureAlive();
     if (!guard.ok) return guard;
 
-    const internalOpts = toInternalSearchOptions(options);
-    const result = ffiSearch(guard.value, query, JSON.stringify(internalOpts));
-
-    if (!result.ok) {
-      return result;
-    }
-
-    return result as Result<SearchResult>;
+    return ffiSearch(
+      guard.value,
+      query,
+      options?.currentFile ?? "",
+      options?.maxThreads ?? 0,
+      options?.pageIndex ?? 0,
+      options?.pageSize ?? 0,
+      options?.comboBoostMultiplier ?? 0,
+      options?.minComboCount ?? 0,
+    );
   }
 
   /**
@@ -209,28 +210,38 @@ export class FileFinder {
    * @example
    * ```typescript
    * // First page
-   * const result = finder.liveGrep("TODO", { mode: "plain" });
+   * const result = finder.grep("TODO", { mode: "plain" });
    * if (result.ok) {
    *   for (const match of result.value.items) {
    *     console.log(`${match.relativePath}:${match.lineNumber}: ${match.lineContent}`);
    *   }
    *   // Fetch next page
    *   if (result.value.nextCursor) {
-   *     const page2 = finder.liveGrep("TODO", {
+   *     const page2 = finder.grep("TODO", {
    *       cursor: result.value.nextCursor,
    *     });
    *   }
    * }
    * ```
    */
-  liveGrep(query: string, options?: GrepOptions): Result<GrepResult> {
+  grep(query: string, options?: GrepOptions): Result<GrepResult> {
     const guard = this.ensureAlive();
     if (!guard.ok) return guard;
 
-    const internalOpts = toInternalGrepOptions(options);
-    const result = ffiLiveGrep(guard.value, query, JSON.stringify(internalOpts));
-
-    return transformGrepResult(result);
+    return ffiLiveGrep(
+      guard.value,
+      query,
+      options?.mode ?? "plain",
+      options?.maxFileSize ?? 0,
+      options?.maxMatchesPerFile ?? 0,
+      options?.smartCase ?? true,
+      options?.cursor?._offset ?? 0,
+      0, // page_limit (0 = default 50)
+      options?.timeBudgetMs ?? 0,
+      options?.beforeContext ?? 0,
+      options?.afterContext ?? 0,
+      false,
+    );
   }
 
   /**
@@ -266,10 +277,20 @@ export class FileFinder {
       return err("patterns array must have at least 1 element");
     }
 
-    const internalOpts = toInternalMultiGrepOptions(options);
-    const result = ffiMultiGrep(guard.value, JSON.stringify(internalOpts));
-
-    return transformGrepResult(result);
+    return ffiMultiGrep(
+      guard.value,
+      options.patterns.join("\n"),
+      options.constraints ?? "",
+      options.maxFileSize ?? 0,
+      options.maxMatchesPerFile ?? 0,
+      options.smartCase ?? true,
+      options.cursor?._offset ?? 0,
+      0, // page_limit (0 = default 50)
+      options.timeBudgetMs ?? 0,
+      options.beforeContext ?? 0,
+      options.afterContext ?? 0,
+      false,
+    );
   }
 
   /**
@@ -410,20 +431,3 @@ export class FileFinder {
   }
 }
 
-function transformGrepResult(result: Result<unknown>): Result<GrepResult> {
-  if (!result.ok) {
-    return result;
-  }
-  const raw = result.value as Record<string, unknown>;
-  const nextFileOffset = raw.nextFileOffset as number;
-  const grepResult: GrepResult = {
-    items: raw.items as GrepResult["items"],
-    totalMatched: raw.totalMatched as number,
-    totalFilesSearched: raw.totalFilesSearched as number,
-    totalFiles: raw.totalFiles as number,
-    filteredFileCount: raw.filteredFileCount as number,
-    nextCursor: nextFileOffset > 0 ? createGrepCursor(nextFileOffset) : null,
-    regexFallbackError: raw.regexFallbackError as string | undefined,
-  };
-  return { ok: true, value: grepResult };
-}

package/src/git-lifecycle.test.ts

@@ -107,7 +107,7 @@ async function waitForFileCount(finder: FileFinder, count: number): Promise<numb
   return result.ok ? result.value.totalFiles : -1;
 }
 
-/** Poll liveGrep until predicate on totalMatched is satisfied, or the timeout is exceeded. */
+/** Poll grep until predicate on totalMatched is satisfied, or the timeout is exceeded. */
 async function waitForGrep(
   finder: FileFinder,
   pattern: string,
@@ -116,11 +116,11 @@ async function waitForGrep(
 ) {
   const start = Date.now();
   while (Date.now() - start < WATCHER_TIMEOUT_MS) {
-    const result = finder.liveGrep(pattern, options);
+    const result = finder.grep(pattern, options);
     if (result.ok && predicate(result.value.totalMatched)) return result;
     await sleep(POLL_INTERVAL_MS);
   }
-  return finder.liveGrep(pattern, options);
+  return finder.grep(pattern, options);
 }
 
 describe.skipIf(process.platform === "win32")("Git lifecycle integration", () => {

package/src/index.test.ts

@@ -162,8 +162,8 @@ describe("FileFinder - Full Lifecycle", () => {
     }
   });
 
-  test("liveGrep plain text returns matching lines", () => {
-    const result = finder.liveGrep("fff-core", {
+  test("grep plain text returns matching lines", () => {
+    const result = finder.grep("fff-core", {
       mode: "plain",
     });
     expect(result.ok).toBe(true);
@@ -197,9 +197,9 @@ describe("FileFinder - Full Lifecycle", () => {
     }
   });
 
-  test("liveGrep fuzzy mode returns results with scores", () => {
+  test("grep fuzzy mode returns results with scores", () => {
     // Intentional typo: "depdnency" instead of "dependency" to exercise fuzzy matching
-    const result = finder.liveGrep("depdnency", {
+    const result = finder.grep("depdnency", {
       mode: "fuzzy",
     });
     expect(result.ok).toBe(true);

package/src/types.ts

@@ -208,62 +208,6 @@ export interface HealthCheck {
   };
 }
 
-/**
- * Internal: Options format sent to Rust FFI
- * @internal
- */
-export interface InitOptionsInternal {
-  base_path: string;
-  frecency_db_path?: string;
-  history_db_path?: string;
-  use_unsafe_no_lock: boolean;
-  warmup_mmap_cache: boolean;
-  ai_mode: boolean;
-}
-
-/**
- * Internal: Search options format sent to Rust FFI
- * @internal
- */
-export interface SearchOptionsInternal {
-  max_threads?: number;
-  current_file?: string;
-  combo_boost_multiplier?: number;
-  min_combo_count?: number;
-  page_index?: number;
-  page_size?: number;
-}
-
-/**
- * Convert public InitOptions to internal format
- * @internal
- */
-export function toInternalInitOptions(opts: InitOptions): InitOptionsInternal {
-  return {
-    base_path: opts.basePath,
-    frecency_db_path: opts.frecencyDbPath,
-    history_db_path: opts.historyDbPath,
-    use_unsafe_no_lock: opts.useUnsafeNoLock ?? false,
-    warmup_mmap_cache: opts.warmupMmapCache ?? false,
-    ai_mode: opts.aiMode ?? false,
-  };
-}
-
-/**
- * Convert public SearchOptions to internal format
- * @internal
- */
-export function toInternalSearchOptions(opts?: SearchOptions): SearchOptionsInternal {
-  return {
-    max_threads: opts?.maxThreads,
-    current_file: opts?.currentFile,
-    combo_boost_multiplier: opts?.comboBoostMultiplier,
-    min_combo_count: opts?.minComboCount,
-    page_index: opts?.pageIndex,
-    page_size: opts?.pageSize,
-  };
-}
-
 /**
  * Grep search mode
  */
@@ -417,78 +361,3 @@ export interface MultiGrepOptions {
   afterContext?: number;
 }
 
-/**
- * Internal: Multi-grep options format sent to Rust FFI
- * @internal
- */
-export interface MultiGrepOptionsInternal {
-  patterns: string[];
-  constraints?: string;
-  max_file_size?: number;
-  max_matches_per_file?: number;
-  smart_case?: boolean;
-  file_offset?: number;
-  page_limit?: number;
-  time_budget_ms?: number;
-  before_context?: number;
-  after_context?: number;
-}
-
-/**
- * Convert public MultiGrepOptions to internal format
- * @internal
- */
-export function toInternalMultiGrepOptions(
-  opts: MultiGrepOptions,
-  pageLimit?: number,
-): MultiGrepOptionsInternal {
-  return {
-    patterns: opts.patterns,
-    constraints: opts.constraints,
-    max_file_size: opts.maxFileSize,
-    max_matches_per_file: opts.maxMatchesPerFile,
-    smart_case: opts.smartCase,
-    file_offset: opts.cursor?._offset ?? 0,
-    page_limit: pageLimit,
-    time_budget_ms: opts.timeBudgetMs,
-    before_context: opts.beforeContext,
-    after_context: opts.afterContext,
-  };
-}
-
-/**
- * Internal: Grep options format sent to Rust FFI
- * @internal
- */
-export interface GrepOptionsInternal {
-  max_file_size?: number;
-  max_matches_per_file?: number;
-  smart_case?: boolean;
-  file_offset?: number;
-  page_limit?: number;
-  mode?: string;
-  time_budget_ms?: number;
-  before_context?: number;
-  after_context?: number;
-}
-
-/**
- * Convert public GrepOptions to internal format
- * @internal
- */
-export function toInternalGrepOptions(
-  opts?: GrepOptions,
-  pageLimit?: number,
-): GrepOptionsInternal {
-  return {
-    max_file_size: opts?.maxFileSize,
-    max_matches_per_file: opts?.maxMatchesPerFile,
-    smart_case: opts?.smartCase,
-    file_offset: opts?.cursor?._offset ?? 0,
-    page_limit: pageLimit,
-    mode: opts?.mode,
-    time_budget_ms: opts?.timeBudgetMs,
-    before_context: opts?.beforeContext,
-    after_context: opts?.afterContext,
-  };
-}