@autorag/librarian 2.6.2 → 2.6.3

package/dist/datasource/connector-timeouts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Timeout policy shared by CLI-backed datasource connectors.
+ *
+ * `sync`/`index` are not interactive. A first run over a real archive routinely
+ * takes minutes — mailcrawl measured ~12 minutes for a Gmail INBOX, lazykatok
+ * ~11 minutes for a ~50k-message semantic index — so a 60-second interactive
+ * default truncates the step before it can finish. A timed-out step never
+ * commits its cursor, so every subsequent refresh restarts from scratch instead
+ * of making progress. Interactive reads (`search`, `doctor`, chunk lookups) keep
+ * the short default.
+ */
+/** Non-interactive budget for a connector `sync`/`index` step (30 minutes). */
+export declare const DEFAULT_CONNECTOR_SYNC_TIMEOUT_MS = 1800000;
+/**
+ * Operator-facing hint appended to a sync/index diagnostic when the connector
+ * timeout killed the step. It names the override and explains why the next
+ * refresh restarts rather than resumes.
+ */
+export declare function connectorSyncTimeoutHint(): string;

package/dist/datasource/crawler-types.d.ts

@@ -39,7 +39,17 @@ export interface CrawlerCliOptions {
     readonly sourcePath?: string;
     readonly configPath?: string;
     readonly syncSource?: string;
+    /**
+     * Spawn timeout for interactive search in milliseconds. Default 60_000.
+     * `sync` is non-interactive and uses {@link indexTimeoutMs} instead.
+     */
     readonly timeoutMs?: number;
+    /**
+     * Spawn timeout for `sync` in milliseconds. Default 1_800_000 (30 min): a first
+     * full import over a real archive can take many minutes, and a timed-out sync
+     * restarts from scratch on the next refresh.
+     */
+    readonly indexTimeoutMs?: number;
     readonly maxBufferBytes?: number;
     readonly env?: Readonly<Record<string, string | undefined>>;
     /** Working directory for the native CLI process, when explicitly needed. */

package/dist/datasource/skills/cloud-drive/rclone-connector.d.ts

@@ -28,6 +28,8 @@ export interface RcloneConnectorOptions {
     readonly exportFormats?: string;
     readonly maxDocuments?: number;
     readonly maxBytesPerFile?: number;
+    /** Characters kept per document body. Default 100000. */
+    readonly maxContentChars?: number;
     readonly concurrency?: number;
     readonly bandwidthLimit?: string;
     readonly dryRun?: boolean;

package/dist/datasource/skills/lazykatok/client.d.ts

@@ -16,6 +16,8 @@ export declare class LazykatokClient {
     chunkGet(chunkId: string, signal?: AbortSignal): Promise<LazykatokChunkResult>;
     context(chunkId: string, signal?: AbortSignal): Promise<LazykatokContextResult>;
     parent(chunkId: string, signal?: AbortSignal): Promise<LazykatokParentResult>;
+    /** `sync`/`index` are non-interactive and share the long budget; reads keep `timeoutMs`. */
+    private syncTimeoutMs;
     /** Single retrieval pipeline: build env, spawn, parse-free raw result. */
     private run;
 }

package/dist/datasource/skills/lazykatok/index.d.ts

@@ -9,4 +9,4 @@ export { LazykatokClient } from "./client.js";
 export { LazykatokBm25Method, type LazykatokMethodOptions, type LazykatokSearchClient, LazykatokSemanticMethod, } from "./methods.js";
 export { LazykatokSkill, type LazykatokSkillClient, type LazykatokSkillOptions } from "./skill.js";
 export type { LazykatokChunkResult, LazykatokDoctorResult, LazykatokFailureReason, LazykatokHit, LazykatokIndexResult, LazykatokOptions, LazykatokSearchMode, LazykatokSearchOptions, LazykatokSearchResult, LazykatokSyncResult, } from "./types.js";
-export { DEFAULT_LAZYKATOK_OPTIONS } from "./types.js";
+export { DEFAULT_LAZYKATOK_INDEX_TIMEOUT_MS, DEFAULT_LAZYKATOK_OPTIONS } from "./types.js";

package/dist/datasource/skills/lazykatok/types.d.ts

@@ -15,8 +15,18 @@ export type LazykatokSearchMode = "semantic" | "keyword" | "hybrid";
 export interface LazykatokOptions {
     /** Explicit path to the `lazykatok` binary. Defaults to a bare `lazykatok` PATH lookup. */
     readonly binaryPath?: string;
-    /** Spawn timeout in milliseconds. Default 60_000 (sync/index over large archives can be slow). */
+    /**
+     * Spawn timeout for interactive invocations (`doctor`, `search`, chunk lookups)
+     * in milliseconds. Default 60_000. `sync`/`index` are non-interactive and use
+     * {@link indexTimeoutMs} instead.
+     */
     readonly timeoutMs?: number;
+    /**
+     * Spawn timeout for `sync`/`index` in milliseconds. Default 1_800_000 (30 min):
+     * the first semantic index over a large archive was measured at ~11 minutes, and
+     * a timed-out build restarts from scratch on the next refresh.
+     */
+    readonly indexTimeoutMs?: number;
     /** Max stdout/stderr bytes retained. Default 16 MiB (an `index --json` report alone is multiple MB on a real archive). */
     readonly maxBufferBytes?: number;
     /** Explicit native lazykatok data directory, passed as `--data-dir`. */
@@ -36,6 +46,12 @@ export interface LazykatokOptions {
 }
 export declare const DEFAULT_LAZYKATOK_BINARY = "lazykatok";
 export declare const DEFAULT_LAZYKATOK_TIMEOUT_MS = 60000;
+/**
+ * `sync`/`index` default budget. They are non-interactive, so they must not share
+ * the 60-second interactive default: a first semantic index over a large archive
+ * was measured at ~11 minutes.
+ */
+export declare const DEFAULT_LAZYKATOK_INDEX_TIMEOUT_MS = 1800000;
 /** The live macOS adapter `sync` names by default on darwin. */
 export declare const DEFAULT_LAZYKATOK_SOURCE = "macos";
 export declare const DEFAULT_LAZYKATOK_MAX_BUFFER_BYTES: number;

package/dist/datasource/skills/rss/connector.d.ts

@@ -19,6 +19,8 @@ export interface RssConnectorOptions {
     readonly fetchImpl?: typeof fetch;
     readonly maxDocuments?: number;
     readonly maxItemsPerFeed?: number;
+    /** Characters kept per item body. Default 20000. */
+    readonly maxContentChars?: number;
 }
 export declare class RssConnector implements DatasourceConnector {
     private readonly options;

package/dist/datasource/skills/spotlight/connector.d.ts

@@ -38,6 +38,8 @@ export interface SpotlightConnectorOptions {
     readonly maxResultsPerQuery?: number;
     /** Total documents hydrated per fetch. Default 300. */
     readonly maxDocuments?: number;
+    /** Characters kept per document body. Default 100000. */
+    readonly maxContentChars?: number;
     /** Files larger than this are skipped. Default 256 KiB. */
     readonly maxBytesPerFile?: number;
     /** Per-process timeout in ms. Default 15s. */

package/dist/dupey/filter.d.ts

@@ -4,5 +4,11 @@ export interface ExactDuplicateFilterResult {
     readonly keepers: ReadonlySet<string>;
     readonly errors: readonly string[];
 }
-/** Selects the newest filesystem copy for each exact canonical-text hash. */
+/** Selects the newest copy for each exact canonical-text hash.
+ *
+ * Uses dupey's own latest-copy ranking — the most recent internal document
+ * modification time, falling back to filesystem mtime when a document records
+ * none — so AutoRAG and dupey never disagree about which copy is newest.
+ * Filesystem mtime is consulted only when dupey supplies no ranking.
+ */
 export declare function selectExactDuplicateExclusions(root: string, scan: DupeyScanResult, isUnavailable?: (path: string) => boolean): Promise<ExactDuplicateFilterResult>;

package/dist/everything/bundle.d.ts

@@ -0,0 +1,62 @@
+/**
+ * voidtools Everything (MIT, closed source) and its MIT-licensed ES command
+ * line client ship inside the AutoRAG package as pinned portable ZIPs under
+ * `vendor/everything`. On Windows they are extracted, SHA-256 verified, into
+ * `<workspace>/.autorag/everything/<version>/<arch>/`. Nothing is downloaded
+ * and nothing is installed system-wide.
+ */
+export type EverythingArch = "x64" | "arm64";
+export interface EverythingArchAssets {
+    readonly everythingArchive: string;
+    readonly everythingArchiveSha256: string;
+    readonly everythingMember: string;
+    readonly everythingSha256: string;
+    readonly esArchive: string;
+    readonly esArchiveSha256: string;
+    readonly esMember: string;
+    readonly esSha256: string;
+}
+export interface EverythingBundleManifest {
+    readonly everythingVersion: string;
+    readonly esVersion: string;
+    readonly licenseFiles: readonly string[];
+    readonly architectures: Partial<Record<EverythingArch, EverythingArchAssets>>;
+}
+export interface EnsureEverythingBinariesOptions {
+    /** Workspace root; binaries are cached under `<root>/.autorag/everything`. */
+    readonly root: string;
+    readonly platform?: NodeJS.Platform;
+    readonly arch?: string;
+    /** Directory holding the bundled ZIPs. Defaults to the packaged `vendor/everything`. */
+    readonly bundleDir?: string;
+    /** Bundle manifest. Defaults to `<bundleDir>/manifest.json`. */
+    readonly manifest?: EverythingBundleManifest;
+}
+export type EnsureEverythingBinariesResult = {
+    readonly ok: true;
+    readonly everythingPath: string;
+    readonly esPath: string;
+    readonly source: "cached" | "installed";
+} | {
+    readonly ok: false;
+    readonly reason: "unsupported-platform" | "bundle-missing" | "install-failed";
+    readonly message: string;
+};
+/**
+ * Locate the packaged `vendor/everything` directory by walking up from this
+ * module. The source tree (`src/everything/`) and the bundled outputs
+ * (`dist/index.js`, `dist/cli/index.js`) sit at different depths.
+ */
+export declare function resolveEverythingBundleDir(): string | undefined;
+export declare function everythingArch(arch: string): EverythingArch | undefined;
+/** Deterministic cache location of the extracted binaries for one workspace. */
+export declare function everythingBinaryPaths(root: string, version: string, arch: EverythingArch): {
+    readonly everythingPath: string;
+    readonly esPath: string;
+};
+export declare function loadEverythingBundleManifest(bundleDir: string): EverythingBundleManifest;
+/**
+ * Extract and verify the bundled Everything + ES binaries for this Windows
+ * host. Never throws: every failure is reported with its underlying message.
+ */
+export declare function ensureEverythingBinaries(options: EnsureEverythingBinariesOptions): Promise<EnsureEverythingBinariesResult>;

package/dist/everything/client.d.ts

@@ -0,0 +1,123 @@
+import { type EnsureEverythingBinariesResult } from "./bundle.js";
+/**
+ * Drives a private, user-level Everything instance per AutoRAG workspace.
+ *
+ * Permission model: the instance indexes only the configured search folders
+ * (Everything "folder indexing"), which needs no administrator rights. It never
+ * requests elevation, never installs the Everything service, never indexes
+ * whole NTFS/ReFS volumes, and never enables the HTTP/ETP servers. Settings and
+ * the database live under `<workspace>/.autorag/everything/`, and the named
+ * instance keeps it isolated from any Everything the user already runs.
+ *
+ * Search goes through the bundled ES CLI over Everything's IPC window.
+ */
+export interface EverythingEntry {
+    readonly path: string;
+    readonly type: "file" | "folder";
+    readonly size: number | undefined;
+    readonly dateModified: string | undefined;
+}
+export type EverythingSort = "name-ascending" | "name-descending" | "path-ascending" | "path-descending" | "size-ascending" | "size-descending" | "date-modified-ascending" | "date-modified-descending";
+export interface EverythingSearchRequest {
+    /** Everything search syntax (wildcards, `ext:`, `dm:`, `size:`, `|`, `!`, quotes for phrases). */
+    readonly query: string;
+    readonly regex?: boolean;
+    readonly matchCase?: boolean;
+    readonly matchPath?: boolean;
+    readonly wholeWord?: boolean;
+    readonly kind?: "files" | "folders";
+    /** Restrict to items under this absolute folder. */
+    readonly path?: string;
+    readonly sort?: EverythingSort;
+    readonly offset?: number;
+    readonly maxResults?: number;
+}
+export type EverythingFailureReason = "unsupported-platform" | "bundle-missing" | "install-failed" | "startup-failed" | "index-failed" | "search-failed";
+export interface EverythingFailure {
+    readonly ok: false;
+    readonly reason: EverythingFailureReason;
+    readonly message: string;
+}
+export type EverythingSearchResult = {
+    readonly ok: true;
+    readonly results: readonly EverythingEntry[];
+} | EverythingFailure;
+export type EverythingIndexResult = {
+    readonly ok: true;
+    readonly indexedFolders: readonly string[];
+    readonly indexedItems: number;
+} | EverythingFailure;
+export interface EverythingRunResult {
+    readonly code: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export type EverythingRunner = (command: string, args: readonly string[], timeoutMs: number) => Promise<EverythingRunResult>;
+export type EverythingLauncher = (command: string, args: readonly string[]) => void;
+export interface EverythingOptions {
+    /** Set false to disable Everything on Windows. */
+    readonly enabled?: boolean;
+    /** Per ES invocation timeout. Default 30s. */
+    readonly timeoutMs?: number;
+    /** How long to wait for a freshly launched instance to answer IPC. Default 20s. */
+    readonly startupTimeoutMs?: number;
+    /** How long indexing waits for the database to finish loading. Default 10 minutes. */
+    readonly indexTimeoutMs?: number;
+}
+export interface EverythingClientOptions extends EverythingOptions {
+    /** Workspace root; state lives under `<root>/.autorag/everything`. */
+    readonly root: string;
+    /** Folders Everything indexes (the configured search paths). */
+    readonly folders: readonly string[];
+    readonly platform?: NodeJS.Platform;
+    readonly resolveBinaries?: () => Promise<EnsureEverythingBinariesResult>;
+    readonly run?: EverythingRunner;
+    readonly launch?: EverythingLauncher;
+    readonly pollIntervalMs?: number;
+}
+/** Stable, workspace-scoped Everything instance name. */
+export declare function everythingInstanceName(root: string): string;
+/**
+ * Everything.ini that confines indexing to the given folders. List values are
+ * double-quoted with `\` escaped, per the Everything INI list syntax.
+ */
+export declare function buildEverythingIni(input: {
+    readonly folders: readonly string[];
+    readonly excludeFolders: readonly string[];
+}): string;
+/**
+ * ES argv for one search. `-argv` makes ES split arguments exactly like
+ * CommandLineToArgvW, which is how Node quotes child-process arguments, so a
+ * query's own double quotes survive as Everything phrase quotes. The query is
+ * placed after `--` so a leading dash is never parsed as an ES switch.
+ */
+export declare function buildEverythingSearchArgs(instance: string, request: EverythingSearchRequest, timeoutMs?: number): string[];
+/** Parse `es -json -full-path-and-name -size -date-modified` output. */
+export declare function parseEverythingJson(stdout: string): EverythingEntry[];
+export declare class EverythingClient {
+    readonly instanceName: string;
+    private readonly options;
+    private readonly platform;
+    private readonly run;
+    private readonly launch;
+    private readonly stateDir;
+    private binaries;
+    private operation;
+    constructor(options: EverythingClientOptions);
+    isSupported(): boolean;
+    /** Start the instance when needed and search it. */
+    search(request: EverythingSearchRequest): Promise<EverythingSearchResult>;
+    /**
+     * (Re)write the folder configuration, restart the instance so Everything
+     * loads it, and wait until the database finished indexing.
+     */
+    index(): Promise<EverythingIndexResult>;
+    /** Exit this workspace's Everything instance if it is running. */
+    stop(): Promise<void>;
+    private serialize;
+    private resolveBinaries;
+    private ensureRunning;
+    /** Exit code 0 only when the instance answered with its version. */
+    private ping;
+    private failure;
+}

package/dist/everything/index.d.ts

@@ -0,0 +1,2 @@
+export { type EnsureEverythingBinariesOptions, type EnsureEverythingBinariesResult, type EverythingArch, type EverythingArchAssets, type EverythingBundleManifest, ensureEverythingBinaries, everythingArch, everythingBinaryPaths, loadEverythingBundleManifest, resolveEverythingBundleDir, } from "./bundle.js";
+export { buildEverythingIni, buildEverythingSearchArgs, EverythingClient, type EverythingClientOptions, type EverythingEntry, type EverythingFailure, type EverythingFailureReason, type EverythingIndexResult, type EverythingLauncher, type EverythingOptions, type EverythingRunner, type EverythingRunResult, type EverythingSearchRequest, type EverythingSearchResult, type EverythingSort, everythingInstanceName, parseEverythingJson, } from "./client.js";

package/dist/fsearch/client.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Drives the user's fsearch-cli (FSearch) as a separate process per AutoRAG
+ * workspace.
+ *
+ * License model: FSearch and fsearch-cli are GPL-2.0-or-later and are NOT
+ * bundled with AutoRAG. The user installs fsearch-cli separately
+ * (`brew install NomaDamas/tap/fsearch-cli`, or the Linux build from
+ * https://github.com/NomaDamas/fsearch-mac) and AutoRAG only spawns it,
+ * communicating over its CLI and daemon socket — mere aggregation per the
+ * FSF FAQ, never a combined work.
+ *
+ * Permission model: the database indexes only the configured search folders
+ * and lives under `<workspace>/.autorag/fsearch/`, isolated from any FSearch
+ * app database the user keeps. A `fsearch-cli watch` daemon per workspace
+ * keeps the index live from FSEvents (macOS) or inotify/fanotify (Linux) and
+ * serves searches over its socket; without the daemon, `fsearch-cli search`
+ * loads the database file directly. When fsearch-cli is not installed,
+ * searches degrade to a bounded slow filesystem walk over the same folders.
+ */
+export interface FSearchEntry {
+    readonly path: string;
+    readonly name: string;
+    readonly type: "file" | "folder";
+    readonly size: number | undefined;
+    readonly dateModified: string | undefined;
+}
+export type FSearchSort = "name-ascending" | "name-descending" | "path-ascending" | "path-descending" | "size-ascending" | "size-descending" | "date-modified-ascending" | "date-modified-descending";
+export interface FSearchSearchRequest {
+    /** FSearch query syntax (wildcards, AND/OR/NOT, `ext:`, `size:`, `path:`). */
+    readonly query: string;
+    readonly regex?: boolean;
+    readonly matchCase?: boolean;
+    readonly matchPath?: boolean;
+    readonly kind?: "files" | "folders";
+    /** Restrict to items under this absolute folder (client-side prefix filter). */
+    readonly path?: string;
+    readonly sort?: FSearchSort;
+    readonly offset?: number;
+    readonly maxResults?: number;
+}
+export type FSearchFailureReason = "unsupported-platform" | "binary-missing" | "index-failed" | "search-failed";
+export interface FSearchFailure {
+    readonly ok: false;
+    readonly reason: FSearchFailureReason;
+    readonly message: string;
+}
+/** Which backend answered a search: the fsearch-cli index or the slow walk. */
+export type FSearchBackend = "fsearch-cli" | "walk";
+export type FSearchSearchResult = {
+    readonly ok: true;
+    readonly backend: FSearchBackend;
+    readonly results: readonly FSearchEntry[];
+    /** Total matches reported by fsearch-cli (may exceed results length). */
+    readonly total?: number;
+    readonly truncated?: boolean;
+    /** Degradation note, e.g. why the slow walk answered instead. */
+    readonly note?: string;
+} | FSearchFailure;
+export type FSearchIndexResult = {
+    readonly ok: true;
+    readonly indexedFolders: readonly string[];
+    readonly indexedItems: number;
+    /** Whether the live watch daemon serves the database after indexing. */
+    readonly watchLive?: boolean;
+} | FSearchFailure;
+export interface FSearchRunResult {
+    readonly code: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export type FSearchRunner = (command: string, args: readonly string[], timeoutMs: number) => Promise<FSearchRunResult>;
+/** Launches a detached daemon; returns its pid when known. */
+export type FSearchLauncher = (command: string, args: readonly string[]) => number | undefined;
+export interface FSearchOptions {
+    /** Set false to disable FSearch on macOS/Linux. */
+    readonly enabled?: boolean;
+    /** fsearch-cli binary to spawn; defaults to PATH lookup. */
+    readonly binaryPath?: string;
+    /** Per fsearch-cli invocation timeout. Default 30s. */
+    readonly timeoutMs?: number;
+    /** How long indexing waits for the watch daemon to serve. Default 10s. */
+    readonly startupTimeoutMs?: number;
+    /** How long an index run may take. Default 10 minutes. */
+    readonly indexTimeoutMs?: number;
+    /** Keep a `fsearch-cli watch` daemon live after indexing. Default true. */
+    readonly watch?: boolean;
+}
+export interface FSearchClientOptions extends FSearchOptions {
+    /** Workspace root; state lives under `<root>/.autorag/fsearch`. */
+    readonly root: string;
+    /** Folders FSearch indexes (the configured search paths). */
+    readonly folders: readonly string[];
+    readonly platform?: NodeJS.Platform;
+    readonly run?: FSearchRunner;
+    readonly launch?: FSearchLauncher;
+    readonly isProcessAlive?: (pid: number) => boolean;
+    readonly killProcess?: (pid: number) => void;
+    readonly pollIntervalMs?: number;
+    /** Slow-walk bounds used when fsearch-cli is missing. */
+    readonly walkMaxVisited?: number;
+    readonly walkDeadlineMs?: number;
+}
+/**
+ * Short, stable daemon socket path for a database. fsearch-cli's default
+ * `<db>.sock` overflows the 104-byte unix sun_path limit for deep workspace
+ * paths — the daemon then binds a truncated name its own clients cannot
+ * derive, and daemon/client rendezvous silently breaks (observed on macOS
+ * with `/private/var/folders/...` workspaces). An explicit short path keyed
+ * by the database's realpath keeps the daemon, stats, and search rendezvous
+ * consistent regardless of which symlinked spelling a caller used.
+ */
+export declare function fsearchSocketPath(dbPath: string): string;
+/**
+ * fsearch-cli argv for one search. The query goes after `--` so a leading
+ * dash is never parsed as a switch. fsearch-cli has no offset flag, so the
+ * caller fetches offset+maxResults (or the cap when a path filter needs
+ * client-side prefix filtering) and pages locally.
+ */
+export declare function buildFSearchSearchArgs(dbPath: string, socketPath: string, request: FSearchSearchRequest): string[];
+/** fsearch-cli argv for one index build over the given folders. */
+export declare function buildFSearchIndexArgs(dbPath: string, folders: readonly string[], excludeFolders: readonly string[]): string[];
+/** Parse `fsearch-cli search --json` JSON-lines output, dropping the trailing done line. */
+export declare function parseFSearchJsonLines(stdout: string): {
+    entries: FSearchEntry[];
+    total: number | undefined;
+};
+/** Parse `fsearch-cli stats` JSON output. */
+export declare function parseFSearchStats(stdout: string): {
+    files: number;
+    folders: number;
+    live: boolean;
+};
+export declare class FSearchClient {
+    private readonly options;
+    private readonly platform;
+    private readonly run;
+    private readonly launch;
+    private readonly isAlive;
+    private readonly kill;
+    private readonly stateDir;
+    private readonly dbPath;
+    private readonly pidPath;
+    private binary;
+    private operation;
+    constructor(options: FSearchClientOptions);
+    isSupported(): boolean;
+    /** Search the workspace database, building it on first use; walks when fsearch-cli is missing. */
+    search(request: FSearchSearchRequest): Promise<FSearchSearchResult>;
+    /** (Re)build the database over the configured folders and keep the watch daemon live. */
+    index(): Promise<FSearchIndexResult>;
+    /** Terminate this workspace's watch daemon when it is running. No-op otherwise. */
+    stop(): Promise<void>;
+    private indexLocked;
+    /**
+     * Restart the live watch daemon against the freshly indexed database.
+     * Index-time always recycles the tracked daemon (Everything parity: a
+     * config-changed index must be the one served); a daemon that serves the
+     * socket without a pid file is adopted, not replaced, because it cannot be
+     * signaled. Searches work without any daemon (fsearch-cli loads the
+     * database file), so a daemon that never serves degrades answer latency,
+     * not correctness.
+     */
+    private ensureWatch;
+    /** True when a watch daemon answers searches for this database over its socket. */
+    private serving;
+    /** Computed per call: the database realpath only exists after indexing ran. */
+    private socketPath;
+    private readWatchPid;
+    private unsupportedFailure;
+    private resolveBinary;
+    private serialize;
+    private failure;
+}

package/dist/fsearch/index.d.ts

@@ -0,0 +1,2 @@
+export { buildFSearchIndexArgs, buildFSearchSearchArgs, type FSearchBackend, FSearchClient, type FSearchClientOptions, type FSearchEntry, type FSearchFailure, type FSearchFailureReason, type FSearchIndexResult, type FSearchLauncher, type FSearchOptions, type FSearchRunner, type FSearchRunResult, type FSearchSearchRequest, type FSearchSearchResult, type FSearchSort, fsearchSocketPath, parseFSearchJsonLines, parseFSearchStats, } from "./client.js";
+export { type FSearchWalkOptions, type FSearchWalkResult, walkFileSearch } from "./walk.js";

package/dist/fsearch/walk.d.ts

@@ -0,0 +1,22 @@
+import type { FSearchEntry, FSearchSearchRequest } from "./client.js";
+/**
+ * Graceful-degradation backend for hosts without fsearch-cli: a bounded,
+ * slow filesystem walk over the configured search folders. It supports a
+ * deliberate subset of the fsearch-cli surface — substring (or regex) name
+ * matching, kind/path filters, and in-memory sorting — and skips AutoRAG
+ * state directories (`.autorag`) the same way the index excludes them.
+ */
+export interface FSearchWalkOptions {
+    /** Directory entries to visit before giving up. Default 500k. */
+    readonly maxVisited?: number;
+    /** Wall-clock budget. Default 20s. */
+    readonly deadlineMs?: number;
+    /** Matches to collect before giving up. Default 10k. */
+    readonly maxMatches?: number;
+}
+export interface FSearchWalkResult {
+    readonly entries: FSearchEntry[];
+    readonly visited: number;
+    readonly truncated: boolean;
+}
+export declare function walkFileSearch(folders: readonly string[], request: FSearchSearchRequest, options?: FSearchWalkOptions): Promise<FSearchWalkResult>;

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { buildSystemPrompt, type SystemPromptConfig } from "./agent/system-promp
 export { AutoRAGLite, type AutoRAGLiteOptions, buildAgentOptions, type CliConfig, createAutoRAGLite, type ResolveConfigInput, resolveConfig, resolveConfigReadOnly, writeConfigObject, writeDefaultConfig, } from "./core.js";
 export * from "./datasource/index.js";
 export * from "./dupey/index.js";
+export * from "./everything/index.js";
+export * from "./fsearch/index.js";
 export * from "./jikji/index.js";
 export * from "./manifest/index.js";
 export * from "./memory/index.js";