@hasna/search 0.0.8 → 0.0.10

package/dist/index.js

@@ -8901,9 +8901,15 @@ var PROVIDER_NAMES = [
   "youtube",
   "hackernews",
   "github",
-  "arxiv"
+  "arxiv",
+  "files",
+  "content"
 ];
 var SearchProviderNameSchema = exports_external.enum(PROVIDER_NAMES);
+var LOCAL_PROVIDER_NAMES = new Set([
+  "files",
+  "content"
+]);
 var EXPORT_FORMATS = ["json", "csv", "md"];
 var ExportFormatSchema = exports_external.enum(EXPORT_FORMATS);
 var SearchOptionsSchema = exports_external.object({
@@ -8926,7 +8932,10 @@ var DEFAULT_CONFIG = {
     fallbackCli: "microservice-transcriber"
   },
   dedup: true,
-  maxConcurrent: 5
+  maxConcurrent: 5,
+  indexStaleMinutes: 5,
+  indexAutoRefresh: true,
+  recordLocalResults: false
 };
 var counter = 0;
 function generateId() {
@@ -8971,7 +8980,7 @@ class ValidationError extends SearchError {
 }
 // src/db/database.ts
 import { Database } from "bun:sqlite";
-import { cpSync, existsSync, mkdirSync } from "fs";
+import { mkdirSync } from "fs";
 
 // src/db/migrations.ts
 var migrations = [
@@ -9101,6 +9110,34 @@ var migrations = [
           ('prof-all',       'all',       'All enabled providers',                            '["google","serpapi","exa","perplexity","brave","bing","twitter","reddit","youtube","hackernews","github","arxiv"]', '{}', datetime('now'));
       `);
     }
+  },
+  {
+    version: 4,
+    description: "Local search providers (files, content) and local profile",
+    up: (db) => {
+      db.exec(`
+        INSERT OR IGNORE INTO providers (name, enabled, api_key_env, rate_limit, metadata) VALUES
+          ('files',   1, '', 0, '{}'),
+          ('content', 1, '', 0, '{}');
+
+        INSERT OR IGNORE INTO search_profiles (id, name, description, providers, options, created_at) VALUES
+          ('prof-local', 'local', 'Local filesystem: file paths + content', '["files","content"]', '{}', datetime('now'));
+      `);
+      const row = db.query("SELECT id, providers FROM search_profiles WHERE name = 'all'").get();
+      if (row) {
+        let providers;
+        try {
+          providers = JSON.parse(row.providers);
+        } catch {
+          providers = [];
+        }
+        for (const name of ["files", "content"]) {
+          if (!providers.includes(name))
+            providers.push(name);
+        }
+        db.prepare("UPDATE search_profiles SET providers = ? WHERE id = ?").run(JSON.stringify(providers), row.id);
+      }
+    }
   }
 ];
 function runMigrations(db) {
@@ -9118,7 +9155,7 @@ function runMigrations(db) {
     db.exec("BEGIN");
     try {
       migration.up(db);
-      db.prepare("INSERT INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
+      db.prepare("INSERT OR IGNORE INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
       db.exec("COMMIT");
     } catch (err) {
       db.exec("ROLLBACK");
@@ -9129,17 +9166,6 @@ function runMigrations(db) {
 
 // src/db/database.ts
 var instance = null;
-function migrateDotfile() {
-  const home = Bun.env.HOME ?? "/tmp";
-  const oldDir = `${home}/.search`;
-  const newDir = `${home}/.hasna/search`;
-  if (existsSync(newDir) || !existsSync(oldDir))
-    return;
-  try {
-    mkdirSync(`${home}/.hasna`, { recursive: true });
-    cpSync(oldDir, newDir, { recursive: true });
-  } catch {}
-}
 function ensureFeedbackTable(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS feedback (
@@ -9158,18 +9184,19 @@ function getDbPath() {
   if (envPath)
     return envPath;
   const home = Bun.env.HOME ?? "/tmp";
-  migrateDotfile();
-  const newDir = `${home}/.hasna/search`;
-  mkdirSync(newDir, { recursive: true });
-  return `${newDir}/data.db`;
+  const dir = `${home}/.hasna/search`;
+  mkdirSync(dir, { recursive: true });
+  return `${dir}/data.db`;
 }
 function getDb() {
   if (instance)
     return instance;
   const path = getDbPath();
   const db = new Database(path);
-  db.exec("PRAGMA synchronous = NORMAL");
   db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA synchronous = NORMAL");
   runMigrations(db);
   ensureFeedbackTable(db);
   instance = db;
@@ -9190,55 +9217,81 @@ function getDbForTesting() {
   ensureFeedbackTable(db);
   return db;
 }
-// src/db/cloud-config.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+// src/db/storage-config.ts
+import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var CONFIG_PATH = join(homedir(), ".hasna", "search", "cloud", "config.json");
-function isMode(value) {
-  return value === "local" || value === "hybrid" || value === "cloud";
-}
-function envConnectionString() {
-  return Bun.env.HASNA_SEARCH_CLOUD_DATABASE_URL ?? Bun.env.OPEN_SEARCH_CLOUD_DATABASE_URL ?? Bun.env.SEARCH_CLOUD_DATABASE_URL;
-}
-function getCloudConfig() {
+var STORAGE_CONFIG_PATH = join(homedir(), ".hasna", "search", "storage", "config.json");
+var SEARCH_STORAGE_ENV = "HASNA_SEARCH_DATABASE_URL";
+var SEARCH_STORAGE_FALLBACK_ENV = "SEARCH_DATABASE_URL";
+var SEARCH_STORAGE_MODE_ENV = "HASNA_SEARCH_STORAGE_MODE";
+var SEARCH_STORAGE_MODE_FALLBACK_ENV = "SEARCH_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [SEARCH_STORAGE_ENV, SEARCH_STORAGE_FALLBACK_ENV];
+var STORAGE_MODE_ENV = [SEARCH_STORAGE_MODE_ENV, SEARCH_STORAGE_MODE_FALLBACK_ENV];
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) : undefined;
+}
+function getStorageConfig() {
   const config = {
     mode: "local",
     rds: {
       host: "",
       port: 5432,
       username: "",
-      password_env: "SEARCH_CLOUD_DATABASE_PASSWORD",
+      password_env: "SEARCH_DATABASE_PASSWORD",
       ssl: true
     }
   };
-  if (existsSync2(CONFIG_PATH)) {
+  if (existsSync(STORAGE_CONFIG_PATH)) {
     try {
-      const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-      config.mode = raw.mode ?? config.mode;
+      const raw = JSON.parse(readFileSync(STORAGE_CONFIG_PATH, "utf-8"));
+      config.mode = normalizeMode(raw.mode) ?? config.mode;
       config.rds = { ...config.rds, ...raw.rds ?? {} };
     } catch {}
   }
-  const modeOverride = Bun.env.HASNA_SEARCH_CLOUD_MODE ?? Bun.env.OPEN_SEARCH_CLOUD_MODE ?? Bun.env.SEARCH_CLOUD_MODE;
-  if (isMode(modeOverride)) {
-    config.mode = modeOverride;
-  } else if (envConnectionString() && config.mode === "local") {
+  const modeOverride = readEnv(SEARCH_STORAGE_MODE_ENV) ?? readEnv(SEARCH_STORAGE_MODE_FALLBACK_ENV);
+  const normalizedMode = normalizeMode(modeOverride);
+  if (normalizedMode) {
+    config.mode = normalizedMode;
+  } else if (getStorageDatabaseUrl() && config.mode === "local") {
     config.mode = "hybrid";
   }
   return config;
 }
-function getConnectionString(dbName = "search") {
-  const direct = envConnectionString();
+function getStorageConnectionString(dbName = "search") {
+  const direct = getStorageDatabaseUrl();
   if (direct)
     return direct;
-  const config = getCloudConfig();
+  const config = getStorageConfig();
   const { host, port, username, password_env, ssl } = config.rds;
   if (!host || !username) {
-    throw new Error("Cloud database is not configured. Set HASNA_SEARCH_CLOUD_DATABASE_URL or configure ~/.hasna/search/cloud/config.json.");
+    throw new Error("Storage database is not configured. Set HASNA_SEARCH_DATABASE_URL or configure ~/.hasna/search/storage/config.json.");
   }
-  const password = Bun.env[password_env];
+  const password = process.env[password_env];
   if (!password) {
-    throw new Error(`Cloud database password is not set. Export ${password_env}.`);
+    throw new Error(`Storage database password is not set. Export ${password_env}.`);
   }
   const sslParam = ssl ? "?sslmode=require" : "";
   return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
@@ -9429,8 +9482,8 @@ async function applyPgMigrations(connectionString) {
   }
   return result;
 }
-// src/db/cloud-sync.ts
-var CLOUD_TABLES = [
+// src/db/storage-sync.ts
+var STORAGE_TABLES = [
   "searches",
   "search_results",
   "saved_searches",
@@ -9517,21 +9570,26 @@ function upsertSqlite(db, table, rows) {
   }
   return written;
 }
-async function getCloudPg() {
-  return new PgAdapterAsync(getConnectionString("search"));
+async function getStoragePg() {
+  return new PgAdapterAsync(getStorageConnectionString("search"));
 }
-async function runCloudMigrations(remote) {
+async function runStorageMigrations(remote) {
   for (const migration of PG_MIGRATIONS) {
     await remote.exec(migration);
   }
 }
-function getCloudStatus(db = getDb()) {
-  const config = getCloudConfig();
+function getStorageStatus(db = getDb()) {
+  const config = getStorageConfig();
+  const activeEnv = getStorageDatabaseEnv();
   return {
+    configured: Boolean(activeEnv) || Boolean(config.rds.host && config.rds.username),
     mode: config.mode,
-    enabled: config.mode === "hybrid" || config.mode === "cloud",
+    enabled: config.mode === "hybrid" || config.mode === "remote",
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "search",
     db_path: getDbPath(),
-    tables: CLOUD_TABLES.map((table) => {
+    tables: STORAGE_TABLES.map((table) => {
       try {
         const row = db.query(`SELECT COUNT(*) as count FROM ${quoteId(table)}`).get();
         return { table, rows: row.count };
@@ -9541,12 +9599,12 @@ function getCloudStatus(db = getDb()) {
     })
   };
 }
-async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pushStorageChanges(tables = [...STORAGE_TABLES]) {
   const db = getDb();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "push", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -9563,12 +9621,12 @@ async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pullStorageChanges(tables = [...STORAGE_TABLES]) {
   const db = getDb();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "pull", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -9585,17 +9643,21 @@ async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function syncCloudChanges(tables = [...CLOUD_TABLES]) {
+async function syncStorageChanges(tables = [...STORAGE_TABLES]) {
   return {
-    push: await pushCloudChanges(tables),
-    pull: await pullCloudChanges(tables)
+    push: await pushStorageChanges(tables),
+    pull: await pullStorageChanges(tables)
   };
 }
-function parseCloudTables(raw) {
+function parseStorageTables(raw) {
   if (!raw)
-    return [...CLOUD_TABLES];
+    return [...STORAGE_TABLES];
   const requested = raw.split(",").map((table) => table.trim()).filter(Boolean);
-  return requested.length > 0 ? requested : [...CLOUD_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown search storage table(s): ${invalid.join(", ")}`);
+  return requested.length > 0 ? requested : [...STORAGE_TABLES];
 }
 // src/db/searches.ts
 function rowToSearch(row) {
@@ -9814,6 +9876,726 @@ function updateSavedSearchLastRun(id, db) {
   const now = new Date().toISOString();
   d.prepare("UPDATE saved_searches SET last_run_at = ? WHERE id = ?").run(now, id);
 }
+// src/lib/local/indexer.ts
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, resolve } from "path";
+
+// src/db/index-db.ts
+import { Database as Database2 } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// src/db/index-migrations.ts
+var migrations2 = [
+  {
+    version: 1,
+    description: "Local file index core",
+    up: (db) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS index_roots (
+          id TEXT PRIMARY KEY,
+          path TEXT NOT NULL UNIQUE,
+          name TEXT NOT NULL,
+          exclude TEXT NOT NULL DEFAULT '[]',
+          content_indexing INTEGER NOT NULL DEFAULT 1,
+          max_file_size INTEGER NOT NULL DEFAULT 524288,
+          status TEXT NOT NULL DEFAULT 'pending',
+          error TEXT,
+          file_count INTEGER NOT NULL DEFAULT 0,
+          last_indexed_at TEXT,
+          last_duration_ms INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS files (
+          id INTEGER PRIMARY KEY,
+          root_id TEXT NOT NULL REFERENCES index_roots(id) ON DELETE CASCADE,
+          rel_path TEXT NOT NULL,
+          name TEXT NOT NULL,
+          ext TEXT NOT NULL DEFAULT '',
+          dir TEXT NOT NULL DEFAULT '',
+          size INTEGER NOT NULL,
+          mtime_ms INTEGER NOT NULL,
+          is_binary INTEGER NOT NULL DEFAULT 0,
+          content_indexed INTEGER NOT NULL DEFAULT 0,
+          indexed_at TEXT NOT NULL,
+          UNIQUE(root_id, rel_path)
+        );
+        CREATE INDEX IF NOT EXISTS idx_files_root ON files(root_id);
+        CREATE INDEX IF NOT EXISTS idx_files_name ON files(name);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS files_fts USING fts5(
+          name, rel_path,
+          content='files',
+          content_rowid='id',
+          tokenize='trigram'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS files_ai AFTER INSERT ON files BEGIN
+          INSERT INTO files_fts(rowid, name, rel_path)
+          VALUES (NEW.id, NEW.name, NEW.rel_path);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_ad AFTER DELETE ON files BEGIN
+          INSERT INTO files_fts(files_fts, rowid, name, rel_path)
+          VALUES ('delete', OLD.id, OLD.name, OLD.rel_path);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_au AFTER UPDATE OF name, rel_path ON files BEGIN
+          INSERT INTO files_fts(files_fts, rowid, name, rel_path)
+          VALUES ('delete', OLD.id, OLD.name, OLD.rel_path);
+          INSERT INTO files_fts(rowid, name, rel_path)
+          VALUES (NEW.id, NEW.name, NEW.rel_path);
+        END;
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS file_content_fts USING fts5(
+          body,
+          content='',
+          contentless_delete=1,
+          tokenize='trigram'
+        );
+      `);
+    }
+  }
+];
+function runIndexMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      version INTEGER PRIMARY KEY,
+      description TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  const applied = new Set(db.query("SELECT version FROM _migrations").all().map((row) => row.version));
+  for (const migration of migrations2) {
+    if (applied.has(migration.version))
+      continue;
+    db.exec("BEGIN");
+    try {
+      migration.up(db);
+      db.prepare("INSERT OR IGNORE INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+}
+
+// src/db/index-db.ts
+var instance2 = null;
+function getIndexDbPath() {
+  const envPath = Bun.env.HASNA_SEARCH_INDEX_DB_PATH ?? Bun.env.SEARCH_INDEX_DB_PATH;
+  if (envPath)
+    return envPath;
+  const home = Bun.env.HOME ?? "/tmp";
+  const dir = `${home}/.hasna/search`;
+  mkdirSync2(dir, { recursive: true });
+  return `${dir}/index.db`;
+}
+function configure(db) {
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA synchronous = NORMAL");
+  runIndexMigrations(db);
+  return db;
+}
+function getIndexDb() {
+  if (instance2)
+    return instance2;
+  instance2 = configure(new Database2(getIndexDbPath()));
+  return instance2;
+}
+function closeIndexDb() {
+  if (instance2) {
+    instance2.close();
+    instance2 = null;
+  }
+}
+function getIndexDbForTesting() {
+  return configure(new Database2(":memory:"));
+}
+
+// src/lib/config.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+function getConfigDir() {
+  const home = Bun.env.HOME ?? "/tmp";
+  const dir = `${home}/.hasna/search`;
+  mkdirSync3(dir, { recursive: true });
+  return dir;
+}
+function getConfigPath() {
+  return `${getConfigDir()}/config.json`;
+}
+function getConfig() {
+  const path = getConfigPath();
+  if (!existsSync2(path)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function setConfig(updates) {
+  const current = getConfig();
+  const merged = { ...current, ...updates };
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(merged, null, 2), "utf-8");
+  return merged;
+}
+function resetConfig() {
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
+  return { ...DEFAULT_CONFIG };
+}
+function getConfigValue(key) {
+  const config = getConfig();
+  return config[key];
+}
+function setConfigValue(key, value) {
+  const config = getConfig();
+  config[key] = value;
+  return setConfig(config);
+}
+
+// src/lib/local/walker.ts
+import { readdirSync, readFileSync as readFileSync3, statSync, openSync, readSync, closeSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/local/ignore.ts
+function classEnd(pattern, open) {
+  let i = open + 1;
+  if (pattern[i] === "!")
+    i++;
+  if (pattern[i] === "]")
+    i++;
+  for (;i < pattern.length; i++) {
+    if (pattern[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (pattern[i] === "]")
+      return i;
+  }
+  return -1;
+}
+function globToRegExp(pattern) {
+  let out = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        const segmentStart = i === 0 || pattern[i - 1] === "/";
+        if (segmentStart && pattern[i + 2] === "/") {
+          out += "(?:[^/]*/)*";
+          i += 3;
+        } else if (segmentStart && i + 2 === pattern.length) {
+          out += ".*";
+          i += 2;
+        } else {
+          out += "[^/]*";
+          i += 2;
+        }
+      } else {
+        out += "[^/]*";
+        i += 1;
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+      i += 1;
+    } else if (ch === "[") {
+      const close = classEnd(pattern, i);
+      if (close === -1) {
+        out += "\\[";
+        i += 1;
+      } else {
+        let cls = pattern.slice(i + 1, close);
+        if (cls.startsWith("!"))
+          cls = "^" + cls.slice(1);
+        let jsCls = "";
+        for (let k = 0;k < cls.length; k++) {
+          const c = cls[k];
+          if (c === "\\" && k + 1 < cls.length) {
+            jsCls += "\\" + cls[k + 1];
+            k++;
+          } else if (c === "]") {
+            jsCls += "\\]";
+          } else if (c === "\\") {
+            jsCls += "\\\\";
+          } else {
+            jsCls += c;
+          }
+        }
+        out += `[${jsCls}]`;
+        i = close + 1;
+      }
+    } else if (ch === "\\" && i + 1 < pattern.length) {
+      out += pattern[i + 1].replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+      i += 2;
+    } else {
+      out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i += 1;
+    }
+  }
+  return out;
+}
+function compile(raw) {
+  let pattern = raw.replace(/\r$/, "");
+  if (!pattern.trim() || pattern.startsWith("#"))
+    return null;
+  let negated = false;
+  if (pattern.startsWith("!")) {
+    negated = true;
+    pattern = pattern.slice(1);
+  }
+  pattern = pattern.replace(/(?<!\\) +$/, "");
+  if (!pattern)
+    return null;
+  let dirOnly = false;
+  if (pattern.endsWith("/")) {
+    dirOnly = true;
+    pattern = pattern.slice(0, -1);
+  }
+  const anchored = pattern.includes("/");
+  if (pattern.startsWith("/"))
+    pattern = pattern.slice(1);
+  const body = globToRegExp(pattern);
+  const prefix = anchored ? "^" : "^(?:.*/)?";
+  const regex = new RegExp(`${prefix}${body}$`);
+  return { regex, negated, dirOnly };
+}
+
+class IgnoreMatcher {
+  patterns;
+  base;
+  constructor(lines, base = "") {
+    this.base = base;
+    this.patterns = lines.map(compile).filter((p) => p !== null);
+  }
+  ignores(relPath, isDir) {
+    let local = relPath;
+    if (this.base) {
+      if (!relPath.startsWith(this.base + "/"))
+        return;
+      local = relPath.slice(this.base.length + 1);
+    }
+    let result;
+    for (const p of this.patterns) {
+      if (p.dirOnly && !isDir)
+        continue;
+      if (p.regex.test(local))
+        result = !p.negated;
+    }
+    return result;
+  }
+}
+
+class IgnoreStack {
+  hard;
+  stack = [];
+  constructor(hard = null) {
+    this.hard = hard;
+  }
+  push(matcher) {
+    this.stack.push(matcher);
+  }
+  pop() {
+    this.stack.pop();
+  }
+  ignores(relPath, isDir) {
+    const hardResult = this.hard?.ignores(relPath, isDir);
+    if (hardResult !== undefined)
+      return hardResult;
+    for (let i = this.stack.length - 1;i >= 0; i--) {
+      const result = this.stack[i].ignores(relPath, isDir);
+      if (result !== undefined)
+        return result;
+    }
+    return false;
+  }
+}
+var DEFAULT_EXCLUDES = [
+  ".git/",
+  "node_modules/",
+  "__pycache__/",
+  ".venv/",
+  "venv/",
+  ".tox/",
+  "dist/",
+  "build/",
+  "out/",
+  ".next/",
+  ".nuxt/",
+  ".cache/",
+  ".turbo/",
+  "target/",
+  "coverage/",
+  ".pnpm-store/",
+  ".bun/",
+  ".DS_Store"
+];
+
+// src/lib/local/walker.ts
+var BINARY_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "bmp",
+  "tiff",
+  "heic",
+  "pdf",
+  "zip",
+  "gz",
+  "tgz",
+  "tar",
+  "bz2",
+  "xz",
+  "zst",
+  "7z",
+  "rar",
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "a",
+  "o",
+  "obj",
+  "class",
+  "jar",
+  "war",
+  "pyc",
+  "wasm",
+  "node",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "mp3",
+  "mp4",
+  "m4a",
+  "avi",
+  "mov",
+  "mkv",
+  "webm",
+  "wav",
+  "flac",
+  "ogg",
+  "sqlite",
+  "db",
+  "bin",
+  "dat",
+  "ds_store"
+]);
+var CONTENT_EXCLUDED_NAMES = [/\.lock$/, /-lock\.(json|yaml)$/, /\.min\.(js|css)$/, /\.map$/, /\.svg$/];
+function hasBinaryExtension(ext) {
+  return BINARY_EXTENSIONS.has(ext.toLowerCase());
+}
+function isContentExcluded(name) {
+  return CONTENT_EXCLUDED_NAMES.some((re) => re.test(name));
+}
+function isBinaryFile(absPath) {
+  const buf = Buffer.alloc(8192);
+  let fd;
+  try {
+    fd = openSync(absPath, "r");
+  } catch {
+    return true;
+  }
+  try {
+    const read = readSync(fd, buf, 0, buf.length, 0);
+    for (let i = 0;i < read; i++) {
+      if (buf[i] === 0)
+        return true;
+    }
+    return false;
+  } finally {
+    closeSync(fd);
+  }
+}
+function readGitignore(dirAbs) {
+  try {
+    return readFileSync3(join2(dirAbs, ".gitignore"), "utf-8").split(`
+`);
+  } catch {
+    return null;
+  }
+}
+function extOf(name) {
+  const idx = name.lastIndexOf(".");
+  return idx > 0 ? name.slice(idx + 1).toLowerCase() : "";
+}
+function scanRoot(rootPath, extraExcludes = []) {
+  const stack = new IgnoreStack(new IgnoreMatcher([...DEFAULT_EXCLUDES, ...extraExcludes]));
+  const files = [];
+  const skippedDirs = [];
+  const walk = (dirAbs, dirRel) => {
+    const gitignore = readGitignore(dirAbs);
+    if (gitignore)
+      stack.push(new IgnoreMatcher(gitignore, dirRel));
+    let entries;
+    try {
+      entries = readdirSync(dirAbs, { withFileTypes: true });
+    } catch (err) {
+      if (gitignore)
+        stack.pop();
+      if (dirRel === "") {
+        throw new Error(`Cannot read index root ${dirAbs}: ${err instanceof Error ? err.message : err}`);
+      }
+      if (err.code !== "ENOENT")
+        skippedDirs.push(dirRel);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink())
+        continue;
+      const relPath = dirRel ? `${dirRel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (entry.name === ".git")
+          continue;
+        if (stack.ignores(relPath, true))
+          continue;
+        walk(join2(dirAbs, entry.name), relPath);
+      } else if (entry.isFile()) {
+        if (stack.ignores(relPath, false))
+          continue;
+        let stat;
+        try {
+          stat = statSync(join2(dirAbs, entry.name));
+        } catch {
+          continue;
+        }
+        files.push({
+          relPath,
+          name: entry.name,
+          ext: extOf(entry.name),
+          dir: dirRel,
+          size: stat.size,
+          mtimeMs: Math.floor(stat.mtimeMs)
+        });
+      }
+    }
+    if (gitignore)
+      stack.pop();
+  };
+  walk(rootPath, "");
+  files.sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0);
+  return { files, skippedDirs };
+}
+
+// src/lib/local/indexer.ts
+function rowToRoot(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    name: row.name,
+    exclude: JSON.parse(row.exclude),
+    contentIndexing: Boolean(row.content_indexing),
+    maxFileSize: row.max_file_size,
+    status: row.status,
+    error: row.error,
+    fileCount: row.file_count,
+    lastIndexedAt: row.last_indexed_at,
+    lastDurationMs: row.last_duration_ms,
+    createdAt: row.created_at
+  };
+}
+function normalizeRootPath(path) {
+  const expanded = path === "~" ? homedir2() : path.startsWith("~/") ? `${homedir2()}/${path.slice(2)}` : path;
+  return resolve(expanded.replace(/\/+$/, "") || "/");
+}
+function listRoots(db) {
+  const d = db ?? getIndexDb();
+  const rows = d.query("SELECT * FROM index_roots ORDER BY path").all();
+  return rows.map(rowToRoot);
+}
+function getRoot(ref, db) {
+  const d = db ?? getIndexDb();
+  const row = d.prepare(`SELECT *, CASE WHEN id = $ref THEN 0 WHEN path = $path THEN 1 ELSE 2 END AS priority
+       FROM index_roots
+       WHERE id = $ref OR path = $path OR name = $ref
+       ORDER BY priority LIMIT 1`).get({ $ref: ref, $path: normalizeRootPath(ref) });
+  return row ? rowToRoot(row) : null;
+}
+function hasReadyRoot(db) {
+  const d = db ?? getIndexDb();
+  const row = d.query("SELECT 1 FROM index_roots WHERE status = 'ready' LIMIT 1").get();
+  return row !== null;
+}
+function addRoot(path, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const normalized = normalizeRootPath(path);
+  let stat;
+  try {
+    stat = statSync2(normalized);
+  } catch {
+    throw new Error(`Path does not exist: ${normalized}`);
+  }
+  if (!stat.isDirectory())
+    throw new Error(`Not a directory: ${normalized}`);
+  if (opts.maxFileSize !== undefined && (!Number.isFinite(opts.maxFileSize) || opts.maxFileSize < 1)) {
+    throw new Error("maxFileSize must be a positive number of bytes");
+  }
+  const existing = getRoot(normalized, d);
+  if (existing && existing.path === normalized) {
+    throw new Error(`Root already indexed: ${existing.path} (${existing.id})`);
+  }
+  const name = opts.name ?? basename(normalized);
+  const nameClash = d.prepare("SELECT path FROM index_roots WHERE name = ?").get(name);
+  if (nameClash) {
+    throw new Error(`Root name "${name}" already used by ${nameClash.path} \u2014 pass a different name.`);
+  }
+  const id = generateId();
+  d.prepare(`INSERT INTO index_roots (id, path, name, exclude, content_indexing, max_file_size, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)`).run(id, normalized, name, JSON.stringify(opts.exclude ?? []), opts.contentIndexing === false ? 0 : 1, opts.maxFileSize ?? 524288, new Date().toISOString());
+  return getRoot(id, d);
+}
+function removeRoot(idOrPath, db) {
+  const d = db ?? getIndexDb();
+  const root = getRoot(idOrPath, d);
+  if (!root)
+    return false;
+  d.exec("BEGIN");
+  try {
+    d.prepare("DELETE FROM file_content_fts WHERE rowid IN (SELECT id FROM files WHERE root_id = ? AND content_indexed = 1)").run(root.id);
+    d.prepare("DELETE FROM index_roots WHERE id = ?").run(root.id);
+    d.exec("COMMIT");
+  } catch (err) {
+    d.exec("ROLLBACK");
+    throw err;
+  }
+  return true;
+}
+function shouldIndexContent(root, file) {
+  return root.contentIndexing && file.size > 0 && file.size <= root.maxFileSize && !hasBinaryExtension(file.ext) && !isContentExcluded(file.name);
+}
+function indexRoot(idOrPath, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const root = getRoot(idOrPath, d);
+  if (!root)
+    throw new Error(`Index root not found: ${idOrPath}`);
+  const start = Date.now();
+  d.prepare("UPDATE index_roots SET status = 'indexing', error = NULL WHERE id = ?").run(root.id);
+  try {
+    const { files: scanned, skippedDirs } = scanRoot(root.path, root.exclude);
+    const now = new Date().toISOString();
+    const existingRows = d.prepare("SELECT id, rel_path, size, mtime_ms, content_indexed FROM files WHERE root_id = ?").all(root.id);
+    const existing = new Map(existingRows.map((r) => [r.rel_path, r]));
+    const insertFile = d.prepare(`INSERT INTO files (root_id, rel_path, name, ext, dir, size, mtime_ms, is_binary, content_indexed, indexed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateFile = d.prepare("UPDATE files SET size = ?, mtime_ms = ?, is_binary = ?, content_indexed = ?, indexed_at = ? WHERE id = ?");
+    const deleteFile = d.prepare("DELETE FROM files WHERE id = ?");
+    const insertContent = d.prepare("INSERT INTO file_content_fts (rowid, body) VALUES (?, ?)");
+    const deleteContent = d.prepare("DELETE FROM file_content_fts WHERE rowid = ?");
+    const stats = {
+      rootId: root.id,
+      added: 0,
+      updated: 0,
+      deleted: 0,
+      contentIndexed: 0,
+      fileCount: scanned.length,
+      skippedDirs: skippedDirs.length,
+      durationMs: 0
+    };
+    d.exec("BEGIN");
+    try {
+      const seen = new Set;
+      for (const file of scanned) {
+        seen.add(file.relPath);
+        const prev = existing.get(file.relPath);
+        const changed = !prev || prev.size !== file.size || prev.mtime_ms !== file.mtimeMs;
+        if (prev && !changed && !opts.force)
+          continue;
+        const wantContent = shouldIndexContent(root, file);
+        const absPath = `${root.path}/${file.relPath}`;
+        let isBinary = wantContent ? isBinaryFile(absPath) : hasBinaryExtension(file.ext);
+        let body = null;
+        if (wantContent && !isBinary) {
+          try {
+            body = readFileSync4(absPath, "utf-8");
+          } catch {
+            isBinary = true;
+          }
+        }
+        const contentIndexed = body !== null ? 1 : 0;
+        if (prev) {
+          if (prev.content_indexed)
+            deleteContent.run(prev.id);
+          updateFile.run(file.size, file.mtimeMs, isBinary ? 1 : 0, contentIndexed, now, prev.id);
+          if (body !== null)
+            insertContent.run(prev.id, body);
+          stats.updated++;
+        } else {
+          const inserted = insertFile.run(root.id, file.relPath, file.name, file.ext, file.dir, file.size, file.mtimeMs, isBinary ? 1 : 0, contentIndexed, now);
+          if (body !== null)
+            insertContent.run(Number(inserted.lastInsertRowid), body);
+          stats.added++;
+        }
+        if (contentIndexed)
+          stats.contentIndexed++;
+      }
+      for (const [relPath, row] of existing) {
+        if (seen.has(relPath))
+          continue;
+        if (row.content_indexed)
+          deleteContent.run(row.id);
+        deleteFile.run(row.id);
+        stats.deleted++;
+      }
+      stats.durationMs = Date.now() - start;
+      d.prepare("UPDATE index_roots SET status = 'ready', file_count = ?, last_indexed_at = ?, last_duration_ms = ? WHERE id = ?").run(scanned.length, now, stats.durationMs, root.id);
+      d.exec("COMMIT");
+    } catch (err) {
+      d.exec("ROLLBACK");
+      throw err;
+    }
+    return stats;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    d.prepare("UPDATE index_roots SET status = 'error', error = ? WHERE id = ?").run(message, root.id);
+    throw err;
+  }
+}
+function indexAllRoots(opts = {}, db) {
+  return listRoots(db).map((root) => indexRoot(root.id, opts, db));
+}
+var refreshing = new Set;
+function refreshStaleRoots(staleMinutes, db) {
+  const cutoff = Date.now() - staleMinutes * 60000;
+  const stats = [];
+  for (const root of listRoots(db)) {
+    if (root.status === "indexing" || root.status === "pending")
+      continue;
+    if (root.lastIndexedAt && Date.parse(root.lastIndexedAt) > cutoff)
+      continue;
+    if (refreshing.has(root.id))
+      continue;
+    refreshing.add(root.id);
+    try {
+      stats.push(indexRoot(root.id, {}, db));
+    } catch {} finally {
+      refreshing.delete(root.id);
+    }
+  }
+  return stats;
+}
+function autoRefreshStaleRoots(db) {
+  const config = getConfig();
+  if (!config.indexAutoRefresh)
+    return [];
+  return refreshStaleRoots(config.indexStaleMinutes, db);
+}
+
 // src/db/providers.ts
 function rowToProvider(row) {
   return {
@@ -9873,6 +10655,8 @@ function updateProviderLastUsed(name, db) {
   d.prepare("UPDATE providers SET last_used_at = ? WHERE name = ?").run(now, name);
 }
 function isProviderConfigured(provider) {
+  if (LOCAL_PROVIDER_NAMES.has(provider.name))
+    return hasReadyRoot();
   if (!provider.apiKeyEnv)
     return true;
   return !!Bun.env[provider.apiKeyEnv];
@@ -9923,94 +10707,1641 @@ function deleteProfile(id, db) {
   const result = d.prepare("DELETE FROM search_profiles WHERE id = ?").run(id);
   return result.changes > 0;
 }
-// src/lib/config.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3, cpSync as cpSync2 } from "fs";
-function getConfigDir() {
-  const home = Bun.env.HOME ?? "/tmp";
-  const newDir = `${home}/.hasna/search`;
-  const oldDir = `${home}/.open-search`;
-  if (!existsSync3(newDir) && existsSync3(oldDir)) {
-    try {
-      mkdirSync2(`${home}/.hasna`, { recursive: true });
-      cpSync2(oldDir, newDir, { recursive: true });
-    } catch {}
+// src/lib/providers/google.ts
+class GoogleProvider {
+  name = "google";
+  displayName = "Google";
+  isConfigured() {
+    return !!Bun.env.SERP_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.SERP_API_KEY;
+    if (!apiKey)
+      throw new Error("SERP_API_KEY not configured");
+    const params = new URLSearchParams({
+      api_key: apiKey,
+      engine: "google",
+      q: query,
+      num: String(options?.limit ?? 10)
+    });
+    if (options?.language)
+      params.set("hl", options.language);
+    if (options?.region)
+      params.set("gl", options.region);
+    if (options?.safeSearch)
+      params.set("safe", "active");
+    const res = await fetch(`https://serpapi.com/search.json?${params}`);
+    if (!res.ok)
+      throw new Error(`SerpAPI error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.error)
+      throw new Error(`SerpAPI error: ${data.error}`);
+    return (data.organic_results ?? []).map((r, i) => ({
+      title: r.title,
+      url: r.link,
+      snippet: r.snippet ?? "",
+      score: 1 - i * 0.05,
+      publishedAt: r.date ?? undefined,
+      thumbnail: r.thumbnail ?? undefined,
+      metadata: { position: r.position ?? i + 1 }
+    }));
   }
-  mkdirSync2(newDir, { recursive: true });
-  return newDir;
-}
-function getConfigPath() {
-  return `${getConfigDir()}/config.json`;
 }
-function getConfig() {
-  const path = getConfigPath();
-  if (!existsSync3(path)) {
-    return { ...DEFAULT_CONFIG };
+
+// src/lib/providers/serpapi.ts
+class SerpApiProvider {
+  name = "serpapi";
+  displayName = "SerpAPI";
+  engine;
+  constructor(engine = "google") {
+    this.engine = engine;
   }
-  try {
-    const raw = readFileSync2(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    return { ...DEFAULT_CONFIG, ...parsed };
-  } catch {
-    return { ...DEFAULT_CONFIG };
+  isConfigured() {
+    return !!Bun.env.SERP_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.SERP_API_KEY;
+    if (!apiKey)
+      throw new Error("SERP_API_KEY not configured");
+    const params = new URLSearchParams({
+      api_key: apiKey,
+      engine: this.engine,
+      q: query,
+      num: String(options?.limit ?? 10)
+    });
+    if (options?.language)
+      params.set("hl", options.language);
+    if (options?.region)
+      params.set("gl", options.region);
+    const res = await fetch(`https://serpapi.com/search.json?${params}`);
+    if (!res.ok)
+      throw new Error(`SerpAPI error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.error)
+      throw new Error(`SerpAPI error: ${data.error}`);
+    return (data.organic_results ?? []).map((r, i) => ({
+      title: r.title,
+      url: r.link,
+      snippet: r.snippet ?? "",
+      score: 1 - i * 0.05,
+      publishedAt: r.date ?? undefined,
+      thumbnail: r.thumbnail ?? undefined,
+      metadata: { engine: this.engine, position: r.position ?? i + 1 }
+    }));
   }
 }
-function setConfig(updates) {
-  const current = getConfig();
-  const merged = { ...current, ...updates };
-  const path = getConfigPath();
-  writeFileSync(path, JSON.stringify(merged, null, 2), "utf-8");
-  return merged;
+
+// src/lib/providers/exa.ts
+class ExaProvider {
+  name = "exa";
+  displayName = "Exa.ai";
+  isConfigured() {
+    return !!Bun.env.EXA_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.EXA_API_KEY;
+    if (!apiKey)
+      throw new Error("EXA_API_KEY not configured");
+    const body = {
+      query,
+      numResults: options?.limit ?? 10,
+      type: "auto",
+      contents: {
+        text: { maxCharacters: 500 }
+      }
+    };
+    if (options?.dateRange?.from)
+      body.startPublishedDate = options.dateRange.from;
+    if (options?.dateRange?.to)
+      body.endPublishedDate = options.dateRange.to;
+    const res = await fetch("https://api.exa.ai/search", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok)
+      throw new Error(`Exa API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    return data.results.map((r) => ({
+      title: r.title,
+      url: r.url,
+      snippet: r.text ?? "",
+      score: r.score,
+      publishedAt: r.publishedDate ?? undefined,
+      thumbnail: r.image ?? undefined,
+      metadata: { author: r.author }
+    }));
+  }
 }
-function resetConfig() {
-  const path = getConfigPath();
-  writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
-  return { ...DEFAULT_CONFIG };
+
+// src/lib/providers/perplexity.ts
+class PerplexityProvider {
+  name = "perplexity";
+  displayName = "Perplexity";
+  isConfigured() {
+    return !!Bun.env.PERPLEXITY_API_KEY;
+  }
+  async search(query, _options) {
+    const apiKey = Bun.env.PERPLEXITY_API_KEY;
+    if (!apiKey)
+      throw new Error("PERPLEXITY_API_KEY not configured");
+    const res = await fetch("https://api.perplexity.ai/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: "sonar",
+        messages: [
+          {
+            role: "system",
+            content: "You are a search assistant. Provide factual, well-sourced answers with citations."
+          },
+          { role: "user", content: query }
+        ],
+        return_citations: true
+      })
+    });
+    if (!res.ok)
+      throw new Error(`Perplexity API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    const content = data.choices[0]?.message?.content ?? "";
+    const citations = data.citations ?? [];
+    return citations.map((citation, i) => {
+      const isString = typeof citation === "string";
+      const url = isString ? citation : citation.url;
+      const title = isString ? url : citation.title ?? url;
+      const snippet = isString ? content.substring(0, 300) : citation.snippet ?? content.substring(0, 300);
+      return {
+        title,
+        url,
+        snippet,
+        score: 1 - i * 0.1,
+        metadata: { aiSummary: content.substring(0, 500) }
+      };
+    });
+  }
 }
-function getConfigValue(key) {
-  const config = getConfig();
-  return config[key];
+
+// src/lib/providers/brave.ts
+class BraveProvider {
+  name = "brave";
+  displayName = "Brave Search";
+  isConfigured() {
+    return !!Bun.env.BRAVE_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.BRAVE_API_KEY;
+    if (!apiKey)
+      throw new Error("BRAVE_API_KEY not configured");
+    const params = new URLSearchParams({
+      q: query,
+      count: String(options?.limit ?? 10)
+    });
+    if (options?.safeSearch)
+      params.set("safesearch", "strict");
+    if (options?.language)
+      params.set("search_lang", options.language);
+    if (options?.region)
+      params.set("country", options.region);
+    const res = await fetch(`https://api.search.brave.com/res/v1/web/search?${params}`, {
+      headers: {
+        Accept: "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": apiKey
+      }
+    });
+    if (!res.ok)
+      throw new Error(`Brave Search API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    return (data.web?.results ?? []).map((r, i) => ({
+      title: r.title,
+      url: r.url,
+      snippet: r.description ?? "",
+      score: 1 - i * 0.05,
+      publishedAt: r.age ?? undefined,
+      thumbnail: r.thumbnail?.src ?? undefined,
+      metadata: {}
+    }));
+  }
 }
-function setConfigValue(key, value) {
+
+// src/lib/providers/bing.ts
+class BingProvider {
+  name = "bing";
+  displayName = "Bing";
+  isConfigured() {
+    return !!Bun.env.BING_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.BING_API_KEY;
+    if (!apiKey)
+      throw new Error("BING_API_KEY not configured");
+    const params = new URLSearchParams({
+      q: query,
+      count: String(options?.limit ?? 10),
+      responseFilter: "Webpages"
+    });
+    if (options?.offset)
+      params.set("offset", String(options.offset));
+    if (options?.safeSearch)
+      params.set("safeSearch", "Strict");
+    if (options?.region)
+      params.set("mkt", options.region);
+    const res = await fetch(`https://api.bing.microsoft.com/v7.0/search?${params}`, {
+      headers: {
+        "Ocp-Apim-Subscription-Key": apiKey
+      }
+    });
+    if (!res.ok)
+      throw new Error(`Bing API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.error)
+      throw new Error(`Bing API error: ${data.error.message}`);
+    return (data.webPages?.value ?? []).map((r, i) => ({
+      title: r.name,
+      url: r.url,
+      snippet: r.snippet ?? "",
+      score: 1 - i * 0.05,
+      publishedAt: r.dateLastCrawled ?? undefined,
+      thumbnail: r.thumbnailUrl ?? undefined,
+      metadata: {
+        totalEstimatedMatches: data.webPages?.totalEstimatedMatches
+      }
+    }));
+  }
+}
+
+// src/lib/providers/twitter.ts
+class TwitterProvider {
+  name = "twitter";
+  displayName = "X / Twitter";
+  isConfigured() {
+    return !!Bun.env.X_BEARER_TOKEN;
+  }
+  async search(query, options) {
+    const token = Bun.env.X_BEARER_TOKEN;
+    if (!token)
+      throw new Error("X_BEARER_TOKEN not configured");
+    const params = new URLSearchParams({
+      query,
+      max_results: String(Math.min(options?.limit ?? 10, 100)),
+      "tweet.fields": "created_at,public_metrics,author_id",
+      expansions: "author_id",
+      "user.fields": "name,username"
+    });
+    if (options?.dateRange?.from)
+      params.set("start_time", new Date(options.dateRange.from).toISOString());
+    if (options?.dateRange?.to)
+      params.set("end_time", new Date(options.dateRange.to).toISOString());
+    const res = await fetch(`https://api.twitter.com/2/tweets/search/recent?${params}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok)
+      throw new Error(`Twitter API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.errors?.length)
+      throw new Error(`Twitter API error: ${data.errors[0].message}`);
+    const users = new Map;
+    for (const u of data.includes?.users ?? []) {
+      users.set(u.id, u);
+    }
+    return (data.data ?? []).map((tweet, i) => {
+      const user = tweet.author_id ? users.get(tweet.author_id) : undefined;
+      const username = user?.username ?? "unknown";
+      return {
+        title: tweet.text.substring(0, 100) + (tweet.text.length > 100 ? "..." : ""),
+        url: `https://x.com/${username}/status/${tweet.id}`,
+        snippet: tweet.text,
+        score: tweet.public_metrics ? (tweet.public_metrics.like_count + tweet.public_metrics.retweet_count * 2) / 1000 : 1 - i * 0.05,
+        publishedAt: tweet.created_at,
+        metadata: {
+          authorName: user?.name,
+          authorUsername: username,
+          metrics: tweet.public_metrics
+        }
+      };
+    });
+  }
+}
+
+// src/lib/providers/reddit.ts
+var cachedToken = null;
+async function getOAuthToken() {
+  if (cachedToken && Date.now() < cachedToken.expiresAt) {
+    return cachedToken.token;
+  }
+  const clientId = Bun.env.REDDIT_CLIENT_ID;
+  const clientSecret = Bun.env.REDDIT_CLIENT_SECRET;
+  if (!clientId || !clientSecret)
+    throw new Error("REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET required");
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  const res = await fetch("https://www.reddit.com/api/v1/access_token", {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${credentials}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "open-search/0.0.1"
+    },
+    body: "grant_type=client_credentials"
+  });
+  if (!res.ok)
+    throw new Error(`Reddit OAuth error: ${res.status}`);
+  const data = await res.json();
+  cachedToken = {
+    token: data.access_token,
+    expiresAt: Date.now() + data.expires_in * 1000 - 60000
+  };
+  return cachedToken.token;
+}
+
+class RedditProvider {
+  name = "reddit";
+  displayName = "Reddit";
+  isConfigured() {
+    return !!Bun.env.REDDIT_CLIENT_ID && !!Bun.env.REDDIT_CLIENT_SECRET;
+  }
+  async search(query, options) {
+    const token = await getOAuthToken();
+    const params = new URLSearchParams({
+      q: query,
+      limit: String(options?.limit ?? 10),
+      sort: "relevance",
+      type: "link"
+    });
+    const res = await fetch(`https://oauth.reddit.com/search?${params}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "open-search/0.0.1"
+      }
+    });
+    if (!res.ok)
+      throw new Error(`Reddit API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.error)
+      throw new Error(`Reddit API error: ${data.message ?? data.error}`);
+    return (data.data?.children ?? []).map((post) => {
+      const p = post.data;
+      return {
+        title: p.title,
+        url: `https://www.reddit.com${p.permalink}`,
+        snippet: p.selftext?.substring(0, 300) ?? "",
+        score: p.score / 1000,
+        publishedAt: new Date(p.created_utc * 1000).toISOString(),
+        thumbnail: p.thumbnail && p.thumbnail !== "self" ? p.thumbnail : undefined,
+        metadata: {
+          subreddit: p.subreddit,
+          upvotes: p.score,
+          comments: p.num_comments,
+          author: p.author,
+          originalUrl: p.url
+        }
+      };
+    });
+  }
+}
+
+// src/lib/providers/youtube.ts
+class YouTubeProvider {
+  name = "youtube";
+  displayName = "YouTube";
+  isConfigured() {
+    return !!Bun.env.YOUTUBE_API_KEY;
+  }
+  async search(query, options) {
+    const apiKey = Bun.env.YOUTUBE_API_KEY;
+    if (!apiKey)
+      throw new Error("YOUTUBE_API_KEY not configured");
+    const params = new URLSearchParams({
+      part: "snippet",
+      q: query,
+      type: "video",
+      maxResults: String(options?.limit ?? 10),
+      key: apiKey,
+      order: "relevance"
+    });
+    if (options?.language)
+      params.set("relevanceLanguage", options.language);
+    if (options?.safeSearch)
+      params.set("safeSearch", "strict");
+    if (options?.dateRange?.from)
+      params.set("publishedAfter", new Date(options.dateRange.from).toISOString());
+    if (options?.dateRange?.to)
+      params.set("publishedBefore", new Date(options.dateRange.to).toISOString());
+    const res = await fetch(`https://www.googleapis.com/youtube/v3/search?${params}`);
+    if (!res.ok)
+      throw new Error(`YouTube API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.error)
+      throw new Error(`YouTube API error: ${data.error.message}`);
+    return (data.items ?? []).filter((item) => item.id.videoId).map((item, i) => ({
+      title: item.snippet.title,
+      url: `https://www.youtube.com/watch?v=${item.id.videoId}`,
+      snippet: item.snippet.description,
+      score: 1 - i * 0.05,
+      publishedAt: item.snippet.publishedAt,
+      thumbnail: item.snippet.thumbnails?.high?.url ?? item.snippet.thumbnails?.medium?.url ?? undefined,
+      metadata: {
+        videoId: item.id.videoId,
+        channelTitle: item.snippet.channelTitle,
+        totalResults: data.pageInfo?.totalResults
+      }
+    }));
+  }
+}
+
+// src/lib/providers/hackernews.ts
+class HackerNewsProvider {
+  name = "hackernews";
+  displayName = "Hacker News";
+  isConfigured() {
+    return true;
+  }
+  async search(query, options) {
+    const params = new URLSearchParams({
+      query,
+      hitsPerPage: String(options?.limit ?? 10),
+      tags: "story"
+    });
+    if (options?.dateRange?.from) {
+      params.set("numericFilters", `created_at_i>${Math.floor(new Date(options.dateRange.from).getTime() / 1000)}`);
+    }
+    const res = await fetch(`https://hn.algolia.com/api/v1/search?${params}`);
+    if (!res.ok)
+      throw new Error(`HN Algolia API error: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    return data.hits.map((hit) => {
+      const hnUrl = `https://news.ycombinator.com/item?id=${hit.objectID}`;
+      return {
+        title: hit.title ?? hit.comment_text?.substring(0, 100) ?? "Untitled",
+        url: hit.url ?? hnUrl,
+        snippet: hit.story_text?.substring(0, 300) ?? hit.comment_text?.substring(0, 300) ?? "",
+        score: (hit.points ?? 0) / 100,
+        publishedAt: hit.created_at,
+        metadata: {
+          hnUrl,
+          author: hit.author,
+          points: hit.points,
+          comments: hit.num_comments,
+          tags: hit._tags,
+          totalHits: data.nbHits
+        }
+      };
+    });
+  }
+}
+
+// src/lib/providers/github.ts
+class GitHubProvider {
+  name = "github";
+  displayName = "GitHub";
+  isConfigured() {
+    return !!Bun.env.GITHUB_TOKEN;
+  }
+  async search(query, options) {
+    const token = Bun.env.GITHUB_TOKEN;
+    if (!token)
+      throw new Error("GITHUB_TOKEN not configured");
+    const limit = options?.limit ?? 10;
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    const [codeResults, repoResults] = await Promise.allSettled([
+      this.searchCode(query, Math.ceil(limit / 2), headers),
+      this.searchRepos(query, Math.ceil(limit / 2), headers)
+    ]);
+    const results = [];
+    if (codeResults.status === "fulfilled")
+      results.push(...codeResults.value);
+    if (repoResults.status === "fulfilled")
+      results.push(...repoResults.value);
+    return results.slice(0, limit);
+  }
+  async searchCode(query, limit, headers) {
+    const params = new URLSearchParams({
+      q: query,
+      per_page: String(limit)
+    });
+    const res = await fetch(`https://api.github.com/search/code?${params}`, {
+      headers: {
+        ...headers,
+        Accept: "application/vnd.github.text-match+json"
+      }
+    });
+    if (!res.ok)
+      return [];
+    const data = await res.json();
+    return data.items.map((item) => ({
+      title: `${item.repository.full_name}/${item.path}`,
+      url: item.html_url,
+      snippet: item.text_matches?.[0]?.fragment ?? `Code match in ${item.path}`,
+      score: (item.repository.stargazers_count ?? 0) / 1e4,
+      metadata: {
+        type: "code",
+        repo: item.repository.full_name,
+        path: item.path,
+        language: item.repository.language,
+        stars: item.repository.stargazers_count
+      }
+    }));
+  }
+  async searchRepos(query, limit, headers) {
+    const params = new URLSearchParams({
+      q: query,
+      per_page: String(limit),
+      sort: "stars",
+      order: "desc"
+    });
+    const res = await fetch(`https://api.github.com/search/repositories?${params}`, {
+      headers
+    });
+    if (!res.ok)
+      return [];
+    const data = await res.json();
+    return data.items.map((item) => ({
+      title: item.full_name,
+      url: item.html_url,
+      snippet: item.description ?? "",
+      score: item.stargazers_count / 1e4,
+      publishedAt: item.updated_at,
+      metadata: {
+        type: "repository",
+        stars: item.stargazers_count,
+        language: item.language,
+        topics: item.topics
+      }
+    }));
+  }
+}
+
+// src/lib/providers/arxiv.ts
+class ArxivProvider {
+  name = "arxiv";
+  displayName = "arXiv";
+  isConfigured() {
+    return true;
+  }
+  async search(query, options) {
+    const limit = options?.limit ?? 10;
+    const offset = options?.offset ?? 0;
+    const params = new URLSearchParams({
+      search_query: `all:${query}`,
+      start: String(offset),
+      max_results: String(limit),
+      sortBy: "relevance",
+      sortOrder: "descending"
+    });
+    const res = await fetch(`https://export.arxiv.org/api/query?${params}`);
+    if (!res.ok)
+      throw new Error(`arXiv API error: ${res.status} ${res.statusText}`);
+    const xml = await res.text();
+    return this.parseAtomFeed(xml);
+  }
+  parseAtomFeed(xml) {
+    const results = [];
+    const entries = xml.split("<entry>");
+    for (let i = 1;i < entries.length; i++) {
+      const entry = entries[i];
+      const title = this.extractTag(entry, "title")?.replace(/\s+/g, " ").trim() ?? "Untitled";
+      const summary = this.extractTag(entry, "summary")?.replace(/\s+/g, " ").trim() ?? "";
+      const published = this.extractTag(entry, "published") ?? undefined;
+      const idUrl = this.extractTag(entry, "id") ?? "";
+      const authors = [];
+      const authorMatches = entry.matchAll(/<author>\s*<name>([^<]+)<\/name>/g);
+      for (const match of authorMatches) {
+        if (match[1])
+          authors.push(match[1].trim());
+      }
+      const categories = [];
+      const catMatches = entry.matchAll(/category[^>]*term="([^"]+)"/g);
+      for (const match of catMatches) {
+        if (match[1])
+          categories.push(match[1]);
+      }
+      const pdfMatch = entry.match(/link[^>]*href="([^"]+)"[^>]*title="pdf"/);
+      const pdfUrl = pdfMatch?.[1];
+      results.push({
+        title,
+        url: idUrl,
+        snippet: summary.substring(0, 400),
+        score: 1 - (i - 1) * 0.05,
+        publishedAt: published,
+        metadata: {
+          authors,
+          categories,
+          pdfUrl,
+          abstract: summary
+        }
+      });
+    }
+    return results;
+  }
+  extractTag(xml, tag) {
+    const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`);
+    const match = xml.match(regex);
+    return match?.[1] ?? null;
+  }
+}
+
+// src/lib/local/query.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+
+// src/lib/local/regex.ts
+function extractRegexLiterals(pattern) {
+  const branches = splitTopLevelAlternation(pattern);
+  const result = [];
+  for (const branch of branches) {
+    const literals = extractSequenceLiterals(branch).filter((l) => l.length >= 3);
+    if (literals.length === 0)
+      return null;
+    result.push({ literals });
+  }
+  return result;
+}
+function splitTopLevelAlternation(pattern) {
+  const branches = [];
+  let depth = 0;
+  let inClass = false;
+  let current = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      current += ch + (pattern[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]")
+        inClass = false;
+      current += ch;
+      continue;
+    }
+    if (ch === "[") {
+      inClass = true;
+      current += ch;
+    } else if (ch === "(") {
+      depth++;
+      current += ch;
+    } else if (ch === ")") {
+      depth--;
+      current += ch;
+    } else if (ch === "|" && depth === 0) {
+      branches.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  branches.push(current);
+  return branches;
+}
+function extractSequenceLiterals(seq) {
+  const literals = [];
+  let run = "";
+  const flush = () => {
+    if (run.length > 0)
+      literals.push(run.toLowerCase());
+    run = "";
+  };
+  let i = 0;
+  while (i < seq.length) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      const next = seq[i + 1];
+      if (next === undefined)
+        break;
+      if (/[a-zA-Z0-9]/.test(next)) {
+        flush();
+        let len = 2;
+        if (next === "x") {
+          len = 4;
+        } else if (next === "u") {
+          if (seq[i + 2] === "{") {
+            const close = seq.indexOf("}", i + 2);
+            len = close === -1 ? 2 : close - i + 1;
+          } else {
+            len = 6;
+          }
+        } else if (next === "c") {
+          len = 3;
+        } else if (next === "k" && seq[i + 2] === "<") {
+          const close = seq.indexOf(">", i + 2);
+          len = close === -1 ? 2 : close - i + 1;
+        } else if ((next === "p" || next === "P") && seq[i + 2] === "{") {
+          const close = seq.indexOf("}", i + 2);
+          len = close === -1 ? 2 : close - i + 1;
+        }
+        i += len;
+        continue;
+      }
+      const q2 = quantifierAt(seq, i + 2);
+      if (q2.optional) {
+        flush();
+      } else {
+        run += next;
+        if (q2.repeats)
+          flush();
+      }
+      i += 2 + q2.length;
+      continue;
+    }
+    if (ch === "(") {
+      const end = findGroupEnd(seq, i);
+      const inner = seq.slice(i + 1, end);
+      const q2 = quantifierAt(seq, end + 1);
+      flush();
+      const isSpecial = inner.startsWith("?") && !inner.startsWith("?:") && !inner.startsWith("?<");
+      const isNamed = inner.startsWith("?<") && !inner.startsWith("?<=") && !inner.startsWith("?<!");
+      const body = inner.startsWith("?:") ? inner.slice(2) : isNamed ? inner.replace(/^\?<[^>]*>/, "") : inner;
+      if (!isSpecial && !q2.optional && !inner.startsWith("?<=") && !inner.startsWith("?<!")) {
+        const groupBranches = splitTopLevelAlternation(body);
+        if (groupBranches.length === 1) {
+          literals.push(...extractSequenceLiterals(body).filter((l) => l.length >= 3));
+        }
+      }
+      i = end + 1 + q2.length;
+      continue;
+    }
+    if (ch === "[") {
+      const end = findClassEnd(seq, i);
+      const q2 = quantifierAt(seq, end + 1);
+      flush();
+      i = end + 1 + q2.length;
+      continue;
+    }
+    if (ch === "." || ch === "^" || ch === "$") {
+      flush();
+      i++;
+      continue;
+    }
+    if (ch === "*" || ch === "?" || ch === "+" || ch === "{") {
+      const q2 = quantifierAt(seq, i);
+      i += Math.max(1, q2.length);
+      continue;
+    }
+    const q = quantifierAt(seq, i + 1);
+    if (q.optional) {
+      flush();
+    } else {
+      run += ch;
+      if (q.repeats)
+        flush();
+    }
+    i += 1 + q.length;
+  }
+  flush();
+  return literals;
+}
+function quantifierAt(seq, pos) {
+  const ch = seq[pos];
+  if (ch === "?")
+    return { length: 1, optional: true, repeats: false };
+  if (ch === "*")
+    return { length: 1, optional: true, repeats: true };
+  if (ch === "+")
+    return { length: 1, optional: false, repeats: true };
+  if (ch === "{") {
+    const end = seq.indexOf("}", pos);
+    if (end === -1)
+      return { length: 0, optional: false, repeats: false };
+    const body = seq.slice(pos + 1, end);
+    const min = parseInt(body, 10);
+    const lazy = seq[end + 1] === "?" ? 1 : 0;
+    return { length: end - pos + 1 + lazy, optional: !(min >= 1), repeats: true };
+  }
+  return { length: 0, optional: false, repeats: false };
+}
+function findGroupEnd(seq, start) {
+  let depth = 0;
+  let inClass = false;
+  for (let i = start;i < seq.length; i++) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]")
+        inClass = false;
+      continue;
+    }
+    if (ch === "[")
+      inClass = true;
+    else if (ch === "(")
+      depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return seq.length - 1;
+}
+function findClassEnd(seq, start) {
+  for (let i = start + 1;i < seq.length; i++) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "]" && i > start + 1)
+      return i;
+  }
+  return seq.length - 1;
+}
+function buildFtsQueryFromRegex(pattern) {
+  const branches = extractRegexLiterals(pattern);
+  if (!branches)
+    return null;
+  const branchExprs = branches.map((b) => {
+    const ands = b.literals.map((l) => l.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "")).filter((l) => l.length >= 3).map((l) => `"${l.replace(/"/g, '""')}"`).join(" AND ");
+    return branches.length > 1 ? `(${ands})` : ands;
+  });
+  if (branchExprs.some((e) => e.length === 0))
+    return null;
+  return branchExprs.join(" OR ");
+}
+function compileSearchRegex(pattern, caseSensitive = false) {
+  return new RegExp(pattern, caseSensitive ? "" : "i");
+}
+
+// src/lib/local/query.ts
+var MAX_LINE_LENGTH = 200;
+var MAX_MATCHES_PER_FILE = 5;
+function tokenize(query) {
+  return query.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").split(/\s+/).filter(Boolean);
+}
+function buildFtsQuery(query) {
+  const tokens = tokenize(query).filter((t) => t.length >= 3);
+  if (tokens.length === 0)
+    return null;
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" AND ");
+}
+function clampLimit(limit, fallback = 20) {
+  if (limit === undefined || !Number.isFinite(limit))
+    return fallback;
+  return Math.max(1, Math.min(500, Math.floor(limit)));
+}
+function filterClauses(opts, db) {
+  const clauses = [];
+  const params = [];
+  if (opts.root) {
+    const root = getRoot(opts.root, db);
+    if (!root)
+      throw new Error(`Index root not found: ${opts.root}`);
+    clauses.push("r.id = ?");
+    params.push(root.id);
+  }
+  if (opts.ext) {
+    clauses.push("f.ext = ?");
+    params.push(opts.ext.replace(/^\./, "").toLowerCase());
+  }
+  if (opts.dir) {
+    clauses.push("f.dir LIKE ? ESCAPE '\\'");
+    const dir = opts.dir.replace(/^\/|\/$/g, "").replace(/[\\%_]/g, "\\$&");
+    params.push(`%${dir}%`);
+  }
+  return { sql: clauses.length > 0 ? ` AND ${clauses.join(" AND ")}` : "", params };
+}
+function rowToHit(row, score) {
+  return {
+    rootId: row.root_id,
+    rootName: row.root_name,
+    rootPath: row.root_path,
+    relPath: row.rel_path,
+    absPath: `${row.root_path}/${row.rel_path}`,
+    name: row.name,
+    ext: row.ext,
+    dir: row.dir,
+    size: row.size,
+    mtimeMs: row.mtime_ms,
+    isBinary: row.is_binary === 1,
+    score
+  };
+}
+function normalizeForMatch(s) {
+  return s.toLowerCase().replace(/[-_.]+/g, " ").trim();
+}
+var EXACT_NAME_FLOOR = 0.72;
+var PREFIX_NAME_FLOOR = 0.58;
+var CONTENT_MAX_SCORE = 0.65;
+function scoreFileName(query, tokens, row) {
+  const q = query.trim().toLowerCase();
+  const qNorm = normalizeForMatch(query);
+  const name = row.name.toLowerCase();
+  const stem = name.replace(/\.[^.]+$/, "");
+  const nameNorm = normalizeForMatch(row.name);
+  const stemNorm = normalizeForMatch(row.name.replace(/\.[^.]+$/, ""));
+  const relPath = row.rel_path.toLowerCase();
+  let score = 0;
+  let floor = 0;
+  if (name === q || stem === q || nameNorm === qNorm || stemNorm === qNorm) {
+    score += 100;
+    floor = EXACT_NAME_FLOOR;
+  } else if (name.startsWith(q) || stem.startsWith(q) || stemNorm.startsWith(qNorm)) {
+    score += 60;
+    floor = PREFIX_NAME_FLOOR;
+  } else if (name.includes(q) || nameNorm.includes(qNorm)) {
+    score += 40;
+  }
+  for (const token of tokens) {
+    const t = token.toLowerCase();
+    if (name.includes(t))
+      score += 15;
+    else if (relPath.includes(t))
+      score += 5;
+  }
+  const depth = row.rel_path.split("/").length - 1;
+  score -= depth * 2;
+  const age = Date.now() - row.mtime_ms;
+  if (age < 7 * 86400000)
+    score += 10;
+  else if (age < 30 * 86400000)
+    score += 5;
+  return Math.max(floor, Math.max(0, score) / (Math.max(0, score) + 60));
+}
+var CANDIDATE_COLUMNS = `
+  f.id, f.root_id, r.name as root_name, r.path as root_path,
+  f.rel_path, f.name, f.ext, f.dir, f.size, f.mtime_ms, f.is_binary
+`;
+function searchFilePaths(query, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const tokens = tokenize(query);
+  if (tokens.length === 0)
+    return [];
+  const ftsQuery = buildFtsQuery(query);
+  const filters = filterClauses(opts, d);
+  const candidateLimit = Math.max(200, limit * 10);
+  let rows;
+  if (ftsQuery) {
+    rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files_fts fts
+         JOIN files f ON f.id = fts.rowid
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE files_fts MATCH ?${filters.sql}
+         ORDER BY bm25(files_fts, 10.0, 1.0)
+         LIMIT ?`).all(ftsQuery, ...filters.params, candidateLimit);
+    const namePattern = `${query.trim().replace(/[\\%_]/g, "\\$&")}%`;
+    const nameRows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files f
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE f.name LIKE ? ESCAPE '\\'${filters.sql}
+         ORDER BY length(f.name)
+         LIMIT 100`).all(namePattern, ...filters.params);
+    const seen = new Set(rows.map((row) => row.id));
+    for (const row of nameRows) {
+      if (!seen.has(row.id))
+        rows.push(row);
+    }
+  } else {
+    const likeClauses = tokens.map(() => "f.rel_path LIKE ? ESCAPE '\\'").join(" AND ");
+    const likeParams = tokens.map((t) => `%${t.replace(/[\\%_]/g, "\\$&")}%`);
+    rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files f
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE ${likeClauses}${filters.sql}
+         LIMIT ?`).all(...likeParams, ...filters.params, candidateLimit);
+  }
+  const shortTokens = tokens.filter((t) => t.length < 3).map((t) => t.toLowerCase());
+  const filtered = shortTokens.length > 0 ? rows.filter((row) => shortTokens.every((t) => row.rel_path.toLowerCase().includes(t))) : rows;
+  return filtered.map((row) => rowToHit(row, scoreFileName(query, tokens, row))).sort((a, b) => b.score - a.score).filter((hit) => existsSync3(hit.absPath)).slice(0, limit);
+}
+function findLineMatches(content, query, tokens) {
+  const lines = content.split(`
+`);
+  const phrase = query.trim().toLowerCase();
+  const lowered = tokens.map((t) => t.toLowerCase());
+  const phraseHits = [];
+  const allTokenHits = [];
+  const anyTokenHits = [];
+  for (let i = 0;i < lines.length; i++) {
+    const text = lines[i];
+    const lower = text.toLowerCase();
+    const match = { line: i + 1, text: text.trim().slice(0, MAX_LINE_LENGTH) };
+    if (phrase.length > 0 && lower.includes(phrase))
+      phraseHits.push(match);
+    else if (lowered.every((t) => lower.includes(t)))
+      allTokenHits.push(match);
+    else if (lowered.some((t) => t.length >= 3 && lower.includes(t)))
+      anyTokenHits.push(match);
+    if (phraseHits.length >= MAX_MATCHES_PER_FILE)
+      break;
+  }
+  const tier = phraseHits.length > 0 ? "phrase" : allTokenHits.length > 0 ? "all" : "any";
+  const combined = [...phraseHits, ...allTokenHits, ...anyTokenHits];
+  return { matches: combined.slice(0, MAX_MATCHES_PER_FILE), tier };
+}
+function searchFilePathsRegex(pattern, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const regex = compileSearchRegex(pattern, opts.caseSensitive);
+  const ftsQuery = buildFtsQueryFromRegex(pattern);
+  if (!ftsQuery) {
+    throw new Error("Regex pattern needs at least one required literal of 3+ characters (e.g. 'handle.*Click', not '\\w+').");
+  }
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM files_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE files_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT 5000`).all(ftsQuery, ...filters.params);
+  const hits = [];
+  for (const row of rows) {
+    if (!regex.test(row.rel_path) && !regex.test(row.name))
+      continue;
+    const depth = row.rel_path.split("/").length - 1;
+    const score = Math.max(0.05, 0.6 - depth * 0.02);
+    const hit = rowToHit(row, score);
+    if (!existsSync3(hit.absPath))
+      continue;
+    hits.push(hit);
+    if (hits.length >= limit)
+      break;
+  }
+  return hits;
+}
+function searchFileContentRegex(pattern, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const regex = compileSearchRegex(pattern, opts.caseSensitive);
+  const ftsQuery = buildFtsQueryFromRegex(pattern);
+  if (!ftsQuery) {
+    throw new Error("Regex pattern needs at least one required literal of 3+ characters (e.g. 'export.*function', not '\\d+').");
+  }
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM file_content_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE file_content_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT ?`).all(ftsQuery, ...filters.params, Math.max(200, limit * 10));
+  const hits = [];
+  for (let i = 0;i < rows.length && hits.length < limit; i++) {
+    const row = rows[i];
+    const absPath = `${row.root_path}/${row.rel_path}`;
+    let content;
+    try {
+      content = readFileSync5(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split(`
+`);
+    const matches = [];
+    for (let n = 0;n < lines.length && matches.length < MAX_MATCHES_PER_FILE; n++) {
+      if (regex.test(lines[n])) {
+        matches.push({ line: n + 1, text: lines[n].trim().slice(0, MAX_LINE_LENGTH) });
+      }
+    }
+    if (matches.length === 0)
+      continue;
+    const score = Math.max(0.25, 0.65 - i * 0.05);
+    hits.push({
+      ...rowToHit(row, score),
+      line: matches[0].line,
+      lineText: matches[0].text,
+      matches
+    });
+  }
+  return hits;
+}
+function searchFileContent(query, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery)
+    return [];
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM file_content_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE file_content_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT ?`).all(ftsQuery, ...filters.params, Math.max(50, limit * 3));
+  const tokens = tokenize(query);
+  const shortTokens = tokens.filter((t) => t.length < 3).map((t) => t.toLowerCase());
+  const scored = [];
+  for (let i = 0;i < rows.length && scored.length < limit * 2; i++) {
+    const row = rows[i];
+    const absPath = `${row.root_path}/${row.rel_path}`;
+    let content;
+    try {
+      content = readFileSync5(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (shortTokens.length > 0) {
+      const lower = content.toLowerCase();
+      if (!shortTokens.every((t) => lower.includes(t)))
+        continue;
+    }
+    const { matches, tier } = findLineMatches(content, query, tokens);
+    if (matches.length === 0)
+      continue;
+    const base = Math.max(0.25, 0.55 - i * 0.04);
+    const tierBoost = tier === "phrase" ? 0.1 : tier === "all" ? 0.05 : 0;
+    const score = Math.min(CONTENT_MAX_SCORE, base + tierBoost);
+    scored.push({
+      ...rowToHit(row, score),
+      line: matches[0].line,
+      lineText: matches[0].text,
+      matches
+    });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// src/lib/providers/files.ts
+class FilesProvider {
+  name = "files";
+  displayName = "Local Files";
+  isConfigured() {
+    return hasReadyRoot();
+  }
+  async search(query, options) {
+    autoRefreshStaleRoots();
+    const hits = searchFilePaths(query, { limit: options?.limit ?? 10 });
+    return hits.map((hit) => ({
+      title: hit.name,
+      url: `file://${hit.absPath}`,
+      snippet: hit.absPath,
+      score: hit.score,
+      publishedAt: new Date(hit.mtimeMs).toISOString(),
+      metadata: {
+        root: hit.rootName,
+        relPath: hit.relPath,
+        dir: hit.dir,
+        ext: hit.ext,
+        size: hit.size,
+        isBinary: hit.isBinary
+      }
+    }));
+  }
+}
+
+// src/lib/providers/content.ts
+class ContentProvider {
+  name = "content";
+  displayName = "Local Content";
+  isConfigured() {
+    return hasReadyRoot();
+  }
+  async search(query, options) {
+    autoRefreshStaleRoots();
+    const hits = searchFileContent(query, { limit: options?.limit ?? 10 });
+    return hits.map((hit) => ({
+      title: hit.name,
+      url: `file://${hit.absPath}`,
+      snippet: `${hit.relPath}:${hit.line}: ${hit.lineText}`,
+      score: hit.score,
+      publishedAt: new Date(hit.mtimeMs).toISOString(),
+      metadata: {
+        root: hit.rootName,
+        relPath: hit.relPath,
+        dir: hit.dir,
+        ext: hit.ext,
+        line: hit.line,
+        matches: hit.matches
+      }
+    }));
+  }
+}
+
+// src/lib/providers/index.ts
+var providerFactories = {
+  google: () => new GoogleProvider,
+  serpapi: () => new SerpApiProvider,
+  exa: () => new ExaProvider,
+  perplexity: () => new PerplexityProvider,
+  brave: () => new BraveProvider,
+  bing: () => new BingProvider,
+  twitter: () => new TwitterProvider,
+  reddit: () => new RedditProvider,
+  youtube: () => new YouTubeProvider,
+  hackernews: () => new HackerNewsProvider,
+  github: () => new GitHubProvider,
+  arxiv: () => new ArxivProvider,
+  files: () => new FilesProvider,
+  content: () => new ContentProvider
+};
+var instanceCache = new Map;
+function getProvider2(name) {
+  let provider = instanceCache.get(name);
+  if (!provider) {
+    const factory = providerFactories[name];
+    if (!factory)
+      throw new Error(`Unknown provider: ${name}`);
+    provider = factory();
+    instanceCache.set(name, provider);
+  }
+  return provider;
+}
+
+// src/lib/dedup.ts
+function normalizeUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "file:")
+      return url.replace(/\/+$/, "");
+    u.hostname = u.hostname.toLowerCase();
+    u.pathname = u.pathname.replace(/\/+$/, "") || "/";
+    const params = new URLSearchParams(u.search);
+    const sorted = new URLSearchParams([...params.entries()].sort());
+    u.search = sorted.toString();
+    u.searchParams.delete("utm_source");
+    u.searchParams.delete("utm_medium");
+    u.searchParams.delete("utm_campaign");
+    u.searchParams.delete("utm_content");
+    u.searchParams.delete("utm_term");
+    u.searchParams.delete("ref");
+    u.searchParams.delete("fbclid");
+    u.searchParams.delete("gclid");
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return url.toLowerCase().replace(/\/+$/, "");
+  }
+}
+function deduplicateResults(results) {
+  const groups = new Map;
+  for (const result of results) {
+    const key = normalizeUrl(result.url);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(result);
+    } else {
+      groups.set(key, [result]);
+    }
+  }
+  const deduped = [];
+  for (const group of groups.values()) {
+    if (group.length === 1) {
+      deduped.push(group[0]);
+      continue;
+    }
+    group.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const best = group[0];
+    const mergedMetadata = { ...best.metadata };
+    for (let i = 1;i < group.length; i++) {
+      const dup = group[i];
+      mergedMetadata[`also_found_on_${dup.source}`] = true;
+      if (dup.snippet.length > best.snippet.length) {
+        best.snippet = dup.snippet;
+      }
+    }
+    best.metadata = mergedMetadata;
+    deduped.push(best);
+  }
+  deduped.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  deduped.forEach((r, i) => {
+    r.rank = i + 1;
+  });
+  return deduped;
+}
+
+// src/lib/search.ts
+async function unifiedSearch(query, opts = {}) {
   const config = getConfig();
-  config[key] = value;
-  return setConfig(config);
+  const startTime = Date.now();
+  const db = opts.db;
+  let providerNames = opts.providers ?? [];
+  if (opts.profile) {
+    const profile = getProfileByName(opts.profile, db);
+    if (profile) {
+      providerNames = profile.providers;
+    }
+  }
+  if (providerNames.length === 0) {
+    if (config.defaultProviders.length > 0) {
+      providerNames = config.defaultProviders;
+    } else {
+      const dbProviders = listProviders(db);
+      providerNames = dbProviders.filter((p) => p.enabled).map((p) => p.name);
+    }
+  }
+  const errors2 = [];
+  const explicitRequest = (opts.providers?.length ?? 0) > 0 || Boolean(opts.profile);
+  const activeProviders = providerNames.filter((name) => {
+    try {
+      if (getProvider2(name).isConfigured())
+        return true;
+      if (explicitRequest) {
+        errors2.push({
+          provider: name,
+          error: LOCAL_PROVIDER_NAMES.has(name) ? "no index roots ready \u2014 run `search index add <path>` first" : "not configured (missing API key)"
+        });
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  });
+  const searchOptions = {
+    limit: config.defaultLimit,
+    ...opts.options
+  };
+  const results = await Promise.allSettled(activeProviders.map(async (name) => {
+    const provider = getProvider2(name);
+    const rawResults = await provider.search(query, searchOptions);
+    updateProviderLastUsed(name, db);
+    return { name, results: rawResults };
+  }));
+  const allResults = [];
+  const searchId = generateId();
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      const { name, results: rawResults } = result.value;
+      const provider = getProvider2(name);
+      for (let i = 0;i < rawResults.length; i++) {
+        const raw = rawResults[i];
+        allResults.push({
+          id: generateId(),
+          searchId,
+          title: raw.title,
+          url: raw.url,
+          snippet: raw.snippet,
+          source: name,
+          provider: provider.displayName,
+          rank: i + 1,
+          score: raw.score ?? null,
+          publishedAt: raw.publishedAt ?? null,
+          thumbnail: raw.thumbnail ?? null,
+          metadata: raw.metadata ?? {},
+          createdAt: new Date().toISOString()
+        });
+      }
+    } else {
+      const providerName = activeProviders[results.indexOf(result)];
+      errors2.push({
+        provider: providerName,
+        error: result.reason?.message ?? "Unknown error"
+      });
+    }
+  }
+  const shouldDedup = opts.dedup ?? config.dedup;
+  const finalResults = shouldDedup ? deduplicateResults(allResults) : allResults;
+  if (!shouldDedup) {
+    finalResults.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    finalResults.forEach((r, i) => {
+      r.rank = i + 1;
+    });
+  }
+  const duration = Date.now() - startTime;
+  if (activeProviders.length === 0) {
+    return {
+      search: {
+        id: searchId,
+        query,
+        providers: [],
+        profileId: null,
+        resultCount: 0,
+        duration,
+        createdAt: new Date().toISOString()
+      },
+      results: finalResults,
+      errors: errors2
+    };
+  }
+  const persistable = config.recordLocalResults ? finalResults : finalResults.filter((r) => !LOCAL_PROVIDER_NAMES.has(r.source));
+  const search = createSearch({
+    query,
+    providers: activeProviders,
+    resultCount: persistable.length,
+    duration
+  }, db);
+  if (persistable.length > 0) {
+    createResults(persistable.map((r) => ({
+      searchId: search.id,
+      title: r.title,
+      url: r.url,
+      snippet: r.snippet,
+      source: r.source,
+      provider: r.provider,
+      rank: r.rank,
+      score: r.score,
+      publishedAt: r.publishedAt,
+      thumbnail: r.thumbnail,
+      metadata: r.metadata
+    })), db);
+  }
+  updateSearchResults(search.id, persistable.length, duration, db);
+  return {
+    search: { ...search, resultCount: finalResults.length, duration },
+    results: finalResults,
+    errors: errors2
+  };
+}
+async function searchSingleProvider(provider, query, options, db) {
+  return unifiedSearch(query, {
+    providers: [provider],
+    options,
+    dedup: false,
+    db
+  });
+}
+// src/lib/export.ts
+function exportResults(searchId, format, db) {
+  const search = getSearch(searchId, db);
+  if (!search)
+    throw new Error(`Search not found: ${searchId}`);
+  const results = listResults(searchId, { limit: 1000 }, db);
+  switch (format) {
+    case "json":
+      return exportJson(results);
+    case "csv":
+      return exportCsv(results);
+    case "md":
+      return exportMarkdown(results, search.query);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function exportJson(results) {
+  return JSON.stringify(results, null, 2);
+}
+function exportCsv(results) {
+  const headers = ["rank", "title", "url", "snippet", "source", "provider", "score", "published_at"];
+  const lines = [headers.join(",")];
+  for (const r of results) {
+    const row = [
+      r.rank,
+      csvEscape(r.title),
+      csvEscape(r.url),
+      csvEscape(r.snippet),
+      r.source,
+      r.provider,
+      r.score ?? "",
+      r.publishedAt ?? ""
+    ];
+    lines.push(row.join(","));
+  }
+  return lines.join(`
+`);
+}
+function exportMarkdown(results, query) {
+  const lines = [];
+  lines.push(`# Search Results: ${query}`);
+  lines.push("");
+  lines.push(`*${results.length} results*`);
+  lines.push("");
+  for (const r of results) {
+    lines.push(`## ${r.rank}. ${r.title}`);
+    lines.push("");
+    lines.push(`**Source:** ${r.provider} | **URL:** ${r.url}`);
+    if (r.publishedAt)
+      lines.push(`**Published:** ${r.publishedAt}`);
+    if (r.score !== null)
+      lines.push(`**Score:** ${r.score.toFixed(3)}`);
+    lines.push("");
+    if (r.snippet) {
+      lines.push(`> ${r.snippet}`);
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes(`
+`)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+// src/lib/local/find.ts
+function findLocal(query, opts = {}, db) {
+  const kind = opts.kind ?? "both";
+  if (kind !== "file" && kind !== "content" && kind !== "both") {
+    throw new Error(`Invalid kind "${kind}" \u2014 use file, content, or both.`);
+  }
+  const limit = clampLimit(opts.limit);
+  const roots = listRoots(db);
+  if (!hasReadyRoot(db)) {
+    return { query, kind, indexed: false, roots: roots.length, total: 0, results: [] };
+  }
+  if (opts.refresh !== false)
+    autoRefreshStaleRoots(db);
+  const queryOpts = {
+    root: opts.root,
+    ext: opts.ext,
+    dir: opts.dir,
+    limit
+  };
+  const merged = new Map;
+  const pathSearch = opts.regex ? () => searchFilePathsRegex(query, { ...queryOpts, caseSensitive: opts.caseSensitive }, db) : () => searchFilePaths(query, queryOpts, db);
+  const contentSearch = opts.regex ? () => searchFileContentRegex(query, { ...queryOpts, caseSensitive: opts.caseSensitive }, db) : () => searchFileContent(query, queryOpts, db);
+  if (kind === "file" || kind === "both") {
+    for (const hit of pathSearch()) {
+      merged.set(hit.absPath, {
+        path: hit.absPath,
+        root: hit.rootName,
+        kind: "file",
+        score: hit.score,
+        snippet: hit.relPath
+      });
+    }
+  }
+  if (kind === "content" || kind === "both") {
+    for (const hit of contentSearch()) {
+      const existing = merged.get(hit.absPath);
+      if (existing) {
+        existing.kind = "both";
+        existing.score = Math.min(1, Math.max(existing.score, hit.score) + 0.1);
+        existing.line = hit.line;
+        existing.snippet = hit.lineText;
+        existing.matches = hit.matches;
+      } else {
+        merged.set(hit.absPath, {
+          path: hit.absPath,
+          root: hit.rootName,
+          kind: "content",
+          score: hit.score,
+          line: hit.line,
+          snippet: hit.lineText,
+          matches: hit.matches
+        });
+      }
+    }
+  }
+  const results = [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+  return {
+    query,
+    kind,
+    indexed: true,
+    roots: roots.length,
+    total: results.length,
+    results
+  };
 }
 export {
   updateSearchResults,
   updateSavedSearchLastRun,
   updateProviderLastUsed,
   updateProvider,
-  syncCloudChanges,
+  unifiedSearch,
+  syncStorageChanges,
   setConfigValue,
   setConfig,
+  searchSingleProvider,
   searchResultsFts,
-  runCloudMigrations,
+  searchFilePaths,
+  searchFileContent,
+  runStorageMigrations,
   resetConfig,
-  pushCloudChanges,
-  pullCloudChanges,
-  parseCloudTables,
+  removeRoot,
+  refreshStaleRoots,
+  pushStorageChanges,
+  pullStorageChanges,
+  parseStorageTables,
+  normalizeRootPath,
   listSearches,
   listSavedSearches,
+  listRoots,
   listResults,
   listProviders,
   listProfiles,
   isProviderConfigured,
+  indexRoot,
+  indexAllRoots,
+  hasReadyRoot,
+  getStorageStatus,
+  getStoragePg,
+  getStorageDatabaseUrl,
+  getStorageDatabaseEnvName,
+  getStorageDatabaseEnv,
+  getStorageConnectionString,
+  getStorageConfig,
   getSearchStats,
   getSearch,
   getSavedSearch,
+  getRoot,
   getResult,
   getProvider,
   getProfileByName,
   getProfile,
+  getIndexDbPath,
+  getIndexDbForTesting,
+  getIndexDb,
   getDbForTesting,
   getDb,
-  getConnectionString,
   getConfigValue,
   getConfig,
-  getCloudStatus,
-  getCloudPg,
-  getCloudConfig,
   generateId,
+  findLocal,
+  exportResults,
   enableProvider,
   disableProvider,
   deleteSearch,
@@ -10021,18 +12352,28 @@ export {
   createResults,
   createResult,
   createProfile,
+  closeIndexDb,
   closeDb,
+  autoRefreshStaleRoots,
   applyPgMigrations,
+  addRoot,
   ValidationError,
   SearchProviderNameSchema,
   SearchOptionsSchema,
   SearchError,
+  STORAGE_TABLES,
+  STORAGE_MODE_ENV,
+  STORAGE_DATABASE_ENV,
+  SEARCH_STORAGE_MODE_FALLBACK_ENV,
+  SEARCH_STORAGE_MODE_ENV,
+  SEARCH_STORAGE_FALLBACK_ENV,
+  SEARCH_STORAGE_ENV,
   ProviderError,
   PgAdapterAsync,
   PROVIDER_NAMES,
   NotFoundError,
+  LOCAL_PROVIDER_NAMES,
   ExportFormatSchema,
   EXPORT_FORMATS,
-  DEFAULT_CONFIG,
-  CLOUD_TABLES
+  DEFAULT_CONFIG
 };