@youtyan/code-viewer 0.9.1 → 0.9.2

package/dist/code-viewer.js

@@ -9763,6 +9763,477 @@ var init_agent_help = __esm(() => {
   ];
 });
 
+// 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 normalizeRelativePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isInsideRoot(root, path) {
+  const rel = relative4(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 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;
+      }
+    }
+    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 };
+}
+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 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 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 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 });
+    }
+  }
+  return { head, entries };
+}
+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));
+  }
+  return { head: parsed.head, entries };
+}
+async function pathSignature(root, entry) {
+  const full = join10(root, entry.path);
+  let stats;
+  try {
+    stats = lstatSync4(full);
+  } catch {
+    return `${entry.status}:absent`;
+  }
+  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;
+}
+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 path of previous.entries.keys()) {
+    if (!next.entries.has(path))
+      paths.push(path);
+  }
+  return { full: false, paths };
+}
+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;
+  }
+  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);
+    }
+  }, 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;
+    }
+    const diff = snapshotDiff(snapshot, next);
+    snapshot = next;
+    if (diff.full) {
+      send({ type: "update" });
+      return;
+    }
+    if (diff.paths.length)
+      send({ type: "update", paths: diff.paths });
+  };
+  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)
@@ -10028,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";
@@ -10048,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) {
@@ -12119,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));
@@ -12496,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")
@@ -12513,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) {
@@ -12525,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)
@@ -12558,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)
@@ -12600,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);
@@ -12628,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);
@@ -12642,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)
@@ -12672,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;
@@ -13264,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 {
@@ -13294,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()}`);
@@ -14304,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);
@@ -14375,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);
@@ -14392,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({
@@ -14419,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;
@@ -14430,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))
@@ -14591,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 {};
@@ -14713,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);
@@ -14818,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);
@@ -14845,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;
@@ -14889,477 +15360,220 @@ function parseDockerDbId(dbId) {
       return null;
     const afterAt = rest.slice(atIdx + 1);
     const colonIdx2 = afterAt.indexOf(":");
-    if (colonIdx2 >= 0) {
-      database = afterAt.slice(colonIdx2 + 1);
-      rest = `${rest.slice(0, atIdx)}@${afterAt.slice(0, colonIdx2)}`;
-    }
-    const [serviceName, encodedRel] = rest.split("@");
-    if (!isSafeDockerServiceName(serviceName))
-      return null;
-    if (!isSafeDockerDatabaseName(database))
-      return null;
-    try {
-      const relDir = decodeURIComponent(encodedRel || "");
-      if (!isSafeDockerRelDir(relDir))
-        return null;
-      return {
-        serviceName,
-        relDir,
-        database,
-        kind
-      };
-    } catch {
-      return null;
-    }
-  }
-  const colonIdx = rest.indexOf(":");
-  if (colonIdx >= 0) {
-    database = rest.slice(colonIdx + 1);
-    rest = rest.slice(0, colonIdx);
-  }
-  if (!isSafeDockerServiceName(rest))
-    return null;
-  if (!isSafeDockerDatabaseName(database))
-    return null;
-  return { serviceName: rest, relDir: "", database, kind };
-}
-function canonicalizeDockerDbId(dbId) {
-  const parsed = parseDockerDbId(dbId);
-  if (!parsed)
-    return null;
-  const database = parsed.database ? `:${parsed.database}` : "";
-  const kindSuffix = parsed.kind ? `#${parsed.kind}` : "";
-  if (!parsed.relDir)
-    return `docker:${parsed.serviceName}${database}${kindSuffix}`;
-  return `docker:${parsed.serviceName}@${encodeURIComponent(parsed.relDir)}${database}${kindSuffix}`;
-}
-async function findDockerServiceByDbIdAsync(cwd, dbId, kind, omitDirNames, signal) {
-  const parsed = parseDockerDbId(dbId);
-  if (!parsed)
-    return null;
-  if (kind && parsed.kind && parsed.kind !== kind)
-    return null;
-  const effectiveKind = parsed.kind ?? kind;
-  const services = await discoverDockerDatabasesAsync(cwd, omitDirNames, signal);
-  return services.find((d) => d.serviceName === parsed.serviceName && d.relDirSlash === parsed.relDir && (!effectiveKind || d.kind === effectiveKind)) || null;
-}
-function isSafeDockerServiceName(value) {
-  return /^[A-Za-z0-9_-]+$/.test(value);
-}
-function isSafeDockerRelDir(value) {
-  if (value === "")
-    return true;
-  if (!/^[A-Za-z0-9_./-]+$/.test(value))
-    return false;
-  const parts = value.split("/");
-  return parts.every((p) => p !== "" && p !== "." && p !== "..");
-}
-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)
+    if (colonIdx2 >= 0) {
+      database = afterAt.slice(colonIdx2 + 1);
+      rest = `${rest.slice(0, atIdx)}@${afterAt.slice(0, colonIdx2)}`;
+    }
+    const [serviceName, encodedRel] = rest.split("@");
+    if (!isSafeDockerServiceName(serviceName))
+      return null;
+    if (!isSafeDockerDatabaseName(database))
       return null;
-    projectId = rest.slice(0, atIdx);
     try {
-      relDir = decodeURIComponent(rest.slice(atIdx + 1));
+      const relDir = decodeURIComponent(encodedRel || "");
+      if (!isSafeDockerRelDir(relDir))
+        return null;
+      return {
+        serviceName,
+        relDir,
+        database,
+        kind
+      };
     } catch {
       return null;
     }
-    if (!isSafeDockerRelDir(relDir))
-      return null;
-  } else {
-    projectId = rest;
   }
-  if (!isSafeDockerServiceName(projectId))
+  const colonIdx = rest.indexOf(":");
+  if (colonIdx >= 0) {
+    database = rest.slice(colonIdx + 1);
+    rest = rest.slice(0, colonIdx);
+  }
+  if (!isSafeDockerServiceName(rest))
     return null;
-  return { projectId, relDir };
+  if (!isSafeDockerDatabaseName(database))
+    return null;
+  return { serviceName: rest, relDir: "", database, kind };
 }
-async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal) {
-  const parsed = parseSupabaseDbId(dbId);
+function canonicalizeDockerDbId(dbId) {
+  const parsed = parseDockerDbId(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;
+  const database = parsed.database ? `:${parsed.database}` : "";
+  const kindSuffix = parsed.kind ? `#${parsed.kind}` : "";
+  if (!parsed.relDir)
+    return `docker:${parsed.serviceName}${database}${kindSuffix}`;
+  return `docker:${parsed.serviceName}@${encodeURIComponent(parsed.relDir)}${database}${kindSuffix}`;
 }
-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(/^\/+/, "");
+async function findDockerServiceByDbIdAsync(cwd, dbId, kind, omitDirNames, signal) {
+  const parsed = parseDockerDbId(dbId);
+  if (!parsed)
+    return null;
+  if (kind && parsed.kind && parsed.kind !== kind)
+    return null;
+  const effectiveKind = parsed.kind ?? kind;
+  const services = await discoverDockerDatabasesAsync(cwd, omitDirNames, signal);
+  return services.find((d) => d.serviceName === parsed.serviceName && d.relDirSlash === parsed.relDir && (!effectiveKind || d.kind === effectiveKind)) || null;
 }
-function isInsideRoot(root, path) {
-  const rel = relative5(root, path).replace(/\\/g, "/");
-  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
+function isSafeDockerServiceName(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value);
 }
-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);
+function isSafeDockerRelDir(value) {
+  if (value === "")
+    return true;
+  if (!/^[A-Za-z0-9_./-]+$/.test(value))
+    return false;
+  const parts = value.split("/");
+  return parts.every((p) => p !== "" && p !== "." && p !== "..");
+}
+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;
     }
-    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);
@@ -16239,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 };
@@ -16263,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, "");
@@ -16908,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}`;
 }
@@ -16959,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: [] };
@@ -18771,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: [] };
@@ -18921,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) {
@@ -18933,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;
@@ -18952,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")}:`);
@@ -19027,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);
@@ -19041,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;
@@ -19539,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 };
@@ -21495,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 };
@@ -21589,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);
@@ -21685,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 {
@@ -21706,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;
@@ -22725,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: [] };
@@ -23343,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;
@@ -23373,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;
@@ -23566,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 [
     {
@@ -25040,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",
@@ -25048,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, {
@@ -25124,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,
@@ -25136,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++) {
@@ -25258,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 {}
@@ -25365,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), {
@@ -25623,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 === "") {
@@ -25814,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)
     }
   });
 }
@@ -25957,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";
@@ -26496,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))
@@ -26618,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);
@@ -26630,7 +27011,7 @@ function moveMacPathIntoTrash(path) {
   }
 }
 async function movePathToTrash(path) {
-  lstatSync4(path);
+  lstatSync5(path);
   if (process.platform === "darwin") {
     return moveMacPathIntoTrash(path);
   }
@@ -26662,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" };
@@ -26818,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 {
@@ -27367,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}`);
@@ -27421,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;
@@ -27719,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));