@buildautomaton/cli 0.1.67 → 0.1.69

package/dist/symbol-index-worker.js

@@ -0,0 +1,4609 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/runtime/cli-process-interrupt.ts
+function isCliImmediateShutdownRequested() {
+  return cliImmediateShutdownRequested;
+}
+var cliImmediateShutdownRequested;
+var init_cli_process_interrupt = __esm({
+  "src/runtime/cli-process-interrupt.ts"() {
+    "use strict";
+    cliImmediateShutdownRequested = false;
+  }
+});
+
+// src/paths/normalize-resolved-path.ts
+import fs from "node:fs";
+import path from "node:path";
+function normalizeResolvedPath(resolved) {
+  const abs = path.resolve(resolved);
+  try {
+    return fs.realpathSync.native(abs);
+  } catch {
+    return abs;
+  }
+}
+var init_normalize_resolved_path = __esm({
+  "src/paths/normalize-resolved-path.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/yield-to-event-loop.ts
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+var init_yield_to_event_loop = __esm({
+  "src/runtime/yield-to-event-loop.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/sqlite-errors.ts
+function isCliSqliteLockError(e) {
+  if (e instanceof CliSqliteInterrupted) return false;
+  const msg = e instanceof Error ? e.message : String(e);
+  const lower = msg.toLowerCase();
+  return lower.includes("database is locked") || lower.includes("sqlite_busy") || lower.includes("sqlite3_busy") || lower.includes("database") && lower.includes("locked");
+}
+var CliSqliteInterrupted;
+var init_sqlite_errors = __esm({
+  "src/sqlite/sqlite-errors.ts"() {
+    "use strict";
+    CliSqliteInterrupted = class extends Error {
+      name = "CliSqliteInterrupted";
+      constructor() {
+        super("CLI SQLite interrupted (shutdown)");
+      }
+    };
+  }
+});
+
+// src/sqlite/sqlite-pragmas.ts
+function applySqliteConcurrencyPragmas(db) {
+  try {
+    db.run("PRAGMA foreign_keys = ON");
+  } catch {
+  }
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA synchronous = NORMAL");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA busy_timeout = 500");
+  } catch {
+  }
+}
+function applySqliteMemoryPragmas(db) {
+  try {
+    db.run("PRAGMA cache_size = -8192");
+    db.run("PRAGMA temp_store = FILE");
+  } catch {
+  }
+}
+var init_sqlite_pragmas = __esm({
+  "src/sqlite/sqlite-pragmas.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/sqlite-lock-retry.ts
+function syncSleepMs(ms) {
+  if (ms <= 0) return;
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(10, deadline - Date.now());
+    if (chunk <= 0) break;
+    try {
+      const sab = new SharedArrayBuffer(4);
+      const ia = new Int32Array(sab);
+      Atomics.wait(ia, 0, 0, chunk);
+    } catch {
+      const end = Date.now() + chunk;
+      while (Date.now() < end) {
+        if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      }
+    }
+  }
+}
+async function asyncDelayMsInterruptible(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(50, end - Date.now());
+    if (chunk <= 0) break;
+    await new Promise((r) => setTimeout(r, chunk));
+    await yieldToEventLoop();
+  }
+}
+var SYNC_RETRY_MAX, ASYNC_RETRY_MAX, ASYNC_BASE_DELAY_MS;
+var init_sqlite_lock_retry = __esm({
+  "src/sqlite/sqlite-lock-retry.ts"() {
+    "use strict";
+    init_cli_process_interrupt();
+    init_yield_to_event_loop();
+    init_sqlite_errors();
+    SYNC_RETRY_MAX = 40;
+    ASYNC_RETRY_MAX = 60;
+    ASYNC_BASE_DELAY_MS = 20;
+  }
+});
+
+// src/sqlite/create-sqlite-database-access.ts
+import sqliteWasm from "node-sqlite3-wasm";
+function createSqliteDatabaseAccess(config) {
+  let migrateDoneForPath = null;
+  function shouldSkipMigrate(sqlitePath, db) {
+    if (migrateDoneForPath !== sqlitePath) return false;
+    try {
+      const row = db.get(
+        "SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='__migrations' LIMIT 1"
+      );
+      return row != null;
+    } catch {
+      return false;
+    }
+  }
+  function safeClose(db) {
+    if (db == null) return;
+    try {
+      if (db.isOpen) db.close();
+    } catch {
+    }
+  }
+  function openConnection(options) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const sqlitePath = config.getPath();
+    config.ensureParentDir(sqlitePath);
+    const db = new SqliteDatabase(sqlitePath);
+    try {
+      applySqliteConcurrencyPragmas(db);
+      applySqliteMemoryPragmas(db);
+      const sqlitePath2 = config.getPath();
+      if (!shouldSkipMigrate(sqlitePath2, db)) {
+        config.migrate(db);
+        migrateDoneForPath = sqlitePath2;
+      }
+      config.afterOpen?.(db, options);
+    } catch (e) {
+      safeClose(db);
+      throw e;
+    }
+    return db;
+  }
+  function withSync(fn, options) {
+    for (let attempt = 1; attempt <= SYNC_RETRY_MAX; attempt++) {
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      let db;
+      try {
+        db = openConnection(options);
+        try {
+          return fn(db);
+        } finally {
+          safeClose(db);
+        }
+      } catch (e) {
+        safeClose(db);
+        if (e instanceof CliSqliteInterrupted) throw e;
+        if (!isCliSqliteLockError(e) || attempt === SYNC_RETRY_MAX) throw e;
+        syncSleepMs(Math.min(500, 12 * attempt));
+      }
+    }
+    throw new Error("withSqliteSync: exhausted retries");
+  }
+  async function withAsync(fn, options) {
+    let lastError;
+    for (let attempt = 1; attempt <= ASYNC_RETRY_MAX; attempt++) {
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      let db;
+      try {
+        db = openConnection(options);
+        try {
+          return await Promise.resolve(fn(db));
+        } finally {
+          safeClose(db);
+        }
+      } catch (e) {
+        lastError = e;
+        safeClose(db);
+        if (e instanceof CliSqliteInterrupted) throw e;
+        if (!isCliSqliteLockError(e) || attempt === ASYNC_RETRY_MAX) throw e;
+        const delayMs = Math.min(600, ASYNC_BASE_DELAY_MS * attempt);
+        await asyncDelayMsInterruptible(delayMs);
+        await yieldToEventLoop();
+      }
+    }
+    if (lastError instanceof Error) throw lastError;
+    throw new Error(String(lastError));
+  }
+  async function ensureInitialized(options) {
+    await withAsync(() => void 0, options);
+  }
+  function closeAllConnections() {
+    migrateDoneForPath = null;
+  }
+  return {
+    safeClose,
+    openConnection,
+    withSync,
+    withAsync,
+    ensureInitialized,
+    closeAllConnections
+  };
+}
+var SqliteDatabase;
+var init_create_sqlite_database_access = __esm({
+  "src/sqlite/create-sqlite-database-access.ts"() {
+    "use strict";
+    init_yield_to_event_loop();
+    init_cli_process_interrupt();
+    init_sqlite_errors();
+    init_sqlite_pragmas();
+    init_sqlite_lock_retry();
+    ({ Database: SqliteDatabase } = sqliteWasm);
+  }
+});
+
+// src/sqlite/code-nav-cache/code-nav-cache-paths.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import os from "node:os";
+function getCodeNavCacheSqlitePath() {
+  const override = process.env.BUILDAMATON_CODE_NAV_CACHE_SQLITE_PATH?.trim();
+  if (override) return path2.resolve(override);
+  return path2.join(os.homedir(), ".buildautomaton", "code-nav-cache.sqlite");
+}
+function ensureCodeNavCacheSqliteParentDir(sqlitePath) {
+  const dir = path2.dirname(sqlitePath);
+  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+}
+var init_code_nav_cache_paths = __esm({
+  "src/sqlite/code-nav-cache/code-nav-cache-paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/read-migration-sql.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function readMigrationSql(filename, ...searchSubdirs) {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = searchSubdirs.flatMap((sub) => [
+    join(moduleDir, sub, filename),
+    join(moduleDir, "..", sub, filename),
+    join(moduleDir, "..", "..", "dist", sub, filename)
+  ]);
+  const resolved = candidates.find((path16) => existsSync(path16));
+  if (!resolved) {
+    throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
+  }
+  return readFileSync(resolved, "utf8");
+}
+function readCliSqliteMigrationSql(filename) {
+  return readMigrationSql(filename, "migrations");
+}
+function readCodeNavCacheMigrationSql(filename) {
+  return readMigrationSql(filename, "code-nav-cache-migrations", "code-nav-cache/migrations");
+}
+var init_read_migration_sql = __esm({
+  "src/sqlite/read-migration-sql.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/run-sqlite-migrations.ts
+function checkpointSatisfiedByLegacyChain(applied, replacesLegacyMigrations) {
+  return Array.isArray(replacesLegacyMigrations) && replacesLegacyMigrations.length > 0 && replacesLegacyMigrations.every((n) => applied.has(n));
+}
+function recordMigrationAndPruneCheckpointLegacy(db, migration, applied) {
+  db.run("INSERT INTO __migrations (name) VALUES (?)", [migration.name]);
+  applied.add(migration.name);
+  if (migration.checkpoint !== true) return;
+  const legacy = migration.replacesLegacyMigrations;
+  if (!legacy?.length) return;
+  for (const legacyName of legacy) {
+    if (legacyName === migration.name) continue;
+    db.run("DELETE FROM __migrations WHERE name = ?", [legacyName]);
+    applied.delete(legacyName);
+  }
+}
+function runSqliteMigrations(db, migrations, bootstrapSql, label) {
+  db.exec(bootstrapSql);
+  const appliedRows = db.all("SELECT name FROM __migrations");
+  const applied = new Set(appliedRows.map((r) => r.name));
+  for (const migration of migrations) {
+    if (applied.has(migration.name)) continue;
+    if (migration.checkpoint === true && checkpointSatisfiedByLegacyChain(applied, migration.replacesLegacyMigrations)) {
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied);
+      continue;
+    }
+    if (migration.alreadyApplied?.(db)) {
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied);
+      continue;
+    }
+    try {
+      migration.migrate(db);
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied);
+    } catch (e) {
+      console.error(`[${label}] Migration failed: ${migration.name}`, e);
+      throw e;
+    }
+  }
+}
+var init_run_sqlite_migrations = __esm({
+  "src/sqlite/run-sqlite-migrations.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/code-nav-cache/migrate-code-nav-cache-sqlite.ts
+function migrateCodeNavCacheSqlite(db) {
+  runSqliteMigrations(
+    db,
+    CODE_NAV_CACHE_SQLITE_MIGRATIONS,
+    readCodeNavCacheMigrationSql("000_bootstrap_migrations_table.sql"),
+    "code-nav-cache"
+  );
+}
+var CHECKPOINT_V1, CHECKPOINT_V1_SQL, MIGRATION_002, MIGRATION_002_SQL, MIGRATION_003, MIGRATION_003_SQL, CODE_NAV_CACHE_SQLITE_MIGRATIONS;
+var init_migrate_code_nav_cache_sqlite = __esm({
+  "src/sqlite/code-nav-cache/migrate-code-nav-cache-sqlite.ts"() {
+    "use strict";
+    init_read_migration_sql();
+    init_run_sqlite_migrations();
+    CHECKPOINT_V1 = "001_code_nav_cache_checkpoint_v1";
+    CHECKPOINT_V1_SQL = readCodeNavCacheMigrationSql("001_code_nav_cache_checkpoint_v1.sql");
+    MIGRATION_002 = "002_content_hash_symbol_index";
+    MIGRATION_002_SQL = readCodeNavCacheMigrationSql("002_content_hash_symbol_index.sql");
+    MIGRATION_003 = "003_content_hash_tag_rows";
+    MIGRATION_003_SQL = readCodeNavCacheMigrationSql("003_content_hash_tag_rows.sql");
+    CODE_NAV_CACHE_SQLITE_MIGRATIONS = [
+      {
+        name: CHECKPOINT_V1,
+        checkpoint: true,
+        migrate: (db) => {
+          db.exec(CHECKPOINT_V1_SQL);
+        },
+        alreadyApplied: (db) => {
+          const row = db.get(
+            `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='file_index_parent_path' LIMIT 1`
+          );
+          return row != null;
+        }
+      },
+      {
+        name: MIGRATION_002,
+        migrate: (db) => {
+          db.exec(MIGRATION_002_SQL);
+        },
+        alreadyApplied: (db) => {
+          const row = db.get(
+            `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
+          );
+          return row != null;
+        }
+      },
+      {
+        name: MIGRATION_003,
+        migrate: (db) => {
+          db.exec(MIGRATION_003_SQL);
+        },
+        alreadyApplied: (db) => {
+          const row = db.get(
+            `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_index_tag' LIMIT 1`
+          );
+          if (row == null) return false;
+          const blob = db.get(
+            `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
+          );
+          return blob == null;
+        }
+      }
+    ];
+  }
+});
+
+// src/sqlite/code-nav-cache/code-nav-cache-sqlite-work-lock.ts
+import fs3 from "node:fs";
+function isSqliteCorruptError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
+}
+function withCodeNavCacheSqliteWorkLock(fn) {
+  if (workLockDepth > 0) {
+    return Promise.resolve(fn());
+  }
+  const run = async () => {
+    workLockDepth += 1;
+    try {
+      return await Promise.resolve(fn());
+    } finally {
+      workLockDepth = Math.max(0, workLockDepth - 1);
+    }
+  };
+  const runWithCorruptRecovery = async () => {
+    try {
+      return await run();
+    } catch (e) {
+      if (!isSqliteCorruptError(e)) throw e;
+      try {
+        fs3.unlinkSync(getCodeNavCacheSqlitePath());
+      } catch {
+      }
+      chain = Promise.resolve();
+      return await run();
+    }
+  };
+  const next = chain.then(runWithCorruptRecovery);
+  chain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+var chain, workLockDepth;
+var init_code_nav_cache_sqlite_work_lock = __esm({
+  "src/sqlite/code-nav-cache/code-nav-cache-sqlite-work-lock.ts"() {
+    "use strict";
+    init_code_nav_cache_paths();
+    chain = Promise.resolve();
+    workLockDepth = 0;
+  }
+});
+
+// src/sqlite/code-nav-cache/code-nav-cache-database.ts
+async function waitForOuterCodeNavCacheAccessAsync() {
+  while (codeNavCacheAccessDepth > 0) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    await yieldToEventLoop();
+  }
+}
+async function withCodeNavCacheSqlite(fn) {
+  return withCodeNavCacheSqliteWorkLock(async () => {
+    const nested = codeNavCacheAccessDepth > 0;
+    if (!nested) await waitForOuterCodeNavCacheAccessAsync();
+    codeNavCacheAccessDepth += 1;
+    try {
+      return await codeNavCacheSqlite.withAsync(fn);
+    } finally {
+      codeNavCacheAccessDepth = Math.max(0, codeNavCacheAccessDepth - 1);
+    }
+  });
+}
+var codeNavCacheSqlite, codeNavCacheAccessDepth, safeCloseCodeNavCacheSqliteDatabase, openCodeNavCacheSqliteConnection;
+var init_code_nav_cache_database = __esm({
+  "src/sqlite/code-nav-cache/code-nav-cache-database.ts"() {
+    "use strict";
+    init_yield_to_event_loop();
+    init_cli_process_interrupt();
+    init_create_sqlite_database_access();
+    init_sqlite_errors();
+    init_code_nav_cache_paths();
+    init_migrate_code_nav_cache_sqlite();
+    init_code_nav_cache_sqlite_work_lock();
+    init_sqlite_errors();
+    codeNavCacheSqlite = createSqliteDatabaseAccess({
+      getPath: getCodeNavCacheSqlitePath,
+      ensureParentDir: ensureCodeNavCacheSqliteParentDir,
+      migrate: migrateCodeNavCacheSqlite
+    });
+    codeNavCacheAccessDepth = 0;
+    safeCloseCodeNavCacheSqliteDatabase = codeNavCacheSqlite.safeClose;
+    openCodeNavCacheSqliteConnection = codeNavCacheSqlite.openConnection;
+  }
+});
+
+// src/sqlite/code-nav-cache/code-nav-cache-sqlite-transaction.ts
+function runCodeNavCacheWriteTransaction(db, fn) {
+  db.run("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.run("COMMIT");
+    return result;
+  } catch (e) {
+    try {
+      db.run("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
+var init_code_nav_cache_sqlite_transaction = __esm({
+  "src/sqlite/code-nav-cache/code-nav-cache-sqlite-transaction.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/deferred-indexing.ts
+function isSymbolIndexDeferredError(err) {
+  return err instanceof SymbolIndexDeferredError;
+}
+var SymbolIndexDeferredError;
+var init_deferred_indexing = __esm({
+  "src/code-nav/symbol-index/deferred-indexing.ts"() {
+    "use strict";
+    SymbolIndexDeferredError = class extends Error {
+      constructor() {
+        super("Symbol indexing deferred for file browser");
+        this.name = "SymbolIndexDeferredError";
+      }
+    };
+  }
+});
+
+// src/files/browser/file-browser-in-flight.ts
+function registerFileBrowserActivityListener(listener) {
+  activityListeners.add(listener);
+  return () => {
+    activityListeners.delete(listener);
+  };
+}
+function fileBrowserRequestInFlight() {
+  return inFlightFileBrowserRequests > 0;
+}
+function isBridgeBrowseInteractiveActive() {
+  if (fileBrowserRequestInFlight()) return true;
+  return Date.now() - lastBrowseActivityAt < BROWSE_INDEX_COOLDOWN_MS;
+}
+function assertBackgroundIndexingAllowed() {
+  if (isBridgeBrowseInteractiveActive()) throw new SymbolIndexDeferredError();
+}
+async function yieldUntilFileBrowserIdle(pollMs = 5) {
+  while (isBridgeBrowseInteractiveActive()) {
+    await yieldToEventLoop();
+    if (isBridgeBrowseInteractiveActive()) {
+      await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+  }
+}
+async function yieldForBridgeInteractivePriority() {
+  await yieldToEventLoop();
+  await yieldUntilFileBrowserIdle();
+}
+var BROWSE_INDEX_COOLDOWN_MS, inFlightFileBrowserRequests, lastBrowseActivityAt, activityListeners;
+var init_file_browser_in_flight = __esm({
+  "src/files/browser/file-browser-in-flight.ts"() {
+    "use strict";
+    init_yield_to_event_loop();
+    init_deferred_indexing();
+    BROWSE_INDEX_COOLDOWN_MS = 2500;
+    inFlightFileBrowserRequests = 0;
+    lastBrowseActivityAt = 0;
+    activityListeners = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/code-nav/yield-during-work.ts
+function createCodeNavYieldState() {
+  return { n: 0 };
+}
+async function yieldDuringCodeNavWork(state) {
+  state.n++;
+  if (state.n % CODE_NAV_YIELD_EVERY !== 0) return;
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+  await yieldForBridgeInteractivePriority();
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+}
+var CODE_NAV_YIELD_EVERY;
+var init_yield_during_work = __esm({
+  "src/code-nav/yield-during-work.ts"() {
+    "use strict";
+    init_cli_process_interrupt();
+    init_file_browser_in_flight();
+    init_code_nav_cache_database();
+    CODE_NAV_YIELD_EVERY = 64;
+  }
+});
+
+// src/sqlite/cli-sqlite-paths.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+import os2 from "node:os";
+function getCliSqlitePath() {
+  const override = process.env.BUILDAMATON_CLI_SQLITE_PATH?.trim();
+  if (override) return path3.resolve(override);
+  return path3.join(os2.homedir(), ".buildautomaton", "cli.sqlite");
+}
+function ensureCliSqliteParentDir(sqlitePath) {
+  const dir = path3.dirname(sqlitePath);
+  if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+}
+var init_cli_sqlite_paths = __esm({
+  "src/sqlite/cli-sqlite-paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/files/index/constants.ts
+import path4 from "node:path";
+import os3 from "node:os";
+var INDEX_WORK_YIELD_EVERY, INDEX_DIR, INDEX_HASH_LEN;
+var init_constants = __esm({
+  "src/files/index/constants.ts"() {
+    "use strict";
+    INDEX_WORK_YIELD_EVERY = 128;
+    INDEX_DIR = path4.join(os3.homedir(), ".buildautomaton");
+    INDEX_HASH_LEN = 16;
+  }
+});
+
+// src/prompt-turn-queue/paths.ts
+import path5 from "node:path";
+import os4 from "node:os";
+function getPromptQueuesDirectory() {
+  const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
+  if (override) return path5.resolve(override);
+  return path5.join(os4.homedir(), ".buildautomaton", "queues");
+}
+var init_paths = __esm({
+  "src/prompt-turn-queue/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/legacy_migration/archive-to-old-version.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+function moveLegacyFileToOldVersionBackup(category, sourcePath) {
+  const destDir = path6.join(OLD_VERSION_DIR, category);
+  fs5.mkdirSync(destDir, { recursive: true });
+  const base = path6.basename(sourcePath);
+  let dest = path6.join(destDir, base);
+  if (fs5.existsSync(dest)) {
+    const ext = path6.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    dest = path6.join(destDir, `${stem}-${Date.now()}${ext}`);
+  }
+  fs5.renameSync(sourcePath, dest);
+}
+var OLD_VERSION_DIR;
+var init_archive_to_old_version = __esm({
+  "src/sqlite/legacy_migration/archive-to-old-version.ts"() {
+    "use strict";
+    init_constants();
+    OLD_VERSION_DIR = path6.join(INDEX_DIR, "old-version");
+  }
+});
+
+// src/sqlite/legacy_migration/archive-file-index-json.ts
+import fs6 from "node:fs";
+import path7 from "node:path";
+function archiveLegacyFileIndexJsonFiles() {
+  try {
+    if (!fs6.existsSync(INDEX_DIR)) return;
+    for (const name of fs6.readdirSync(INDEX_DIR)) {
+      if (name.startsWith(".file-index-") && name.endsWith(".json")) {
+        const full = path7.join(INDEX_DIR, name);
+        try {
+          moveLegacyFileToOldVersionBackup("file-index", full);
+        } catch (err) {
+          console.error(`[cli-sqlite] legacy import: could not archive ${name}`, err);
+        }
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: archive file-index json failed", e);
+  }
+}
+var init_archive_file_index_json = __esm({
+  "src/sqlite/legacy_migration/archive-file-index-json.ts"() {
+    "use strict";
+    init_constants();
+    init_archive_to_old_version();
+  }
+});
+
+// src/sqlite/legacy_migration/import-agent-sessions-from-disk.ts
+import fs7 from "node:fs";
+import path8 from "node:path";
+import os5 from "node:os";
+function importLegacyAgentSessionsFromDisk(db) {
+  try {
+    if (!fs7.existsSync(LEGACY_AGENT_SESSION_DIR)) return;
+    const names = fs7.readdirSync(LEGACY_AGENT_SESSION_DIR).filter((n) => n.endsWith(".json"));
+    for (const name of names) {
+      const sessionKey = name.slice(0, -".json".length);
+      const full = path8.join(LEGACY_AGENT_SESSION_DIR, name);
+      let raw;
+      try {
+        raw = fs7.readFileSync(full, "utf8");
+      } catch {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (parsed.v !== 1) continue;
+      const acpSessionId = typeof parsed.acpSessionId === "string" ? parsed.acpSessionId : null;
+      const backendAgentType = typeof parsed.backendAgentType === "string" ? parsed.backendAgentType : null;
+      const configOptionsJson = Array.isArray(parsed.configOptions) ? JSON.stringify(parsed.configOptions) : null;
+      const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
+      db.run(
+        `INSERT OR REPLACE INTO agent_session (session_key, acp_session_id, backend_agent_type, config_options_json, updated_at)
+         VALUES (?, ?, ?, ?, ?)`,
+        [sessionKey, acpSessionId, backendAgentType, configOptionsJson, updatedAt]
+      );
+      try {
+        moveLegacyFileToOldVersionBackup("agent-sessions", full);
+      } catch {
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: agent_sessions from disk failed", e);
+  }
+}
+var LEGACY_AGENT_SESSION_DIR;
+var init_import_agent_sessions_from_disk = __esm({
+  "src/sqlite/legacy_migration/import-agent-sessions-from-disk.ts"() {
+    "use strict";
+    init_archive_to_old_version();
+    LEGACY_AGENT_SESSION_DIR = path8.join(os5.homedir(), ".buildautomaton", "agent-sessions");
+  }
+});
+
+// src/sqlite/legacy_migration/parse-persisted-queue-json.ts
+function parsePersistedQueueFromJson(raw) {
+  try {
+    const o = JSON.parse(raw);
+    const queueKey = typeof o.queueKey === "string" ? o.queueKey : typeof o.queueKeyHash === "string" ? o.queueKeyHash : null;
+    if (!queueKey || typeof o.updatedAt !== "string" || !Array.isArray(o.turns)) return null;
+    return { queueKey, updatedAt: o.updatedAt, turns: o.turns };
+  } catch {
+    return null;
+  }
+}
+var init_parse_persisted_queue_json = __esm({
+  "src/sqlite/legacy_migration/parse-persisted-queue-json.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts
+import fs8 from "node:fs";
+import path9 from "node:path";
+function importLegacyPromptQueuesFromDisk(db) {
+  try {
+    const dir = getPromptQueuesDirectory();
+    if (!fs8.existsSync(dir)) return;
+    for (const name of fs8.readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const full = path9.join(dir, name);
+      let raw;
+      try {
+        raw = fs8.readFileSync(full, "utf8");
+      } catch {
+        continue;
+      }
+      const file = parsePersistedQueueFromJson(raw);
+      if (!file) continue;
+      db.run(
+        `INSERT OR REPLACE INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)`,
+        [file.queueKey, file.updatedAt, JSON.stringify(file.turns)]
+      );
+      try {
+        moveLegacyFileToOldVersionBackup("queues", full);
+      } catch {
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: prompt queues from disk failed", e);
+  }
+}
+var init_import_prompt_queues_from_disk = __esm({
+  "src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts"() {
+    "use strict";
+    init_paths();
+    init_archive_to_old_version();
+    init_parse_persisted_queue_json();
+  }
+});
+
+// src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts
+import fs9 from "node:fs";
+function legacyCliDiskMigrationIsPending() {
+  try {
+    if (fs9.existsSync(INDEX_DIR)) {
+      for (const name of fs9.readdirSync(INDEX_DIR)) {
+        if (name.startsWith(".file-index-") && name.endsWith(".json")) return true;
+      }
+    }
+  } catch {
+  }
+  try {
+    if (fs9.existsSync(LEGACY_AGENT_SESSION_DIR)) {
+      if (fs9.readdirSync(LEGACY_AGENT_SESSION_DIR).some((n) => n.endsWith(".json"))) return true;
+    }
+  } catch {
+  }
+  try {
+    const dir = getPromptQueuesDirectory();
+    if (fs9.existsSync(dir) && fs9.readdirSync(dir).some((n) => n.endsWith(".json"))) return true;
+  } catch {
+  }
+  return false;
+}
+function importCliSqliteLegacyDiskData(db, log) {
+  const pending = legacyCliDiskMigrationIsPending();
+  if (pending && log) {
+    log("Migrating legacy on-disk CLI data to SQLite\u2026");
+  }
+  archiveLegacyFileIndexJsonFiles();
+  importLegacyAgentSessionsFromDisk(db);
+  importLegacyPromptQueuesFromDisk(db);
+  if (pending && log) {
+    log("Legacy on-disk CLI data migration finished.");
+  }
+}
+var init_import_cli_legacy_disk_data = __esm({
+  "src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts"() {
+    "use strict";
+    init_constants();
+    init_paths();
+    init_archive_file_index_json();
+    init_import_agent_sessions_from_disk();
+    init_import_prompt_queues_from_disk();
+  }
+});
+
+// src/sqlite/migrate-cli-sqlite.ts
+function agentCapabilitiesTableState(db) {
+  const rows = db.all(
+    `SELECT name FROM sqlite_master WHERE type='table' AND name IN ('agent_capabilities', 'agent_capability_cache')`
+  );
+  const names = new Set(rows.map((r) => r.name));
+  if (names.has("agent_capabilities")) return "current";
+  if (names.has("agent_capability_cache")) return "legacy";
+  return "new";
+}
+function migrateCliSqlite(db) {
+  runSqliteMigrations(
+    db,
+    CLI_SQLITE_MIGRATIONS,
+    readCliSqliteMigrationSql("000_bootstrap_migrations_table.sql"),
+    "cli-sqlite"
+  );
+}
+var CHECKPOINT_V12, CHECKPOINT_V1_SQL2, AGENT_CAPABILITIES_SQL, DROP_CACHE_TABLES_SQL, CLI_SQLITE_MIGRATIONS;
+var init_migrate_cli_sqlite = __esm({
+  "src/sqlite/migrate-cli-sqlite.ts"() {
+    "use strict";
+    init_read_migration_sql();
+    init_run_sqlite_migrations();
+    CHECKPOINT_V12 = "001_cli_sqlite_checkpoint_v1";
+    CHECKPOINT_V1_SQL2 = readCliSqliteMigrationSql("001_cli_sqlite_checkpoint_v1.sql");
+    AGENT_CAPABILITIES_SQL = readCliSqliteMigrationSql("002_agent_capabilities.sql");
+    DROP_CACHE_TABLES_SQL = readCliSqliteMigrationSql("006_drop_cache_tables.sql");
+    CLI_SQLITE_MIGRATIONS = [
+      {
+        name: CHECKPOINT_V12,
+        checkpoint: true,
+        migrate: (db) => {
+          db.exec(CHECKPOINT_V1_SQL2);
+        }
+      },
+      {
+        name: "002_agent_capabilities",
+        migrate: (db) => {
+          const state = agentCapabilitiesTableState(db);
+          if (state === "current") return;
+          if (state === "legacy") {
+            db.exec(`
+          ALTER TABLE agent_capability_cache RENAME TO agent_capabilities;
+          DROP INDEX IF EXISTS idx_agent_capability_cache_workspace;
+          CREATE INDEX IF NOT EXISTS idx_agent_capabilities_workspace ON agent_capabilities(workspace_id);
+        `);
+            return;
+          }
+          db.exec(AGENT_CAPABILITIES_SQL);
+        },
+        alreadyApplied: (db) => agentCapabilitiesTableState(db) === "current"
+      },
+      {
+        name: "006_drop_cache_tables",
+        migrate: (db) => {
+          db.exec(DROP_CACHE_TABLES_SQL);
+        },
+        alreadyApplied: (db) => {
+          const row = db.get(
+            `SELECT 1 as ok FROM sqlite_master
+         WHERE type='table' AND name IN ('file_index_parent_path', 'file_index_child_path', 'file_index_path')
+         LIMIT 1`
+          );
+          return row == null;
+        }
+      }
+    ];
+  }
+});
+
+// src/sqlite/cli-database.ts
+var cliSqlite, safeCloseCliSqliteDatabase, closeAllCliSqliteConnections, openCliSqliteConnection, withCliSqliteSync, withCliSqlite, ensureCliSqliteInitialized;
+var init_cli_database = __esm({
+  "src/sqlite/cli-database.ts"() {
+    "use strict";
+    init_cli_process_interrupt();
+    init_cli_sqlite_paths();
+    init_create_sqlite_database_access();
+    init_import_cli_legacy_disk_data();
+    init_migrate_cli_sqlite();
+    init_sqlite_errors();
+    cliSqlite = createSqliteDatabaseAccess({
+      getPath: getCliSqlitePath,
+      ensureParentDir: ensureCliSqliteParentDir,
+      migrate: migrateCliSqlite,
+      afterOpen: (db, options) => {
+        importCliSqliteLegacyDiskData(db, options?.logLegacyMigration);
+      }
+    });
+    safeCloseCliSqliteDatabase = cliSqlite.safeClose;
+    closeAllCliSqliteConnections = cliSqlite.closeAllConnections;
+    openCliSqliteConnection = cliSqlite.openConnection;
+    withCliSqliteSync = cliSqlite.withSync;
+    withCliSqlite = cliSqlite.withAsync;
+    ensureCliSqliteInitialized = cliSqlite.ensureInitialized;
+  }
+});
+
+// src/files/index/walk-workspace-tree.ts
+function shouldSkipWorkspaceWalkEntry(name) {
+  return DEPENDENCY_INSTALL_DIR_NAMES.has(name);
+}
+function createWalkYieldState() {
+  return { n: 0 };
+}
+var DEPENDENCY_INSTALL_DIR_NAMES;
+var init_walk_workspace_tree = __esm({
+  "src/files/index/walk-workspace-tree.ts"() {
+    "use strict";
+    init_file_browser_in_flight();
+    init_cli_process_interrupt();
+    init_cli_database();
+    init_constants();
+    DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
+      "node_modules",
+      "bower_components",
+      "vendor",
+      "Pods",
+      "Carthage",
+      "DerivedData",
+      ".yarn",
+      ".pnpm-store"
+    ]);
+  }
+});
+
+// ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path16, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path16);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path16, originalPath, doThrow) => {
+      if (!isString(path16)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path16) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path16)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path16 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path16,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path16, cache, checkUnignored, slices);
+      }
+      checkIgnore(path16) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path16)) {
+          return this.test(path16);
+        }
+        const slices = path16.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path16, false, MODE_CHECK_IGNORE);
+      }
+      _t(path16, cache, checkUnignored, slices) {
+        if (path16 in cache) {
+          return cache[path16];
+        }
+        if (!slices) {
+          slices = path16.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path16] = this._rules.test(path16, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path16] = parent.ignored ? parent : this._rules.test(path16, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path16) {
+        return this._test(path16, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path16) => !this.ignores(path16);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path16) {
+        return this._test(path16, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path16) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// src/code-nav/gitignore-filter.ts
+import fs10 from "node:fs";
+import path10 from "node:path";
+function normalizeRelPath(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+function isUnderDir(relPath, dirRel) {
+  return relPath === dirRel || relPath.startsWith(`${dirRel}/`);
+}
+async function createGitignoreFilterForRelativePath(root, relPath) {
+  const filter = new GitignoreFilter();
+  await filter.enterDirectory(root, "");
+  const dirRel = normalizeRelPath(path10.dirname(relPath));
+  if (dirRel === "." || dirRel === "") return filter;
+  let abs = root;
+  let rel = "";
+  for (const segment of dirRel.split("/")) {
+    abs = path10.join(abs, segment);
+    rel = rel ? `${rel}/${segment}` : segment;
+    await filter.enterDirectory(abs, rel);
+  }
+  return filter;
+}
+async function isPathGitIgnored(root, relPath) {
+  const normalized = normalizeRelPath(relPath);
+  const filter = await createGitignoreFilterForRelativePath(root, normalized);
+  return filter.isIgnored(normalized);
+}
+var import_ignore, DEFAULT_IGNORED, GitignoreFilter;
+var init_gitignore_filter = __esm({
+  "src/code-nav/gitignore-filter.ts"() {
+    "use strict";
+    import_ignore = __toESM(require_ignore(), 1);
+    DEFAULT_IGNORED = [".git", ".git/**"];
+    GitignoreFilter = class {
+      layers = [{ dirRel: "", ig: (0, import_ignore.default)().add(DEFAULT_IGNORED) }];
+      /** Load `.gitignore` in `absDir` and push a layer when the file exists. */
+      async enterDirectory(absDir, dirRel) {
+        try {
+          const content = await fs10.promises.readFile(path10.join(absDir, ".gitignore"), "utf8");
+          this.layers.push({ dirRel, ig: (0, import_ignore.default)().add(content) });
+        } catch {
+        }
+      }
+      /** Pop the ignore layer for `dirRel` when leaving that directory during a walk. */
+      leaveDirectory(dirRel) {
+        const top = this.layers[this.layers.length - 1];
+        if (top != null && top.dirRel === dirRel) {
+          this.layers.pop();
+        }
+      }
+      isIgnored(relPath, opts) {
+        const normalized = normalizeRelPath(relPath);
+        const checkPath = opts?.directory && !normalized.endsWith("/") ? `${normalized}/` : normalized;
+        for (const layer of this.layers) {
+          if (layer.dirRel !== "" && !isUnderDir(normalized, layer.dirRel)) continue;
+          const local = layer.dirRel === "" ? checkPath : checkPath.slice(layer.dirRel.length + 1);
+          if (local !== "" && layer.ig.ignores(local)) return true;
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// src/code-nav/language-registry.ts
+import path11 from "node:path";
+function languageAssetPaths(key, wasmFile) {
+  return {
+    wasmFile,
+    tagsQueryFile: `tree-sitter-${key}/tags.scm`
+  };
+}
+function getLanguageKeyForFilePath(filePath) {
+  const ext = path11.extname(filePath).replace(/^\./, "").toLowerCase();
+  if (!ext) return null;
+  return EXT_TO_LANGUAGE_KEY[ext] ?? null;
+}
+function getLanguageSpec(languageKey) {
+  return LANGUAGE_SPECS[languageKey] ?? null;
+}
+function isCodeNavSupportedPath(filePath) {
+  const key = getLanguageKeyForFilePath(filePath);
+  return key != null && getLanguageSpec(key) != null;
+}
+var EXT_TO_LANGUAGE_KEY, LANGUAGE_SPECS;
+var init_language_registry = __esm({
+  "src/code-nav/language-registry.ts"() {
+    "use strict";
+    EXT_TO_LANGUAGE_KEY = {
+      js: "javascript",
+      jsx: "javascript",
+      mjs: "javascript",
+      cjs: "javascript",
+      ts: "typescript",
+      tsx: "tsx",
+      py: "python",
+      go: "go",
+      rs: "rust",
+      rb: "ruby",
+      java: "java",
+      c: "c",
+      h: "c",
+      cpp: "cpp",
+      cc: "cpp",
+      cxx: "cpp",
+      hpp: "cpp"
+    };
+    LANGUAGE_SPECS = {
+      javascript: languageAssetPaths("javascript", "tree-sitter-javascript.wasm"),
+      typescript: languageAssetPaths("typescript", "tree-sitter-typescript.wasm"),
+      tsx: languageAssetPaths("typescript", "tree-sitter-tsx.wasm"),
+      python: languageAssetPaths("python", "tree-sitter-python.wasm"),
+      go: languageAssetPaths("go", "tree-sitter-go.wasm"),
+      rust: languageAssetPaths("rust", "tree-sitter-rust.wasm"),
+      ruby: languageAssetPaths("ruby", "tree-sitter-ruby.wasm"),
+      java: languageAssetPaths("java", "tree-sitter-java.wasm"),
+      c: languageAssetPaths("c", "tree-sitter-c.wasm"),
+      cpp: languageAssetPaths("cpp", "tree-sitter-cpp.wasm")
+    };
+  }
+});
+
+// src/code-nav/walk-code-nav-files.ts
+import fs11 from "node:fs";
+import path12 from "node:path";
+async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile, state) {
+  await filter.enterDirectory(dir, relDir);
+  let names;
+  try {
+    names = await fs11.promises.readdir(dir);
+  } catch {
+    filter.leaveDirectory(relDir);
+    return;
+  }
+  for (const name of names) {
+    if (shouldSkipWorkspaceWalkEntry(name)) continue;
+    if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      await yieldForBridgeInteractivePriority();
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    }
+    state.n++;
+    const relPath = relDir ? `${relDir}/${name}` : name;
+    const full = path12.join(dir, name);
+    let stat;
+    try {
+      stat = await fs11.promises.stat(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (filter.isIgnored(relPath, { directory: true })) continue;
+      await walkCodeNavFilesInDirectory(full, baseDir, relPath, filter, onFile, state);
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    if (filter.isIgnored(relPath)) continue;
+    if (!isCodeNavSupportedPath(relPath)) continue;
+    await Promise.resolve(onFile(relPath));
+  }
+  filter.leaveDirectory(relDir);
+}
+async function walkCodeNavFilesAsync(rootDir, onFile, state = createWalkYieldState()) {
+  const resolved = path12.resolve(rootDir);
+  const filter = new GitignoreFilter();
+  await walkCodeNavFilesInDirectory(resolved, resolved, "", filter, onFile, state);
+}
+var init_walk_code_nav_files = __esm({
+  "src/code-nav/walk-code-nav-files.ts"() {
+    "use strict";
+    init_walk_workspace_tree();
+    init_file_browser_in_flight();
+    init_cli_process_interrupt();
+    init_cli_database();
+    init_constants();
+    init_gitignore_filter();
+    init_language_registry();
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/symbol-index-version.ts
+var SYMBOL_INDEX_VERSION;
+var init_symbol_index_version = __esm({
+  "src/code-nav/symbol-index/sqlite/symbol-index-version.ts"() {
+    "use strict";
+    SYMBOL_INDEX_VERSION = 11;
+  }
+});
+
+// src/files/cwd/bridge-root.ts
+function getBridgeRoot() {
+  if (bridgeRootPath == null) {
+    bridgeRootPath = normalizeResolvedPath(process.cwd());
+  }
+  return bridgeRootPath;
+}
+var bridgeRootPath;
+var init_bridge_root = __esm({
+  "src/files/cwd/bridge-root.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    bridgeRootPath = null;
+  }
+});
+
+// src/files/index/paths.ts
+import path13 from "node:path";
+import crypto from "node:crypto";
+function getCwdHashForFileIndex(resolvedCwd) {
+  return crypto.createHash("sha256").update(path13.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+}
+var init_paths2 = __esm({
+  "src/files/index/paths.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/parent-path.ts
+function normalizeParentPath(resolved) {
+  return normalizeResolvedPath(resolved);
+}
+function resolveParentKind(resolved) {
+  return normalizeParentPath(resolved) === normalizeParentPath(getBridgeRoot()) ? "base" : "overlay";
+}
+function ensureBaseParentId(db) {
+  const bridgeRoot = normalizeParentPath(getBridgeRoot());
+  const existing = db.get("SELECT id FROM symbol_index_parent_path WHERE path = ?", [bridgeRoot]);
+  if (existing != null) return Number(existing.id);
+  return upsertSymbolIndexParentPath(db, bridgeRoot);
+}
+function upsertSymbolIndexParentPath(db, resolved) {
+  const normalized = normalizeParentPath(resolved);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const kind = resolveParentKind(normalized);
+  const baseParentId = kind === "overlay" ? ensureBaseParentId(db) : null;
+  db.run(
+    `INSERT INTO symbol_index_parent_path (path, path_hash, updated_at, index_version, kind, base_parent_id)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(path) DO UPDATE SET
+       path_hash = excluded.path_hash,
+       updated_at = excluded.updated_at,
+       index_version = excluded.index_version,
+       kind = excluded.kind,
+       base_parent_id = excluded.base_parent_id`,
+    [normalized, getCwdHashForFileIndex(normalized), now, SYMBOL_INDEX_VERSION, kind, baseParentId]
+  );
+  const row = db.get("SELECT id FROM symbol_index_parent_path WHERE path = ?", [normalized]);
+  if (row == null) throw new Error(`Failed to upsert symbol index parent path: ${normalized}`);
+  return Number(row.id);
+}
+function rowToSymbolIndexParentContext(row) {
+  return {
+    parentId: Number(row.id),
+    path: row.path,
+    kind: row.kind,
+    baseParentId: row.base_parent_id != null ? Number(row.base_parent_id) : null
+  };
+}
+function getSymbolIndexParentContext(db, resolvedParentPath) {
+  const row = db.get(
+    `SELECT id, path, kind, base_parent_id
+     FROM symbol_index_parent_path
+     WHERE path = ?`,
+    [normalizeParentPath(resolvedParentPath)]
+  );
+  if (row == null) return null;
+  return rowToSymbolIndexParentContext(row);
+}
+var init_parent_path = __esm({
+  "src/code-nav/symbol-index/sqlite/parent-path.ts"() {
+    "use strict";
+    init_bridge_root();
+    init_paths2();
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_symbol_index_version();
+  }
+});
+
+// src/code-nav/symbol-index/storage/content-hash-check.ts
+function contentHashFileHasTags(db, contentHash, filePath) {
+  const row = db.get(
+    "SELECT 1 as ok FROM symbol_index_tag WHERE content_hash = ? AND file_path = ? LIMIT 1",
+    [contentHash, filePath]
+  );
+  return row != null;
+}
+function contentHashFileHasImports(db, contentHash, filePath) {
+  const row = db.get(
+    "SELECT 1 as ok FROM symbol_index_import WHERE content_hash = ? AND file_path = ? LIMIT 1",
+    [contentHash, filePath]
+  );
+  return row != null;
+}
+var init_content_hash_check = __esm({
+  "src/code-nav/symbol-index/storage/content-hash-check.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/storage/insert-symbol-content.ts
+function insertSymbolTagsForContent(db, contentHash, filePath, tags) {
+  const ins = db.prepare(
+    `INSERT OR IGNORE INTO symbol_index_tag
+      (content_hash, file_path, name, role, kind, start_line, start_column, end_line, end_column,
+       scope_start_line, scope_start_column, parent_scope_start_line, parent_scope_start_column,
+       nav_target_path, scope_chain)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  try {
+    for (const tag of tags) {
+      ins.run([
+        contentHash,
+        filePath,
+        tag.name,
+        tag.role,
+        tag.kind,
+        tag.startLine,
+        tag.startColumn,
+        tag.endLine,
+        tag.endColumn,
+        tag.scopeStartLine ?? null,
+        tag.scopeStartColumn ?? null,
+        tag.parentScopeStartLine ?? null,
+        tag.parentScopeStartColumn ?? null,
+        tag.navTargetPath ?? null,
+        tag.scopeChain ?? null
+      ]);
+    }
+  } finally {
+    ins.finalize();
+  }
+}
+function insertSymbolImportsForContent(db, contentHash, filePath, imports) {
+  const ins = db.prepare(
+    `INSERT OR IGNORE INTO symbol_index_import
+      (content_hash, file_path, local_name, source_name, module_specifier, source_file_path, import_kind, start_line, start_column)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  try {
+    for (const binding of imports) {
+      ins.run([
+        contentHash,
+        filePath,
+        binding.localName,
+        binding.sourceName,
+        binding.moduleSpecifier,
+        binding.sourceFilePath,
+        binding.importKind,
+        binding.startLine,
+        binding.startColumn
+      ]);
+    }
+  } finally {
+    ins.finalize();
+  }
+}
+var init_insert_symbol_content = __esm({
+  "src/code-nav/symbol-index/storage/insert-symbol-content.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/storage/parent-file-map.ts
+function getParentFileMapHash(db, parentId, filePath) {
+  const row = db.get(
+    "SELECT content_hash FROM symbol_parent_file_map WHERE parent_id = ? AND file_path = ?",
+    [parentId, filePath]
+  );
+  if (row == null) return void 0;
+  return row.content_hash;
+}
+function countParentFileMapRefs(db, contentHash) {
+  const row = db.get("SELECT COUNT(*) as n FROM symbol_parent_file_map WHERE content_hash = ?", [
+    contentHash
+  ]);
+  return Number(row.n);
+}
+function setParentFileMapEntry(db, parentId, filePath, contentHash) {
+  const previous = getParentFileMapHash(db, parentId, filePath);
+  if (contentHash == null) {
+    db.run(
+      `INSERT INTO symbol_parent_file_map (parent_id, file_path, content_hash)
+       VALUES (?, ?, NULL)
+       ON CONFLICT(parent_id, file_path) DO UPDATE SET content_hash = NULL`,
+      [parentId, filePath]
+    );
+  } else {
+    db.run(
+      `INSERT INTO symbol_parent_file_map (parent_id, file_path, content_hash)
+       VALUES (?, ?, ?)
+       ON CONFLICT(parent_id, file_path) DO UPDATE SET content_hash = excluded.content_hash`,
+      [parentId, filePath, contentHash]
+    );
+  }
+  return previous === void 0 ? null : previous;
+}
+function removeParentFileMapEntry(db, parentId, filePath) {
+  const previous = getParentFileMapHash(db, parentId, filePath);
+  db.run("DELETE FROM symbol_parent_file_map WHERE parent_id = ? AND file_path = ?", [parentId, filePath]);
+  return previous === void 0 ? null : previous;
+}
+function clearParentFileMapBatch(db, parentId, limit) {
+  const rows = db.all(
+    `SELECT file_path, content_hash
+     FROM symbol_parent_file_map
+     WHERE parent_id = ?
+     LIMIT ?`,
+    [parentId, limit]
+  );
+  if (rows.length === 0) return { released: [], remaining: false };
+  const del = db.prepare("DELETE FROM symbol_parent_file_map WHERE parent_id = ? AND file_path = ?");
+  try {
+    for (const row of rows) {
+      del.run([parentId, row.file_path]);
+    }
+  } finally {
+    del.finalize();
+  }
+  return {
+    released: rows.flatMap((row) => row.content_hash == null ? [] : [row.content_hash]),
+    remaining: rows.length >= limit
+  };
+}
+var init_parent_file_map = __esm({
+  "src/code-nav/symbol-index/storage/parent-file-map.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/storage/symbol-content-index.ts
+function upsertSymbolContentIndex(db, contentHash, filePath, tags, imports) {
+  if (tags.length > 0 && !contentHashFileHasTags(db, contentHash, filePath)) {
+    insertSymbolTagsForContent(db, contentHash, filePath, tags);
+  }
+  if (imports.length > 0 && !contentHashFileHasImports(db, contentHash, filePath)) {
+    insertSymbolImportsForContent(db, contentHash, filePath, imports);
+  }
+}
+function deleteSymbolContentIfUnreferenced(db, contentHash) {
+  if (countParentFileMapRefs(db, contentHash) > 0) return;
+  db.run("DELETE FROM symbol_index_tag WHERE content_hash = ?", [contentHash]);
+  db.run("DELETE FROM symbol_index_import WHERE content_hash = ?", [contentHash]);
+}
+var init_symbol_content_index = __esm({
+  "src/code-nav/symbol-index/storage/symbol-content-index.ts"() {
+    "use strict";
+    init_content_hash_check();
+    init_insert_symbol_content();
+    init_parent_file_map();
+  }
+});
+
+// src/code-nav/symbol-index/storage/effective-content.ts
+function getEffectiveContentHash(db, ctx, filePath) {
+  const overlayHash = getParentFileMapHash(db, ctx.parentId, filePath);
+  if (overlayHash !== void 0) return overlayHash;
+  if (ctx.baseParentId == null) return null;
+  const baseHash = getParentFileMapHash(db, ctx.baseParentId, filePath);
+  if (baseHash === void 0) return null;
+  return baseHash;
+}
+function listEffectiveIndexedFilePaths(db, ctx) {
+  const paths = /* @__PURE__ */ new Set();
+  if (ctx.baseParentId != null) {
+    const baseRows = db.all("SELECT file_path FROM symbol_parent_file_map WHERE parent_id = ? AND content_hash IS NOT NULL", [
+      ctx.baseParentId
+    ]);
+    for (const row of baseRows) paths.add(row.file_path);
+  }
+  const overlayRows = db.all("SELECT file_path, content_hash FROM symbol_parent_file_map WHERE parent_id = ?", [
+    ctx.parentId
+  ]);
+  for (const row of overlayRows) {
+    if (row.content_hash == null) paths.delete(row.file_path);
+    else paths.add(row.file_path);
+  }
+  if (ctx.baseParentId == null) {
+    const ownRows = db.all("SELECT file_path FROM symbol_parent_file_map WHERE parent_id = ? AND content_hash IS NOT NULL", [
+      ctx.parentId
+    ]);
+    for (const row of ownRows) paths.add(row.file_path);
+  }
+  return [...paths];
+}
+var init_effective_content = __esm({
+  "src/code-nav/symbol-index/storage/effective-content.ts"() {
+    "use strict";
+    init_parent_file_map();
+  }
+});
+
+// src/code-nav/symbol-index/persistence/symbol-file-content-hash.ts
+import crypto2 from "node:crypto";
+function hashSymbolFileContent(source) {
+  return crypto2.createHash("sha256").update(source ?? "").digest("hex");
+}
+var init_symbol_file_content_hash = __esm({
+  "src/code-nav/symbol-index/persistence/symbol-file-content-hash.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/file-data-persistence.ts
+function gcReleasedHashes(db, hashes) {
+  for (const hash of hashes) {
+    if (hash != null) deleteSymbolContentIfUnreferenced(db, hash);
+  }
+}
+function persistFileSymbolData(db, ctx, filePath, contentHash, tags, imports) {
+  upsertSymbolContentIndex(db, contentHash, filePath, tags, imports);
+  if (ctx.kind === "overlay" && ctx.baseParentId != null) {
+    const baseHash = getParentFileMapHash(db, ctx.baseParentId, filePath);
+    if (baseHash === contentHash) {
+      const released2 = removeParentFileMapEntry(db, ctx.parentId, filePath);
+      gcReleasedHashes(db, [released2]);
+      return;
+    }
+  }
+  const released = setParentFileMapEntry(db, ctx.parentId, filePath, contentHash);
+  gcReleasedHashes(db, [released]);
+}
+function persistSymbolIndexFileData(db, ctx, filePath, source, tags, imports) {
+  const contentHash = hashSymbolFileContent(source);
+  persistFileSymbolData(db, ctx, filePath, contentHash, tags, imports);
+}
+function removeSymbolIndexFileData(db, ctx, filePath) {
+  if (ctx.kind === "overlay") {
+    const released2 = setParentFileMapEntry(db, ctx.parentId, filePath, null);
+    gcReleasedHashes(db, [released2]);
+    return;
+  }
+  const released = removeParentFileMapEntry(db, ctx.parentId, filePath);
+  gcReleasedHashes(db, [released]);
+}
+function clearSymbolIndexParentDataBatch(db, ctx, limit) {
+  const { released, remaining } = clearParentFileMapBatch(db, ctx.parentId, limit);
+  gcReleasedHashes(db, released);
+  return remaining;
+}
+var init_file_data_persistence = __esm({
+  "src/code-nav/symbol-index/sqlite/file-data-persistence.ts"() {
+    "use strict";
+    init_symbol_content_index();
+    init_effective_content();
+    init_parent_file_map();
+    init_symbol_file_content_hash();
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/population.ts
+var init_population = __esm({
+  "src/code-nav/symbol-index/sqlite/population.ts"() {
+    "use strict";
+    init_code_nav_cache_database();
+    init_parent_path();
+    init_symbol_index_version();
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/symbol-index-sqlite.ts
+var init_symbol_index_sqlite = __esm({
+  "src/code-nav/symbol-index/sqlite/symbol-index-sqlite.ts"() {
+    "use strict";
+    init_symbol_index_version();
+    init_parent_path();
+    init_file_data_persistence();
+    init_population();
+  }
+});
+
+// src/code-nav/symbol-index/sqlite/symbol-index-sqlite-lock.ts
+function withSymbolIndexSqliteLock(fn) {
+  return withCodeNavCacheSqliteWorkLock(fn);
+}
+var init_symbol_index_sqlite_lock = __esm({
+  "src/code-nav/symbol-index/sqlite/symbol-index-sqlite-lock.ts"() {
+    "use strict";
+    init_code_nav_cache_sqlite_work_lock();
+  }
+});
+
+// src/code-nav/symbol-index/query/tag-query-shared.ts
+var TAG_SELECT;
+var init_tag_query_shared = __esm({
+  "src/code-nav/symbol-index/query/tag-query-shared.ts"() {
+    "use strict";
+    TAG_SELECT = `file_path, name, role, kind, start_line, start_column, end_line, end_column,
+  scope_start_line, scope_start_column, parent_scope_start_line, parent_scope_start_column, nav_target_path, scope_chain`;
+  }
+});
+
+// src/code-nav/symbol-index/storage/file-content-load.ts
+function loadFileTags(db, ctx, filePath) {
+  const contentHash = getEffectiveContentHash(db, ctx, filePath);
+  if (contentHash == null) return [];
+  return db.all(
+    `SELECT ${TAG_SELECT}
+     FROM symbol_index_tag
+     WHERE content_hash = ? AND file_path = ?
+     ORDER BY start_line, start_column`,
+    [contentHash, filePath]
+  );
+}
+function loadFileImports(db, ctx, filePath) {
+  const contentHash = getEffectiveContentHash(db, ctx, filePath);
+  if (contentHash == null) return [];
+  return db.all(
+    `SELECT file_path, local_name, source_name, module_specifier, source_file_path, import_kind, start_line, start_column
+     FROM symbol_index_import
+     WHERE content_hash = ? AND file_path = ?
+     ORDER BY start_line, start_column`,
+    [contentHash, filePath]
+  );
+}
+var init_file_content_load = __esm({
+  "src/code-nav/symbol-index/storage/file-content-load.ts"() {
+    "use strict";
+    init_tag_query_shared();
+    init_effective_content();
+  }
+});
+
+// src/code-nav/symbol-index/storage/symbol-parent-file-map.ts
+var init_symbol_parent_file_map = __esm({
+  "src/code-nav/symbol-index/storage/symbol-parent-file-map.ts"() {
+    "use strict";
+    init_parent_file_map();
+    init_effective_content();
+    init_file_content_load();
+  }
+});
+
+// src/code-nav/symbol-index/build/load-indexed-file-entry.ts
+function dbTagToSymbolTag(row) {
+  return {
+    name: row.name,
+    role: row.role,
+    kind: row.kind,
+    startLine: row.start_line,
+    startColumn: row.start_column,
+    endLine: row.end_line,
+    endColumn: row.end_column,
+    scopeStartLine: row.scope_start_line ?? void 0,
+    scopeStartColumn: row.scope_start_column ?? void 0,
+    parentScopeStartLine: row.parent_scope_start_line ?? void 0,
+    parentScopeStartColumn: row.parent_scope_start_column ?? void 0,
+    navTargetPath: row.nav_target_path ?? void 0,
+    scopeChain: row.scope_chain ?? void 0
+  };
+}
+function dbImportToSymbolImport(row) {
+  return {
+    localName: row.local_name,
+    sourceName: row.source_name,
+    moduleSpecifier: row.module_specifier,
+    sourceFilePath: row.source_file_path,
+    importKind: row.import_kind,
+    startLine: row.start_line,
+    startColumn: row.start_column
+  };
+}
+function loadIndexedFileEntry(db, ctx, relPath) {
+  const tags = loadFileTags(db, ctx, relPath);
+  const imports = loadFileImports(db, ctx, relPath);
+  if (tags.length === 0 && imports.length === 0) return void 0;
+  return {
+    relPath,
+    source: null,
+    tags: tags.map(dbTagToSymbolTag),
+    imports: imports.map(dbImportToSymbolImport)
+  };
+}
+var init_load_indexed_file_entry = __esm({
+  "src/code-nav/symbol-index/build/load-indexed-file-entry.ts"() {
+    "use strict";
+    init_symbol_parent_file_map();
+  }
+});
+
+// src/code-nav/symbol-index/query/list-direct-import-targets.ts
+function normalizeRelPath2(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function listDirectImportTargetsWithDb(db, resolved, relPath) {
+  const ctx = getSymbolIndexParentContext(db, resolved);
+  if (ctx == null) return [];
+  const entry = loadIndexedFileEntry(db, ctx, relPath);
+  if (entry == null) return [];
+  const paths = /* @__PURE__ */ new Set();
+  for (const binding of entry.imports) {
+    if (binding.sourceFilePath) paths.add(binding.sourceFilePath);
+  }
+  return Array.from(paths);
+}
+async function listDirectImportTargetsForFileAsync(parentPath, filePath) {
+  const resolved = normalizeResolvedPath(parentPath);
+  const relPath = normalizeRelPath2(filePath);
+  if (!relPath) return [];
+  return withCodeNavCacheSqlite((db) => listDirectImportTargetsWithDb(db, resolved, relPath));
+}
+var init_list_direct_import_targets = __esm({
+  "src/code-nav/symbol-index/query/list-direct-import-targets.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_load_indexed_file_entry();
+    init_symbol_index_sqlite();
+  }
+});
+
+// src/code-nav/symbol-index/lifecycle/symbol-index-file-ready.ts
+function symbolIndexFileIsReadyWithDb(db, parentPath, filePath) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalizedFile) return false;
+  const ctx = getSymbolIndexParentContext(db, normalizedParent);
+  if (ctx == null) return false;
+  const versionRow = db.get("SELECT index_version FROM symbol_index_parent_path WHERE id = ?", [
+    ctx.parentId
+  ]);
+  if (versionRow == null || versionRow.index_version < SYMBOL_INDEX_VERSION) return false;
+  return getEffectiveContentHash(db, ctx, normalizedFile) != null;
+}
+async function symbolIndexFileIsReadyAsync(parentPath, filePath) {
+  return withCodeNavCacheSqlite((db) => symbolIndexFileIsReadyWithDb(db, parentPath, filePath));
+}
+async function loadSymbolIndexReadyFileSet(parentPath) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const paths = await withCodeNavCacheSqlite((db) => {
+    const ctx = getSymbolIndexParentContext(db, normalizedParent);
+    if (ctx == null) return [];
+    const versionRow = db.get("SELECT index_version FROM symbol_index_parent_path WHERE id = ?", [
+      ctx.parentId
+    ]);
+    if (versionRow == null || versionRow.index_version < SYMBOL_INDEX_VERSION) return [];
+    return listEffectiveIndexedFilePaths(db, ctx);
+  });
+  return new Set(paths);
+}
+var init_symbol_index_file_ready = __esm({
+  "src/code-nav/symbol-index/lifecycle/symbol-index-file-ready.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_symbol_index_sqlite();
+    init_symbol_parent_file_map();
+  }
+});
+
+// src/code-nav/symbol-index/imports/star-reexport-names.ts
+function isModuleLevelDef(tag) {
+  return tag.role === "def" && tag.parentScopeStartLine == null && tag.parentScopeStartColumn == null;
+}
+function collectExportableNamesFromTags(tags) {
+  const names = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    if (!isModuleLevelDef(tag)) continue;
+    if (!names.has(tag.name)) names.set(tag.name, tag.name);
+  }
+  return names;
+}
+function existingLocalNames(imports) {
+  return new Set(imports.map((binding) => binding.localName));
+}
+function resolveExportableNames(filePath, entriesByPath, visited) {
+  if (visited.has(filePath)) return /* @__PURE__ */ new Map();
+  visited.add(filePath);
+  const entry = entriesByPath.get(filePath);
+  if (!entry) return /* @__PURE__ */ new Map();
+  const out = collectExportableNamesFromTags(entry.tags);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [name, sourceName] of out) {
+    resolved.set(name, { sourceName, sourceFilePath: filePath });
+  }
+  for (const binding of entry.imports) {
+    if (binding.importKind !== "star" || !binding.sourceFilePath) continue;
+    const upstream = resolveExportableNames(binding.sourceFilePath, entriesByPath, visited);
+    for (const [name, info] of upstream) {
+      if (!resolved.has(name)) resolved.set(name, info);
+    }
+  }
+  for (const binding of entry.imports) {
+    if (binding.importKind !== "reexport" && binding.importKind !== "type") continue;
+    if (!binding.sourceFilePath) continue;
+    if (!resolved.has(binding.localName)) {
+      resolved.set(binding.localName, {
+        sourceName: binding.sourceName,
+        sourceFilePath: binding.sourceFilePath
+      });
+    }
+  }
+  return resolved;
+}
+var STAR_LOCAL_NAME;
+var init_star_reexport_names = __esm({
+  "src/code-nav/symbol-index/imports/star-reexport-names.ts"() {
+    "use strict";
+    STAR_LOCAL_NAME = "*";
+  }
+});
+
+// src/code-nav/symbol-index/imports/star-reexport-upstream.ts
+function collectUpstreamEntries(entry, resolveEntry) {
+  const entriesByPath = /* @__PURE__ */ new Map();
+  entriesByPath.set(entry.relPath, entry);
+  const visit = (filePath, visited) => {
+    if (visited.has(filePath)) return;
+    visited.add(filePath);
+    const resolved = resolveEntry(filePath);
+    if (resolved == null) return;
+    entriesByPath.set(filePath, resolved);
+    for (const binding of resolved.imports) {
+      if (binding.sourceFilePath) visit(binding.sourceFilePath, visited);
+    }
+  };
+  for (const star of entry.imports) {
+    if (star.importKind !== "star" || !star.sourceFilePath) continue;
+    visit(star.sourceFilePath, /* @__PURE__ */ new Set());
+  }
+  return [...entriesByPath.values()];
+}
+var init_star_reexport_upstream = __esm({
+  "src/code-nav/symbol-index/imports/star-reexport-upstream.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/imports/expand-star-reexports.ts
+function expandStarReexportForFile(entry, resolveEntry) {
+  const collected = collectUpstreamEntries(entry, resolveEntry);
+  return expandStarReexportBindings(collected).find((row) => row.relPath === entry.relPath) ?? entry;
+}
+function expandStarReexportBindings(collected) {
+  const entriesByPath = new Map(collected.map((entry) => [entry.relPath, entry]));
+  return collected.map((entry) => {
+    const stars = entry.imports.filter((binding) => binding.importKind === "star");
+    if (stars.length === 0) return entry;
+    const localNames = existingLocalNames(entry.imports);
+    const materialized = [];
+    for (const star of stars) {
+      if (!star.sourceFilePath) continue;
+      const exportable = resolveExportableNames(star.sourceFilePath, entriesByPath, /* @__PURE__ */ new Set());
+      for (const [localName, info] of exportable) {
+        if (localName === STAR_LOCAL_NAME || localNames.has(localName)) continue;
+        localNames.add(localName);
+        materialized.push({
+          localName,
+          sourceName: info.sourceName,
+          moduleSpecifier: star.moduleSpecifier,
+          sourceFilePath: info.sourceFilePath,
+          importKind: star.importKind === "type" ? "type" : "reexport",
+          startLine: star.startLine,
+          startColumn: star.startColumn
+        });
+      }
+    }
+    if (materialized.length === 0) return entry;
+    return { ...entry, imports: [...entry.imports, ...materialized] };
+  });
+}
+var init_expand_star_reexports = __esm({
+  "src/code-nav/symbol-index/imports/expand-star-reexports.ts"() {
+    "use strict";
+    init_star_reexport_names();
+    init_star_reexport_upstream();
+  }
+});
+
+// src/code-nav/symbol-index/persistence/persist-single-file.ts
+async function persistSymbolIndexFileAsync(resolved, relPath, source, tags, imports) {
+  await withCodeNavCacheSqlite(async (db) => {
+    runCodeNavCacheWriteTransaction(db, () => {
+      upsertSymbolIndexParentPath(db, resolved);
+      const ctx = getSymbolIndexParentContext(db, resolved);
+      if (ctx == null) throw new Error(`Failed to resolve symbol index parent: ${resolved}`);
+      persistSymbolIndexFileData(db, ctx, relPath, source, tags, imports);
+    });
+  });
+}
+async function removeSymbolIndexFileAsync(resolved, relPath) {
+  await withCodeNavCacheSqlite(async (db) => {
+    runCodeNavCacheWriteTransaction(db, () => {
+      upsertSymbolIndexParentPath(db, resolved);
+      const ctx = getSymbolIndexParentContext(db, resolved);
+      if (ctx == null) throw new Error(`Failed to resolve symbol index parent: ${resolved}`);
+      removeSymbolIndexFileData(db, ctx, relPath);
+    });
+  });
+}
+var init_persist_single_file = __esm({
+  "src/code-nav/symbol-index/persistence/persist-single-file.ts"() {
+    "use strict";
+    init_code_nav_cache_database();
+    init_code_nav_cache_sqlite_transaction();
+    init_symbol_index_sqlite();
+  }
+});
+
+// src/code-nav/resolve-module-import-path.ts
+import path14 from "node:path";
+function normalizeWorkspacePath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isRelativeModuleSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+}
+function firstExistingPath(candidates, workspaceFiles) {
+  for (const candidate of candidates) {
+    const normalized = normalizeWorkspacePath(candidate);
+    if (workspaceFiles.has(normalized)) return normalized;
+  }
+  return null;
+}
+function withSuffixes(basePath, suffixes) {
+  return suffixes.map((suffix) => basePath + suffix);
+}
+function tsJsImportCandidates(joined) {
+  const candidates = withSuffixes(joined, TS_JS_EXTENSIONS);
+  const extensionRewrites = [
+    [".js", [".ts", ".tsx", ".js", ".jsx"]],
+    [".jsx", [".tsx", ".ts", ".jsx", ".js"]],
+    [".mjs", [".mts", ".ts", ".mjs", ".js"]],
+    [".cjs", [".cts", ".ts", ".cjs", ".js"]]
+  ];
+  for (const [fromExt, toExts] of extensionRewrites) {
+    if (!joined.endsWith(fromExt)) continue;
+    const stem = joined.slice(0, -fromExt.length);
+    for (const toExt of toExts) {
+      candidates.unshift(stem + toExt);
+    }
+    for (const indexSuffix of ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
+      candidates.unshift(stem + indexSuffix);
+    }
+  }
+  return candidates;
+}
+function resolveModuleImportPath(importerFilePath, moduleSpecifier, workspaceFiles) {
+  const spec = moduleSpecifier.trim();
+  if (!spec || !isRelativeModuleSpecifier(spec)) return null;
+  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  const joined = normalizeWorkspacePath(path14.posix.normalize(path14.posix.join(importerDir, spec)));
+  return firstExistingPath(tsJsImportCandidates(joined), workspaceFiles);
+}
+function resolvePythonModulePath(importerFilePath, moduleSpecifier, workspaceFiles) {
+  const moduleName = moduleSpecifier.trim().replace(/\s+/g, "");
+  if (!moduleName) return null;
+  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  if (moduleName.startsWith(".")) {
+    const dotMatch = /^(\.+)(.*)$/.exec(moduleName);
+    const dotCount = dotMatch?.[1]?.length ?? 1;
+    const rest = (dotMatch?.[2] ?? "").replace(/^\./, "");
+    let baseDir = importerDir;
+    for (let i = 1; i < dotCount; i++) {
+      baseDir = path14.posix.dirname(baseDir);
+    }
+    const dottedPath2 = rest ? rest.split(".").join("/") : "";
+    const relativeBase = dottedPath2 ? path14.posix.join(baseDir, dottedPath2) : baseDir;
+    return firstExistingPath(
+      [
+        ...withSuffixes(relativeBase, PYTHON_EXTENSIONS),
+        ...withSuffixes(path14.posix.join(relativeBase, "__init__"), [".py"])
+      ],
+      workspaceFiles
+    );
+  }
+  const dottedPath = moduleName.split(".").join("/");
+  return firstExistingPath(
+    [
+      ...withSuffixes(dottedPath, PYTHON_EXTENSIONS),
+      ...withSuffixes(path14.posix.join(importerDir, dottedPath), PYTHON_EXTENSIONS)
+    ],
+    workspaceFiles
+  );
+}
+function resolveIncludePath(importerFilePath, includePath, workspaceFiles) {
+  const spec = includePath.trim().replace(/^["']|["']$/g, "");
+  if (!spec) return null;
+  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  const joined = normalizeWorkspacePath(
+    path14.posix.normalize(path14.posix.join(importerDir, spec.replace(/\\/g, "/")))
+  );
+  if (workspaceFiles.has(joined)) return joined;
+  return firstExistingPath(withSuffixes(joined, C_CPP_EXTENSIONS), workspaceFiles);
+}
+function resolveJavaImportPath(moduleSpecifier, workspaceFiles) {
+  const spec = moduleSpecifier.trim();
+  if (!spec) return null;
+  const pathLike = `${spec.replace(/\./g, "/")}.java`;
+  if (workspaceFiles.has(pathLike)) return pathLike;
+  for (const file of workspaceFiles) {
+    if (file === pathLike || file.endsWith(`/${pathLike}`)) return file;
+  }
+  return null;
+}
+function resolveGoImportPath(importerFilePath, moduleSpecifier, workspaceFiles) {
+  const spec = moduleSpecifier.trim();
+  if (!spec) return null;
+  if (isRelativeModuleSpecifier(spec)) {
+    const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+    const joined = normalizeWorkspacePath(path14.posix.normalize(path14.posix.join(importerDir, spec)));
+    if (workspaceFiles.has(joined)) return joined;
+    return firstExistingPath(withSuffixes(joined, [".go"]), workspaceFiles);
+  }
+  const leaf = spec.split("/").filter(Boolean).at(-1);
+  if (!leaf) return null;
+  for (const file of workspaceFiles) {
+    if (file.endsWith(`/${leaf}.go`) || file === `${leaf}.go`) return file;
+  }
+  return null;
+}
+function resolveImportSourcePath(importerFilePath, moduleSpecifier, workspaceFiles) {
+  const spec = moduleSpecifier.trim();
+  if (!spec) return null;
+  const tsResult = resolveModuleImportPath(importerFilePath, spec, workspaceFiles);
+  if (tsResult) return tsResult;
+  const languageKey = getLanguageKeyForFilePath(importerFilePath);
+  switch (languageKey) {
+    case "python":
+      return resolvePythonModulePath(importerFilePath, spec, workspaceFiles);
+    case "c":
+    case "cpp":
+      return resolveIncludePath(importerFilePath, spec, workspaceFiles);
+    case "java":
+      return resolveJavaImportPath(spec, workspaceFiles);
+    case "go":
+      return resolveGoImportPath(importerFilePath, spec, workspaceFiles);
+    default:
+      return null;
+  }
+}
+function isModulePathSpecifier(name) {
+  return isRelativeModuleSpecifier(name.trim());
+}
+var TS_JS_EXTENSIONS, PYTHON_EXTENSIONS, C_CPP_EXTENSIONS;
+var init_resolve_module_import_path = __esm({
+  "src/code-nav/resolve-module-import-path.ts"() {
+    "use strict";
+    init_language_registry();
+    TS_JS_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+    PYTHON_EXTENSIONS = [".py", "/__init__.py"];
+    C_CPP_EXTENSIONS = ["", ".h", ".hpp", ".hh", ".hxx", ".c", ".cpp", ".cc", ".cxx"];
+  }
+});
+
+// src/code-nav/enrich-tag-module-paths.ts
+function enrichTagsWithModulePaths(tags, filePath, workspaceFiles) {
+  return tags.map((tag) => {
+    if (tag.kind !== "module" || tag.role !== "ref" || !isModulePathSpecifier(tag.name)) {
+      return tag;
+    }
+    const resolved = resolveModuleImportPath(filePath, tag.name, workspaceFiles);
+    if (!resolved) return tag;
+    return { ...tag, navTargetPath: resolved };
+  });
+}
+var init_enrich_tag_module_paths = __esm({
+  "src/code-nav/enrich-tag-module-paths.ts"() {
+    "use strict";
+    init_resolve_module_import_path();
+  }
+});
+
+// src/code-nav/enrich-tag-module-paths-async.ts
+async function enrichTagsWithModulePathsAsync(tags, filePath, workspaceFiles, state) {
+  const chunkSize = 64;
+  const enriched = [];
+  for (let i = 0; i < tags.length; i += chunkSize) {
+    await yieldDuringCodeNavWork(state);
+    const chunk = tags.slice(i, i + chunkSize);
+    enriched.push(...enrichTagsWithModulePaths(chunk, filePath, workspaceFiles));
+  }
+  return enriched;
+}
+var init_enrich_tag_module_paths_async = __esm({
+  "src/code-nav/enrich-tag-module-paths-async.ts"() {
+    "use strict";
+    init_yield_during_work();
+    init_enrich_tag_module_paths();
+  }
+});
+
+// src/code-nav/augment-function-type-param-references.ts
+function tagDedupeKey(tag) {
+  return `${tag.startLine}:${tag.startColumn}:${tag.endLine}:${tag.endColumn}:${tag.role}:${tag.kind}:${tag.name}`;
+}
+function collectParamNames(functionTypeNode) {
+  const names = /* @__PURE__ */ new Set();
+  const parameters = functionTypeNode.childForFieldName("parameters");
+  if (!parameters) return names;
+  function walk(node) {
+    if (PARAM_NODE_TYPES.has(node.type)) {
+      const nameNode = node.childForFieldName("pattern") ?? node.namedChildren.find((c) => c.type === "identifier");
+      if (nameNode?.type === "identifier") names.add(nameNode.text);
+      return;
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(parameters);
+  return names;
+}
+function isDefinitionName(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (PARAM_NODE_TYPES.has(parent.type)) return true;
+  if (parent.type === "type_parameter" && parent.childForFieldName("name") === node) return true;
+  return false;
+}
+function tagFromIdentifierNode(node) {
+  return {
+    name: node.text,
+    role: "ref",
+    kind: "variable",
+    startLine: node.startPosition.row,
+    startColumn: node.startPosition.column,
+    endLine: node.endPosition.row,
+    endColumn: node.endPosition.column
+  };
+}
+function enclosingFunctionTypes(node) {
+  const types = [];
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_type") types.push(current);
+    current = current.parent;
+  }
+  return types;
+}
+function isFunctionTypeParamReference(node) {
+  if (node.type !== "identifier" || isDefinitionName(node)) return false;
+  for (const functionType of enclosingFunctionTypes(node)) {
+    const returnType = functionType.childForFieldName("return_type");
+    if (!returnType?.descendantsOfType("identifier").some((desc) => desc.id === node.id)) continue;
+    if (collectParamNames(functionType).has(node.text)) return true;
+  }
+  return false;
+}
+async function augmentFunctionTypeParamReferenceTags(tags, nameNodes, root) {
+  const seen = new Set(tags.map(tagDedupeKey));
+  const out = [...tags];
+  const state = createCodeNavYieldState();
+  async function walk(node) {
+    if (isFunctionTypeParamReference(node)) {
+      const tag = tagFromIdentifierNode(node);
+      const key = tagDedupeKey(tag);
+      if (!seen.has(key)) {
+        seen.add(key);
+        out.push(tag);
+        nameNodes.set(`${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`, node);
+      }
+    }
+    for (const child of node.children) {
+      await yieldDuringCodeNavWork(state);
+      await walk(child);
+    }
+  }
+  await walk(root);
+  return out;
+}
+var PARAM_NODE_TYPES;
+var init_augment_function_type_param_references = __esm({
+  "src/code-nav/augment-function-type-param-references.ts"() {
+    "use strict";
+    init_yield_during_work();
+    PARAM_NODE_TYPES = /* @__PURE__ */ new Set(["required_parameter", "optional_parameter"]);
+  }
+});
+
+// src/code-nav/augment-type-reference-tags.ts
+function tagDedupeKey2(tag) {
+  return `${tag.startLine}:${tag.startColumn}:${tag.endLine}:${tag.endColumn}:${tag.role}:${tag.kind}:${tag.name}`;
+}
+function isTypeDefinitionName(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  return TYPE_DEFINITION_CONTAINER_TYPES.has(parent.type) && parent.childForFieldName("name") === node;
+}
+function tagFromTypeIdentifierNode(node) {
+  return {
+    name: node.text,
+    role: "ref",
+    kind: "type",
+    startLine: node.startPosition.row,
+    startColumn: node.startPosition.column,
+    endLine: node.endPosition.row,
+    endColumn: node.endPosition.column
+  };
+}
+async function augmentTypeReferenceTags(tags, nameNodes, root) {
+  const seen = new Set(tags.map(tagDedupeKey2));
+  const out = [...tags];
+  const state = createCodeNavYieldState();
+  async function walk(node) {
+    if (node.type === "type_identifier" && !isTypeDefinitionName(node)) {
+      const tag = tagFromTypeIdentifierNode(node);
+      const key = tagDedupeKey2(tag);
+      if (!seen.has(key)) {
+        seen.add(key);
+        out.push(tag);
+        nameNodes.set(`${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`, node);
+      }
+    }
+    for (const child of node.children) {
+      await yieldDuringCodeNavWork(state);
+      await walk(child);
+    }
+  }
+  await walk(root);
+  return out;
+}
+var TYPE_DEFINITION_CONTAINER_TYPES;
+var init_augment_type_reference_tags = __esm({
+  "src/code-nav/augment-type-reference-tags.ts"() {
+    "use strict";
+    init_yield_during_work();
+    TYPE_DEFINITION_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+      "function_declaration",
+      "function_signature",
+      "generator_function_declaration",
+      "class_declaration",
+      "abstract_class_declaration",
+      "interface_declaration",
+      "type_alias_declaration",
+      "enum_declaration",
+      "module",
+      "type_parameter",
+      "method_definition",
+      "method_signature",
+      "abstract_method_signature",
+      "property_signature",
+      "public_field_definition"
+    ]);
+  }
+});
+
+// src/code-nav/scope-chain.ts
+function serializeScopeChain(chain2) {
+  if (chain2.length === 0) return null;
+  return chain2.map((anchor) => `${anchor.startLine}:${anchor.startColumn}`).join(",");
+}
+var init_scope_chain = __esm({
+  "src/code-nav/scope-chain.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/enrich-tag-scope.ts
+function scopeAnchorFromNode(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) {
+    return {
+      startLine: nameNode.startPosition.row,
+      startColumn: nameNode.startPosition.column
+    };
+  }
+  return {
+    startLine: node.startPosition.row,
+    startColumn: node.startPosition.column
+  };
+}
+function findEnclosingScopeChain(nameNode) {
+  const chain2 = [];
+  let current = nameNode.parent;
+  while (current) {
+    if (SCOPE_CONTAINER_TYPES.has(current.type)) {
+      chain2.push(scopeAnchorFromNode(current));
+    }
+    current = current.parent;
+  }
+  return chain2;
+}
+function findEnclosingScopes(nameNode) {
+  const scopeChain = findEnclosingScopeChain(nameNode);
+  return {
+    scope: scopeChain[0] ?? null,
+    parentScope: scopeChain[1] ?? null,
+    scopeChain
+  };
+}
+async function enrichTagsWithEnclosingScope(tags, nameNodes) {
+  const state = createCodeNavYieldState();
+  const out = [];
+  for (const tag of tags) {
+    await yieldDuringCodeNavWork(state);
+    const key = `${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`;
+    const nameNode = nameNodes.get(key);
+    if (!nameNode) {
+      out.push(tag);
+      continue;
+    }
+    const { scope, parentScope, scopeChain } = findEnclosingScopes(nameNode);
+    if (!scope) {
+      out.push(tag);
+      continue;
+    }
+    out.push({
+      ...tag,
+      scopeStartLine: scope.startLine,
+      scopeStartColumn: scope.startColumn,
+      parentScopeStartLine: parentScope?.startLine,
+      parentScopeStartColumn: parentScope?.startColumn,
+      scopeChain: serializeScopeChain(scopeChain) ?? void 0
+    });
+  }
+  return out;
+}
+var SCOPE_CONTAINER_TYPES;
+var init_enrich_tag_scope = __esm({
+  "src/code-nav/enrich-tag-scope.ts"() {
+    "use strict";
+    init_scope_chain();
+    init_yield_during_work();
+    SCOPE_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+      "function_declaration",
+      "function_expression",
+      "generator_function",
+      "generator_function_declaration",
+      "method_definition",
+      "method_signature",
+      "abstract_method_signature",
+      "class_declaration",
+      "abstract_class_declaration",
+      "interface_declaration",
+      "module",
+      "arrow_function",
+      "function_type",
+      "function_item",
+      "impl_item",
+      "function_definition",
+      "class_definition"
+    ]);
+  }
+});
+
+// src/code-nav/member-access/c.ts
+var C_MEMBER_ACCESS_RULES;
+var init_c = __esm({
+  "src/code-nav/member-access/c.ts"() {
+    "use strict";
+    C_MEMBER_ACCESS_RULES = [
+      { parentType: "field_expression", objectField: "argument", propertyField: "field", tagKind: "member" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/cpp.ts
+var CPP_MEMBER_ACCESS_RULES;
+var init_cpp = __esm({
+  "src/code-nav/member-access/cpp.ts"() {
+    "use strict";
+    init_c();
+    CPP_MEMBER_ACCESS_RULES = [
+      ...C_MEMBER_ACCESS_RULES,
+      { parentType: "qualified_identifier", objectField: "scope", propertyField: "name", tagKind: "member" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/go.ts
+var GO_MEMBER_ACCESS_RULES;
+var init_go = __esm({
+  "src/code-nav/member-access/go.ts"() {
+    "use strict";
+    GO_MEMBER_ACCESS_RULES = [
+      { parentType: "selector_expression", objectField: "operand", propertyField: "field", tagKind: "member" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/javascript.ts
+var ECMA_SCRIPT_MEMBER_ACCESS_RULES, JAVASCRIPT_MEMBER_ACCESS_RULES;
+var init_javascript = __esm({
+  "src/code-nav/member-access/javascript.ts"() {
+    "use strict";
+    ECMA_SCRIPT_MEMBER_ACCESS_RULES = [
+      { parentType: "member_expression", objectField: "object", propertyField: "property", tagKind: "member" }
+    ];
+    JAVASCRIPT_MEMBER_ACCESS_RULES = ECMA_SCRIPT_MEMBER_ACCESS_RULES;
+  }
+});
+
+// src/code-nav/member-access/java.ts
+var JAVA_MEMBER_ACCESS_RULES;
+var init_java = __esm({
+  "src/code-nav/member-access/java.ts"() {
+    "use strict";
+    JAVA_MEMBER_ACCESS_RULES = [
+      { parentType: "field_access", objectField: "object", propertyField: "field", tagKind: "member" },
+      { parentType: "method_invocation", objectField: "object", propertyField: "name", tagKind: "call" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/python.ts
+var PYTHON_MEMBER_ACCESS_RULES;
+var init_python = __esm({
+  "src/code-nav/member-access/python.ts"() {
+    "use strict";
+    PYTHON_MEMBER_ACCESS_RULES = [
+      { parentType: "attribute", objectField: "object", propertyField: "attribute", tagKind: "member" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/ruby.ts
+var RUBY_MEMBER_ACCESS_RULES;
+var init_ruby = __esm({
+  "src/code-nav/member-access/ruby.ts"() {
+    "use strict";
+    RUBY_MEMBER_ACCESS_RULES = [
+      { parentType: "call", objectField: "receiver", propertyField: "method", tagKind: "call" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/rust.ts
+var RUST_MEMBER_ACCESS_RULES;
+var init_rust = __esm({
+  "src/code-nav/member-access/rust.ts"() {
+    "use strict";
+    RUST_MEMBER_ACCESS_RULES = [
+      { parentType: "field_expression", objectField: "value", propertyField: "field", tagKind: "member" },
+      { parentType: "scoped_identifier", objectField: "path", propertyField: "name", tagKind: "member" }
+    ];
+  }
+});
+
+// src/code-nav/member-access/tsx.ts
+var init_tsx = __esm({
+  "src/code-nav/member-access/tsx.ts"() {
+    "use strict";
+    init_javascript();
+  }
+});
+
+// src/code-nav/member-access/typescript.ts
+var init_typescript = __esm({
+  "src/code-nav/member-access/typescript.ts"() {
+    "use strict";
+    init_javascript();
+  }
+});
+
+// src/code-nav/member-access/registry.ts
+function memberAccessRulesForLanguageKey(languageKey) {
+  if (!languageKey) return [];
+  return MEMBER_ACCESS_RULES_BY_LANGUAGE_KEY[languageKey] ?? [];
+}
+var MEMBER_ACCESS_RULES_BY_LANGUAGE_KEY;
+var init_registry = __esm({
+  "src/code-nav/member-access/registry.ts"() {
+    "use strict";
+    init_c();
+    init_cpp();
+    init_go();
+    init_javascript();
+    init_java();
+    init_python();
+    init_ruby();
+    init_rust();
+    init_tsx();
+    init_typescript();
+    MEMBER_ACCESS_RULES_BY_LANGUAGE_KEY = {
+      javascript: JAVASCRIPT_MEMBER_ACCESS_RULES,
+      typescript: ECMA_SCRIPT_MEMBER_ACCESS_RULES,
+      tsx: ECMA_SCRIPT_MEMBER_ACCESS_RULES,
+      python: PYTHON_MEMBER_ACCESS_RULES,
+      go: GO_MEMBER_ACCESS_RULES,
+      rust: RUST_MEMBER_ACCESS_RULES,
+      ruby: RUBY_MEMBER_ACCESS_RULES,
+      java: JAVA_MEMBER_ACCESS_RULES,
+      c: C_MEMBER_ACCESS_RULES,
+      cpp: CPP_MEMBER_ACCESS_RULES
+    };
+  }
+});
+
+// src/code-nav/member-access/types.ts
+var MEMBER_NAME_NODE_TYPES;
+var init_types = __esm({
+  "src/code-nav/member-access/types.ts"() {
+    "use strict";
+    MEMBER_NAME_NODE_TYPES = /* @__PURE__ */ new Set([
+      "identifier",
+      "property_identifier",
+      "field_identifier",
+      "type_identifier",
+      "constant",
+      "package_identifier"
+    ]);
+  }
+});
+
+// src/code-nav/member-access/shared.ts
+function nodesMatch(a, b) {
+  return a.startPosition.row === b.startPosition.row && a.startPosition.column === b.startPosition.column && a.text === b.text;
+}
+function fieldNodeMatches(node, candidate) {
+  return node != null && nodesMatch(node, candidate);
+}
+function isReceiverNameNode(node) {
+  return MEMBER_NAME_NODE_TYPES.has(node.type) || node.type === "this" || node.type === "self" || node.type === "super";
+}
+function objectNodeFromAccessNode(accessNode, rule) {
+  const objectNode = accessNode.childForFieldName(rule.objectField);
+  if (!objectNode || !isReceiverNameNode(objectNode)) return null;
+  return objectNode;
+}
+function isMemberAccessPropertyNameNode(nameNode, rules) {
+  const parent = nameNode.parent;
+  if (!parent) return false;
+  for (const rule of rules) {
+    if (parent.type !== rule.parentType) continue;
+    if (fieldNodeMatches(parent.childForFieldName(rule.propertyField), nameNode)) return true;
+  }
+  return false;
+}
+var init_shared = __esm({
+  "src/code-nav/member-access/shared.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/code-nav/member-access/index.ts
+function tagDedupeKey3(tag) {
+  return `${tag.startLine}:${tag.startColumn}:${tag.endLine}:${tag.endColumn}:${tag.role}:${tag.kind}:${tag.name}`;
+}
+function tagFromReceiverNode(node) {
+  return {
+    name: node.text,
+    role: "ref",
+    kind: "variable",
+    startLine: node.startPosition.row,
+    startColumn: node.startPosition.column,
+    endLine: node.endPosition.row,
+    endColumn: node.endPosition.column
+  };
+}
+function lookupNameNode(nameNodes, tag) {
+  const key = `${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`;
+  if (nameNodes.has(key)) return nameNodes.get(key);
+  for (const node of nameNodes.values()) {
+    if (node.text === tag.name && node.startPosition.row === tag.startLine && node.startPosition.column === tag.startColumn) {
+      return node;
+    }
+  }
+  return null;
+}
+function filterMemberAccessPropertyTags(tags, nameNodes, languageKey) {
+  const rules = memberAccessRulesForLanguageKey(languageKey);
+  if (rules.length === 0) return tags;
+  return tags.filter((tag) => {
+    if (tag.role !== "ref") return true;
+    const nameNode = lookupNameNode(nameNodes, tag);
+    if (!nameNode) return true;
+    return !isMemberAccessPropertyNameNode(nameNode, rules);
+  });
+}
+async function augmentMemberReceiverTags(tags, nameNodes, root, languageKey) {
+  const rules = memberAccessRulesForLanguageKey(languageKey);
+  if (rules.length === 0) return tags;
+  const seen = new Set(tags.map(tagDedupeKey3));
+  const seenRefPositions = new Set(
+    tags.filter((tag) => tag.role === "ref").map((tag) => `${tag.startLine}:${tag.startColumn}:${tag.name}`)
+  );
+  const out = [...tags];
+  const state = createCodeNavYieldState();
+  for (const rule of rules) {
+    for (const accessNode of root.descendantsOfType(rule.parentType)) {
+      await yieldDuringCodeNavWork(state);
+      const receiverNode = objectNodeFromAccessNode(accessNode, rule);
+      if (!receiverNode) continue;
+      const refPositionKey = `${receiverNode.startPosition.row}:${receiverNode.startPosition.column}:${receiverNode.text}`;
+      if (seenRefPositions.has(refPositionKey)) continue;
+      const tag = tagFromReceiverNode(receiverNode);
+      const key = tagDedupeKey3(tag);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      seenRefPositions.add(refPositionKey);
+      out.push(tag);
+      nameNodes.set(`${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`, receiverNode);
+    }
+  }
+  return out;
+}
+var init_member_access = __esm({
+  "src/code-nav/member-access/index.ts"() {
+    "use strict";
+    init_yield_during_work();
+    init_registry();
+    init_shared();
+  }
+});
+
+// src/code-nav/tree-sitter-assets-dir.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function repoNodeModulesDir(fromDir) {
+  return join2(fromDir, "..", "..", "..", "node_modules");
+}
+function firstDirWithWebTreeSitterWasm(candidates) {
+  for (const dir of candidates) {
+    if (existsSync2(join2(dir, "web-tree-sitter.wasm"))) return dir;
+  }
+  return null;
+}
+function getTreeSitterAssetsDir() {
+  const moduleDir = dirname2(fileURLToPath2(import.meta.url));
+  const fromModule = firstDirWithWebTreeSitterWasm([
+    join2(moduleDir, "tree-sitter"),
+    join2(moduleDir, "..", "tree-sitter"),
+    join2(moduleDir, "..", "..", "dist", "tree-sitter")
+  ]);
+  if (fromModule) return fromModule;
+  const fromNodeModules = firstDirWithWebTreeSitterWasm([join2(repoNodeModulesDir(moduleDir), "web-tree-sitter")]);
+  if (fromNodeModules) return fromNodeModules;
+  throw new Error(
+    "Missing web-tree-sitter.wasm. Run `pnpm build` in packages/cli to copy tree-sitter assets into dist/tree-sitter."
+  );
+}
+var init_tree_sitter_assets_dir = __esm({
+  "src/code-nav/tree-sitter-assets-dir.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/parser/tree-sitter-runtime.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { Parser, Language, Query, LANGUAGE_VERSION, MIN_COMPATIBLE_VERSION } from "web-tree-sitter";
+function withTreeSitterRuntimeLock(fn) {
+  const next = runtimeChain.then(() => Promise.resolve(fn()));
+  runtimeChain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+async function ensureParserInit() {
+  if (!initPromise) {
+    const assetsDir = getTreeSitterAssetsDir();
+    initPromise = Parser.init({
+      locateFile: (scriptName) => join3(assetsDir, scriptName)
+    }).catch((e) => {
+      initPromise = null;
+      throw e;
+    });
+  }
+  await initPromise;
+}
+function resolveWasmPath(assetsDir, wasmFile) {
+  const candidates = [
+    join3(assetsDir, wasmFile),
+    join3(assetsDir, "..", "..", "dist", "tree-sitter", wasmFile),
+    join3(assetsDir, "..", "..", "..", "node_modules", wasmFile.replace(".wasm", ""), wasmFile)
+  ];
+  const hit = candidates.find((p) => existsSync3(p));
+  if (!hit) throw new Error(`Missing tree-sitter wasm: ${wasmFile}`);
+  return hit;
+}
+function resolveTagsPath(assetsDir, tagsQueryFile) {
+  const pkgName = tagsQueryFile.split("/")[0] ?? "";
+  const candidates = [
+    join3(CODE_NAV_QUERIES_ROOT, tagsQueryFile),
+    join3(assetsDir, tagsQueryFile),
+    join3(assetsDir, "..", "..", "dist", "tree-sitter", tagsQueryFile),
+    join3(assetsDir, "..", "..", "..", "node_modules", pkgName, "queries", "tags.scm")
+  ];
+  const hit = candidates.find((p) => existsSync3(p));
+  if (!hit) throw new Error(`Missing tags query: ${tagsQueryFile}`);
+  return hit;
+}
+async function loadLanguage(languageKey) {
+  const spec = getLanguageSpec(languageKey);
+  if (!spec) return null;
+  if (failedLanguageKeys.has(languageKey)) return null;
+  const cached = loadedByKey.get(languageKey);
+  if (cached) return cached;
+  await ensureParserInit();
+  const assetsDir = getTreeSitterAssetsDir();
+  const language = await Language.load(resolveWasmPath(assetsDir, spec.wasmFile));
+  const abiVersion = language.abiVersion;
+  if (abiVersion < MIN_COMPATIBLE_VERSION || abiVersion > LANGUAGE_VERSION) {
+    failedLanguageKeys.add(languageKey);
+    throw new Error(
+      `Incompatible tree-sitter ABI for ${languageKey}: grammar=${abiVersion}, runtime=${MIN_COMPATIBLE_VERSION}-${LANGUAGE_VERSION}`
+    );
+  }
+  const tagsSource = readFileSync2(resolveTagsPath(assetsDir, spec.tagsQueryFile), "utf8");
+  const query = new Query(language, tagsSource);
+  const loaded = { language, query };
+  loadedByKey.set(languageKey, loaded);
+  return loaded;
+}
+var initPromise, loadedByKey, failedLanguageKeys, runtimeChain, CODE_NAV_QUERIES_ROOT;
+var init_tree_sitter_runtime = __esm({
+  "src/code-nav/parser/tree-sitter-runtime.ts"() {
+    "use strict";
+    init_tree_sitter_assets_dir();
+    init_language_registry();
+    initPromise = null;
+    loadedByKey = /* @__PURE__ */ new Map();
+    failedLanguageKeys = /* @__PURE__ */ new Set();
+    runtimeChain = Promise.resolve();
+    CODE_NAV_QUERIES_ROOT = join3(dirname3(fileURLToPath3(import.meta.url)), "..", "queries");
+  }
+});
+
+// src/code-nav/parser/parse-source-root.ts
+import { Parser as Parser2 } from "web-tree-sitter";
+async function parseSourceRoot(filePath, source) {
+  const languageKey = getLanguageKeyForFilePath(filePath);
+  if (!languageKey) return null;
+  return withTreeSitterRuntimeLock(async () => {
+    await yieldForBridgeInteractivePriority();
+    let loaded;
+    try {
+      loaded = await loadLanguage(languageKey);
+    } catch {
+      return null;
+    }
+    if (!loaded) return null;
+    const parser = new Parser2();
+    parser.setLanguage(loaded.language);
+    let tree = null;
+    try {
+      await yieldForBridgeInteractivePriority();
+      assertBackgroundIndexingAllowed();
+      tree = parser.parse(source);
+      assertBackgroundIndexingAllowed();
+      await yieldForBridgeInteractivePriority();
+      if (!tree) return null;
+      return {
+        root: tree.rootNode,
+        loaded,
+        cleanup: () => {
+          tree?.delete();
+          parser.delete();
+        }
+      };
+    } catch (err) {
+      tree?.delete();
+      parser.delete();
+      if (isSymbolIndexDeferredError(err)) throw err;
+      return null;
+    }
+  });
+}
+var init_parse_source_root = __esm({
+  "src/code-nav/parser/parse-source-root.ts"() {
+    "use strict";
+    init_file_browser_in_flight();
+    init_deferred_indexing();
+    init_language_registry();
+    init_tree_sitter_runtime();
+  }
+});
+
+// src/code-nav/parser/run-tags-query.ts
+async function runTagsQuery(loaded, root) {
+  await yieldForBridgeInteractivePriority();
+  assertBackgroundIndexingAllowed();
+  const matches = loaded.query.matches(root);
+  assertBackgroundIndexingAllowed();
+  await yieldForBridgeInteractivePriority();
+  return matches;
+}
+var init_run_tags_query = __esm({
+  "src/code-nav/parser/run-tags-query.ts"() {
+    "use strict";
+    init_file_browser_in_flight();
+  }
+});
+
+// src/code-nav/parser/tags-from-matches.ts
+function parseCaptureRole(captureName) {
+  if (captureName === "name") return null;
+  const dot = captureName.indexOf(".");
+  if (dot < 0) return null;
+  const prefix = captureName.slice(0, dot);
+  const kind = captureName.slice(dot + 1);
+  if (prefix === "definition") return { role: "def", kind };
+  if (prefix === "reference") return { role: "ref", kind };
+  return null;
+}
+function tagDedupeKey4(tag) {
+  return `${tag.startLine}:${tag.startColumn}:${tag.endLine}:${tag.endColumn}:${tag.role}:${tag.kind}:${tag.name}`;
+}
+function tagsFromMatches(matches) {
+  const tags = [];
+  const nameNodes = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    let name = null;
+    let nameNode = null;
+    const roleNodes = [];
+    for (const capture of match.captures) {
+      if (capture.name === "name") {
+        name = capture.node.text;
+        nameNode = capture.node;
+        continue;
+      }
+      const parsed = parseCaptureRole(capture.name);
+      if (parsed) roleNodes.push({ ...parsed, node: capture.node });
+    }
+    if (!name || !nameNode || roleNodes.length === 0) continue;
+    for (const roleNode of roleNodes) {
+      const tag = {
+        name,
+        role: roleNode.role,
+        kind: roleNode.kind,
+        startLine: nameNode.startPosition.row,
+        startColumn: nameNode.startPosition.column,
+        endLine: nameNode.endPosition.row,
+        endColumn: nameNode.endPosition.column
+      };
+      const key = tagDedupeKey4(tag);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      tags.push(tag);
+      nameNodes.set(`${tag.startLine}:${tag.startColumn}:${tag.name}:${tag.role}:${tag.kind}`, nameNode);
+    }
+  }
+  return { tags, nameNodes };
+}
+var init_tags_from_matches = __esm({
+  "src/code-nav/parser/tags-from-matches.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/parser/tags-from-matches-async.ts
+function tagDedupeKey5(tag) {
+  return `${tag.startLine}:${tag.startColumn}:${tag.endLine}:${tag.endColumn}:${tag.role}:${tag.kind}:${tag.name}`;
+}
+async function tagsFromMatchesAsync(matches, state) {
+  const tags = [];
+  const nameNodes = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    await yieldDuringCodeNavWork(state);
+    const partial = tagsFromMatches([match]);
+    for (const tag of partial.tags) {
+      const key = tagDedupeKey5(tag);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      tags.push(tag);
+    }
+    for (const [key, node] of partial.nameNodes) nameNodes.set(key, node);
+  }
+  return { tags, nameNodes };
+}
+var init_tags_from_matches_async = __esm({
+  "src/code-nav/parser/tags-from-matches-async.ts"() {
+    "use strict";
+    init_yield_during_work();
+    init_tags_from_matches();
+  }
+});
+
+// src/code-nav/parser/extract-tags.ts
+async function extractTagsFromSource(filePath, source) {
+  const languageKey = getLanguageKeyForFilePath(filePath);
+  await yieldForBridgeInteractivePriority();
+  const parsed = await parseSourceRoot(filePath, source);
+  if (!parsed) return [];
+  try {
+    const yieldState = createCodeNavYieldState();
+    const matches = await runTagsQuery(parsed.loaded, parsed.root);
+    const { tags, nameNodes } = await tagsFromMatchesAsync(matches, yieldState);
+    await yieldDuringCodeNavWork(yieldState);
+    const filtered = filterMemberAccessPropertyTags(tags, nameNodes, languageKey);
+    const withTypes = await augmentTypeReferenceTags(filtered, nameNodes, parsed.root);
+    await yieldDuringCodeNavWork(yieldState);
+    const withFunctionTypeParamRefs = await augmentFunctionTypeParamReferenceTags(withTypes, nameNodes, parsed.root);
+    await yieldDuringCodeNavWork(yieldState);
+    const withReceivers = await augmentMemberReceiverTags(withFunctionTypeParamRefs, nameNodes, parsed.root, languageKey);
+    await yieldDuringCodeNavWork(yieldState);
+    return await enrichTagsWithEnclosingScope(withReceivers, nameNodes);
+  } catch (err) {
+    if (isSymbolIndexDeferredError(err)) throw err;
+    return [];
+  } finally {
+    parsed.cleanup();
+  }
+}
+var init_extract_tags = __esm({
+  "src/code-nav/parser/extract-tags.ts"() {
+    "use strict";
+    init_language_registry();
+    init_augment_function_type_param_references();
+    init_augment_type_reference_tags();
+    init_enrich_tag_scope();
+    init_member_access();
+    init_yield_during_work();
+    init_file_browser_in_flight();
+    init_deferred_indexing();
+    init_parse_source_root();
+    init_run_tags_query();
+    init_tags_from_matches_async();
+  }
+});
+
+// src/code-nav/parser-runtime.ts
+var init_parser_runtime = __esm({
+  "src/code-nav/parser-runtime.ts"() {
+    "use strict";
+    init_extract_tags();
+    init_parse_source_root();
+  }
+});
+
+// src/code-nav/symbol-index/imports/shared.ts
+function pushBinding(out, filePath, workspaceFiles, moduleSpecifier, localName, sourceName, importKind, nameNode) {
+  if (!localName) return;
+  out.push({
+    localName,
+    sourceName,
+    moduleSpecifier,
+    sourceFilePath: resolveImportSourcePath(filePath, moduleSpecifier, workspaceFiles),
+    importKind,
+    startLine: nameNode.startPosition.row,
+    startColumn: nameNode.startPosition.column
+  });
+}
+function stripQuotes(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function stringLiteralText(node) {
+  const fragment = node.descendantsOfType("string_fragment")[0];
+  return stripQuotes(fragment?.text ?? node.text);
+}
+var init_shared2 = __esm({
+  "src/code-nav/symbol-index/imports/shared.ts"() {
+    "use strict";
+    init_resolve_module_import_path();
+  }
+});
+
+// src/code-nav/symbol-index/imports/c.ts
+function extractCIncludeBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("preproc_include")) {
+    const pathNode = node.childForFieldName("path");
+    if (!pathNode) continue;
+    const includePath = stringLiteralText(pathNode);
+    const localName = includePath.split("/").filter(Boolean).at(-1)?.replace(/\.(h|hpp)$/, "") ?? includePath;
+    pushBinding(out, filePath, workspaceFiles, includePath, localName, localName, "default", pathNode);
+  }
+  return out;
+}
+var init_c2 = __esm({
+  "src/code-nav/symbol-index/imports/c.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/cpp.ts
+function extractCppImportBindings(root, filePath, workspaceFiles) {
+  return extractCIncludeBindings(root, filePath, workspaceFiles);
+}
+var init_cpp2 = __esm({
+  "src/code-nav/symbol-index/imports/cpp.ts"() {
+    "use strict";
+    init_c2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/ecma-script-imports.ts
+function importKindForSpecifier(specifier, statementKind) {
+  if (specifier.children.some((child) => child.type === "type")) return "type";
+  return statementKind;
+}
+function collectFromImportSpecifier(out, filePath, workspaceFiles, moduleSpecifier, importKind, specifier) {
+  const nameNode = specifier.childForFieldName("name");
+  const aliasNode = specifier.childForFieldName("alias");
+  if (!nameNode) return;
+  const sourceName = nameNode.text;
+  const localName = aliasNode?.text ?? sourceName;
+  const effectiveKind = importKindForSpecifier(specifier, importKind);
+  pushBinding(out, filePath, workspaceFiles, moduleSpecifier, localName, sourceName, effectiveKind, aliasNode ?? nameNode);
+}
+function collectFromImportClause(out, filePath, workspaceFiles, moduleSpecifier, importKind, clause) {
+  const defaultName = clause.childForFieldName("name");
+  if (defaultName) {
+    pushBinding(out, filePath, workspaceFiles, moduleSpecifier, defaultName.text, defaultName.text, "default", defaultName);
+  }
+  for (const child of clause.children) {
+    if (child.type === "named_imports") {
+      for (const spec of child.children) {
+        if (spec.type === "import_specifier") {
+          collectFromImportSpecifier(out, filePath, workspaceFiles, moduleSpecifier, importKind, spec);
+        }
+      }
+    }
+    if (child.type === "import_specifier") {
+      collectFromImportSpecifier(out, filePath, workspaceFiles, moduleSpecifier, importKind, child);
+    }
+    if (child.type === "namespace_import") {
+      const alias = child.childForFieldName("name") ?? child.namedChildren.find((n) => n.type === "identifier");
+      if (alias) {
+        pushBinding(out, filePath, workspaceFiles, moduleSpecifier, alias.text, alias.text, "namespace", alias);
+      }
+    }
+  }
+}
+function moduleSpecifierFromImport(node) {
+  const source = node.childForFieldName("source");
+  if (!source) return null;
+  return stringLiteralText(source);
+}
+function collectFromImportStatement(out, filePath, workspaceFiles, node) {
+  const moduleSpecifier = moduleSpecifierFromImport(node);
+  if (!moduleSpecifier) return;
+  const isTypeImport = node.children.some((child) => child.type === "type");
+  const importKind = isTypeImport ? "type" : "named";
+  const clause = node.children.find((child) => child.type === "import_clause");
+  if (clause) {
+    collectFromImportClause(out, filePath, workspaceFiles, moduleSpecifier, importKind, clause);
+  }
+}
+function extractEcmaScriptImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("import_statement")) {
+    collectFromImportStatement(out, filePath, workspaceFiles, node);
+  }
+  return out;
+}
+var init_ecma_script_imports = __esm({
+  "src/code-nav/symbol-index/imports/ecma-script-imports.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/ecma-script-exports.ts
+function exportKindForSpecifier(specifier, statementKind) {
+  if (specifier.children.some((child) => child.type === "type")) return "type";
+  return statementKind;
+}
+function collectFromExportSpecifier(out, filePath, workspaceFiles, moduleSpecifier, exportKind, specifier) {
+  const nameNode = specifier.childForFieldName("name");
+  const aliasNode = specifier.childForFieldName("alias");
+  if (!nameNode) return;
+  const sourceName = nameNode.text;
+  const localName = aliasNode?.text ?? sourceName;
+  const effectiveKind = exportKindForSpecifier(specifier, exportKind);
+  pushBinding(out, filePath, workspaceFiles, moduleSpecifier, localName, sourceName, effectiveKind, aliasNode ?? nameNode);
+}
+function moduleSpecifierFromExport(node) {
+  const source = node.childForFieldName("source");
+  if (!source) return null;
+  return stringLiteralText(source);
+}
+function isStarReexport(node) {
+  if (!moduleSpecifierFromExport(node)) return false;
+  if (node.descendantsOfType("export_specifier").length > 0) return false;
+  if (node.descendantsOfType("namespace_export").length > 0) return false;
+  if (node.childForFieldName("declaration")) return false;
+  return node.text.includes("*");
+}
+function extractEcmaScriptReexportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("export_statement")) {
+    const moduleSpecifier = moduleSpecifierFromExport(node);
+    if (!moduleSpecifier) continue;
+    const isTypeExport = node.children.some((child) => child.type === "type");
+    const exportKind = isTypeExport ? "type" : "reexport";
+    if (isStarReexport(node)) {
+      const anchor = node.childForFieldName("source") ?? node;
+      pushBinding(out, filePath, workspaceFiles, moduleSpecifier, "*", "*", "star", anchor);
+      continue;
+    }
+    for (const spec of node.descendantsOfType("export_specifier")) {
+      collectFromExportSpecifier(out, filePath, workspaceFiles, moduleSpecifier, exportKind, spec);
+    }
+    for (const ns of node.descendantsOfType("namespace_export")) {
+      const alias = ns.childForFieldName("name") ?? ns.namedChildren.find((n) => n.type === "identifier");
+      if (alias) {
+        pushBinding(out, filePath, workspaceFiles, moduleSpecifier, alias.text, alias.text, "namespace", alias);
+      }
+    }
+  }
+  return out;
+}
+var init_ecma_script_exports = __esm({
+  "src/code-nav/symbol-index/imports/ecma-script-exports.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/ecma-script.ts
+function extractEcmaScriptBindings(root, filePath, workspaceFiles) {
+  const imports = extractEcmaScriptImportBindings(root, filePath, workspaceFiles);
+  const reexports = extractEcmaScriptReexportBindings(root, filePath, workspaceFiles);
+  return [...imports, ...reexports];
+}
+var init_ecma_script = __esm({
+  "src/code-nav/symbol-index/imports/ecma-script.ts"() {
+    "use strict";
+    init_ecma_script_imports();
+    init_ecma_script_exports();
+    init_ecma_script_imports();
+  }
+});
+
+// src/code-nav/symbol-index/imports/go.ts
+function collectImportSpec(out, filePath, workspaceFiles, spec) {
+  const pathNode = spec.childForFieldName("path");
+  if (!pathNode) return;
+  const modulePath = stringLiteralText(pathNode);
+  const nameNode = spec.childForFieldName("name");
+  if (nameNode) {
+    pushBinding(out, filePath, workspaceFiles, modulePath, nameNode.text, nameNode.text, "namespace", nameNode);
+    return;
+  }
+  const localName = modulePath.split("/").filter(Boolean).at(-1) ?? modulePath;
+  pushBinding(out, filePath, workspaceFiles, modulePath, localName, localName, "namespace", pathNode);
+}
+function extractGoImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("import_declaration")) {
+    for (const spec of node.descendantsOfType("import_spec")) {
+      collectImportSpec(out, filePath, workspaceFiles, spec);
+    }
+  }
+  return out;
+}
+var init_go2 = __esm({
+  "src/code-nav/symbol-index/imports/go.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/java.ts
+function localNameFromImport(nameNode) {
+  return nameNode.text.split(".").at(-1) ?? nameNode.text;
+}
+function collectImportDeclaration(out, filePath, workspaceFiles, node) {
+  for (const child of node.namedChildren) {
+    if (child.type === "scoped_identifier" || child.type === "identifier") {
+      const sourceName = child.text;
+      const localName = localNameFromImport(child);
+      pushBinding(out, filePath, workspaceFiles, sourceName, localName, sourceName, "named", child);
+    }
+  }
+}
+function extractJavaImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("import_declaration")) {
+    collectImportDeclaration(out, filePath, workspaceFiles, node);
+  }
+  return out;
+}
+var init_java2 = __esm({
+  "src/code-nav/symbol-index/imports/java.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/python.ts
+function dottedNameText(node) {
+  return node.text.replace(/\s+/g, "");
+}
+function collectImportStatement(out, filePath, workspaceFiles, node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const moduleName = dottedNameText(nameNode);
+  const localName = moduleName.split(".").at(-1) ?? moduleName;
+  pushBinding(out, filePath, workspaceFiles, moduleName, localName, localName, "namespace", nameNode);
+}
+function collectImportFromStatement(out, filePath, workspaceFiles, node) {
+  const moduleNode = node.childForFieldName("module_name");
+  const moduleName = moduleNode ? dottedNameText(moduleNode) : "";
+  for (const child of node.namedChildren) {
+    if (child.type !== "dotted_name" && child.type !== "aliased_import") continue;
+    if (child === moduleNode) continue;
+    if (child.type === "dotted_name") {
+      const sourceName2 = dottedNameText(child);
+      const localName2 = sourceName2.split(".").at(-1) ?? sourceName2;
+      pushBinding(out, filePath, workspaceFiles, moduleName, localName2, sourceName2, "named", child);
+      continue;
+    }
+    const nameNode = child.childForFieldName("name");
+    const aliasNode = child.childForFieldName("alias");
+    if (!nameNode) continue;
+    const sourceName = dottedNameText(nameNode);
+    const localName = aliasNode ? aliasNode.text : sourceName.split(".").at(-1) ?? sourceName;
+    pushBinding(out, filePath, workspaceFiles, moduleName, localName, sourceName, "named", aliasNode ?? nameNode);
+  }
+}
+function extractPythonImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("import_statement")) {
+    collectImportStatement(out, filePath, workspaceFiles, node);
+  }
+  for (const node of root.descendantsOfType("import_from_statement")) {
+    collectImportFromStatement(out, filePath, workspaceFiles, node);
+  }
+  return out;
+}
+var init_python2 = __esm({
+  "src/code-nav/symbol-index/imports/python.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/ruby.ts
+function collectRequireCall(out, filePath, workspaceFiles, node) {
+  const methodNode = node.childForFieldName("method");
+  if (!methodNode || methodNode.text !== "require" && methodNode.text !== "require_relative") return;
+  const args = node.childForFieldName("arguments");
+  const stringNode = args?.descendantsOfType("string")[0] ?? args?.descendantsOfType("string_content")[0];
+  if (!stringNode) return;
+  const modulePath = stringLiteralText(stringNode);
+  const localName = modulePath.split("/").filter(Boolean).at(-1)?.replace(/\.rb$/, "") ?? modulePath;
+  pushBinding(out, filePath, workspaceFiles, modulePath, localName, localName, "default", stringNode);
+}
+function extractRubyImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("call")) {
+    collectRequireCall(out, filePath, workspaceFiles, node);
+  }
+  return out;
+}
+var init_ruby2 = __esm({
+  "src/code-nav/symbol-index/imports/ruby.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/rust.ts
+function identifierFromUseTree(node) {
+  if (node.type === "identifier" || node.type === "type_identifier") return node;
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode;
+  for (const child of node.namedChildren) {
+    const hit = identifierFromUseTree(child);
+    if (hit) return hit;
+  }
+  return null;
+}
+function useDeclarationIsPublic(node) {
+  return node.children.some((child) => child.type === "visibility_modifier" && child.text === "pub");
+}
+function collectUseTree(out, filePath, workspaceFiles, pathPrefix, node, importKind = "named") {
+  if (node.type === "use_as_clause") {
+    const pathNode = node.childForFieldName("path");
+    const aliasNode = node.childForFieldName("alias");
+    if (!pathNode || !aliasNode) return;
+    const sourceName = identifierFromUseTree(pathNode)?.text ?? pathNode.text.split("::").at(-1) ?? "";
+    pushBinding(out, filePath, workspaceFiles, pathPrefix, aliasNode.text, sourceName, importKind, aliasNode);
+    return;
+  }
+  if (node.type === "identifier" || node.type === "type_identifier") {
+    const sourceName = node.text;
+    pushBinding(out, filePath, workspaceFiles, pathPrefix, sourceName, sourceName, importKind, node);
+    return;
+  }
+  if (node.type === "scoped_identifier") {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const sourceName = nameNode.text;
+    pushBinding(out, filePath, workspaceFiles, pathPrefix, sourceName, sourceName, importKind, nameNode);
+    return;
+  }
+  if (node.type === "use_list") {
+    for (const child of node.namedChildren) {
+      collectUseTree(out, filePath, workspaceFiles, pathPrefix, child, importKind);
+    }
+    return;
+  }
+  if (node.type === "scoped_use_list") {
+    const pathNode = node.childForFieldName("path");
+    const nextPrefix = pathNode ? `${pathPrefix}${pathNode.text}::` : pathPrefix;
+    for (const child of node.namedChildren) {
+      if (child === pathNode) continue;
+      collectUseTree(out, filePath, workspaceFiles, nextPrefix, child, importKind);
+    }
+    return;
+  }
+  for (const child of node.namedChildren) {
+    collectUseTree(out, filePath, workspaceFiles, pathPrefix, child, importKind);
+  }
+}
+function extractRustImportBindings(root, filePath, workspaceFiles) {
+  const out = [];
+  for (const node of root.descendantsOfType("use_declaration")) {
+    const argument = node.childForFieldName("argument");
+    if (!argument) continue;
+    const importKind = useDeclarationIsPublic(node) ? "reexport" : "named";
+    collectUseTree(out, filePath, workspaceFiles, "", argument, importKind);
+  }
+  return out;
+}
+var init_rust2 = __esm({
+  "src/code-nav/symbol-index/imports/rust.ts"() {
+    "use strict";
+    init_shared2();
+  }
+});
+
+// src/code-nav/symbol-index/imports/index.ts
+async function extractImportBindingsFromSource(filePath, source, workspaceFiles) {
+  const languageKey = getLanguageKeyForFilePath(filePath);
+  if (!languageKey) return [];
+  const extract = EXTRACTORS_BY_LANGUAGE_KEY[languageKey];
+  if (!extract) return [];
+  const parsed = await parseSourceRoot(filePath, source);
+  if (!parsed) return [];
+  try {
+    await yieldToEventLoop();
+    const yieldState = createCodeNavYieldState();
+    await yieldDuringCodeNavWork(yieldState);
+    const bindings = extract(parsed.root, filePath, workspaceFiles);
+    await yieldDuringCodeNavWork(yieldState);
+    return bindings;
+  } finally {
+    parsed.cleanup();
+  }
+}
+var EXTRACTORS_BY_LANGUAGE_KEY;
+var init_imports = __esm({
+  "src/code-nav/symbol-index/imports/index.ts"() {
+    "use strict";
+    init_language_registry();
+    init_parser_runtime();
+    init_yield_during_work();
+    init_yield_to_event_loop();
+    init_c2();
+    init_cpp2();
+    init_ecma_script();
+    init_go2();
+    init_java2();
+    init_python2();
+    init_ruby2();
+    init_rust2();
+    EXTRACTORS_BY_LANGUAGE_KEY = {
+      javascript: extractEcmaScriptBindings,
+      typescript: extractEcmaScriptBindings,
+      tsx: extractEcmaScriptBindings,
+      python: extractPythonImportBindings,
+      go: extractGoImportBindings,
+      rust: extractRustImportBindings,
+      ruby: extractRubyImportBindings,
+      java: extractJavaImportBindings,
+      c: extractCIncludeBindings,
+      cpp: extractCppImportBindings
+    };
+  }
+});
+
+// src/code-nav/symbol-index/build/read-index-source.ts
+var MAX_INDEX_FILE_BYTES;
+var init_read_index_source = __esm({
+  "src/code-nav/symbol-index/build/read-index-source.ts"() {
+    "use strict";
+    init_cli_process_interrupt();
+    init_code_nav_cache_database();
+    MAX_INDEX_FILE_BYTES = 512 * 1024;
+  }
+});
+
+// src/code-nav/symbol-index/build/workspace-files.ts
+function listWorkspaceFiles(db, workspacePath, includePath) {
+  const files = /* @__PURE__ */ new Set([includePath.replace(/\\/g, "/")]);
+  const normalizedWorkspace = normalizeResolvedPath(workspacePath);
+  const parentRow = db.get("SELECT id FROM file_index_parent_path WHERE path = ?", [normalizedWorkspace]);
+  if (parentRow != null) {
+    const fromIndex = db.all("SELECT path FROM file_index_child_path WHERE parent_id = ?", [
+      Number(parentRow.id)
+    ]);
+    for (const row of fromIndex) files.add(row.path.replace(/\\/g, "/"));
+  }
+  const ctx = getSymbolIndexParentContext(db, normalizedWorkspace);
+  if (ctx != null) {
+    for (const filePath of listEffectiveIndexedFilePaths(db, ctx)) {
+      files.add(filePath.replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+var init_workspace_files = __esm({
+  "src/code-nav/symbol-index/build/workspace-files.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_symbol_index_sqlite();
+    init_symbol_parent_file_map();
+  }
+});
+
+// src/code-nav/symbol-index/build/extract-file-symbol-data.ts
+import fs12 from "node:fs";
+import path15 from "node:path";
+async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride) {
+  await yieldForBridgeInteractivePriority();
+  const absPath = path15.join(resolved, relPath);
+  let tags = [];
+  let source = null;
+  if (isCodeNavSupportedPath(relPath) && !await isPathGitIgnored(resolved, relPath)) {
+    try {
+      const stat = await fs12.promises.stat(absPath);
+      if (stat.isFile() && stat.size <= MAX_INDEX_FILE_BYTES) {
+        source = await fs12.promises.readFile(absPath, "utf8");
+        await yieldForBridgeInteractivePriority();
+        tags = await extractTagsFromSource(relPath, source);
+      }
+    } catch (err) {
+      if (isSymbolIndexDeferredError(err)) throw err;
+      tags = [];
+      source = null;
+    }
+  }
+  await yieldForBridgeInteractivePriority();
+  const workspaceFiles = workspaceFilesOverride ?? await withCodeNavCacheSqlite((db) => listWorkspaceFiles(db, resolved, relPath));
+  const imports = source != null ? await extractImportBindingsFromSource(relPath, source, workspaceFiles) : [];
+  const yieldState = createCodeNavYieldState();
+  return {
+    source,
+    tags: await enrichTagsWithModulePathsAsync(tags, relPath, workspaceFiles, yieldState),
+    imports
+  };
+}
+var init_extract_file_symbol_data = __esm({
+  "src/code-nav/symbol-index/build/extract-file-symbol-data.ts"() {
+    "use strict";
+    init_file_browser_in_flight();
+    init_deferred_indexing();
+    init_code_nav_cache_database();
+    init_enrich_tag_module_paths_async();
+    init_gitignore_filter();
+    init_language_registry();
+    init_parser_runtime();
+    init_yield_during_work();
+    init_imports();
+    init_read_index_source();
+    init_workspace_files();
+  }
+});
+
+// src/code-nav/symbol-index/build/index-one-symbol-file-for-build.ts
+async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
+  await yieldForBridgeInteractivePriority();
+  const data = await extractFileSymbolData(resolved, relPath, workspaceFiles);
+  let entry = {
+    relPath,
+    source: data.source,
+    tags: data.tags,
+    imports: data.imports
+  };
+  if (data.imports.some((binding) => binding.importKind === "star")) {
+    await yieldForBridgeInteractivePriority();
+    entry = await withCodeNavCacheSqlite((db) => {
+      const ctx = getSymbolIndexParentContext(db, resolved);
+      if (ctx == null) return entry;
+      const resolveEntry = (filePath) => loadIndexedFileEntry(db, ctx, filePath);
+      return expandStarReexportForFile(entry, resolveEntry);
+    });
+    entry.source = data.source;
+  }
+  await withSymbolIndexSqliteLock(async () => {
+    await yieldForBridgeInteractivePriority();
+    await persistSymbolIndexFileAsync(resolved, relPath, entry.source, entry.tags, entry.imports);
+  });
+}
+var init_index_one_symbol_file_for_build = __esm({
+  "src/code-nav/symbol-index/build/index-one-symbol-file-for-build.ts"() {
+    "use strict";
+    init_file_browser_in_flight();
+    init_code_nav_cache_database();
+    init_expand_star_reexports();
+    init_persist_single_file();
+    init_symbol_index_sqlite();
+    init_symbol_index_sqlite_lock();
+    init_extract_file_symbol_data();
+    init_load_indexed_file_entry();
+  }
+});
+
+// src/code-nav/symbol-index/build/normalize-symbol-index-rel-path.ts
+function normalizeSymbolIndexRelPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+var init_normalize_symbol_index_rel_path = __esm({
+  "src/code-nav/symbol-index/build/normalize-symbol-index-rel-path.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/build/ensure-symbol-index-file-impl.ts
+async function ensureSymbolIndexFileImpl(parentPath, filePath, opts) {
+  const resolved = normalizeResolvedPath(parentPath);
+  const relPath = normalizeSymbolIndexRelPath(filePath);
+  if (!relPath) return false;
+  const importDepth = opts?.importDepth ?? 0;
+  await withCodeNavCacheSqlite((db) => {
+    upsertSymbolIndexParentPath(db, resolved);
+  });
+  if (!await symbolIndexFileIsReadyAsync(resolved, relPath)) {
+    await indexOneSymbolFileForBuild(resolved, relPath, void 0);
+  }
+  if (importDepth > 0 && await symbolIndexFileIsReadyAsync(resolved, relPath)) {
+    const targets = (await listDirectImportTargetsForFileAsync(resolved, relPath)).slice(
+      0,
+      MAX_IMPORT_PREFETCH_COUNT
+    );
+    for (const target of targets) {
+      if (!await symbolIndexFileIsReadyAsync(resolved, target)) {
+        await ensureSymbolIndexFileImpl(resolved, target, { importDepth: importDepth - 1 });
+      }
+    }
+  }
+  return await symbolIndexFileIsReadyAsync(resolved, relPath);
+}
+var MAX_IMPORT_PREFETCH_COUNT;
+var init_ensure_symbol_index_file_impl = __esm({
+  "src/code-nav/symbol-index/build/ensure-symbol-index-file-impl.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_list_direct_import_targets();
+    init_symbol_index_file_ready();
+    init_symbol_index_sqlite();
+    init_index_one_symbol_file_for_build();
+    init_normalize_symbol_index_rel_path();
+    init_index_one_symbol_file_for_build();
+    MAX_IMPORT_PREFETCH_COUNT = 8;
+  }
+});
+
+// src/code-nav/symbol-index/build/build-symbol-index-impl.ts
+async function buildSymbolIndexImpl(parentPath) {
+  const resolved = normalizeResolvedPath(parentPath);
+  let clearRemaining = true;
+  while (clearRemaining) {
+    await withSymbolIndexSqliteLock(async () => {
+      clearRemaining = await withCodeNavCacheSqlite(
+        (db) => runCodeNavCacheWriteTransaction(db, () => {
+          upsertSymbolIndexParentPath(db, resolved);
+          const ctx = getSymbolIndexParentContext(db, resolved);
+          return ctx == null ? false : clearSymbolIndexParentDataBatch(db, ctx, SYMBOL_PARENT_CLEAR_BATCH_SIZE);
+        })
+      );
+    });
+  }
+  const workspaceFiles = /* @__PURE__ */ new Set();
+  const walkState = createWalkYieldState();
+  const yieldState = createCodeNavYieldState();
+  await walkCodeNavFilesAsync(
+    resolved,
+    async (relPath) => {
+      await yieldDuringCodeNavWork(yieldState);
+      workspaceFiles.add(relPath);
+    },
+    walkState
+  );
+  let fileCount = 0;
+  await walkCodeNavFilesAsync(
+    resolved,
+    async (relPath) => {
+      await yieldDuringCodeNavWork(yieldState);
+      await indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles);
+      fileCount += 1;
+    },
+    walkState
+  );
+  return { fileCount, tagCount: 0 };
+}
+var SYMBOL_PARENT_CLEAR_BATCH_SIZE;
+var init_build_symbol_index_impl = __esm({
+  "src/code-nav/symbol-index/build/build-symbol-index-impl.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_code_nav_cache_sqlite_transaction();
+    init_yield_during_work();
+    init_walk_code_nav_files();
+    init_symbol_index_sqlite();
+    init_symbol_index_sqlite_lock();
+    init_ensure_symbol_index_file_impl();
+    SYMBOL_PARENT_CLEAR_BATCH_SIZE = 256;
+  }
+});
+
+// src/code-nav/symbol-index/build/build-symbol-index-host.ts
+var init_build_symbol_index_host = __esm({
+  "src/code-nav/symbol-index/build/build-symbol-index-host.ts"() {
+    "use strict";
+    init_build_symbol_index_impl();
+  }
+});
+
+// src/code-nav/symbol-index/build/ensure-symbol-index-file-host.ts
+var init_ensure_symbol_index_file_host = __esm({
+  "src/code-nav/symbol-index/build/ensure-symbol-index-file-host.ts"() {
+    "use strict";
+    init_ensure_symbol_index_file_impl();
+  }
+});
+
+// src/code-nav/symbol-index/lifecycle/normalize-symbol-index-path.ts
+var init_normalize_symbol_index_path = __esm({
+  "src/code-nav/symbol-index/lifecycle/normalize-symbol-index-path.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/build/update-symbol-index-file-impl.ts
+async function updateSymbolIndexRelPathImpl(parentPath, relPath) {
+  const normalizedRel = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalizedRel) return;
+  const resolved = normalizeResolvedPath(parentPath);
+  const { source, tags, imports } = await extractFileSymbolData(resolved, normalizedRel);
+  await yieldToEventLoop();
+  await withSymbolIndexSqliteLock(async () => {
+    await persistSymbolIndexFileAsync(resolved, normalizedRel, source, tags, imports);
+  });
+}
+async function removeSymbolIndexRelPathImpl(parentPath, relPath) {
+  const normalizedRel = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalizedRel) return;
+  const resolved = normalizeResolvedPath(parentPath);
+  await withSymbolIndexSqliteLock(async () => {
+    await removeSymbolIndexFileAsync(resolved, normalizedRel);
+  });
+}
+var init_update_symbol_index_file_impl = __esm({
+  "src/code-nav/symbol-index/build/update-symbol-index-file-impl.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_yield_to_event_loop();
+    init_normalize_symbol_index_path();
+    init_persist_single_file();
+    init_symbol_index_sqlite_lock();
+    init_extract_file_symbol_data();
+  }
+});
+
+// src/code-nav/symbol-index/build/update-symbol-index-file-host.ts
+var init_update_symbol_index_file_host = __esm({
+  "src/code-nav/symbol-index/build/update-symbol-index-file-host.ts"() {
+    "use strict";
+    init_update_symbol_index_file_impl();
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host-post.ts
+function postSafe(port, message) {
+  try {
+    port.postMessage(message);
+  } catch {
+  }
+}
+var init_symbol_index_worker_host_post = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host-post.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host-index-handlers.ts
+function postWorkerError(port, requestId, err) {
+  postSafe(port, {
+    type: "error",
+    requestId,
+    message: err instanceof Error ? err.message : String(err)
+  });
+}
+async function handleIndexWorkerMessage(port, msg) {
+  switch (msg.type) {
+    case "buildFull": {
+      try {
+        const result = await buildSymbolIndexImpl(msg.parentPath);
+        postSafe(port, { type: "buildComplete", requestId: msg.requestId, ...result });
+      } catch (err) {
+        postWorkerError(port, msg.requestId, err);
+      }
+      return;
+    }
+    case "updateFile": {
+      try {
+        await updateSymbolIndexRelPathImpl(msg.parentPath, msg.relPath);
+        postSafe(port, { type: "updateComplete", requestId: msg.requestId });
+      } catch (err) {
+        postWorkerError(port, msg.requestId, err);
+      }
+      return;
+    }
+    case "removeFile": {
+      try {
+        await removeSymbolIndexRelPathImpl(msg.parentPath, msg.relPath);
+        postSafe(port, { type: "removeComplete", requestId: msg.requestId });
+      } catch (err) {
+        postWorkerError(port, msg.requestId, err);
+      }
+      return;
+    }
+    case "ensureFile": {
+      try {
+        const ready = await ensureSymbolIndexFileImpl(msg.parentPath, msg.filePath, {
+          importDepth: msg.importDepth
+        });
+        postSafe(port, { type: "ensureComplete", requestId: msg.requestId, ready });
+      } catch (err) {
+        postWorkerError(port, msg.requestId, err);
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+var init_symbol_index_worker_host_index_handlers = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host-index-handlers.ts"() {
+    "use strict";
+    init_build_symbol_index_host();
+    init_ensure_symbol_index_file_host();
+    init_update_symbol_index_file_host();
+    init_symbol_index_worker_host_post();
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/task-priority-heap.ts
+function higherPriority(a, b) {
+  return a.priority > b.priority;
+}
+var SymbolIndexTaskPriorityHeap;
+var init_task_priority_heap = __esm({
+  "src/code-nav/symbol-index/scheduler/task-priority-heap.ts"() {
+    "use strict";
+    SymbolIndexTaskPriorityHeap = class {
+      heap = [];
+      clear() {
+        this.heap.length = 0;
+      }
+      push(task) {
+        this.heap.push(task);
+        let i = this.heap.length - 1;
+        while (i > 0) {
+          const parent = Math.floor((i - 1) / 2);
+          if (!higherPriority(this.heap[i], this.heap[parent])) break;
+          this.swap(i, parent);
+          i = parent;
+        }
+      }
+      pop() {
+        if (this.heap.length === 0) return void 0;
+        const top = this.heap[0];
+        const last = this.heap.pop();
+        if (this.heap.length > 0) {
+          this.heap[0] = last;
+          this.sink(0);
+        }
+        return top;
+      }
+      get size() {
+        return this.heap.length;
+      }
+      sink(start) {
+        let i = start;
+        while (true) {
+          const left = i * 2 + 1;
+          const right = left + 1;
+          let best = i;
+          if (left < this.heap.length && higherPriority(this.heap[left], this.heap[best])) best = left;
+          if (right < this.heap.length && higherPriority(this.heap[right], this.heap[best])) best = right;
+          if (best === i) break;
+          this.swap(i, best);
+          i = best;
+        }
+      }
+      swap(i, j) {
+        const tmp = this.heap[i];
+        this.heap[i] = this.heap[j];
+        this.heap[j] = tmp;
+      }
+    };
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/task-queue-types.ts
+function symbolIndexTaskKey(parentPath, filePath) {
+  return `${parentPath}\0${filePath}`;
+}
+var init_task_queue_types = __esm({
+  "src/code-nav/symbol-index/scheduler/task-queue-types.ts"() {
+    "use strict";
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/task-queue-store.ts
+function setSymbolIndexWorkerRunning(running) {
+  symbolIndexWorkerRunning = running;
+}
+function taskMatchesCurrentPending(task) {
+  const current = pendingSymbolIndexTasks.get(symbolIndexTaskKey(task.parentPath, task.filePath));
+  return current === task;
+}
+function pickNextSymbolIndexTask() {
+  while (symbolIndexTaskHeap.size > 0) {
+    const task = symbolIndexTaskHeap.pop();
+    if (task == null || !taskMatchesCurrentPending(task)) continue;
+    return task;
+  }
+  return void 0;
+}
+function addPendingSymbolIndexTask(task) {
+  const key = symbolIndexTaskKey(task.parentPath, task.filePath);
+  const existing = pendingSymbolIndexTasks.get(key);
+  if (existing != null && existing.priority >= task.priority) return false;
+  pendingSymbolIndexTasks.set(key, task);
+  symbolIndexTaskHeap.push(task);
+  return true;
+}
+function clearSymbolIndexHeapIfEmpty() {
+  if (pendingSymbolIndexTasks.size === 0) symbolIndexTaskHeap.clear();
+}
+var pendingSymbolIndexTasks, symbolIndexTaskHeap, latestActiveSequenceByParent, symbolIndexWorkerRunning;
+var init_task_queue_store = __esm({
+  "src/code-nav/symbol-index/scheduler/task-queue-store.ts"() {
+    "use strict";
+    init_task_priority_heap();
+    init_task_queue_types();
+    pendingSymbolIndexTasks = /* @__PURE__ */ new Map();
+    symbolIndexTaskHeap = new SymbolIndexTaskPriorityHeap();
+    latestActiveSequenceByParent = /* @__PURE__ */ new Map();
+    symbolIndexWorkerRunning = false;
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/task-queue-core.ts
+function enqueueSymbolIndexTaskInternal(parentPath, filePath, priority, sequence) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalizedFile) return false;
+  return addPendingSymbolIndexTask({
+    parentPath: normalizedParent,
+    filePath: normalizedFile,
+    priority,
+    sequence
+  });
+}
+function markLatestActiveSymbolIndexTaskInternal(parentPath, sequence) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const existing = latestActiveSequenceByParent.get(normalizedParent);
+  if (existing != null && existing >= sequence) return;
+  latestActiveSequenceByParent.set(normalizedParent, sequence);
+  for (const [key, task] of pendingSymbolIndexTasks) {
+    if (task.parentPath === normalizedParent && task.sequence != null && task.sequence < sequence) {
+      pendingSymbolIndexTasks.delete(key);
+    }
+  }
+  if (pendingSymbolIndexTasks.size === 0) symbolIndexTaskHeap.clear();
+}
+function deferBackgroundSymbolIndexTasks() {
+  if (pendingSymbolIndexTasks.size === 0) return;
+  for (const [key, task] of pendingSymbolIndexTasks) {
+    if (task.priority <= SYMBOL_INDEX_BACKGROUND_PRIORITY_MAX) {
+      pendingSymbolIndexTasks.delete(key);
+    }
+  }
+  symbolIndexTaskHeap.clear();
+  for (const task of pendingSymbolIndexTasks.values()) {
+    symbolIndexTaskHeap.push(task);
+  }
+}
+var SYMBOL_INDEX_BACKGROUND_PRIORITY_MAX;
+var init_task_queue_core = __esm({
+  "src/code-nav/symbol-index/scheduler/task-queue-core.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_task_queue_store();
+    SYMBOL_INDEX_BACKGROUND_PRIORITY_MAX = 499999;
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/task-queue-worker.ts
+async function runWorkerLoop() {
+  if (symbolIndexWorkerRunning) return;
+  setSymbolIndexWorkerRunning(true);
+  try {
+    const yieldState = createCodeNavYieldState();
+    while (pendingSymbolIndexTasks.size > 0) {
+      const task = pickNextSymbolIndexTask();
+      if (task == null) break;
+      pendingSymbolIndexTasks.delete(symbolIndexTaskKey(task.parentPath, task.filePath));
+      await yieldDuringCodeNavWork(yieldState);
+      const latestActiveSequence = latestActiveSequenceByParent.get(task.parentPath);
+      if (latestActiveSequence != null && task.sequence != null && task.sequence < latestActiveSequence) {
+        continue;
+      }
+      if (!await symbolIndexFileIsReadyAsync(task.parentPath, task.filePath)) {
+        try {
+          await ensureSymbolIndexFileImpl(task.parentPath, task.filePath);
+        } catch (err) {
+          if (isSymbolIndexDeferredError(err)) {
+            if (addPendingSymbolIndexTask(task)) kickSymbolIndexWorkerLoop();
+            continue;
+          }
+          throw err;
+        }
+      }
+    }
+  } finally {
+    clearSymbolIndexHeapIfEmpty();
+    setSymbolIndexWorkerRunning(false);
+    if (pendingSymbolIndexTasks.size > 0) void runWorkerLoop();
+  }
+}
+function kickSymbolIndexWorkerLoop() {
+  void runWorkerLoop();
+}
+var init_task_queue_worker = __esm({
+  "src/code-nav/symbol-index/scheduler/task-queue-worker.ts"() {
+    "use strict";
+    init_deferred_indexing();
+    init_yield_during_work();
+    init_ensure_symbol_index_file_host();
+    init_symbol_index_file_ready();
+    init_task_queue_store();
+    init_task_queue_types();
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host-queue-handlers.ts
+function handleQueueWorkerMessage(msg) {
+  switch (msg.type) {
+    case "enqueue":
+      if (enqueueSymbolIndexTaskInternal(msg.parentPath, msg.filePath, msg.priority, msg.sequence)) {
+        kickSymbolIndexWorkerLoop();
+      }
+      return;
+    case "markLatestActive":
+      markLatestActiveSymbolIndexTaskInternal(msg.parentPath, msg.sequence);
+      return;
+    case "deferBackground":
+      deferBackgroundSymbolIndexTasks();
+      return;
+    default:
+      return;
+  }
+}
+var init_symbol_index_worker_host_queue_handlers = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host-queue-handlers.ts"() {
+    "use strict";
+    init_task_queue_core();
+    init_task_queue_worker();
+  }
+});
+
+// src/code-nav/symbol-index/build/register-symbol-index-parent.ts
+async function registerSymbolIndexParentAsync(parentPath) {
+  const resolved = normalizeResolvedPath(parentPath);
+  await withCodeNavCacheSqlite((db) => {
+    upsertSymbolIndexParentPath(db, resolved);
+  });
+}
+var init_register_symbol_index_parent = __esm({
+  "src/code-nav/symbol-index/build/register-symbol-index-parent.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_code_nav_cache_database();
+    init_symbol_index_sqlite();
+  }
+});
+
+// src/code-nav/symbol-index/scheduler/symbol-index-warmup-host.ts
+function scheduleWarmupWhenIdle() {
+  if (warmupIdleTimer != null) clearTimeout(warmupIdleTimer);
+  warmupIdleTimer = setTimeout(() => {
+    warmupIdleTimer = null;
+    if (fileBrowserRequestInFlight()) {
+      scheduleWarmupWhenIdle();
+      return;
+    }
+    for (const parentPath of [...pendingWarmupParents]) {
+      void runWarmupWalk(parentPath);
+    }
+  }, WARMUP_IDLE_MS);
+}
+async function runWarmupWalk(resolved) {
+  if (warmupCompleted.has(resolved) || warmupWalkInProgress.has(resolved)) {
+    pendingWarmupParents.delete(resolved);
+    return;
+  }
+  warmupWalkInProgress.add(resolved);
+  pendingWarmupParents.delete(resolved);
+  try {
+    const readyFiles = await loadSymbolIndexReadyFileSet(resolved);
+    const walkState = createWalkYieldState();
+    const yieldState = createCodeNavYieldState();
+    await walkCodeNavFilesAsync(
+      resolved,
+      async (relPath) => {
+        await yieldDuringCodeNavWork(yieldState);
+        if (!readyFiles.has(relPath)) {
+          if (enqueueSymbolIndexTaskInternal(resolved, relPath, ++warmupSeq, requestSeq)) {
+            kickSymbolIndexWorkerLoop();
+          }
+        }
+      },
+      walkState
+    );
+    warmupCompleted.add(resolved);
+  } finally {
+    warmupWalkInProgress.delete(resolved);
+  }
+}
+function scheduleSymbolIndexWarmupInWorkerHost(parentPath) {
+  const resolved = normalizeResolvedPath(parentPath);
+  if (warmupCompleted.has(resolved)) return;
+  pendingWarmupParents.add(resolved);
+  scheduleWarmupWhenIdle();
+}
+var requestSeq, warmupSeq, warmupCompleted, pendingWarmupParents, warmupWalkInProgress, WARMUP_IDLE_MS, warmupIdleTimer;
+var init_symbol_index_warmup_host = __esm({
+  "src/code-nav/symbol-index/scheduler/symbol-index-warmup-host.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    init_file_browser_in_flight();
+    init_yield_during_work();
+    init_walk_code_nav_files();
+    init_symbol_index_file_ready();
+    init_task_queue_core();
+    init_task_queue_worker();
+    requestSeq = 0;
+    warmupSeq = 0;
+    warmupCompleted = /* @__PURE__ */ new Set();
+    pendingWarmupParents = /* @__PURE__ */ new Set();
+    warmupWalkInProgress = /* @__PURE__ */ new Set();
+    WARMUP_IDLE_MS = 3e3;
+    warmupIdleTimer = null;
+    registerFileBrowserActivityListener(() => {
+      if (pendingWarmupParents.size > 0) scheduleWarmupWhenIdle();
+    });
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host-setup-handlers.ts
+async function handleSetupWorkerMessage(msg) {
+  switch (msg.type) {
+    case "registerParent":
+      await registerSymbolIndexParentAsync(msg.parentPath);
+      return;
+    case "scheduleWarmup":
+      scheduleSymbolIndexWarmupInWorkerHost(msg.parentPath);
+      return;
+    case "shutdown":
+      return;
+    default:
+      return;
+  }
+}
+var init_symbol_index_worker_host_setup_handlers = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host-setup-handlers.ts"() {
+    "use strict";
+    init_register_symbol_index_parent();
+    init_symbol_index_warmup_host();
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host-handle-message.ts
+async function handleRequestMessage(port, msg) {
+  if (isCliImmediateShutdownRequested()) return;
+  switch (msg.type) {
+    case "enqueue":
+    case "markLatestActive":
+    case "deferBackground":
+      handleQueueWorkerMessage(msg);
+      return;
+    case "registerParent":
+    case "scheduleWarmup":
+    case "shutdown":
+      await handleSetupWorkerMessage(msg);
+      return;
+    case "buildFull":
+    case "updateFile":
+    case "removeFile":
+    case "ensureFile":
+      await handleIndexWorkerMessage(port, msg);
+      return;
+    default:
+      return;
+  }
+}
+var init_symbol_index_worker_host_handle_message = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host-handle-message.ts"() {
+    "use strict";
+    init_cli_process_interrupt();
+    init_symbol_index_worker_host_index_handlers();
+    init_symbol_index_worker_host_queue_handlers();
+    init_symbol_index_worker_host_setup_handlers();
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker-host.ts
+function attachSymbolIndexWorkerHost(port) {
+  port.onMessage((message) => {
+    void handleRequestMessage(port, message);
+  });
+  postSafe(port, { type: "ready" });
+}
+var init_symbol_index_worker_host = __esm({
+  "src/code-nav/symbol-index/worker/symbol-index-worker-host.ts"() {
+    "use strict";
+    init_symbol_index_worker_host_handle_message();
+    init_symbol_index_worker_host_post();
+  }
+});
+
+// src/code-nav/symbol-index/worker/symbol-index-worker.ts
+init_symbol_index_worker_host();
+import { parentPort } from "node:worker_threads";
+if (parentPort == null) {
+  throw new Error("symbol-index-worker must run as a worker thread");
+}
+attachSymbolIndexWorkerHost({
+  postMessage(message) {
+    parentPort.postMessage(message);
+  },
+  onMessage(handler) {
+    parentPort.on("message", handler);
+  }
+});
+//# sourceMappingURL=symbol-index-worker.js.map