@ff-labs/fff-bun 0.9.7-nightly.fce72fa → 0.10.0

package/README.md

@@ -95,6 +95,56 @@ finder.destroy();
 ```
 
 
+## Watching files
+
+Subscribe to filesystem changes with a glob, an exact path, or a directory
+subtree. Events reflect applied index changes and are delivered in batches of
+up to 128, so callbacks stay cheap even under heavy churn.
+
+```typescript
+// Each path appears at most once per batch
+const sub = finder.watch("src/**/*.ts", (events) => {
+  for (const e of events) console.log(e.kind, e.path); // created | modified | removed | rescan
+});
+
+// No pattern: watch the entire indexed tree
+const all = finder.watch((events) => {
+  for (const e of events) console.log(e.kind, e.path);
+});
+
+// Unsubscribe: call the handle
+if (sub.ok) sub.value();
+```
+
+Directory subtrees are watched by passing the directory itself (parcel-watcher
+style), with per-subscription excludes:
+
+```typescript
+const dirSub = finder.watch(
+  projectRoot,
+  (events) => {
+    for (const e of events) console.log(e.kind, e.path);
+  },
+  { ignore: ["node_modules", "*.log"] },
+);
+```
+
+Notes:
+
+- Globs are matched against the base-path-relative path; absolute globs must
+  live under `basePath`. Wildcard-free patterns resolve inside the indexed
+  tree: an existing directory watches its whole subtree, anything else is an
+  exact file path.
+- `ignore` entries exclude matches per subscription: wildcards are globs,
+  everything else is a path prefix (a file or a whole subtree).
+- Gitignored paths never produce events.
+- A `rescan` event means changes were lost (index overflow, ignore-file
+  change) — re-stat anything you care about.
+- Unsubscribing takes effect synchronously on the JS thread: once it
+  returns, the callback will not be invoked again.
+- Watching requires the instance to be created with watching enabled
+  (the default).
+
 ## API Reference
 
 Verify the latest API in the local interface at [`./src/fff-api.ts`](./src/fff-api.ts). Every field and type is documented.

package/examples/watch.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+import { FileFinder } from "../src/index";
+import type { WatchEvent } from "../src/index";
+
+const KIND = {
+  created: "+ created ",
+  modified: "~ modified",
+  removed: "- removed ",
+  rescan: "! rescan  ",
+} as const;
+
+const targetDir = process.argv[2] || process.cwd();
+const pattern = process.argv[3]; // if omitted watch the entire indexed tree
+
+const created = FileFinder.create({ basePath: targetDir });
+if (!created.ok) {
+  console.error(`Init failed: ${created.error}`);
+  process.exit(1);
+}
+const finder = created.value;
+
+// Wait for the initial scan + watcher so indexing noise isn't reported.
+await finder.waitForScan(30_000);
+for (
+  let p = finder.getScanProgress();
+  !p.ok || !p.value.isWatcherReady;
+  p = finder.getScanProgress()
+) {
+  await Bun.sleep(50);
+}
+
+let batch = 0;
+const onBatch = (events: WatchEvent[]) => {
+  console.log(`\nbatch #${++batch} (${events.length} events)`);
+  for (const e of events) console.log(`  ${KIND[e.kind]} ${e.path}`);
+};
+
+const sub = pattern ? finder.watch(pattern, onBatch) : finder.watch(onBatch);
+if (!sub.ok) {
+  console.error(`Watch failed: ${sub.error}`);
+  finder.destroy();
+  process.exit(1);
+}
+
+console.log(
+  `Watching ${targetDir} (pattern: ${pattern ?? "whole tree"}), Ctrl-C to stop.`,
+);
+
+// A recurring timer keeps the event loop alive so watch batches are delivered.
+const keepAlive = setInterval(() => {}, 1000);
+
+process.on("SIGINT", () => {
+  clearInterval(keepAlive);
+  sub.value();
+  finder.destroy();
+  process.exit(0);
+});

package/package.json

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

package/src/fff-api.ts

@@ -1,6 +1,6 @@
 // ----------------------------------------------------------------------------
 // GENERATED FILE - DO NOT EDIT.
-// Source of truth: packages/shared/fff-api.ts
+// Copied from: packages/shared/fff-api.ts
 // Run make sync-js-api from the repo root to regenerate.
 // ----------------------------------------------------------------------------
 
@@ -49,23 +49,17 @@ export interface InitOptions {
   frecencyDbPath?: string;
   /** Path to query history database (optional, omit to skip query tracker initialization) */
   historyDbPath?: string;
-  /**
-   * @deprecated No-op. The no-lock LMDB flags showed no measurable win under
-   * realistic contention and are now ignored. Kept for source-compat.
-   */
+  /** @deprecated no-op */
   useUnsafeNoLock?: boolean;
   /**
    * Disable mmap cache warmup after the initial scan. When mmap cache is
    * enabled (the default), the first grep search is as fast as subsequent
    * ones at the cost of a longer scan time and higher initial memory usage.
-   * (default: false)
    */
   disableMmapCache?: boolean;
   /**
    * Disable the content index built after the initial scan.
    * Content indexing enables faster content-aware filtering during grep.
-   * When omitted, follows `disableMmapCache` for backward compatibility.
-   * (default: follows `disableMmapCache`)
    */
   disableContentIndexing?: boolean;
   /**
@@ -97,10 +91,10 @@ export interface InitOptions {
   /** Override for the per-file byte cap in the content cache. */
   cacheBudgetMaxFileSize?: number;
   /**
-   * Allow indexing the filesystem root (`/`). Off by default, having fff instance at the large folder  
-   * will generally require file watcher
-  * */
-
+   * Allow indexing the filesystem root (`/`).
+   * Off by default, having fff instance at the large folder will generally require
+   * file watcher and indexing which will consume a lot of resources if performed uncontrolled
+   **/
   enableFsRootScanning?: boolean;
   /** Allow indexing the user's home directory. Same trade-off as `enableFsRootScanning`. */
   enableHomeDirScanning?: boolean;
@@ -300,8 +294,36 @@ export interface ScanProgress {
 }
 
 /**
- * Database health information
+ * Normalized watch event kind.
+ * A file removed and recreated in one processed batch is marked as modified.
+ *
+ * rescan = internal OS buffers were overloaded, some events might be missing.
+ * The `path` is going to be a folder needs to be rescanned
+ */
+export type WatchEventKind = "created" | "modified" | "removed" | "rescan";
+
+/** A single filesystem change notification. */
+export interface WatchEvent {
+  /** Absolute path of the affected file (base path to rescan if `kind ==rescan`) */
+  path: string;
+  kind: WatchEventKind;
+}
+
+/** Options for watch subscriptions. */
+export interface WatchOptions {
+  /** Additional glob wildcard patterns to ignore */
+  ignore?: string[];
+}
+
+/**
+ * Receives normalized batches of up to 128 events. Each path appears once.
  */
+export type WatchBatchCallback = (events: WatchEvent[]) => void;
+
+/** Call me to unsubscribe. */
+export type WatchUnsubscribe = () => void;
+
+/** Database health information */
 export interface DbHealth {
   /** Path to the database */
   path: string;
@@ -551,10 +573,16 @@ export interface FileFinderApi {
   glob(pattern: string, options?: GlobOptions): Result<SearchResult>;
 
   /** Fuzzy directory search. */
-  directorySearch(query: string, options?: DirSearchOptions): Result<DirSearchResult>;
+  directorySearch(
+    query: string,
+    options?: DirSearchOptions,
+  ): Result<DirSearchResult>;
 
   /** Fuzzy search over files and directories interleaved by score. */
-  mixedSearch(query: string, options?: SearchOptions): Result<MixedSearchResult>;
+  mixedSearch(
+    query: string,
+    options?: SearchOptions,
+  ): Result<MixedSearchResult>;
 
   /** Content search (live grep). */
   grep(query: string, options?: GrepOptions): Result<GrepResult>;
@@ -610,6 +638,25 @@ export interface FileFinderApi {
   /** Get a historical query by offset (0 = most recent). */
   getHistoricalQuery(offset: number): Result<string | null>;
 
+  /**
+   * Subscribe to filesystem changes matching `pattern`.
+   *
+   * Patterns may be base-relative globs (./ works), exact paths inside the indexed
+   * tree, or existing directories. An empty pattern watches the whole tree.
+   *
+   * Events are debounced and submitted in batches per 100-ms window at most 128 events.
+   * Gitignored and other ignored files are never triggering watcher.
+   */
+  watch(
+    callback: WatchBatchCallback,
+    options?: WatchOptions,
+  ): Result<WatchUnsubscribe>;
+  watch(
+    pattern: string,
+    callback: WatchBatchCallback,
+    options?: WatchOptions,
+  ): Result<WatchUnsubscribe>;
+
   /** Health/diagnostics information for this instance. */
   healthCheck(testPath?: string): Result<HealthCheck>;
 }

package/src/ffi.ts

@@ -8,7 +8,15 @@
  * be passed to all subsequent calls and freed with `ffiDestroy`.
  */
 
-import { CString, dlopen, FFIType, type Pointer, ptr, read } from "bun:ffi";
+import {
+  CString,
+  dlopen,
+  FFIType,
+  type JSCallback,
+  type Pointer,
+  ptr,
+  read,
+} from "bun:ffi";
 import { findBinary } from "./download";
 import { embeddedLibPath } from "./embedded";
 import type {
@@ -24,6 +32,8 @@ import type {
   ScanProgress,
   Score,
   SearchResult,
+  WatchEvent,
+  WatchEventKind,
 } from "./fff-api";
 import { createGrepCursor, err } from "./fff-api";
 
@@ -192,6 +202,44 @@ const ffiDefinition = {
     returns: FFIType.ptr,
   },
 
+  // Watch subscriptions
+  fff_set_watch_callback: {
+    args: [
+      FFIType.ptr, // handle
+      FFIType.function, // FffWatchCallback (instance-wide)
+      FFIType.ptr, // user_data
+    ],
+    returns: FFIType.ptr,
+  },
+  fff_watch: {
+    args: [
+      FFIType.ptr, // handle
+      FFIType.cstring, // pattern
+      FFIType.ptr, // *const FffWatchOptions (or NULL)
+    ],
+    returns: FFIType.ptr,
+  },
+  fff_unwatch: {
+    args: [FFIType.ptr, FFIType.u64], // handle, watch_id
+    returns: FFIType.ptr,
+  },
+  fff_free_watch_events: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  fff_watch_events_count: {
+    args: [FFIType.ptr],
+    returns: FFIType.u32,
+  },
+  fff_watch_events_get_path: {
+    args: [FFIType.ptr, FFIType.u32],
+    returns: FFIType.ptr,
+  },
+  fff_watch_events_get_kind: {
+    args: [FFIType.ptr, FFIType.u32],
+    returns: FFIType.u8,
+  },
+
   // Git
   fff_refresh_git_status: {
     args: [FFIType.ptr],
@@ -1327,6 +1375,118 @@ export function ffiRestartIndex(handle: NativeHandle, newPath: string): Result<v
   return parseVoidResult(resultPtr);
 }
 
+// ---------------------------------------------------------------------------
+// Watch struct byte offsets (must match #[repr(C)] layout on 64-bit)
+// ---------------------------------------------------------------------------
+
+// MUST match `crates/fff-c`::FffWatchOptions
+const FFF_WATCH_OPTIONS_VERSION = 1;
+const FFF_WATCH_OPTIONS_SIZE = 24;
+const FWO_VERSION = 0; // u32 (4 + 4 pad)
+const FWO_IGNORE = 8; // *const *const c_char (8)
+const FWO_IGNORE_COUNT = 16; // u32 (4 + 4 pad)
+
+/** kind u8 -> WatchEventKind. Unknown values degrade to "rescan". */
+const WATCH_EVENT_KINDS: readonly WatchEventKind[] = [
+  "created",
+  "modified",
+  "removed",
+  "rescan",
+];
+
+/**
+ * Parse an FffWatchEventBatch delivered to a watch callback, then free it.
+ * Ownership of the batch transfers to JS at callback time, so this MUST be
+ * called exactly once per delivered batch pointer.
+ */
+export function readWatchEventBatch(batchPtr: Pointer | number | null): WatchEvent[] {
+  if (batchPtr === null || (batchPtr as unknown as number) === 0) {
+    return [];
+  }
+
+  const bp = batchPtr as unknown as Pointer;
+  const symbols = loadLibrary().symbols;
+  const count = symbols.fff_watch_events_count(bp);
+
+  const events: WatchEvent[] = [];
+  for (let i = 0; i < count; i++) {
+    const path = symbols.fff_watch_events_get_path(bp, i) as Pointer | null;
+    const kind = symbols.fff_watch_events_get_kind(bp, i) as number;
+    events.push({
+      path: readCString(path) ?? "",
+      kind: WATCH_EVENT_KINDS[kind] ?? "rescan",
+    });
+  }
+
+  symbols.fff_free_watch_events(bp);
+  return events;
+}
+
+/**
+ * Register the instance-wide watch callback. Must be called before the
+ * first `ffiWatch`. The caller owns `callback` (a threadsafe `JSCallback`
+ * built in finder.ts) and must keep it alive until after `ffiDestroy`
+ * returns for this handle — that call is the delivery quiescence barrier.
+ */
+export function ffiSetWatchCallback(
+  handle: NativeHandle,
+  callback: JSCallback,
+): Result<void> {
+  const library = loadLibrary();
+  if (callback.ptr === null) {
+    return err("watch callback has been closed");
+  }
+  const resultPtr = library.symbols.fff_set_watch_callback(handle, callback.ptr, null);
+  return parseVoidResult(resultPtr);
+}
+
+/**
+ * Subscribe to filesystem changes; batches are delivered through the
+ * instance callback registered with `ffiSetWatchCallback`, tagged with the
+ * watch id this function returns.
+ *
+ * @returns The native watch id carried in `FffResult.int_value`.
+ */
+export function ffiWatch(
+  handle: NativeHandle,
+  pattern: string,
+  ignore: string[] = [],
+): Result<number> {
+  const library = loadLibrary();
+
+  // Keep every buffer referenced until the FFI call returns: the options
+  // struct, the pointer array, and each encoded ignore string.
+  const opts = Buffer.alloc(FFF_WATCH_OPTIONS_SIZE);
+  opts.writeUInt32LE(FFF_WATCH_OPTIONS_VERSION, FWO_VERSION);
+
+  const ignoreBuffers = ignore.map((entry) => encodeString(entry));
+  const ignorePtrs = Buffer.alloc(Math.max(ignoreBuffers.length, 1) * 8);
+  for (let i = 0; i < ignoreBuffers.length; i++) {
+    ignorePtrs.writeBigUInt64LE(BigInt(ptr(ignoreBuffers[i] as Uint8Array)), i * 8);
+  }
+  opts.writeBigUInt64LE(
+    ignoreBuffers.length > 0 ? BigInt(ptr(ignorePtrs)) : 0n,
+    FWO_IGNORE,
+  );
+  opts.writeUInt32LE(ignoreBuffers.length, FWO_IGNORE_COUNT);
+
+  const resultPtr = library.symbols.fff_watch(
+    handle,
+    ptr(encodeString(pattern)),
+    ptr(opts),
+  );
+  return parseIntResult(resultPtr);
+}
+
+/**
+ * Remove a watch subscription. Returns true if the id was found.
+ */
+export function ffiUnwatch(handle: NativeHandle, watchId: number): Result<boolean> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_unwatch(handle, BigInt(watchId));
+  return parseBoolResult(resultPtr);
+}
+
 /**
  * Refresh git status.
  */

package/src/finder.ts

@@ -8,6 +8,8 @@
  * All methods return Result types for explicit error handling.
  */
 
+import { FFIType, JSCallback, type Pointer } from "bun:ffi";
+
 import {
   ensureLoaded,
   ffiCreate,
@@ -26,10 +28,14 @@ import {
   ffiSearch,
   ffiSearchDirectories,
   ffiSearchMixed,
+  ffiSetWatchCallback,
   ffiTrackQuery,
+  ffiUnwatch,
   ffiWaitForScan,
+  ffiWatch,
   isAvailable,
   type NativeHandle,
+  readWatchEventBatch,
 } from "./ffi";
 
 import type {
@@ -47,6 +53,9 @@ import type {
   ScanProgress,
   SearchOptions,
   SearchResult,
+  WatchBatchCallback,
+  WatchOptions,
+  WatchUnsubscribe,
 } from "./fff-api";
 
 import { err } from "./fff-api";
@@ -85,6 +94,14 @@ import { err } from "./fff-api";
  */
 export class FileFinder implements FileFinderApi {
   private handle: NativeHandle | null;
+  /** Active watch subscriptions: native watch id -> JS batch handler. */
+  private watchHandlers = new Map<number, WatchBatchCallback>();
+  /**
+   * ONE threadsafe JSCallback per instance, registered lazily with
+   * `fff_set_watch_callback` on the first subscription and closed in
+   * `destroy()` after `fff_destroy` returns (the quiescence barrier).
+   */
+  private watchJsCallback: JSCallback | null = null;
 
   private constructor(handle: NativeHandle) {
     this.handle = handle;
@@ -138,14 +155,19 @@ export class FileFinder implements FileFinderApi {
   /**
    * Destroy and clean up all resources.
    *
-   * Call this when you're done using the file finder to free memory
-   * and stop background file watching. After calling this, the instance
-   * must not be used again.
+   * Frees the native instance (unsubscribing all watches), then closes the
+   * instance watch trampoline. After calling this, the instance must not be
+   * used again.
    */
   destroy(): void {
     if (this.handle !== null) {
+      this.watchHandlers.clear();
       ffiDestroy(this.handle);
       this.handle = null;
+      // Handlers were cleared first, so a delivery racing the destroy is a
+      // benign id-map miss before the trampoline is closed.
+      this.watchJsCallback?.close();
+      this.watchJsCallback = null;
     }
   }
 
@@ -571,6 +593,119 @@ export class FileFinder implements FileFinderApi {
     return ffiGetHistoricalQuery(guard.value, offset);
   }
 
+  /**
+   * Lazily create + register the instance-wide watch trampoline. Routes
+   * every delivered batch to the handler registered for its watch id;
+   * unknown ids (unsubscribe races) are benign — the batch is just freed.
+   */
+  private ensureWatchTrampoline(handle: NativeHandle): Result<void> {
+    if (this.watchJsCallback !== null) return { ok: true, value: undefined };
+
+    // Threadsafe: the native callback thread enqueues the invocation onto the
+    // JS event loop; the batch stays valid because JS owns it until it frees
+    // it inside readWatchEventBatch.
+    const jsCallback = new JSCallback(
+      (watchId: bigint | number, batchPtr: Pointer, _userData: Pointer) => {
+        const events = readWatchEventBatch(batchPtr);
+        const handler = this.watchHandlers.get(Number(watchId));
+        if (handler !== undefined && events.length > 0) {
+          handler(events);
+        }
+      },
+      {
+        // an attempt to fix the bug that is kept unfixed in the zig version of bun :()
+        // https://github.com/oven-sh/bun/issues/33840:
+        //
+        // watch_id is declared `ptr`, not `u64`: ABI-identical (one 64-bit
+        // register), but u64 args make bun allocate a JSBigInt on the CALLING
+        // (non-JS) thread, corrupting the JS heap
+        args: [FFIType.ptr, FFIType.ptr, FFIType.ptr],
+        returns: FFIType.void,
+        threadsafe: true,
+      },
+    );
+
+    const registered = ffiSetWatchCallback(handle, jsCallback);
+    if (!registered.ok) {
+      jsCallback.close();
+      return registered;
+    }
+    this.watchJsCallback = jsCallback;
+    return { ok: true, value: undefined };
+  }
+
+  /**
+   * Subscribe to filesystem changes matching `pattern` (glob, exact file,
+   * or directory subtree). Omit the pattern to watch the entire indexed
+   * tree. Normalized batches of up to 128 events are delivered on the JS event
+   * loop, with each path appearing at most once. See `FileFinderApi.watch`.
+   *
+   * @example
+   * ```typescript
+   * const sub = finder.watch("**\/*.ts", (events) => {
+   *   for (const e of events) console.log(e.kind, e.path);
+   * });
+   * if (sub.ok) sub.value(); // unsubscribe
+   *
+   * // no pattern: everything under the indexed base path
+   * const all = finder.watch((events) => console.log(events.length));
+   * ```
+   */
+  watch(callback: WatchBatchCallback, options?: WatchOptions): Result<WatchUnsubscribe>;
+  watch(
+    pattern: string,
+    callback: WatchBatchCallback,
+    options?: WatchOptions,
+  ): Result<WatchUnsubscribe>;
+  watch(
+    patternOrCallback: string | WatchBatchCallback,
+    callbackOrOptions?: WatchBatchCallback | WatchOptions,
+    maybeOptions?: WatchOptions,
+  ): Result<WatchUnsubscribe> {
+    // Overload shift: watch(cb, opts?) -> empty pattern = whole tree.
+    const noPattern = typeof patternOrCallback === "function";
+    const pattern = noPattern ? "" : patternOrCallback;
+    const callback = noPattern
+      ? patternOrCallback
+      : (callbackOrOptions as WatchBatchCallback);
+    const options = noPattern
+      ? (callbackOrOptions as WatchOptions | undefined)
+      : maybeOptions;
+
+    if (typeof callback !== "function") {
+      return err("watch callback must be a function");
+    }
+
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+
+    const trampoline = this.ensureWatchTrampoline(guard.value);
+    if (!trampoline.ok) return trampoline;
+
+    const result = ffiWatch(guard.value, pattern, options?.ignore ?? []);
+    if (!result.ok) return result;
+
+    // No startup race: the threadsafe trampoline only runs on the JS event
+    // loop, so this synchronous set always precedes the first routing lookup.
+    const watchId = result.value;
+    this.watchHandlers.set(watchId, callback);
+
+    return { ok: true, value: () => this.unwatchById(watchId) };
+  }
+
+  /**
+   * Remove a subscription from the routing map, then from the native side.
+   * Map removal is synchronous on the JS thread, so once this returns the
+   * handler can never run again (late native batches miss the lookup).
+   * Idempotent.
+   */
+  private unwatchById(watchId: number): void {
+    if (!this.watchHandlers.delete(watchId)) return;
+    if (this.handle !== null) {
+      ffiUnwatch(this.handle, watchId);
+    }
+  }
+
   /**
    * Get health check information.
    *

package/src/index.ts

@@ -24,6 +24,11 @@ export type {
   Score,
   SearchOptions,
   SearchResult,
+  WatchBatchCallback,
+  WatchEvent,
+  WatchEventKind,
+  WatchOptions,
+  WatchUnsubscribe,
 } from "./fff-api";
 
 export { FileFinder } from "./finder";