@youtyan/code-viewer 0.9.0 → 0.9.2

package/dist/code-viewer.js

@@ -1167,8 +1167,12 @@ function runBytesAsync(args, cwd, options = {}) {
   return new Promise((resolve) => {
     const proc = spawn(args[0], args.slice(1), {
       cwd,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"]
     });
+    if (options.stdin !== undefined) {
+      proc.stdin?.on("error", () => {});
+      proc.stdin?.end(options.stdin);
+    }
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -1448,9 +1452,10 @@ function run(args, cwd) {
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
 }
-function runGitAsync(args, cwd) {
+function runGitAsync(args, cwd, options = {}) {
   return runAsync(resolveGitArgs(args), cwd, {
-    timeout: GIT_COMMAND_TIMEOUT_MS
+    timeout: GIT_COMMAND_TIMEOUT_MS,
+    ...options
   });
 }
 function resolveGitArgs(args) {
@@ -1530,7 +1535,7 @@ async function repoStatusMapAsync(cwd, now = Date.now()) {
     "status",
     "--porcelain=v1",
     "-z",
-    "--untracked-files=all"
+    "--untracked-files=normal"
   ], cwd);
   if (res.code !== 0)
     return map;
@@ -1542,7 +1547,7 @@ async function repoStatusMapAsync(cwd, now = Date.now()) {
     if (!path)
       continue;
     if (xy === "??") {
-      map.set(path, "A");
+      map.set(path, "U");
       continue;
     }
     if (xy[0] === "R" || xy[0] === "C" || xy[1] === "R" || xy[1] === "C") {
@@ -1557,6 +1562,27 @@ async function repoStatusMapAsync(cwd, now = Date.now()) {
   setTimedCacheEntry(repoStatusMapCache, cwd, { map }, now);
   return map;
 }
+function repoStatusForPath(map, path) {
+  const own = map.get(path) ?? map.get(`${path}/`);
+  if (own)
+    return { code: own, inherited: false };
+  for (let slash = path.lastIndexOf("/");slash > 0; slash = path.lastIndexOf("/", slash - 1)) {
+    const ancestor = map.get(`${path.slice(0, slash)}/`);
+    if (ancestor)
+      return { code: ancestor, inherited: true };
+  }
+  return;
+}
+async function ignoredPathsAsync(paths, cwd) {
+  if (!paths.length)
+    return new Set;
+  const res = await runGitAsync(["git", "check-ignore", "-z", "--stdin"], cwd, {
+    stdin: paths.join("\x00")
+  });
+  if (res.code !== 0 && res.code !== 1)
+    return new Set;
+  return new Set(res.stdout.split("\x00").filter(Boolean));
+}
 function showAsync(ref, path, cwd) {
   return runGitAsync(["git", "show", `${ref}:${path}`], cwd);
 }
@@ -9737,245 +9763,716 @@ var init_agent_help = __esm(() => {
   ];
 });
 
-// web-src/server/database/serialize.ts
-function serializeDbValue(value) {
-  if (value === null || value === undefined)
-    return null;
-  if (typeof value === "bigint") {
-    return value >= MIN_SAFE && value <= MAX_SAFE ? Number(value) : value.toString();
-  }
-  if (value instanceof Uint8Array) {
-    return `<blob ${value.byteLength} bytes>`;
-  }
-  if (typeof value === "object") {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  }
-  return value;
+// web-src/server/worktree-watcher.ts
+import {
+  lstatSync as lstatSync3,
+  readdirSync as nodeReaddirSync,
+  watch as nodeWatch
+} from "node:fs";
+import { join as join9, relative as relative4 } from "node:path";
+function supportsNativeRecursiveWatch(platform) {
+  return platform === "darwin" || platform === "win32";
 }
-function serializeDbRow(row) {
-  return row.map(serializeDbValue);
+function normalizeRelativePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
 }
-function serializeDbRows(rows) {
-  return rows.map(serializeDbRow);
+function isInsideRoot(root, path) {
+  const rel = relative4(root, path).replace(/\\/g, "/");
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
 }
-function coerceDbValue(value, columnType) {
-  if (value === null)
-    return null;
-  const t = (columnType || "").toLowerCase();
-  if (/bool/.test(t)) {
-    const v = value.trim().toLowerCase();
-    if (v === "")
-      return null;
-    if (v === "true" || v === "t" || v === "1")
-      return true;
-    if (v === "false" || v === "f" || v === "0")
+function startWorktreeUpdateWatch(options) {
+  const watch = options.watch || nodeWatch;
+  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
+  const isDirectory = options.isDirectory || ((path) => {
+    try {
+      return lstatSync3(path).isDirectory();
+    } catch {
       return false;
-    return value;
-  }
-  if (/int|serial|real|floa|doub|numeric|decimal|number/.test(t)) {
-    const trimmed = value.trim();
-    if (trimmed === "")
+    }
+  });
+  const directorySignature = options.directorySignature || ((path) => {
+    try {
+      const stats = lstatSync3(path);
+      if (!stats.isDirectory())
+        return null;
+      return `${stats.dev}:${stats.ino}`;
+    } catch {
       return null;
-    const n = Number(trimmed);
-    if (Number.isFinite(n) && String(n) === trimmed)
-      return n;
-    return value;
-  }
-  return value;
-}
-var MIN_SAFE, MAX_SAFE;
-var init_serialize = __esm(() => {
-  MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
-  MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
-});
-
-// web-src/server/database/sql-utils.ts
-function sanitizeIdentifier(name, kind = "sqlite") {
-  if (kind === "mysql")
-    return `\`${name.replace(/`/g, "``")}\``;
-  return `"${name.replace(/"/g, '""')}"`;
-}
-function escapeSqlString(value, kind) {
-  const escaped = kind === "mysql" ? value.replace(/\\/g, "\\\\").replace(/'/g, "''") : value.replace(/'/g, "''");
-  return `'${escaped}'`;
-}
-function buildFilterWhere(grouped, kind, exact) {
-  const whereParts = [];
-  const params = [];
-  const useParams = kind === "sqlite";
-  const castOf = (column) => kind === "mysql" ? `CAST(${sanitizeIdentifier(column, kind)} AS CHAR)` : `CAST(${sanitizeIdentifier(column, kind)} AS TEXT)`;
-  for (const [value, cols] of grouped) {
-    const likeVal = useParams ? "?" : escapeSqlString(`%${value}%`, kind);
-    if (cols.length === 1) {
-      whereParts.push(`${castOf(cols[0])} LIKE ${likeVal}`);
-      if (useParams)
-        params.push(`%${value}%`);
-    } else {
-      const orParts = cols.map((column) => `${castOf(column)} LIKE ${likeVal}`);
-      whereParts.push(`(${orParts.join(" OR ")})`);
-      if (useParams) {
-        for (let i = 0;i < cols.length; i++)
-          params.push(`%${value}%`);
+    }
+  });
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 250;
+  const recursive = options.recursive === true;
+  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
+  const watchers = new Map;
+  const signatures = new Map;
+  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
+  const initialScanQueue = [];
+  let initialScanTimer = null;
+  let processingInitialScan = false;
+  const pendingPathInspections = new Map;
+  let pathInspectionTimer = null;
+  let timer = null;
+  const pendingChangedPaths = new Set;
+  let fullUpdatePending = false;
+  let watchLimitReported = false;
+  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative4(options.root, dir));
+  const ignoredDirectory = (dir) => {
+    const rel = directoryRelativePath(dir);
+    return Boolean(rel && ignored(rel));
+  };
+  const scheduleUpdate = (changedPath) => {
+    if (changedPath)
+      pendingChangedPaths.add(changedPath);
+    else
+      fullUpdatePending = true;
+    if (timer)
+      clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      const paths = !fullUpdatePending && pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
+      pendingChangedPaths.clear();
+      fullUpdatePending = false;
+      options.onUpdate(paths);
+    }, debounceMs);
+  };
+  const reportWatchLimit = () => {
+    if (watchLimitReported)
+      return;
+    watchLimitReported = true;
+    options.onWatchLimit?.(maxWatchedDirectories);
+    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
+  };
+  const closeSubtree = (dir) => {
+    for (const [watchedDir, watcher] of [...watchers]) {
+      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
+        continue;
+      try {
+        watcher.close?.();
+      } catch {}
+      watchers.delete(watchedDir);
+      signatures.delete(watchedDir);
+    }
+  };
+  const closeAll = () => {
+    if (initialScanTimer) {
+      clearTimer(initialScanTimer);
+      initialScanTimer = null;
+    }
+    if (pathInspectionTimer) {
+      clearTimer(pathInspectionTimer);
+      pathInspectionTimer = null;
+    }
+    initialScanQueue.length = 0;
+    pendingPathInspections.clear();
+    for (const watcher of [...watchers.values()]) {
+      try {
+        watcher.close?.();
+      } catch {}
+    }
+    watchers.clear();
+    signatures.clear();
+  };
+  const readChildDirectories = (dir) => {
+    let entries;
+    try {
+      entries = readDirs(dir);
+    } catch (error) {
+      options.onError?.(error);
+      return [];
+    }
+    const children = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const child = join9(dir, entry.name);
+      if (ignoredDirectory(child))
+        continue;
+      children.push(child);
+    }
+    return children;
+  };
+  const processInitialScanQueue = () => {
+    initialScanTimer = null;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+      return;
+    }
+    const next = initialScanQueue.shift();
+    if (next) {
+      processingInitialScan = true;
+      try {
+        watchDirectory(next, true);
+      } finally {
+        processingInitialScan = false;
       }
     }
-  }
-  for (const cond of exact ?? []) {
-    const rhs = useParams ? "?" : escapeSqlString(cond.value, kind);
-    whereParts.push(`${castOf(cond.column)} = ${rhs}`);
-    if (useParams)
-      params.push(cond.value);
-  }
-  return { where: whereParts.join(" AND "), params, useParams };
-}
-function filterGroupedColumns(grouped, columnNames) {
-  const validColumns = new Set(columnNames);
-  const filtered = new Map;
-  for (const [value, columns] of grouped) {
-    const valid = columns.filter((column) => validColumns.has(column));
-    if (valid.length > 0)
-      filtered.set(value, valid);
-  }
-  return filtered;
-}
-function filterExactColumns(exact, columnNames) {
-  if (!exact || exact.length === 0)
-    return [];
-  const validColumns = new Set(columnNames);
-  return exact.filter((cond) => validColumns.has(cond.column));
-}
-function filterOrderByColumns(orderBy, columnNames) {
-  if (!orderBy)
-    return;
-  const validColumns = new Set(columnNames);
-  const filtered = orderBy.filter((order) => validColumns.has(order.column));
-  return filtered.length > 0 ? filtered : undefined;
-}
-function buildOrderClause(orderBy, kind = "sqlite") {
-  if (!orderBy?.length)
-    return "";
-  const parts = orderBy.map((o) => `${sanitizeIdentifier(o.column, kind)} ${o.direction === "desc" ? "DESC" : "ASC"}`);
-  return ` ORDER BY ${parts.join(", ")}`;
-}
-function useParamsFor(kind) {
-  return kind === "sqlite";
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+    }
+    if (initialScanQueue.length)
+      initialScanTimer = setTimer(processInitialScanQueue, 50);
+  };
+  const queueInitialChildren = (dir) => {
+    const remaining = maxWatchedDirectories - watchers.size;
+    if (remaining <= 0) {
+      reportWatchLimit();
+      return;
+    }
+    const children = readChildDirectories(dir);
+    if (children.length > remaining)
+      reportWatchLimit();
+    initialScanQueue.push(...children.slice(0, remaining));
+    if (!initialScanTimer && !processingInitialScan)
+      initialScanTimer = setTimer(processInitialScanQueue, 5000);
+  };
+  const processChangedPath = (changed, fullChangedPath) => {
+    const known = watchers.has(fullChangedPath);
+    if (isDirectory(fullChangedPath)) {
+      if (known) {
+        const signature = directorySignature(fullChangedPath);
+        if (signature && signature !== signatures.get(fullChangedPath)) {
+          closeSubtree(fullChangedPath);
+          watchDirectory(fullChangedPath, initialScanAsync);
+        }
+        scheduleUpdate(changed);
+        return;
+      }
+      watchDirectory(fullChangedPath, initialScanAsync);
+    } else if (known) {
+      closeSubtree(fullChangedPath);
+    }
+    scheduleUpdate(changed);
+  };
+  const processPathInspections = () => {
+    pathInspectionTimer = null;
+    const entries = [...pendingPathInspections];
+    pendingPathInspections.clear();
+    for (const [changed, fullChangedPath] of entries) {
+      processChangedPath(changed, fullChangedPath);
+    }
+  };
+  const queuePathInspection = (changed, fullChangedPath) => {
+    pendingPathInspections.set(changed, fullChangedPath);
+    if (!pathInspectionTimer)
+      pathInspectionTimer = setTimer(processPathInspections, 25);
+  };
+  const watchDirectory = (dir, initialScan = false) => {
+    if (watchers.has(dir))
+      return;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    const rel = directoryRelativePath(dir);
+    if (rel && ignored(rel))
+      return;
+    try {
+      const watcher = watch(dir, { persistent: false, recursive }, (_event, filename) => {
+        if (!filename) {
+          scheduleUpdate();
+          return;
+        }
+        const changed = normalizeRelativePath(join9(rel, filename.toString()));
+        if (ignored(changed))
+          return;
+        const fullChangedPath = join9(options.root, changed);
+        if (!isInsideRoot(options.root, fullChangedPath))
+          return;
+        if (recursive) {
+          scheduleUpdate(changed);
+          return;
+        }
+        if (initialScanAsync) {
+          queuePathInspection(changed, fullChangedPath);
+          return;
+        }
+        processChangedPath(changed, fullChangedPath);
+      }) || {};
+      watchers.set(dir, watcher);
+      const signature = directorySignature(dir);
+      if (signature)
+        signatures.set(dir, signature);
+      watcher.on?.("error", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+      watcher.on?.("close", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+    } catch (error) {
+      options.onError?.(error);
+      return;
+    }
+    if (recursive)
+      return;
+    if (initialScanAsync && initialScan) {
+      queueInitialChildren(dir);
+      return;
+    }
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    for (const child of readChildDirectories(dir))
+      watchDirectory(child);
+  };
+  watchDirectory(options.root, true);
+  return { started: watchers.size > 0, close: closeAll };
 }
-function placeValue(coerced, kind, useParams, params) {
-  if (useParams) {
-    params.push(typeof coerced === "boolean" ? coerced ? 1 : 0 : coerced);
-    return "?";
-  }
-  if (coerced === null)
-    return "NULL";
-  if (typeof coerced === "number")
-    return String(coerced);
-  if (typeof coerced === "boolean")
-    return coerced ? "TRUE" : "FALSE";
-  const text = coerced instanceof Uint8Array ? new TextDecoder().decode(coerced) : String(coerced);
-  return escapeSqlString(text, kind);
+var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 1024, MIN_WORKTREE_WATCH_DIRECTORY_LIMIT = 1, MAX_WORKTREE_WATCH_DIRECTORY_LIMIT = 65536;
+var init_worktree_watcher = __esm(() => {
+  init_search();
+});
+
+// web-src/server/watch-child.ts
+var exports_watch_child = {};
+__export(exports_watch_child, {
+  runWatchChild: () => runWatchChild,
+  parsePorcelainV2: () => parsePorcelainV2
+});
+import { createHash as createHash2 } from "node:crypto";
+import { createReadStream as createReadStream2, lstatSync as lstatSync4 } from "node:fs";
+import { join as join10 } from "node:path";
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
 }
-function coerceCell(cell, columnType) {
-  return coerceDbValue(cell.value, columnType);
+function readConfigLine() {
+  return new Promise((resolve2, reject) => {
+    let buffer = "";
+    const stdin = process.stdin;
+    stdin.setEncoding("utf8");
+    const onData = (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf(`
+`);
+      if (newline === -1)
+        return;
+      stdin.off("data", onData);
+      stdin.off("end", onEnd);
+      resolve2(buffer.slice(0, newline));
+    };
+    const onEnd = () => {
+      stdin.off("data", onData);
+      reject(new Error("watch child: stdin closed before config arrived"));
+    };
+    stdin.on("data", onData);
+    stdin.on("end", onEnd);
+  });
 }
-function formatWriteComparisons(cells, columnTypes, kind, useParams, params, separator) {
-  return cells.map((cell) => `${sanitizeIdentifier(cell.column, kind)} = ${placeValue(coerceCell(cell, columnTypes.get(cell.column) ?? "TEXT"), kind, useParams, params)}`).join(separator);
+function hashFile(path) {
+  return new Promise((resolve2) => {
+    const hash = createHash2("sha256");
+    const stream = createReadStream2(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve2(hash.digest("hex")));
+    stream.on("error", () => resolve2("unreadable"));
+  });
 }
-function buildInsertSql(table, cells, columnTypes, kind) {
-  if (cells.length === 0) {
-    throw new Error("insert requires at least one column value");
+function parsePorcelainV2(raw) {
+  const records = raw.split("\x00");
+  let head = "";
+  const entries = [];
+  for (let i = 0;i < records.length; i++) {
+    const record = records[i];
+    if (!record)
+      continue;
+    if (record.startsWith("# branch.oid ")) {
+      head = record.slice("# branch.oid ".length);
+      continue;
+    }
+    if (record.startsWith("# "))
+      continue;
+    const kind = record[0];
+    if (kind === "1" || kind === "2" || kind === "u") {
+      const metaCount = kind === "1" ? 8 : kind === "2" ? 9 : 10;
+      const status = record.split(" ").slice(0, metaCount).join(" ");
+      entries.push({ path: record.slice(status.length + 1), status });
+      if (kind === "2")
+        i++;
+      continue;
+    }
+    if (kind === "?" || kind === "!") {
+      entries.push({ path: record.slice(2), status: kind });
+    }
   }
-  const useParams = useParamsFor(kind);
-  const params = [];
-  const cols = cells.map((c) => sanitizeIdentifier(c.column, kind));
-  const placeholders = cells.map((c) => placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params));
-  const sql = `INSERT INTO ${sanitizeIdentifier(table, kind)} (${cols.join(", ")}) VALUES (${placeholders.join(", ")})`;
-  return { sql, params };
+  return { head, entries };
 }
-function buildUpdateSql(table, set, pk, columnTypes, kind) {
-  if (set.length === 0) {
-    throw new Error("update requires at least one column to set");
-  }
-  if (pk.length === 0) {
-    throw new Error("update requires a primary key condition");
+async function readWorktreeSnapshot(config) {
+  const result = await runAsync([
+    "git",
+    "--no-optional-locks",
+    "-c",
+    "core.fsmonitor=false",
+    "status",
+    "--porcelain=v2",
+    "-z",
+    "--branch",
+    "--untracked-files=all"
+  ], config.root, { timeout: 60000 });
+  if (result.code !== 0)
+    return null;
+  const parsed = parsePorcelainV2(result.stdout);
+  const entries = new Map;
+  for (const entry of parsed.entries) {
+    if (!entry.path)
+      continue;
+    if (isSkippableSearchPath(entry.path, config.omitDirNames, config.excludeNames))
+      continue;
+    entries.set(entry.path, await pathSignature(config.root, entry));
   }
-  const useParams = useParamsFor(kind);
-  const params = [];
-  const setSql = formatWriteComparisons(set, columnTypes, kind, useParams, params, ", ");
-  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
-  const sql = `UPDATE ${sanitizeIdentifier(table, kind)} SET ${setSql} WHERE ${whereSql}`;
-  return { sql, params };
+  return { head: parsed.head, entries };
 }
-function buildDeleteSql(table, pk, columnTypes, kind) {
-  if (pk.length === 0) {
-    throw new Error("delete requires a primary key condition");
+async function pathSignature(root, entry) {
+  const full = join10(root, entry.path);
+  let stats;
+  try {
+    stats = lstatSync4(full);
+  } catch {
+    return `${entry.status}:absent`;
   }
-  const useParams = useParamsFor(kind);
-  const params = [];
-  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
-  const sql = `DELETE FROM ${sanitizeIdentifier(table, kind)} WHERE ${whereSql}`;
-  return { sql, params };
+  const base = `${entry.status}:${stats.size}:${stats.mtimeMs}:${stats.mode}`;
+  if (stats.isFile() && stats.size <= MAX_HASHED_FILE_BYTES) {
+    return `${base}:${await hashFile(full)}`;
+  }
+  return base;
 }
-var init_sql_utils = __esm(() => {
-  init_serialize();
-});
-
-// web-src/server/database/mutate.ts
-function assertCells(cells, label) {
-  if (!Array.isArray(cells)) {
-    throw new Error(`${label} must be an array`);
+function snapshotDiff(previous, next) {
+  if (previous.head !== next.head)
+    return { full: true, paths: [] };
+  const paths = [];
+  for (const [path, signature] of next.entries) {
+    if (previous.entries.get(path) !== signature)
+      paths.push(path);
   }
-  for (const cell of cells) {
-    if (!cell || typeof cell !== "object" || typeof cell.column !== "string" || cell.value !== null && typeof cell.value !== "string") {
-      throw new Error(`${label} contains an invalid cell`);
-    }
+  for (const path of previous.entries.keys()) {
+    if (!next.entries.has(path))
+      paths.push(path);
   }
-  return cells;
+  return { full: false, paths };
 }
-function buildMutationStatements(table, mutations, columns, kind) {
-  if (!Array.isArray(mutations) || mutations.length === 0) {
-    throw new Error("no mutations provided");
-  }
-  if (mutations.length > MAX_MUTATIONS) {
-    throw new Error(`too many mutations (max ${MAX_MUTATIONS})`);
+async function runWatchChild() {
+  const config = JSON.parse(await readConfigLine());
+  process.stdin.on("end", () => process.exit(0));
+  process.stdin.on("close", () => process.exit(0));
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => process.exit(0));
+  }
+  let watching = false;
+  if (!config.pollOnly) {
+    const recursive = supportsNativeRecursiveWatch(process.platform);
+    const watch = startWorktreeUpdateWatch({
+      root: config.root,
+      omitDirNames: config.omitDirNames,
+      excludeNames: config.excludeNames,
+      recursive,
+      initialScanMode: recursive ? "sync" : "async",
+      maxWatchedDirectories: config.maxWatchedDirectories,
+      debounceMs: config.debounceMs,
+      onUpdate: (paths) => send({ type: "update", paths }),
+      onWatchLimit: (limit) => send({ type: "watch-limit", limit }),
+      onError: (error) => send({
+        type: "warn",
+        message: error instanceof Error ? error.message : String(error)
+      })
+    });
+    watching = watch.started;
   }
-  const columnTypes = new Map(columns.map((c) => [c.name, c.type]));
-  const columnNames = new Set(columns.map((c) => c.name));
-  const pkColumns = columns.filter((c) => c.primaryKey).map((c) => c.name);
-  const pkNames = new Set(pkColumns);
-  const requireKnownColumns = (cells, label) => {
-    for (const cell of cells) {
-      if (!columnNames.has(cell.column)) {
-        throw new Error(`unknown column: ${cell.column}`);
-      }
-    }
-  };
-  const requirePrimaryKey = (pk) => {
-    if (pkColumns.length === 0) {
-      throw new Error("table has no primary key; row update/delete is not supported");
+  send({ type: "ready", watching, pollOnly: config.pollOnly });
+  setInterval(() => send({ type: "heartbeat" }), config.heartbeatIntervalMs).unref?.();
+  setInterval(() => {
+    try {
+      process.kill(config.parentPid, 0);
+    } catch {
+      process.exit(0);
     }
-    const provided = new Set(pk.map((c) => c.column));
-    for (const name of pkColumns) {
-      if (!provided.has(name)) {
-        throw new Error(`missing primary key column: ${name}`);
-      }
+  }, config.heartbeatIntervalMs);
+  let snapshot = null;
+  let baselineEstablished = false;
+  const poll = async () => {
+    const next = await readWorktreeSnapshot(config);
+    if (!next)
+      return;
+    if (!snapshot) {
+      snapshot = next;
+      if (baselineEstablished)
+        send({ type: "update" });
+      baselineEstablished = true;
+      return;
     }
-    for (const cell of pk) {
-      if (!pkNames.has(cell.column)) {
-        throw new Error(`not a primary key column: ${cell.column}`);
-      }
-      if (cell.value === null) {
-        throw new Error(`primary key column cannot be null: ${cell.column}`);
-      }
+    const diff = snapshotDiff(snapshot, next);
+    snapshot = next;
+    if (diff.full) {
+      send({ type: "update" });
+      return;
     }
+    if (diff.paths.length)
+      send({ type: "update", paths: diff.paths });
   };
-  const statements = [];
-  for (const mutation of mutations) {
-    if (!mutation || typeof mutation !== "object") {
-      throw new Error("invalid mutation");
-    }
+  setInterval(() => {
+    poll().catch((error) => send({
+      type: "warn",
+      message: error instanceof Error ? error.message : String(error)
+    }));
+  }, config.pollIntervalMs);
+}
+var MAX_HASHED_FILE_BYTES;
+var init_watch_child = __esm(() => {
+  init_runtime();
+  init_search();
+  init_worktree_watcher();
+  MAX_HASHED_FILE_BYTES = 4 * 1024 * 1024;
+});
+
+// web-src/server/database/serialize.ts
+function serializeDbValue(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "bigint") {
+    return value >= MIN_SAFE && value <= MAX_SAFE ? Number(value) : value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return `<blob ${value.byteLength} bytes>`;
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return value;
+}
+function serializeDbRow(row) {
+  return row.map(serializeDbValue);
+}
+function serializeDbRows(rows) {
+  return rows.map(serializeDbRow);
+}
+function coerceDbValue(value, columnType) {
+  if (value === null)
+    return null;
+  const t = (columnType || "").toLowerCase();
+  if (/bool/.test(t)) {
+    const v = value.trim().toLowerCase();
+    if (v === "")
+      return null;
+    if (v === "true" || v === "t" || v === "1")
+      return true;
+    if (v === "false" || v === "f" || v === "0")
+      return false;
+    return value;
+  }
+  if (/int|serial|real|floa|doub|numeric|decimal|number/.test(t)) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return null;
+    const n = Number(trimmed);
+    if (Number.isFinite(n) && String(n) === trimmed)
+      return n;
+    return value;
+  }
+  return value;
+}
+var MIN_SAFE, MAX_SAFE;
+var init_serialize = __esm(() => {
+  MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+  MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+});
+
+// web-src/server/database/sql-utils.ts
+function sanitizeIdentifier(name, kind = "sqlite") {
+  if (kind === "mysql")
+    return `\`${name.replace(/`/g, "``")}\``;
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function escapeSqlString(value, kind) {
+  const escaped = kind === "mysql" ? value.replace(/\\/g, "\\\\").replace(/'/g, "''") : value.replace(/'/g, "''");
+  return `'${escaped}'`;
+}
+function buildFilterWhere(grouped, kind, exact) {
+  const whereParts = [];
+  const params = [];
+  const useParams = kind === "sqlite";
+  const castOf = (column) => kind === "mysql" ? `CAST(${sanitizeIdentifier(column, kind)} AS CHAR)` : `CAST(${sanitizeIdentifier(column, kind)} AS TEXT)`;
+  for (const [value, cols] of grouped) {
+    const likeVal = useParams ? "?" : escapeSqlString(`%${value}%`, kind);
+    if (cols.length === 1) {
+      whereParts.push(`${castOf(cols[0])} LIKE ${likeVal}`);
+      if (useParams)
+        params.push(`%${value}%`);
+    } else {
+      const orParts = cols.map((column) => `${castOf(column)} LIKE ${likeVal}`);
+      whereParts.push(`(${orParts.join(" OR ")})`);
+      if (useParams) {
+        for (let i = 0;i < cols.length; i++)
+          params.push(`%${value}%`);
+      }
+    }
+  }
+  for (const cond of exact ?? []) {
+    const rhs = useParams ? "?" : escapeSqlString(cond.value, kind);
+    whereParts.push(`${castOf(cond.column)} = ${rhs}`);
+    if (useParams)
+      params.push(cond.value);
+  }
+  return { where: whereParts.join(" AND "), params, useParams };
+}
+function filterGroupedColumns(grouped, columnNames) {
+  const validColumns = new Set(columnNames);
+  const filtered = new Map;
+  for (const [value, columns] of grouped) {
+    const valid = columns.filter((column) => validColumns.has(column));
+    if (valid.length > 0)
+      filtered.set(value, valid);
+  }
+  return filtered;
+}
+function filterExactColumns(exact, columnNames) {
+  if (!exact || exact.length === 0)
+    return [];
+  const validColumns = new Set(columnNames);
+  return exact.filter((cond) => validColumns.has(cond.column));
+}
+function filterOrderByColumns(orderBy, columnNames) {
+  if (!orderBy)
+    return;
+  const validColumns = new Set(columnNames);
+  const filtered = orderBy.filter((order) => validColumns.has(order.column));
+  return filtered.length > 0 ? filtered : undefined;
+}
+function buildOrderClause(orderBy, kind = "sqlite") {
+  if (!orderBy?.length)
+    return "";
+  const parts = orderBy.map((o) => `${sanitizeIdentifier(o.column, kind)} ${o.direction === "desc" ? "DESC" : "ASC"}`);
+  return ` ORDER BY ${parts.join(", ")}`;
+}
+function useParamsFor(kind) {
+  return kind === "sqlite";
+}
+function placeValue(coerced, kind, useParams, params) {
+  if (useParams) {
+    params.push(typeof coerced === "boolean" ? coerced ? 1 : 0 : coerced);
+    return "?";
+  }
+  if (coerced === null)
+    return "NULL";
+  if (typeof coerced === "number")
+    return String(coerced);
+  if (typeof coerced === "boolean")
+    return coerced ? "TRUE" : "FALSE";
+  const text = coerced instanceof Uint8Array ? new TextDecoder().decode(coerced) : String(coerced);
+  return escapeSqlString(text, kind);
+}
+function coerceCell(cell, columnType) {
+  return coerceDbValue(cell.value, columnType);
+}
+function formatWriteComparisons(cells, columnTypes, kind, useParams, params, separator) {
+  return cells.map((cell) => `${sanitizeIdentifier(cell.column, kind)} = ${placeValue(coerceCell(cell, columnTypes.get(cell.column) ?? "TEXT"), kind, useParams, params)}`).join(separator);
+}
+function buildInsertSql(table, cells, columnTypes, kind) {
+  if (cells.length === 0) {
+    throw new Error("insert requires at least one column value");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const cols = cells.map((c) => sanitizeIdentifier(c.column, kind));
+  const placeholders = cells.map((c) => placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params));
+  const sql = `INSERT INTO ${sanitizeIdentifier(table, kind)} (${cols.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  return { sql, params };
+}
+function buildUpdateSql(table, set, pk, columnTypes, kind) {
+  if (set.length === 0) {
+    throw new Error("update requires at least one column to set");
+  }
+  if (pk.length === 0) {
+    throw new Error("update requires a primary key condition");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const setSql = formatWriteComparisons(set, columnTypes, kind, useParams, params, ", ");
+  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
+  const sql = `UPDATE ${sanitizeIdentifier(table, kind)} SET ${setSql} WHERE ${whereSql}`;
+  return { sql, params };
+}
+function buildDeleteSql(table, pk, columnTypes, kind) {
+  if (pk.length === 0) {
+    throw new Error("delete requires a primary key condition");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
+  const sql = `DELETE FROM ${sanitizeIdentifier(table, kind)} WHERE ${whereSql}`;
+  return { sql, params };
+}
+var init_sql_utils = __esm(() => {
+  init_serialize();
+});
+
+// web-src/server/database/mutate.ts
+function assertCells(cells, label) {
+  if (!Array.isArray(cells)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const cell of cells) {
+    if (!cell || typeof cell !== "object" || typeof cell.column !== "string" || cell.value !== null && typeof cell.value !== "string") {
+      throw new Error(`${label} contains an invalid cell`);
+    }
+  }
+  return cells;
+}
+function buildMutationStatements(table, mutations, columns, kind) {
+  if (!Array.isArray(mutations) || mutations.length === 0) {
+    throw new Error("no mutations provided");
+  }
+  if (mutations.length > MAX_MUTATIONS) {
+    throw new Error(`too many mutations (max ${MAX_MUTATIONS})`);
+  }
+  const columnTypes = new Map(columns.map((c) => [c.name, c.type]));
+  const columnNames = new Set(columns.map((c) => c.name));
+  const pkColumns = columns.filter((c) => c.primaryKey).map((c) => c.name);
+  const pkNames = new Set(pkColumns);
+  const requireKnownColumns = (cells, label) => {
+    for (const cell of cells) {
+      if (!columnNames.has(cell.column)) {
+        throw new Error(`unknown column: ${cell.column}`);
+      }
+    }
+  };
+  const requirePrimaryKey = (pk) => {
+    if (pkColumns.length === 0) {
+      throw new Error("table has no primary key; row update/delete is not supported");
+    }
+    const provided = new Set(pk.map((c) => c.column));
+    for (const name of pkColumns) {
+      if (!provided.has(name)) {
+        throw new Error(`missing primary key column: ${name}`);
+      }
+    }
+    for (const cell of pk) {
+      if (!pkNames.has(cell.column)) {
+        throw new Error(`not a primary key column: ${cell.column}`);
+      }
+      if (cell.value === null) {
+        throw new Error(`primary key column cannot be null: ${cell.column}`);
+      }
+    }
+  };
+  const statements = [];
+  for (const mutation of mutations) {
+    if (!mutation || typeof mutation !== "object") {
+      throw new Error("invalid mutation");
+    }
     if (mutation.kind === "insert") {
       const values = assertCells(mutation.values, "insert values");
       requireKnownColumns(values, "insert values");
@@ -10002,7 +10499,7 @@ var init_mutate = __esm(() => {
 });
 
 // web-src/server/database/sources/sql-snapshot.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function normalizeRawValue(v) {
   if (v === null)
     return "\\N";
@@ -10022,7 +10519,7 @@ function rowToPayloadJson(columns, row) {
 }
 function computeRowHash(columns, row) {
   const parts = columns.map((_, i) => normalizeRawValue(row[i]));
-  return createHash2("sha256").update(parts.join("\t")).digest("hex");
+  return createHash3("sha256").update(parts.join("\t")).digest("hex");
 }
 function buildRowKeyJson(pkColumns, allColumns, row, rowIndex) {
   if (pkColumns.length === 0) {
@@ -12093,7 +12590,7 @@ __export(exports_redis, {
   canonicalizeRedisSnapshotContainer: () => canonicalizeRedisSnapshotContainer,
   __setRedisClientFactoryForTest: () => __setRedisClientFactoryForTest
 });
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { createClient } from "@redis/client";
 function __setRedisClientFactoryForTest(factory) {
   createRedisClientImpl = factory ?? ((options) => createClient(options));
@@ -12470,7 +12967,7 @@ function createRedisAdapter(config) {
     if (type === "none") {
       return {
         payload: { type: "none" },
-        fullHash: createHash3("sha256").update("").digest("hex")
+        fullHash: createHash4("sha256").update("").digest("hex")
       };
     }
     if (type === "string")
@@ -12487,7 +12984,7 @@ function createRedisAdapter(config) {
       return snapshotFetchStream(db, hexKey, signal);
     return {
       payload: { type: "none" },
-      fullHash: createHash3("sha256").update("").digest("hex")
+      fullHash: createHash4("sha256").update("").digest("hex")
     };
   }
   async function evalHex(db, luaBody, extraArgv, label, signal) {
@@ -12499,7 +12996,7 @@ function createRedisAdapter(config) {
   }
   async function snapshotFetchString(db, hexKey, signal) {
     const fullSize = Number(await evalHex(db, `${LUA_HEX_KEY_PRELUDE} return redis.call('STRLEN', fromhex(ARGV[1]))`, [hexKey], "STRLEN", signal)) || 0;
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     let previewBytes = Buffer.alloc(0);
     for (let offset = 0;offset < fullSize; offset += REDIS_STRING_BYTE_LIMIT) {
       if (signal?.aborted)
@@ -12532,7 +13029,7 @@ function createRedisAdapter(config) {
   }
   async function snapshotFetchList(db, hexKey, signal) {
     const total = Number(await evalHex(db, `${LUA_HEX_KEY_PRELUDE} return redis.call('LLEN', fromhex(ARGV[1]))`, [hexKey], "LLEN", signal)) || 0;
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     let previewItems = [];
     for (let offset = 0;offset < total; offset += REDIS_COLLECTION_LIMIT) {
       if (signal?.aborted)
@@ -12574,7 +13071,7 @@ function createRedisAdapter(config) {
       uniquePairs.push(p);
     }
     uniquePairs.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     for (const [f, v] of uniquePairs) {
       hashHexItem(hasher, f);
       hashHexItem(hasher, v);
@@ -12602,7 +13099,7 @@ function createRedisAdapter(config) {
     } while (cursor !== "0");
     const dedup = Array.from(new Set(allMembers));
     dedup.sort();
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     for (const m of dedup)
       hashHexItem(hasher, m);
     const previewMembers = dedup.slice(0, REDIS_COLLECTION_LIMIT).map(decodeHexItem);
@@ -12616,7 +13113,7 @@ function createRedisAdapter(config) {
   }
   async function snapshotFetchZset(db, hexKey, signal) {
     const total = Number(await evalHex(db, `${LUA_HEX_KEY_PRELUDE} return redis.call('ZCARD', fromhex(ARGV[1]))`, [hexKey], "ZCARD", signal)) || 0;
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     let previewMembers = [];
     for (let offset = 0;offset < total; offset += REDIS_COLLECTION_LIMIT) {
       if (signal?.aborted)
@@ -12646,7 +13143,7 @@ function createRedisAdapter(config) {
   }
   async function snapshotFetchStream(db, hexKey, signal) {
     const total = Number(await evalHex(db, `${LUA_HEX_KEY_PRELUDE} return redis.call('XLEN', fromhex(ARGV[1]))`, [hexKey], "XLEN", signal)) || 0;
-    const hasher = createHash3("sha256");
+    const hasher = createHash4("sha256");
     let previewEntries = [];
     let startId = "-";
     const seenIds = new Set;
@@ -13238,7 +13735,7 @@ var init_raw_file_headers = __esm(() => {
 
 // web-src/server/database/adapters/s3.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash4, createHmac } from "node:crypto";
+import { createHash as createHash5, createHmac } from "node:crypto";
 function createS3RequestDeadline() {
   const timeoutMs = s3RequestTimeoutMs;
   return {
@@ -13268,10 +13765,10 @@ function hmac(key, value) {
   return createHmac("sha256", key).update(value, "utf8").digest();
 }
 function sha256(value) {
-  return createHash4("sha256").update(value, "utf8").digest("hex");
+  return createHash5("sha256").update(value, "utf8").digest("hex");
 }
 function sha256Bytes(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function encodeRfc3986(value) {
   return encodeURIComponent(value).replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`);
@@ -14278,7 +14775,7 @@ import {
   statSync as statSync5
 } from "node:fs";
 import { lstat, open as open2, readdir, readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { basename, join as join9, relative as relative4 } from "node:path";
+import { basename, join as join11, relative as relative5 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
     const stat3 = statSync5(fullPath);
@@ -14349,7 +14846,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
         return;
       if (omitSet.has(entry.toLowerCase()))
         continue;
-      const full = join9(dir, entry);
+      const full = join11(dir, entry);
       let entryStat;
       try {
         entryStat = await lstat(full);
@@ -14366,7 +14863,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
           continue;
         if (!await isSqliteFileAsync(full))
           continue;
-        const rel = relative4(cwd, full);
+        const rel = relative5(cwd, full);
         if (rel.startsWith("..") || rel.startsWith("/"))
           continue;
         results.push({
@@ -14393,7 +14890,7 @@ function validateDbPath(cwd, dbPath) {
   const parts = dbPath.split(/[\\/]+/);
   if (parts.some((p) => p === ".." || p.toLowerCase() === ".git" || p.toLowerCase() === ".code-viewer"))
     return null;
-  const full = join9(cwd, dbPath);
+  const full = join11(cwd, dbPath);
   if (!existsSync6(full))
     return null;
   let realCwd;
@@ -14404,7 +14901,7 @@ function validateDbPath(cwd, dbPath) {
   } catch {
     return null;
   }
-  const rel = relative4(realCwd, realFull);
+  const rel = relative5(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/"))
     return null;
   if (!isSqliteFile(realFull))
@@ -14565,7 +15062,7 @@ function resolveEnvValue(raw, composeDirEnv = {}) {
 }
 async function readDotenvAsync(composeDir) {
   try {
-    const content = await readFile2(join9(composeDir, ".env"), "utf-8");
+    const content = await readFile2(join11(composeDir, ".env"), "utf-8");
     return parseDotenvContent(content);
   } catch {
     return {};
@@ -14687,7 +15184,7 @@ function parseComposeContent(content, filepath, composeDir, cwd, composeDirEnv,
   for (let match = serviceRegex.exec(servicesBlock);match !== null; match = serviceRegex.exec(servicesBlock)) {
     servicePositions.push({ name: match[1], start: match.index });
   }
-  const relDir = relative4(cwd, composeDir);
+  const relDir = relative5(cwd, composeDir);
   const isRoot = relDir === "" || relDir === ".";
   const relDirSlash = relDir.replace(/\\/g, "/");
   const filename = basename(filepath);
@@ -14792,7 +15289,7 @@ async function walkForMarkerFileAsync(dir, depth, omitSet, hasCapacity, visitDir
       return;
     if (omitSet.has(entry.toLowerCase()))
       continue;
-    const full = join9(dir, entry);
+    const full = join11(dir, entry);
     let entryStat;
     try {
       entryStat = await lstat(full);
@@ -14819,7 +15316,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   omitSet.add("node_modules");
   await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_DOCKER_SERVICES, async (dir) => {
     for (const filename of COMPOSE_FILENAMES) {
-      const filepath = join9(dir, filename);
+      const filepath = join11(dir, filename);
       if (await pathExistsAsync(filepath)) {
         await parseComposeFileAsync(filepath, dir, cwd, results);
         break;
@@ -14930,410 +15427,153 @@ function isSafeDockerRelDir(value) {
 }
 function isSafeDockerDatabaseName(value) {
   if (value === undefined)
-    return true;
-  if (value === "")
-    return false;
-  if (hasControlCharacter(value))
-    return false;
-  return /^[A-Za-z0-9_$.-]+$/.test(value);
-}
-function cloneSupabaseDiscoveryResult(result) {
-  return result.map((entry) => ({ ...entry }));
-}
-function parseSupabaseConfigToml(content) {
-  let section = null;
-  let projectId = null;
-  let dbPort = null;
-  for (const rawLine of content.split(`
-`)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#"))
-      continue;
-    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
-    if (sectionMatch) {
-      section = sectionMatch[1];
-      continue;
-    }
-    const kvMatch = line.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.+)$/);
-    if (!kvMatch)
-      continue;
-    const value = stripScalarSyntax(kvMatch[2]);
-    if (section === null && kvMatch[1] === "project_id") {
-      projectId = value;
-    } else if (section === "db" && kvMatch[1] === "port") {
-      dbPort = value;
-    }
-  }
-  if (!projectId || !isSafeDockerServiceName(projectId))
-    return null;
-  return {
-    projectId,
-    dbPort: dbPort && /^\d+$/.test(dbPort) ? dbPort : DEFAULT_SUPABASE_DB_PORT
-  };
-}
-async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal) {
-  const cacheKey = discoveryCacheKey(cwd, omitDirNames);
-  const now = Date.now();
-  const cached = supabaseDiscoveryCache.get(cacheKey);
-  if (cached && cached.expiresAt > now) {
-    return cloneSupabaseDiscoveryResult(cached.result);
-  }
-  const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
-  omitSet.add(".git");
-  omitSet.add("node_modules");
-  const results = [];
-  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
-    const configPath = join9(dir, "supabase", "config.toml");
-    if (!await pathExistsAsync(configPath))
-      return;
-    try {
-      const content = await readFile2(configPath, "utf-8");
-      const parsed = parseSupabaseConfigToml(content);
-      if (!parsed)
-        return;
-      const relDir = relative4(cwd, dir);
-      const isRoot = relDir === "" || relDir === ".";
-      const relDirSlash = relDir.replace(/\\/g, "/");
-      const id = isRoot ? `supabase:${parsed.projectId}` : `supabase:${parsed.projectId}@${encodeURIComponent(relDirSlash)}`;
-      const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
-      results.push({
-        id,
-        path: isRoot ? "supabase/config.toml" : `${relDirSlash}/supabase/config.toml`,
-        name: `${parsed.projectId} (Supabase CLI, postgres@127.0.0.1:${parsed.dbPort}/postgres${labelPath})`,
-        sizeBytes: 0,
-        kind: "postgresql",
-        projectId: parsed.projectId,
-        relDirSlash,
-        dbPort: parsed.dbPort
-      });
-    } catch {}
-  }, signal);
-  if (signal?.aborted)
-    return cloneSupabaseDiscoveryResult(results);
-  supabaseDiscoveryCache.set(cacheKey, {
-    expiresAt: now + SUPABASE_DISCOVERY_TTL_MS,
-    result: cloneSupabaseDiscoveryResult(results)
-  });
-  return cloneSupabaseDiscoveryResult(results);
-}
-function parseSupabaseDbId(dbId) {
-  if (!dbId.startsWith("supabase:"))
-    return null;
-  const rest = dbId.slice("supabase:".length);
-  if (!rest)
-    return null;
-  const atIdx = rest.indexOf("@");
-  let projectId;
-  let relDir = "";
-  if (atIdx >= 0) {
-    if (rest.indexOf("@", atIdx + 1) >= 0)
-      return null;
-    projectId = rest.slice(0, atIdx);
-    try {
-      relDir = decodeURIComponent(rest.slice(atIdx + 1));
-    } catch {
-      return null;
-    }
-    if (!isSafeDockerRelDir(relDir))
-      return null;
-  } else {
-    projectId = rest;
-  }
-  if (!isSafeDockerServiceName(projectId))
-    return null;
-  return { projectId, relDir };
-}
-async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal) {
-  const parsed = parseSupabaseDbId(dbId);
-  if (!parsed)
-    return null;
-  const projects = await discoverSupabaseCliProjectsAsync(cwd, omitDirNames, signal);
-  return projects.find((p) => p.projectId === parsed.projectId && p.relDirSlash === parsed.relDir) || null;
-}
-var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, DB_KIND_VALUES, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
-var init_discovery = __esm(() => {
-  SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3", ".s3db"]);
-  sqliteDiscoveryCache = new Map;
-  COMPOSE_FILENAMES = [
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    "compose.yml",
-    "compose.yaml"
-  ];
-  dockerDiscoveryCache = new Map;
-  DB_KIND_VALUES = new Set([
-    "sqlite",
-    "postgresql",
-    "mysql",
-    "redis",
-    "elasticsearch",
-    "s3",
-    "dynamodb"
-  ]);
-  supabaseDiscoveryCache = new Map;
-});
-
-// web-src/server/worktree-watcher.ts
-import {
-  lstatSync as lstatSync3,
-  readdirSync as nodeReaddirSync,
-  watch as nodeWatch
-} from "node:fs";
-import { join as join10, relative as relative5 } from "node:path";
-function normalizeRelativePath(path) {
-  return path.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-function isInsideRoot(root, path) {
-  const rel = relative5(root, path).replace(/\\/g, "/");
-  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
-}
-function startWorktreeUpdateWatch(options) {
-  const watch = options.watch || nodeWatch;
-  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
-  const isDirectory = options.isDirectory || ((path) => {
-    try {
-      return lstatSync3(path).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  const directorySignature = options.directorySignature || ((path) => {
-    try {
-      const stats = lstatSync3(path);
-      if (!stats.isDirectory())
-        return null;
-      return `${stats.dev}:${stats.ino}`;
-    } catch {
-      return null;
-    }
-  });
-  const setTimer = options.setTimeoutFn || setTimeout;
-  const clearTimer = options.clearTimeoutFn || clearTimeout;
-  const debounceMs = options.debounceMs ?? 250;
-  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
-  const watchers = new Map;
-  const signatures = new Map;
-  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
-  const initialScanQueue = [];
-  let initialScanTimer = null;
-  let processingInitialScan = false;
-  const pendingPathInspections = new Map;
-  let pathInspectionTimer = null;
-  let timer = null;
-  const pendingChangedPaths = new Set;
-  let watchLimitReported = false;
-  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
-  const directoryRelativePath = (dir) => normalizeRelativePath(relative5(options.root, dir));
-  const ignoredDirectory = (dir) => {
-    const rel = directoryRelativePath(dir);
-    return Boolean(rel && ignored(rel));
-  };
-  const scheduleUpdate = (changedPath) => {
-    if (changedPath)
-      pendingChangedPaths.add(changedPath);
-    if (timer)
-      clearTimer(timer);
-    timer = setTimer(() => {
-      timer = null;
-      const paths = pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
-      pendingChangedPaths.clear();
-      options.onUpdate(paths);
-    }, debounceMs);
-  };
-  const reportWatchLimit = () => {
-    if (watchLimitReported)
-      return;
-    watchLimitReported = true;
-    options.onWatchLimit?.(maxWatchedDirectories);
-    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
-  };
-  const closeSubtree = (dir) => {
-    for (const [watchedDir, watcher] of [...watchers]) {
-      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
-        continue;
-      try {
-        watcher.close?.();
-      } catch {}
-      watchers.delete(watchedDir);
-      signatures.delete(watchedDir);
-    }
-  };
-  const closeAll = () => {
-    if (initialScanTimer) {
-      clearTimer(initialScanTimer);
-      initialScanTimer = null;
-    }
-    if (pathInspectionTimer) {
-      clearTimer(pathInspectionTimer);
-      pathInspectionTimer = null;
-    }
-    initialScanQueue.length = 0;
-    pendingPathInspections.clear();
-    for (const watcher of [...watchers.values()]) {
-      try {
-        watcher.close?.();
-      } catch {}
-    }
-    watchers.clear();
-    signatures.clear();
-  };
-  const readChildDirectories = (dir) => {
-    let entries;
-    try {
-      entries = readDirs(dir);
-    } catch (error) {
-      options.onError?.(error);
-      return [];
-    }
-    const children = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const child = join10(dir, entry.name);
-      if (ignoredDirectory(child))
-        continue;
-      children.push(child);
-    }
-    return children;
-  };
-  const processInitialScanQueue = () => {
-    initialScanTimer = null;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-      return;
-    }
-    const next = initialScanQueue.shift();
-    if (next) {
-      processingInitialScan = true;
-      try {
-        watchDirectory(next, true);
-      } finally {
-        processingInitialScan = false;
-      }
-    }
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-    }
-    if (initialScanQueue.length)
-      initialScanTimer = setTimer(processInitialScanQueue, 50);
-  };
-  const queueInitialChildren = (dir) => {
-    const remaining = maxWatchedDirectories - watchers.size;
-    if (remaining <= 0) {
-      reportWatchLimit();
-      return;
-    }
-    const children = readChildDirectories(dir);
-    if (children.length > remaining)
-      reportWatchLimit();
-    initialScanQueue.push(...children.slice(0, remaining));
-    if (!initialScanTimer && !processingInitialScan)
-      initialScanTimer = setTimer(processInitialScanQueue, 5000);
-  };
-  const processChangedPath = (changed, fullChangedPath) => {
-    const known = watchers.has(fullChangedPath);
-    if (isDirectory(fullChangedPath)) {
-      if (known) {
-        const signature = directorySignature(fullChangedPath);
-        if (signature && signature !== signatures.get(fullChangedPath)) {
-          closeSubtree(fullChangedPath);
-          watchDirectory(fullChangedPath, initialScanAsync);
-        }
-        scheduleUpdate(changed);
-        return;
-      }
-      watchDirectory(fullChangedPath, initialScanAsync);
-    } else if (known) {
-      closeSubtree(fullChangedPath);
+    return true;
+  if (value === "")
+    return false;
+  if (hasControlCharacter(value))
+    return false;
+  return /^[A-Za-z0-9_$.-]+$/.test(value);
+}
+function cloneSupabaseDiscoveryResult(result) {
+  return result.map((entry) => ({ ...entry }));
+}
+function parseSupabaseConfigToml(content) {
+  let section = null;
+  let projectId = null;
+  let dbPort = null;
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1];
+      continue;
     }
-    scheduleUpdate(changed);
-  };
-  const processPathInspections = () => {
-    pathInspectionTimer = null;
-    const entries = [...pendingPathInspections];
-    pendingPathInspections.clear();
-    for (const [changed, fullChangedPath] of entries) {
-      processChangedPath(changed, fullChangedPath);
+    const kvMatch = line.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.+)$/);
+    if (!kvMatch)
+      continue;
+    const value = stripScalarSyntax(kvMatch[2]);
+    if (section === null && kvMatch[1] === "project_id") {
+      projectId = value;
+    } else if (section === "db" && kvMatch[1] === "port") {
+      dbPort = value;
     }
+  }
+  if (!projectId || !isSafeDockerServiceName(projectId))
+    return null;
+  return {
+    projectId,
+    dbPort: dbPort && /^\d+$/.test(dbPort) ? dbPort : DEFAULT_SUPABASE_DB_PORT
   };
-  const queuePathInspection = (changed, fullChangedPath) => {
-    pendingPathInspections.set(changed, fullChangedPath);
-    if (!pathInspectionTimer)
-      pathInspectionTimer = setTimer(processPathInspections, 25);
-  };
-  const watchDirectory = (dir, initialScan = false) => {
-    if (watchers.has(dir))
-      return;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
-    }
-    const rel = directoryRelativePath(dir);
-    if (rel && ignored(rel))
+}
+async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal) {
+  const cacheKey = discoveryCacheKey(cwd, omitDirNames);
+  const now = Date.now();
+  const cached = supabaseDiscoveryCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return cloneSupabaseDiscoveryResult(cached.result);
+  }
+  const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
+  omitSet.add(".git");
+  omitSet.add("node_modules");
+  const results = [];
+  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
+    const configPath = join11(dir, "supabase", "config.toml");
+    if (!await pathExistsAsync(configPath))
       return;
     try {
-      const watcher = watch(dir, { persistent: false }, (_event, filename) => {
-        if (!filename) {
-          scheduleUpdate();
-          return;
-        }
-        const changed = normalizeRelativePath(join10(rel, filename.toString()));
-        if (ignored(changed))
-          return;
-        const fullChangedPath = join10(options.root, changed);
-        if (!isInsideRoot(options.root, fullChangedPath))
-          return;
-        if (initialScanAsync) {
-          queuePathInspection(changed, fullChangedPath);
-          return;
-        }
-        processChangedPath(changed, fullChangedPath);
-      }) || {};
-      watchers.set(dir, watcher);
-      const signature = directorySignature(dir);
-      if (signature)
-        signatures.set(dir, signature);
-      watcher.on?.("error", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
-      });
-      watcher.on?.("close", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
+      const content = await readFile2(configPath, "utf-8");
+      const parsed = parseSupabaseConfigToml(content);
+      if (!parsed)
+        return;
+      const relDir = relative5(cwd, dir);
+      const isRoot = relDir === "" || relDir === ".";
+      const relDirSlash = relDir.replace(/\\/g, "/");
+      const id = isRoot ? `supabase:${parsed.projectId}` : `supabase:${parsed.projectId}@${encodeURIComponent(relDirSlash)}`;
+      const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
+      results.push({
+        id,
+        path: isRoot ? "supabase/config.toml" : `${relDirSlash}/supabase/config.toml`,
+        name: `${parsed.projectId} (Supabase CLI, postgres@127.0.0.1:${parsed.dbPort}/postgres${labelPath})`,
+        sizeBytes: 0,
+        kind: "postgresql",
+        projectId: parsed.projectId,
+        relDirSlash,
+        dbPort: parsed.dbPort
       });
-    } catch (error) {
-      options.onError?.(error);
-      return;
-    }
-    if (initialScanAsync && initialScan) {
-      queueInitialChildren(dir);
-      return;
-    }
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
+    } catch {}
+  }, signal);
+  if (signal?.aborted)
+    return cloneSupabaseDiscoveryResult(results);
+  supabaseDiscoveryCache.set(cacheKey, {
+    expiresAt: now + SUPABASE_DISCOVERY_TTL_MS,
+    result: cloneSupabaseDiscoveryResult(results)
+  });
+  return cloneSupabaseDiscoveryResult(results);
+}
+function parseSupabaseDbId(dbId) {
+  if (!dbId.startsWith("supabase:"))
+    return null;
+  const rest = dbId.slice("supabase:".length);
+  if (!rest)
+    return null;
+  const atIdx = rest.indexOf("@");
+  let projectId;
+  let relDir = "";
+  if (atIdx >= 0) {
+    if (rest.indexOf("@", atIdx + 1) >= 0)
+      return null;
+    projectId = rest.slice(0, atIdx);
+    try {
+      relDir = decodeURIComponent(rest.slice(atIdx + 1));
+    } catch {
+      return null;
     }
-    for (const child of readChildDirectories(dir))
-      watchDirectory(child);
-  };
-  watchDirectory(options.root, true);
-  return { started: watchers.size > 0, close: closeAll };
+    if (!isSafeDockerRelDir(relDir))
+      return null;
+  } else {
+    projectId = rest;
+  }
+  if (!isSafeDockerServiceName(projectId))
+    return null;
+  return { projectId, relDir };
 }
-var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 1024, MIN_WORKTREE_WATCH_DIRECTORY_LIMIT = 1, MAX_WORKTREE_WATCH_DIRECTORY_LIMIT = 65536;
-var init_worktree_watcher = __esm(() => {
-  init_search();
+async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal) {
+  const parsed = parseSupabaseDbId(dbId);
+  if (!parsed)
+    return null;
+  const projects = await discoverSupabaseCliProjectsAsync(cwd, omitDirNames, signal);
+  return projects.find((p) => p.projectId === parsed.projectId && p.relDirSlash === parsed.relDir) || null;
+}
+var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, DB_KIND_VALUES, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
+var init_discovery = __esm(() => {
+  SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3", ".s3db"]);
+  sqliteDiscoveryCache = new Map;
+  COMPOSE_FILENAMES = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml"
+  ];
+  dockerDiscoveryCache = new Map;
+  DB_KIND_VALUES = new Set([
+    "sqlite",
+    "postgresql",
+    "mysql",
+    "redis",
+    "elasticsearch",
+    "s3",
+    "dynamodb"
+  ]);
+  supabaseDiscoveryCache = new Map;
 });
 
 // web-src/server/state-store.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function codeViewerPath(root, fileName) {
-  return join11(root, CODE_VIEWER_DIR2, fileName);
+  return join12(root, CODE_VIEWER_DIR2, fileName);
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -16213,7 +16453,7 @@ var init_d1 = __esm(() => {
 
 // web-src/server/database/adapters/dynamodb.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { createHash as createHash5, createHmac as createHmac2 } from "node:crypto";
+import { createHash as createHash6, createHmac as createHmac2 } from "node:crypto";
 function createDynamoDbRequestDeadline() {
   const timeoutMs = dynamoDbRequestTimeoutMs;
   return { expiresAt: Date.now() + timeoutMs, timeoutMs };
@@ -16237,7 +16477,7 @@ function hmac2(key, value) {
   return createHmac2("sha256", key).update(value, "utf8").digest();
 }
 function sha2562(value) {
-  return createHash5("sha256").update(value, "utf8").digest("hex");
+  return createHash6("sha256").update(value, "utf8").digest("hex");
 }
 function amzDate2(date = new Date) {
   const iso = date.toISOString().replace(/[:-]|\.\d{3}/g, "");
@@ -16882,7 +17122,7 @@ var init_credential_store = __esm(() => {
 // web-src/server/database/connections-store.ts
 import { randomUUID } from "node:crypto";
 import { chmod } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function secretKey(cwd, id) {
   return `${cwd}\x00${id}`;
 }
@@ -16933,7 +17173,7 @@ function withRuntimeSecrets(cwd, connection) {
   };
 }
 function connectionsFilePath(root) {
-  return join12(root, ".code-viewer", CONNECTIONS_FILE_NAME);
+  return join13(root, ".code-viewer", CONNECTIONS_FILE_NAME);
 }
 function emptyState() {
   return { version: 1, connections: [] };
@@ -18745,9 +18985,9 @@ var init_handle_s3 = __esm(() => {
 });
 
 // web-src/server/database/query-history.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function historyFilePath(root) {
-  return join13(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
+  return join14(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
 }
 function emptyState2() {
   return { version: 1, entries: [] };
@@ -18895,11 +19135,11 @@ var init_query_history = __esm(() => {
 });
 
 // web-src/server/database/snapshot-store.ts
-import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash7, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 async function getStoreDb(cwd) {
-  const dbPath = join14(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
+  const dbPath = join15(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
     return storeDb;
   if (storeDb) {
@@ -18907,7 +19147,7 @@ async function getStoreDb(cwd) {
       storeDb.close();
     } catch {}
   }
-  mkdirSync3(join14(cwd, CODE_VIEWER_DIR4), { recursive: true });
+  mkdirSync3(join15(cwd, CODE_VIEWER_DIR4), { recursive: true });
   const DbClass = await loadSqliteClass();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
@@ -18926,7 +19166,7 @@ function makeId2(prefix) {
   return `${prefix}-${randomBytes2(8).toString("hex")}`;
 }
 function hashPayload(payloadJson) {
-  return createHash6("sha256").update(payloadJson).digest("hex");
+  return createHash7("sha256").update(payloadJson).digest("hex");
 }
 function hashLengthPrefixed(hasher, value) {
   hasher.update(`${Buffer.byteLength(value, "utf8")}:`);
@@ -19001,7 +19241,7 @@ async function addSnapshotTableRows(cwd, revisionId, rows) {
   db.exec("BEGIN");
   try {
     for (const row of rows) {
-      const rowKeyHash = createHash6("sha256").update(row.rowKeyJson).digest("hex");
+      const rowKeyHash = createHash7("sha256").update(row.rowKeyJson).digest("hex");
       const payloadHash = hashPayload(row.payloadJson);
       insertRow.run(revisionId, rowKeyHash, row.rowKeyJson, row.rowHash, payloadHash);
       insertPayload.run(payloadHash, row.payloadJson);
@@ -19015,7 +19255,7 @@ async function addSnapshotTableRows(cwd, revisionId, rows) {
   }
 }
 function computeRevisionTableHash(db, revisionId) {
-  const hasher = createHash6("sha256");
+  const hasher = createHash7("sha256");
   hashLengthPrefixed(hasher, `snapshot-table-v${SNAPSHOT_TABLE_HASH_VERSION}`);
   let rowCount = 0;
   let last;
@@ -19513,9 +19753,9 @@ var init_snapshot_runner = __esm(() => {
 });
 
 // web-src/server/database/tabs-store.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function tabsFilePath(root) {
-  return join15(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
+  return join16(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
 }
 function emptyState3() {
   return { version: 1, tabs: [], activeTabId: null };
@@ -21469,7 +21709,7 @@ var init_handle = __esm(() => {
 
 // web-src/server/doctor.ts
 import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
-import { dirname as dirname5, join as join16, relative as relative6 } from "node:path";
+import { dirname as dirname5, join as join17, relative as relative6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function statusWorse(a, b) {
   const rank = { ok: 0, warn: 1, error: 2 };
@@ -21563,7 +21803,7 @@ function findCodeViewerPackageJson() {
       cursor = dirname5(process.argv[1] || ".");
     }
     for (let depth = 0;depth < 8; depth += 1) {
-      const candidate = join16(cursor, "package.json");
+      const candidate = join17(cursor, "package.json");
       try {
         const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
@@ -21659,7 +21899,7 @@ async function checkSqlite(cwd) {
   return { id: "sqlite", title: "SQLite driver", rows };
 }
 async function trySnapshotDbOpen(cwd) {
-  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join17(cwd, SNAPSHOT_DB_REL);
   try {
     statSync6(dbPath);
   } catch {
@@ -21680,7 +21920,7 @@ async function trySnapshotDbOpen(cwd) {
   }
 }
 function checkSnapshotStore(cwd) {
-  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join17(cwd, SNAPSHOT_DB_REL);
   const dir = dirname5(dbPath);
   let dirStatus = "ok";
   let dirDetail = dir;
@@ -22699,12 +22939,12 @@ function startDevAssetReload(options) {
 var init_dev_assets = () => {};
 
 // web-src/server/journal.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function dailyJournalFilePath(root) {
-  return join17(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
+  return join18(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
 }
 function journalTasksFilePath(root) {
-  return join17(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
+  return join18(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
 }
 function emptyDailyJournalState() {
   return { version: 1, entries: [] };
@@ -23317,7 +23557,7 @@ var init_journal2 = __esm(() => {
 // web-src/server/search-service.ts
 import { existsSync as existsSync7, realpathSync as realpathSync6 } from "node:fs";
 import { lstat as lstat2, readFile as readFile3 } from "node:fs/promises";
-import { join as join18, relative as relative7 } from "node:path";
+import { join as join19, relative as relative7 } from "node:path";
 async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
@@ -23347,7 +23587,7 @@ function safeWorktreePath(env, path) {
     return null;
   if (isGitInternalPath(path))
     return null;
-  const full = join18(env.cwd, path);
+  const full = join19(env.cwd, path);
   if (!existsSync7(full))
     return null;
   let realCwd;
@@ -23540,7 +23780,7 @@ var init_search_service = __esm(() => {
 
 // web-src/server/mcp.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function defaultMcpTools(options = {}) {
   return [
     {
@@ -25014,7 +25254,7 @@ var init_mcp = __esm(() => {
   init_search_cli();
   init_search_service();
   init_status_cli();
-  PACKAGE_VERSION = JSON.parse(readFileSync7(join19(ROOT, "package.json"), "utf8")).version;
+  PACKAGE_VERSION = JSON.parse(readFileSync7(join20(ROOT, "package.json"), "utf8")).version;
   MCP_SERVER_INFO = {
     name: "code-viewer",
     title: "code-viewer",
@@ -25022,6 +25262,172 @@ var init_mcp = __esm(() => {
   };
 });
 
+// web-src/server/watch-supervisor.ts
+import { spawn as spawn3 } from "node:child_process";
+import { join as join21 } from "node:path";
+function watchChildCommand() {
+  const entry = process.argv[1] ?? "";
+  const script = entry.endsWith(".ts") ? join21(import.meta.dir, "cli.ts") : entry;
+  return [process.argv[0], script, "watch-child"];
+}
+function startWatchSupervisor(options) {
+  const spawnChild = options.spawnFn || spawn3;
+  const now = options.nowFn || Date.now;
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const setRepeating = options.setIntervalFn || setInterval;
+  const clearRepeating = options.clearIntervalFn || clearInterval;
+  const heartbeatMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const command = options.command ?? watchChildCommand();
+  let child = null;
+  let closed = false;
+  let watchFailures = 0;
+  let pollOnly = false;
+  let sawReady = false;
+  let lastSignalAt = now();
+  let watchdog = null;
+  const report = (error) => options.onError?.(error);
+  const abandon = (victim) => {
+    victim.removeAllListeners?.();
+    victim.stdout?.removeAllListeners?.();
+    victim.stderr?.removeAllListeners?.();
+    try {
+      victim.kill("SIGTERM");
+    } catch {}
+    const grace = setTimer(() => {
+      try {
+        victim.kill("SIGKILL");
+      } catch {}
+    }, KILL_GRACE_MS);
+    grace.unref?.();
+  };
+  const handleMessage = (message) => {
+    lastSignalAt = now();
+    if (message.type === "heartbeat")
+      return;
+    if (message.type === "ready") {
+      if (message.pollOnly || message.watching) {
+        sawReady = true;
+        watchFailures = 0;
+      } else {
+        watchFailures++;
+      }
+      return;
+    }
+    if (message.type === "update") {
+      options.onUpdate(message.paths);
+      return;
+    }
+    if (message.type === "watch-limit") {
+      options.onWatchLimit?.(message.limit);
+      return;
+    }
+    if (message.type === "warn")
+      report(new Error(message.message));
+  };
+  const start = () => {
+    if (closed)
+      return;
+    if (!pollOnly && watchFailures >= WATCH_FAILURES_BEFORE_POLL_ONLY) {
+      pollOnly = true;
+      options.onPollOnly?.();
+    }
+    const config = {
+      root: options.root,
+      omitDirNames: options.omitDirNames,
+      excludeNames: options.excludeNames,
+      maxWatchedDirectories: options.maxWatchedDirectories,
+      debounceMs: options.debounceMs ?? 250,
+      pollIntervalMs,
+      heartbeatIntervalMs: heartbeatMs,
+      parentPid: process.pid,
+      pollOnly
+    };
+    let spawned;
+    try {
+      spawned = spawnChild(command[0], command.slice(1), {
+        cwd: options.root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      report(error);
+      return;
+    }
+    child = spawned;
+    sawReady = false;
+    lastSignalAt = now();
+    try {
+      spawned.stdin?.write(`${JSON.stringify(config)}
+`);
+    } catch (error) {
+      report(error);
+    }
+    let buffer = "";
+    spawned.stdout?.setEncoding?.("utf8");
+    spawned.stdout?.on("data", (chunk) => {
+      buffer += chunk;
+      let newline = buffer.indexOf(`
+`);
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (line) {
+          try {
+            handleMessage(JSON.parse(line));
+          } catch {}
+        }
+        newline = buffer.indexOf(`
+`);
+      }
+    });
+    spawned.stderr?.setEncoding?.("utf8");
+    spawned.stderr?.on("data", (chunk) => {
+      const text = String(chunk).trim();
+      if (text)
+        console.warn(`[code-viewer] watch child: ${text}`);
+    });
+    spawned.on("error", (error) => report(error));
+    spawned.on("exit", () => {
+      if (closed || child !== spawned)
+        return;
+      if (!sawReady)
+        watchFailures++;
+      child = null;
+      const retry = setTimer(start, heartbeatMs);
+      retry.unref?.();
+    });
+  };
+  start();
+  watchdog = setRepeating(() => {
+    if (closed || !child)
+      return;
+    if (now() - lastSignalAt < heartbeatMs * HEARTBEAT_MISS_LIMIT)
+      return;
+    const victim = child;
+    child = null;
+    watchFailures++;
+    report(new Error("watch child stopped reporting; restarting"));
+    abandon(victim);
+    start();
+  }, heartbeatMs);
+  watchdog.unref?.();
+  return {
+    close: () => {
+      closed = true;
+      if (watchdog)
+        clearRepeating(watchdog);
+      watchdog = null;
+      const victim = child;
+      child = null;
+      if (victim)
+        abandon(victim);
+    },
+    pollOnly: () => pollOnly
+  };
+}
+var DEFAULT_HEARTBEAT_MS = 5000, DEFAULT_POLL_MS = 15000, HEARTBEAT_MISS_LIMIT = 3, KILL_GRACE_MS = 2000, WATCH_FAILURES_BEFORE_POLL_ONLY = 2;
+var init_watch_supervisor = () => {};
+
 // web-src/server/state-route.ts
 var exports_state_route = {};
 __export(exports_state_route, {
@@ -25098,7 +25504,7 @@ import {
   closeSync as closeSync2,
   constants as constants3,
   existsSync as existsSync8,
-  lstatSync as lstatSync4,
+  lstatSync as lstatSync5,
   mkdirSync as mkdirSync4,
   openSync as openSync2,
   readFileSync as readFileSync8,
@@ -25110,7 +25516,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname6, extname as extname2, join as join20, relative as relative8 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname as extname2, join as join22, relative as relative8 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -25232,7 +25638,7 @@ Examples:
 }
 function warnIfLegacyConfigPresent() {
   try {
-    if (existsSync8(join20(cwd, ".code-viewer.json"))) {
+    if (existsSync8(join22(cwd, ".code-viewer.json"))) {
       console.warn("[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed.");
     }
   } catch {}
@@ -25339,7 +25745,7 @@ function staticFile(pathname) {
   const spec = map[pathname];
   if (!spec)
     return null;
-  const full = join20(WEB_ROOT, spec[0]);
+  const full = join22(WEB_ROOT, spec[0]);
   if (!existsSync8(full))
     return text("not found", 404);
   return new Response(readFileSync8(full), {
@@ -25597,7 +26003,7 @@ function safeWorktreePath2(path) {
   return safeWorktreePath(currentSearchEnv(), path);
 }
 function worktreePath(path) {
-  return join20(cwd, path);
+  return join22(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -25750,9 +26156,14 @@ async function handleTree(url) {
   if (tree.error)
     return text(tree.error, tree.status ?? 500);
   const entries = tree.entries.filter((entry) => !isExcludedScopePath(entry.path, excludeNames));
-  const statusMap = target === "worktree" || target === "" ? await repoStatusMapAsync(cwd) : null;
+  const worktreeTarget = target === "worktree" || target === "";
+  const [statusMap, ignoredPaths] = worktreeTarget ? await Promise.all([
+    repoStatusMapAsync(cwd),
+    ignoredPathsAsync(entries.map((entry) => entry.path), cwd)
+  ]) : [null, null];
   const withStatus = (entry) => {
-    const status = statusMap?.get(entry.path);
+    const found = statusMap && repoStatusForPath(statusMap, entry.path);
+    const status = ignoredPaths?.has(entry.path) && (!found || found.inherited) ? "I" : found?.code;
     return status ? { ...entry, status } : entry;
   };
   const deletedEntries = !recursive && statusMap ? deletedTreeEntriesForPath(statusMap, path) : [];
@@ -25766,7 +26177,7 @@ async function handleTree(url) {
       ...deletedEntries
     ],
     readme: await readReadme(target, path),
-    upload_enabled: uploadEnabled && (target === "worktree" || target === "")
+    upload_enabled: uploadEnabled && worktreeTarget
   });
 }
 async function handleSettings() {
@@ -25783,7 +26194,8 @@ async function handleSettings() {
       watch_limit_effective: scopeWatchLimit,
       watch_limit_default: DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT,
       watch_limit_min: MIN_WORKTREE_WATCH_DIRECTORY_LIMIT,
-      watch_limit_max: MAX_WORKTREE_WATCH_DIRECTORY_LIMIT
+      watch_limit_max: MAX_WORKTREE_WATCH_DIRECTORY_LIMIT,
+      watch_recursive: supportsNativeRecursiveWatch(process.platform)
     }
   });
 }
@@ -25926,7 +26338,7 @@ async function handleLog(url) {
 }
 function blamePathKey(p) {
   try {
-    const st = statSync7(join20(cwd, p));
+    const st = statSync7(join22(cwd, p));
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "missing";
@@ -26465,7 +26877,7 @@ async function handleUploadFiles(req) {
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
-    const target = join20(realDir, safeName);
+    const target = join22(realDir, safeName);
     if (relative8(realDir, dirname6(target)) !== "")
       return text("invalid filename", 400);
     if (existsSync8(target))
@@ -26587,9 +26999,9 @@ function triggerUpdate(changedPaths) {
   sendSse("update", data);
 }
 function moveMacPathIntoTrash(path) {
-  const trashDir = join20(homedir3(), ".Trash");
+  const trashDir = join22(homedir3(), ".Trash");
   const base = basename3(path) || "code-viewer-trash-item";
-  const target = join20(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
+  const target = join22(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
   try {
     mkdirSync4(trashDir, { recursive: true });
     renameSync(path, target);
@@ -26599,7 +27011,7 @@ function moveMacPathIntoTrash(path) {
   }
 }
 async function movePathToTrash(path) {
-  lstatSync4(path);
+  lstatSync5(path);
   if (process.platform === "darwin") {
     return moveMacPathIntoTrash(path);
   }
@@ -26631,7 +27043,7 @@ async function restoreTrashPath(originalPath, trashPath) {
     if (!existsSync8(trashPath))
       return { ok: false, error: "trash item not found" };
     try {
-      const trashRoot = join20(homedir3(), ".Trash");
+      const trashRoot = join22(homedir3(), ".Trash");
       const trashRelative = relative8(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
@@ -26787,7 +27199,7 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join20(parent, name);
+  const target = join22(parent, name);
   if (existsSync8(target))
     return text("already exists", 409);
   try {
@@ -27336,18 +27748,19 @@ async function shutdown(exitCode = 0) {
 }
 function startScopedWorktreeWatch() {
   watchLimitReached = null;
-  return startWorktreeUpdateWatch({
+  return startWatchSupervisor({
     root: cwd,
     omitDirNames: scopeOmitDirNames,
     excludeNames: scopeExcludeNames,
-    watch,
-    initialScanMode: "async",
     maxWatchedDirectories: scopeWatchLimit,
     onUpdate: triggerUpdate,
     onWatchLimit: (limit) => {
       watchLimitReached = limit;
       sendSse("watch-limit", String(limit));
     },
+    onPollOnly: () => {
+      console.warn("[code-viewer] file watching is unavailable; updates now come from periodic polling");
+    },
     onError: (error) => {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`code-viewer worktree watch skipped: ${message}`);
@@ -27390,9 +27803,10 @@ var init_preview = __esm(async () => {
   init_search_service();
   init_server_registry();
   init_state_store();
+  init_watch_supervisor();
   init_worktree_watcher();
-  WEB_ROOT = join20(ROOT, "web");
-  VERSION = JSON.parse(readFileSync8(join20(ROOT, "package.json"), "utf8")).version;
+  WEB_ROOT = join22(ROOT, "web");
+  VERSION = JSON.parse(readFileSync8(join22(ROOT, "package.json"), "utf8")).version;
   DEFAULT_ARGS = ["HEAD"];
   WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
   LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
@@ -27688,6 +28102,9 @@ if (process.argv[2] === "agent-help") {
 } else if (process.argv[2] === "skill") {
   const { runSkillCli: runSkillCli2 } = await Promise.resolve().then(() => (init_skill_cli(), exports_skill_cli));
   runSkillCli2(process.argv.slice(3));
+} else if (process.argv[2] === "watch-child") {
+  const { runWatchChild: runWatchChild2 } = await Promise.resolve().then(() => (init_watch_child(), exports_watch_child));
+  await runWatchChild2();
 } else if (process.argv[2] === "doctor") {
   const { runDoctorCli: runDoctorCli2 } = await Promise.resolve().then(() => (init_doctor_cli(), exports_doctor_cli));
   await runDoctorCli2(process.argv.slice(3));