@youtyan/code-viewer 0.8.1 → 0.8.3

package/dist/code-viewer.js

@@ -666,9 +666,47 @@ var init_annotations = __esm(() => {
   });
 });
 
+// web-src/server/cache.ts
+import { lstatSync } from "node:fs";
+import { join as join2 } from "node:path";
+function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
+  return !!cached && now - cached.storedAt <= ttlMs;
+}
+function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
+  cache.set(key, { ...value, storedAt: now });
+  while (cache.size > maxEntries) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+function worktreeFileSignature(path, cwd) {
+  try {
+    const stats = lstatSync(join2(cwd, path));
+    const inode = "ino" in stats ? stats.ino : 0;
+    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
+  } catch {
+    return "state:missing";
+  }
+}
+function fileDiffCacheKey(options) {
+  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
+  if (options.isUntracked && !worktreeTarget) {
+    throw new Error("untracked file diffs require a worktree range");
+  }
+  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
+  if (options.isUntracked) {
+    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
+  }
+  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
+}
+var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
+var init_cache = () => {};
+
 // web-src/server/command-resolver.ts
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { dirname as dirname2, isAbsolute, join as join2, relative } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join3, relative } from "node:path";
 function isExternalCommandName(value) {
   return commandNameSet.has(value);
 }
@@ -803,7 +841,7 @@ function findGitRootByWalking(start) {
   let current = start;
   for (;; ) {
     try {
-      statSync(join2(current, ".git"));
+      statSync(join3(current, ".git"));
       return realpathSync(current);
     } catch {}
     const parent = dirname2(current);
@@ -835,6 +873,110 @@ var init_command_resolver = __esm(() => {
   activeOverrides = new Map;
 });
 
+// web-src/server/name-pattern.ts
+function parseGlobSegment(pattern) {
+  const matchers = [];
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      matchers.push({ kind: "star" });
+    } else if (ch === "?") {
+      matchers.push({ kind: "any" });
+    } else if (ch === "[") {
+      const close = pattern.indexOf("]", i + 1);
+      if (close === -1) {
+        matchers.push({ kind: "literal", ch: "[" });
+        continue;
+      }
+      const rawBody = pattern.slice(i + 1, close);
+      const negate = rawBody.startsWith("!");
+      matchers.push({
+        kind: "class",
+        body: negate ? rawBody.slice(1) : rawBody,
+        negate
+      });
+      i = close;
+    } else {
+      matchers.push({ kind: "literal", ch });
+    }
+  }
+  return matchers;
+}
+function charInClassBody(ch, body) {
+  for (let i = 0;i < body.length; ) {
+    if (body[i + 1] === "-" && i + 2 < body.length) {
+      if (ch >= body[i] && ch <= body[i + 2])
+        return true;
+      i += 3;
+    } else {
+      if (ch === body[i])
+        return true;
+      i += 1;
+    }
+  }
+  return false;
+}
+function matchesAt(matcher, ch) {
+  switch (matcher.kind) {
+    case "literal":
+      return matcher.ch === ch;
+    case "any":
+      return true;
+    case "class":
+      return charInClassBody(ch, matcher.body) !== matcher.negate;
+    case "star":
+      return false;
+  }
+}
+function matchGlobSegment(matchers, name) {
+  let mi = 0;
+  let ni = 0;
+  let starMi = -1;
+  let starNi = -1;
+  while (ni < name.length) {
+    const matcher = matchers[mi];
+    if (matcher && matcher.kind === "star") {
+      starMi = mi;
+      starNi = ni;
+      mi++;
+    } else if (matcher && matchesAt(matcher, name[ni])) {
+      mi++;
+      ni++;
+    } else if (starMi !== -1) {
+      mi = starMi + 1;
+      starNi++;
+      ni = starNi;
+    } else {
+      return false;
+    }
+  }
+  while (matchers[mi]?.kind === "star")
+    mi++;
+  return mi === matchers.length;
+}
+function compileNamePatterns(patterns) {
+  const literals = new Set;
+  const globs = [];
+  for (const pattern of patterns) {
+    const lower = pattern.toLowerCase();
+    if (GLOB_CHARS.test(lower)) {
+      globs.push(parseGlobSegment(lower));
+    } else {
+      literals.add(lower);
+    }
+  }
+  return {
+    matches(name) {
+      const lower = name.toLowerCase();
+      return literals.has(lower) || globs.some((matchers) => matchGlobSegment(matchers, lower));
+    }
+  };
+}
+var GLOB_CHARS;
+var init_name_pattern = __esm(() => {
+  GLOB_CHARS = /[*?[\]]/;
+});
+
 // web-src/server/runtime.ts
 import { spawn, spawnSync } from "node:child_process";
 import { createReadStream, promises as fs } from "node:fs";
@@ -1113,14 +1255,16 @@ var init_runtime = () => {};
 import {
   closeSync,
   existsSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   openSync,
   readdirSync,
   readFileSync,
+  readlinkSync,
   readSync,
+  realpathSync as realpathSync2,
   statSync as statSync2
 } from "node:fs";
-import { join as join3 } from "node:path";
+import { dirname as dirname3, join as join4, posix, relative as relative2 } from "node:path";
 function normalizeBlameRef(ref, base) {
   const rawRef = ref || "worktree";
   if (base === "worktree" && rawRef !== "worktree") {
@@ -1218,12 +1362,76 @@ async function statusPorcelainForPathAsync(path, cwd) {
     error: gitFailureMessage(res, "git status failed")
   };
 }
+async function repoStatusMapAsync(cwd, now = Date.now()) {
+  const cached = repoStatusMapCache.get(cwd);
+  if (cacheFresh(cached, now))
+    return cached.map;
+  const map = new Map;
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ], cwd);
+  if (res.code !== 0)
+    return map;
+  const records = res.stdout.split("\x00").filter(Boolean);
+  for (let i = 0;i < records.length; i++) {
+    const record = records[i];
+    const xy = record.slice(0, 2);
+    const path = record.slice(3);
+    if (!path)
+      continue;
+    if (xy === "??") {
+      map.set(path, "A");
+      continue;
+    }
+    if (xy[0] === "R" || xy[0] === "C" || xy[1] === "R" || xy[1] === "C") {
+      i++;
+      map.set(path, "R");
+      continue;
+    }
+    const code = xy[0] !== " " ? xy[0] : xy[1];
+    if (code && code !== " ")
+      map.set(path, code);
+  }
+  setTimedCacheEntry(repoStatusMapCache, cwd, { map }, now);
+  return map;
+}
 function show(ref, path, cwd) {
   return run(["git", "show", `${ref}:${path}`], cwd);
 }
 function showAsync(ref, path, cwd) {
   return runGitAsync(["git", "show", `${ref}:${path}`], cwd);
 }
+function resolveSymlinkPath(linkPath, target) {
+  if (!target || target.startsWith("/") || target.includes("\x00"))
+    return null;
+  const baseDir = dirname3(linkPath);
+  const combined = baseDir === "." ? target : `${baseDir}/${target}`;
+  const normalized = posix.normalize(combined);
+  if (normalized === "." || normalized === "")
+    return "";
+  if (normalized === ".." || normalized.startsWith("../"))
+    return null;
+  return normalized;
+}
+async function gitSymlinkTargetMetadataAsync(ref, path, cwd) {
+  const res = await showAsync(ref, path, cwd);
+  if (res.code !== 0)
+    return { symlink_target_type: "missing" };
+  const target = res.stdout;
+  const resolved = resolveSymlinkPath(path, target);
+  if (resolved === null)
+    return { symlink_target: target, symlink_target_type: "missing" };
+  const type = await runGitAsync(["git", "cat-file", "-t", `${ref}:${resolved}`], cwd);
+  const kind = type.stdout.trim();
+  const symlink_target_type = kind === "tree" ? "tree" : kind === "blob" ? "blob" : "missing";
+  return symlink_target_type === "missing" ? { symlink_target: target, symlink_target_type } : { symlink_target: target, symlink_target_type, resolved_path: resolved };
+}
 function catFileBlobStream(oid, cwd) {
   return spawnStream(resolveGitArgs(["git", "cat-file", "blob", oid]), cwd);
 }
@@ -1854,7 +2062,7 @@ function isGitInternalPath(path) {
   return pathHasSegment(path, ".git");
 }
 function syntheticUncommittedBlameFromWorktree(cwd, path) {
-  const filePath = join3(cwd, path);
+  const filePath = join4(cwd, path);
   try {
     const stat = statSync2(filePath);
     if (!stat.isFile())
@@ -2110,10 +2318,10 @@ function sortTreeEntries(entries) {
 function omittedWorktreeDirectoryReason(name, omitDirNames) {
   if (name === ".git")
     return "internal";
-  return omitDirNames.has(name) ? "heavy" : undefined;
+  return omitDirNames.matches(name) ? "heavy" : undefined;
 }
 function worktreeSubmodulePaths(cwd) {
-  if (!existsSync(join3(cwd, ".gitmodules")))
+  if (!existsSync(join4(cwd, ".gitmodules")))
     return new Set;
   const res = run(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
   if (res.code !== 0)
@@ -2125,7 +2333,7 @@ function worktreeSubmodulePaths(cwd) {
   }).filter(Boolean));
 }
 async function worktreeSubmodulePathsAsync(cwd) {
-  if (!existsSync(join3(cwd, ".gitmodules")))
+  if (!existsSync(join4(cwd, ".gitmodules")))
     return new Set;
   const res = await runGitAsync(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
   if (res.code !== 0)
@@ -2136,18 +2344,67 @@ async function worktreeSubmodulePathsAsync(cwd) {
     return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
   }).filter(Boolean));
 }
-function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames, submodulePaths) {
-  if (excludeNames.has(name.toLowerCase()))
+function realpathWithinRepo(cwd, full, allowRoot) {
+  try {
+    const realCwd = realpathSync2(cwd);
+    const realFull = realpathSync2(full);
+    const rel = relative2(realCwd, realFull);
+    if (rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
+      return null;
+    if (rel === "" && !allowRoot)
+      return null;
+    return realFull;
+  } catch {
+    return null;
+  }
+}
+function resolveWorktreeSymlinkTarget(cwd, full) {
+  let symlink_target;
+  try {
+    symlink_target = readlinkSync(full);
+  } catch {
+    symlink_target = undefined;
+  }
+  let symlink_target_type = "missing";
+  if (realpathWithinRepo(cwd, full, false) !== null) {
+    try {
+      const stat = statSync2(full);
+      symlink_target_type = stat.isDirectory() ? "tree" : stat.isFile() ? "blob" : "missing";
+    } catch {
+      symlink_target_type = "missing";
+    }
+  }
+  return symlink_target === undefined ? { symlink_target_type } : { symlink_target, symlink_target_type };
+}
+function recursiveWorktreeFileEntry(cwd, full, name, path, isSymlink) {
+  const symlinkInfo = isSymlink ? resolveWorktreeSymlinkTarget(cwd, full) : null;
+  return {
+    name,
+    path,
+    type: "blob",
+    ...symlinkInfo ? { is_symlink: true, ...symlinkInfo } : {}
+  };
+}
+function worktreeEntryFromDirent(cwd, base, dir, name, isDirectory, isSymlink, omitDirNames, excludeNames, submodulePaths) {
+  if (excludeNames.matches(name))
     return {
       name,
       path: "",
       type: isDirectory ? "tree" : "blob"
     };
   const entryPath = base ? `${base}/${name}` : name;
-  const type = isDirectory ? hasDotGitEntry(join3(dir, name)) ? "commit" : "tree" : "blob";
+  const symlinkInfo = isSymlink ? resolveWorktreeSymlinkTarget(cwd, join4(dir, name)) : null;
+  const resolvedIsDirectory = symlinkInfo ? symlinkInfo.symlink_target_type === "tree" : isDirectory;
+  const type = symlinkInfo && symlinkInfo.symlink_target_type === "missing" ? "blob" : resolvedIsDirectory ? hasDotGitEntry(join4(dir, name)) ? "commit" : "tree" : "blob";
   const omittedReason = type === "tree" ? omittedWorktreeDirectoryReason(name, omitDirNames) : undefined;
   const submodule = type === "commit" && submodulePaths.has(entryPath) ? true : undefined;
-  const baseEntry = submodule ? { name, path: entryPath, type, submodule } : { name, path: entryPath, type };
+  const baseEntry = {
+    name,
+    path: entryPath,
+    type,
+    ...submodule ? { submodule } : {},
+    ...symlinkInfo ? { is_symlink: true, ...symlinkInfo } : {}
+  };
   return omittedReason ? {
     ...baseEntry,
     children_omitted: true,
@@ -2156,14 +2413,16 @@ function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, exc
 }
 function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
-  const root = join3(cwd, base);
-  const omitDirNameSet = new Set(omitDirNames);
-  const excludeNameSet = new Set(excludeNames.map((name) => name.toLowerCase()));
+  const root = join4(cwd, base);
+  if (realpathWithinRepo(cwd, root, true) === null)
+    return [];
+  const omitDirNameSet = compileNamePatterns(omitDirNames);
+  const excludeNameSet = compileNamePatterns(excludeNames);
   const submodulePaths = worktreeSubmodulePaths(cwd);
   let directEntries;
   try {
     const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(cwd, base, root, entry.name, entry.isDirectory(), entry.isSymbolicLink(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
   } catch {
     return [];
   }
@@ -2200,10 +2459,10 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
       return;
     }
     for (const entry of entries) {
-      if (excludeNameSet.has(entry.name.toLowerCase()))
+      if (excludeNameSet.matches(entry.name))
         continue;
       const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
         if (omittedReason) {
@@ -2221,11 +2480,7 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
           continue;
         walk(full, entryPath, depth + 1);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
-        if (!pushRecursiveEntry({
-          name: entry.name,
-          path: entryPath,
-          type: "blob"
-        }))
+        if (!pushRecursiveEntry(recursiveWorktreeFileEntry(cwd, full, entry.name, entryPath, entry.isSymbolicLink())))
           return;
       }
     }
@@ -2235,14 +2490,16 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
 }
 async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
-  const root = join3(cwd, base);
-  const omitDirNameSet = new Set(omitDirNames);
-  const excludeNameSet = new Set(excludeNames.map((name) => name.toLowerCase()));
+  const root = join4(cwd, base);
+  if (realpathWithinRepo(cwd, root, true) === null)
+    return [];
+  const omitDirNameSet = compileNamePatterns(omitDirNames);
+  const excludeNameSet = compileNamePatterns(excludeNames);
   const submodulePaths = await worktreeSubmodulePathsAsync(cwd);
   let directEntries;
   try {
     const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(cwd, base, root, entry.name, entry.isDirectory(), entry.isSymbolicLink(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
   } catch {
     return [];
   }
@@ -2287,10 +2544,10 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
       return;
     }
     for (const entry of entries) {
-      if (excludeNameSet.has(entry.name.toLowerCase()))
+      if (excludeNameSet.matches(entry.name))
         continue;
       const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
         if (omittedReason) {
@@ -2308,11 +2565,7 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
           continue;
         await walk(full, entryPath, depth + 1);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
-        if (!pushRecursiveEntry({
-          name: entry.name,
-          path: entryPath,
-          type: "blob"
-        }))
+        if (!pushRecursiveEntry(recursiveWorktreeFileEntry(cwd, full, entry.name, entryPath, entry.isSymbolicLink())))
           return;
       }
     }
@@ -2322,12 +2575,24 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
 }
 function hasDotGitEntry(dir) {
   try {
-    lstatSync(join3(dir, ".git"));
+    lstatSync2(join4(dir, ".git"));
     return true;
   } catch (err) {
     return !!err && typeof err === "object" && "code" in err && err.code !== "ENOENT";
   }
 }
+function parseLsTreeRecord(rec, allowedTypes) {
+  const match = rec.match(new RegExp(`^(\\d+)\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
+  if (!match)
+    return null;
+  const [, mode, type, entryPath] = match;
+  return {
+    name: entryPath.split("/").pop() || entryPath,
+    path: entryPath,
+    type,
+    ...mode === LS_TREE_SYMLINK_MODE ? { is_symlink: true } : {}
+  };
+}
 function gitTreeEntries(ref, path, cwd, recursive) {
   const base = normalizeTreePath(path);
   const args = ["git", "-c", "core.quotepath=false", "ls-tree"];
@@ -2340,17 +2605,7 @@ function gitTreeEntries(ref, path, cwd, recursive) {
   if (res.code !== 0)
     return { code: res.code, entries: [], stderr: res.stderr };
   const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match)
-      return null;
-    const entryPath = match[2];
-    return {
-      name: entryPath.split("/").pop() || entryPath,
-      path: entryPath,
-      type: match[1]
-    };
-  }).filter((entry) => !!entry);
+  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
   if (recursive)
     entries.sort((a, b) => a.path.localeCompare(b.path));
   else
@@ -2369,17 +2624,7 @@ async function gitTreeEntriesAsync(ref, path, cwd, recursive) {
   if (res.code !== 0)
     return { code: res.code, entries: [], stderr: res.stderr };
   const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match)
-      return null;
-    const entryPath = match[2];
-    return {
-      name: entryPath.split("/").pop() || entryPath,
-      path: entryPath,
-      type: match[1]
-    };
-  }).filter((entry) => !!entry);
+  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
   if (recursive)
     entries.sort((a, b) => a.path.localeCompare(b.path));
   else
@@ -2443,7 +2688,7 @@ async function listTreeResultAsync(ref, path, cwd, options = {}) {
 }
 function untrackedMeta(cwd) {
   return untracked(cwd).flatMap((path) => {
-    const full = join3(cwd, path);
+    const full = join4(cwd, path);
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
@@ -2475,7 +2720,7 @@ function untrackedMeta(cwd) {
 async function untrackedMetaAsync(cwd) {
   const paths = await untrackedAsync(cwd);
   return paths.flatMap((path) => {
-    const full = join3(cwd, path);
+    const full = join4(cwd, path);
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
@@ -2723,9 +2968,11 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
+var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, repoStatusMapCache, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200, LS_TREE_SYMLINK_MODE = "120000";
 var init_git = __esm(() => {
+  init_cache();
   init_command_resolver();
+  init_name_pattern();
   init_runtime();
   ALWAYS_WORKTREE_OMIT_DIR_NAMES = [".devbox", ".direnv"];
   DEFAULT_WORKTREE_OMIT_DIR_NAMES = [
@@ -2772,6 +3019,7 @@ var init_git = __esm(() => {
     "bin",
     "obj"
   ];
+  repoStatusMapCache = new Map;
 });
 
 // web-src/server/server-registry.ts
@@ -2784,16 +3032,16 @@ import {
   writeFileSync
 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function registryDir() {
   const override = process.env.CODE_VIEWER_TEST_SERVER_REGISTRY_DIR;
   if (override)
     return override;
-  return join4(homedir(), ".cache", "code-viewer", "servers");
+  return join5(homedir(), ".cache", "code-viewer", "servers");
 }
 function serverRegistryFilePath(root) {
   const hash = createHash("sha256").update(root).digest("hex").slice(0, 16);
-  return join4(registryDir(), `${hash}.json`);
+  return join5(registryDir(), `${hash}.json`);
 }
 function writeServerRegistry(entry) {
   try {
@@ -2834,7 +3082,7 @@ function removeServerRegistry(root, pid) {
 var init_server_registry = () => {};
 
 // web-src/server/cli-helpers.ts
-import { realpathSync as realpathSync2 } from "node:fs";
+import { realpathSync as realpathSync3 } from "node:fs";
 function takeValue(argv, index, flag) {
   const value = argv[index + 1];
   if (value === undefined)
@@ -2893,7 +3141,7 @@ function resolveRepoRootSafe(cwdOption) {
   const base = cwdOption || process.cwd();
   let baseReal;
   try {
-    baseReal = realpathSync2(base);
+    baseReal = realpathSync3(base);
   } catch {
     return {
       ok: false,
@@ -4003,8 +4251,8 @@ __export(exports_file_cli, {
   FILE_DEFAULT_HISTORY_LIMIT: () => FILE_DEFAULT_HISTORY_LIMIT,
   FILE_AGENT_HELP: () => FILE_AGENT_HELP
 });
-import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
-import { join as join5, relative as relative2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
+import { join as join6, relative as relative3 } from "node:path";
 function validatePath(value) {
   return validateRepoRelativePathValue(value, "--path");
 }
@@ -4408,13 +4656,13 @@ function sliceLines(text, start, end) {
 function safeWorktreePathFromRoot(root, path) {
   if (validatePath(path))
     return null;
-  const full = join5(root, path);
+  const full = join6(root, path);
   if (!existsSync3(full))
     return null;
   try {
-    const realRoot = realpathSync3(root);
-    const realFull = realpathSync3(full);
-    const rel = relative2(realRoot, realFull);
+    const realRoot = realpathSync4(root);
+    const realFull = realpathSync4(full);
+    const rel = relative3(realRoot, realFull);
     if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\")) {
       return null;
     }
@@ -8766,11 +9014,11 @@ function normalizeGrepMax(value) {
   return Math.min(parsed, GREP_ABSOLUTE_MAX);
 }
 function isSkippableSearchPath(path, omitDirNames = [], excludeNames = []) {
-  const omitDirs = new Set(omitDirNames.map((name) => name.toLowerCase()));
-  const excluded = new Set(excludeNames.map((name) => name.toLowerCase()));
+  const omitDirs = compileNamePatterns(omitDirNames);
+  const excluded = compileNamePatterns(excludeNames);
   return path.split(/[\\/]+/).some((part) => {
     const lower = part.toLowerCase();
-    return lower === ".git" || lower === ".code-viewer" || omitDirs.has(lower) || excluded.has(lower);
+    return lower === ".git" || lower === ".code-viewer" || omitDirs.matches(part) || excluded.matches(part);
   });
 }
 function fixedStringLineMatches(path, text, query, max) {
@@ -8877,6 +9125,7 @@ function parseGitGrepOutput(stdout, ref, max, omitDirNames = [], excludeNames =
 }
 var GREP_DEFAULT_MAX = 200, GREP_ABSOLUTE_MAX = 500, GREP_MAX_FILE_BYTES, FILE_SEARCH_ABSOLUTE_MAX = 50000, DEFAULT_EXCLUDE_NAMES;
 var init_search = __esm(() => {
+  init_name_pattern();
   GREP_MAX_FILE_BYTES = 2 * 1024 * 1024;
   DEFAULT_EXCLUDE_NAMES = [".DS_Store"];
 });
@@ -9317,24 +9566,24 @@ Parse failures and unreachable servers exit 1.
 
 // web-src/server/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname3, join as join6, normalize } from "node:path";
+import { dirname as dirname4, join as join7, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 function findRoot(start) {
   let current = start;
   for (let i = 0;i < 5; i++) {
-    if (existsSync4(join6(current, "package.json")) && existsSync4(join6(current, "web"))) {
+    if (existsSync4(join7(current, "package.json")) && existsSync4(join7(current, "web"))) {
       return normalize(current);
     }
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current)
       break;
     current = parent;
   }
-  return normalize(join6(start, "..", ".."));
+  return normalize(join7(start, "..", ".."));
 }
 var ROOT;
 var init_root = __esm(() => {
-  ROOT = findRoot(dirname3(fileURLToPath(import.meta.url)));
+  ROOT = findRoot(dirname4(fileURLToPath(import.meta.url)));
 });
 
 // web-src/server/skill-cli.ts
@@ -9349,7 +9598,7 @@ __export(exports_skill_cli, {
 });
 import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join7, resolve } from "node:path";
+import { join as join8, resolve } from "node:path";
 function parseAgentList(value) {
   if (value === "all")
     return [...AGENT_NAMES];
@@ -9409,7 +9658,7 @@ function parseSkillArgs(argv) {
 function discoverBundledSkills(skillsRoot) {
   if (!existsSync5(skillsRoot))
     return [];
-  return readdirSync2(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync5(join7(skillsRoot, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
+  return readdirSync2(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync5(join8(skillsRoot, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
 }
 function installSkill(args, deps) {
   const skills = discoverBundledSkills(deps.skillsRoot);
@@ -9423,8 +9672,8 @@ function installSkill(args, deps) {
   const results = [];
   for (const agent of args.agents) {
     for (const skill of skills) {
-      const sourceDir = join7(deps.skillsRoot, skill);
-      const target = join7(base, AGENT_SKILL_DIRS[agent], "skills", skill);
+      const sourceDir = join8(deps.skillsRoot, skill);
+      const target = join8(base, AGENT_SKILL_DIRS[agent], "skills", skill);
       const action = existsSync5(target) ? "updated" : "installed";
       try {
         mkdirSync2(target, { recursive: true });
@@ -9453,7 +9702,7 @@ function runSkillCli(argv) {
     return;
   }
   const result = installSkill(parsed.args, {
-    skillsRoot: join7(ROOT, "skills"),
+    skillsRoot: join8(ROOT, "skills"),
     homeDir: homedir2(),
     projectDir: process.cwd()
   });
@@ -14517,11 +14766,11 @@ import {
   existsSync as existsSync6,
   openSync as openSync2,
   readSync as readSync2,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   statSync as statSync4
 } from "node:fs";
 import { lstat, open, readdir, readFile as readFile2, stat } from "node:fs/promises";
-import { basename, join as join8, relative as relative3 } from "node:path";
+import { basename, join as join9, relative as relative4 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
     const stat2 = statSync4(fullPath);
@@ -14592,7 +14841,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
         return;
       if (omitSet.has(entry.toLowerCase()))
         continue;
-      const full = join8(dir, entry);
+      const full = join9(dir, entry);
       let entryStat;
       try {
         entryStat = await lstat(full);
@@ -14609,7 +14858,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
           continue;
         if (!await isSqliteFileAsync(full))
           continue;
-        const rel = relative3(cwd, full);
+        const rel = relative4(cwd, full);
         if (rel.startsWith("..") || rel.startsWith("/"))
           continue;
         results.push({
@@ -14636,18 +14885,18 @@ function validateDbPath(cwd, dbPath) {
   const parts = dbPath.split(/[\\/]+/);
   if (parts.some((p) => p === ".." || p.toLowerCase() === ".git" || p.toLowerCase() === ".code-viewer"))
     return null;
-  const full = join8(cwd, dbPath);
+  const full = join9(cwd, dbPath);
   if (!existsSync6(full))
     return null;
   let realCwd;
   let realFull;
   try {
-    realCwd = realpathSync4(cwd);
-    realFull = realpathSync4(full);
+    realCwd = realpathSync5(cwd);
+    realFull = realpathSync5(full);
   } catch {
     return null;
   }
-  const rel = relative3(realCwd, realFull);
+  const rel = relative4(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/"))
     return null;
   if (!isSqliteFile(realFull))
@@ -14806,7 +15055,7 @@ function resolveEnvValue(raw, composeDirEnv = {}) {
 }
 async function readDotenvAsync(composeDir) {
   try {
-    const content = await readFile2(join8(composeDir, ".env"), "utf-8");
+    const content = await readFile2(join9(composeDir, ".env"), "utf-8");
     return parseDotenvContent(content);
   } catch {
     return {};
@@ -14928,7 +15177,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 = relative3(cwd, composeDir);
+  const relDir = relative4(cwd, composeDir);
   const isRoot = relDir === "" || relDir === ".";
   const relDirSlash = relDir.replace(/\\/g, "/");
   const filename = basename(filepath);
@@ -15033,7 +15282,7 @@ async function walkForMarkerFileAsync(dir, depth, omitSet, hasCapacity, visitDir
       return;
     if (omitSet.has(entry.toLowerCase()))
       continue;
-    const full = join8(dir, entry);
+    const full = join9(dir, entry);
     let entryStat;
     try {
       entryStat = await lstat(full);
@@ -15060,7 +15309,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 = join8(dir, filename);
+      const filepath = join9(dir, filename);
       if (await pathExistsAsync(filepath)) {
         await parseComposeFileAsync(filepath, dir, cwd, results);
         break;
@@ -15224,7 +15473,7 @@ async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal)
   omitSet.add("node_modules");
   const results = [];
   await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
-    const configPath = join8(dir, "supabase", "config.toml");
+    const configPath = join9(dir, "supabase", "config.toml");
     if (!await pathExistsAsync(configPath))
       return;
     try {
@@ -15232,7 +15481,7 @@ async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal)
       const parsed = parseSupabaseConfigToml(content);
       if (!parsed)
         return;
-      const relDir = relative3(cwd, dir);
+      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)}`;
@@ -15333,16 +15582,16 @@ function makeId(prefix) {
 
 // web-src/server/worktree-watcher.ts
 import {
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   readdirSync as nodeReaddirSync,
   watch as nodeWatch
 } from "node:fs";
-import { join as join9, relative as relative4 } from "node:path";
+import { join as join10, relative as relative5 } from "node:path";
 function normalizeRelativePath(path) {
   return path.replace(/\\/g, "/").replace(/^\/+/, "");
 }
 function isInsideRoot(root, path) {
-  const rel = relative4(root, path).replace(/\\/g, "/");
+  const rel = relative5(root, path).replace(/\\/g, "/");
   return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
 }
 function startWorktreeUpdateWatch(options) {
@@ -15350,14 +15599,14 @@ function startWorktreeUpdateWatch(options) {
   const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
   const isDirectory = options.isDirectory || ((path) => {
     try {
-      return lstatSync2(path).isDirectory();
+      return lstatSync3(path).isDirectory();
     } catch {
       return false;
     }
   });
   const directorySignature = options.directorySignature || ((path) => {
     try {
-      const stats = lstatSync2(path);
+      const stats = lstatSync3(path);
       if (!stats.isDirectory())
         return null;
       return `${stats.dev}:${stats.ino}`;
@@ -15380,7 +15629,7 @@ function startWorktreeUpdateWatch(options) {
   const pendingChangedPaths = new Set;
   let watchLimitReported = false;
   const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
-  const directoryRelativePath = (dir) => normalizeRelativePath(relative4(options.root, dir));
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative5(options.root, dir));
   const ignoredDirectory = (dir) => {
     const rel = directoryRelativePath(dir);
     return Boolean(rel && ignored(rel));
@@ -15446,7 +15695,7 @@ function startWorktreeUpdateWatch(options) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = join9(dir, entry.name);
+      const child = join10(dir, entry.name);
       if (ignoredDirectory(child))
         continue;
       children.push(child);
@@ -15530,10 +15779,10 @@ function startWorktreeUpdateWatch(options) {
           scheduleUpdate();
           return;
         }
-        const changed = normalizeRelativePath(join9(rel, filename.toString()));
+        const changed = normalizeRelativePath(join10(rel, filename.toString()));
         if (ignored(changed))
           return;
-        const fullChangedPath = join9(options.root, changed);
+        const fullChangedPath = join10(options.root, changed);
         if (!isInsideRoot(options.root, fullChangedPath))
           return;
         if (initialScanAsync) {
@@ -15582,9 +15831,9 @@ var init_worktree_watcher = __esm(() => {
 });
 
 // web-src/server/state-store.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function codeViewerPath(root, fileName) {
-  return join10(root, CODE_VIEWER_DIR2, fileName);
+  return join11(root, CODE_VIEWER_DIR2, fileName);
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -16700,7 +16949,7 @@ var init_connection_pool = __esm(() => {
 // web-src/server/database/connections-store.ts
 import { randomUUID } from "node:crypto";
 import { chmod } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function secretKey(cwd, id) {
   return `${cwd}\x00${id}`;
 }
@@ -16721,7 +16970,7 @@ function withRuntimeSecrets(cwd, connection) {
   };
 }
 function connectionsFilePath(root) {
-  return join11(root, ".code-viewer", CONNECTIONS_FILE_NAME);
+  return join12(root, ".code-viewer", CONNECTIONS_FILE_NAME);
 }
 function emptyState() {
   return { version: 1, connections: [] };
@@ -18503,9 +18752,9 @@ var init_handle_s3 = __esm(() => {
 });
 
 // web-src/server/database/query-history.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function historyFilePath(root) {
-  return join12(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
+  return join13(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
 }
 function emptyState2() {
   return { version: 1, entries: [] };
@@ -18655,9 +18904,9 @@ var init_query_history = __esm(() => {
 // web-src/server/database/snapshot-store.ts
 import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function getStoreDb(cwd) {
-  const dbPath = join13(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
+  const dbPath = join14(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
     return storeDb;
   if (storeDb) {
@@ -18665,7 +18914,7 @@ async function getStoreDb(cwd) {
       storeDb.close();
     } catch {}
   }
-  mkdirSync3(join13(cwd, CODE_VIEWER_DIR4), { recursive: true });
+  mkdirSync3(join14(cwd, CODE_VIEWER_DIR4), { recursive: true });
   const DbClass = await loadSqliteClass();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
@@ -19271,9 +19520,9 @@ var init_snapshot_runner = __esm(() => {
 });
 
 // web-src/server/database/tabs-store.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function tabsFilePath(root) {
-  return join14(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
+  return join15(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
 }
 function emptyState3() {
   return { version: 1, tabs: [], activeTabId: null };
@@ -21210,7 +21459,7 @@ var init_handle = __esm(() => {
 
 // web-src/server/doctor.ts
 import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
-import { dirname as dirname4, join as join15, relative as relative5 } from "node:path";
+import { dirname as dirname5, join as join16, 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 };
@@ -21299,12 +21548,12 @@ function findCodeViewerPackageJson() {
   try {
     let cursor;
     try {
-      cursor = dirname4(fileURLToPath2(import.meta.url));
+      cursor = dirname5(fileURLToPath2(import.meta.url));
     } catch {
-      cursor = dirname4(process.argv[1] || ".");
+      cursor = dirname5(process.argv[1] || ".");
     }
     for (let depth = 0;depth < 8; depth += 1) {
-      const candidate = join15(cursor, "package.json");
+      const candidate = join16(cursor, "package.json");
       try {
         const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
@@ -21312,7 +21561,7 @@ function findCodeViewerPackageJson() {
           return { version: pkg.version, path: candidate };
         }
       } catch {}
-      const next = dirname4(cursor);
+      const next = dirname5(cursor);
       if (next === cursor)
         break;
       cursor = next;
@@ -21400,7 +21649,7 @@ async function checkSqlite(cwd) {
   return { id: "sqlite", title: "SQLite driver", rows };
 }
 async function trySnapshotDbOpen(cwd) {
-  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
   try {
     statSync5(dbPath);
   } catch {
@@ -21421,8 +21670,8 @@ async function trySnapshotDbOpen(cwd) {
   }
 }
 function checkSnapshotStore(cwd) {
-  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
-  const dir = dirname4(dbPath);
+  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
+  const dir = dirname5(dbPath);
   let dirStatus = "ok";
   let dirDetail = dir;
   let dirHint;
@@ -21495,7 +21744,7 @@ async function checkGit(cwd, signal) {
   if (repoCheck && repoCheck.code === 0 && /true/.test(repoCheck.stdout)) {
     const topRes = await runCached(gitCache, TTL.gitRepo, commandForExternal("git"), ["rev-parse", "--show-toplevel"], TIMEOUT.git, signal, cwd);
     const top = topRes?.stdout.trim() || cwd;
-    const insideCwd = relative5(top, cwd) || ".";
+    const insideCwd = relative6(top, cwd) || ".";
     rows.push({
       id: "git.repo",
       title: "Working tree",
@@ -22423,44 +22672,6 @@ function normalizeNewDirectoryName(name) {
   return trimmed;
 }
 
-// web-src/server/cache.ts
-import { lstatSync as lstatSync3 } from "node:fs";
-import { join as join16 } from "node:path";
-function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
-  return !!cached && now - cached.storedAt <= ttlMs;
-}
-function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
-  cache.set(key, { ...value, storedAt: now });
-  while (cache.size > maxEntries) {
-    const oldest = cache.keys().next().value;
-    if (oldest === undefined)
-      break;
-    cache.delete(oldest);
-  }
-}
-function worktreeFileSignature(path, cwd) {
-  try {
-    const stats = lstatSync3(join16(cwd, path));
-    const inode = "ino" in stats ? stats.ino : 0;
-    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
-  } catch {
-    return "state:missing";
-  }
-}
-function fileDiffCacheKey(options) {
-  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
-  if (options.isUntracked && !worktreeTarget) {
-    throw new Error("untracked file diffs require a worktree range");
-  }
-  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
-  if (options.isUntracked) {
-    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
-  }
-  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
-}
-var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
-var init_cache = () => {};
-
 // web-src/server/dev-assets.ts
 import { basename as basename2 } from "node:path";
 function startDevAssetReload(options) {
@@ -23123,8 +23334,8 @@ var init_journal2 = __esm(() => {
 });
 
 // web-src/server/search-service.ts
-import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
-import { join as join18, relative as relative6 } from "node:path";
+import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync6 } from "node:fs";
+import { join as join18, relative as relative7 } from "node:path";
 async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
@@ -23141,7 +23352,8 @@ async function rgAvailableAsync(cwd) {
   return rgAvailableCache;
 }
 function isExcludedScopePath(path, excludeNames) {
-  return path.split(/[\\/]+/).some((part) => excludeNames.some((name) => part.toLowerCase() === name.toLowerCase()));
+  const excluded = compileNamePatterns(excludeNames);
+  return path.split(/[\\/]+/).some((part) => excluded.matches(part));
 }
 function isSafePath(path) {
   if (!path || path.startsWith("/") || path.startsWith("\\") || path.includes("\x00"))
@@ -23159,12 +23371,12 @@ function safeWorktreePath(env, path) {
   let realCwd;
   let realFull;
   try {
-    realCwd = realpathSync5(env.cwd);
-    realFull = realpathSync5(full);
+    realCwd = realpathSync6(env.cwd);
+    realFull = realpathSync6(full);
   } catch {
     return null;
   }
-  const rel = relative6(realCwd, realFull);
+  const rel = relative7(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
     return null;
   if (isGitInternalPath(rel))
@@ -23340,6 +23552,7 @@ var init_search_service = __esm(() => {
   init_command_resolver();
   init_spawn_runner();
   init_git();
+  init_name_pattern();
   init_search();
 });
 
@@ -24907,7 +25120,7 @@ import {
   mkdirSync as mkdirSync4,
   openSync as openSync3,
   readFileSync as readFileSync9,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   renameSync,
   statSync as statSync6,
   unlinkSync as unlinkSync2,
@@ -24915,7 +25128,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname5, extname as extname2, join as join20, relative as relative7 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname as extname2, join as join20, relative as relative8 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -24969,7 +25182,7 @@ Examples:
         process.exit(1);
       }
       try {
-        cwd = realpathSync6(next);
+        cwd = realpathSync7(next);
         cwdWasExplicit = true;
       } catch {
         console.error("--cwd must point to an existing directory");
@@ -25400,7 +25613,7 @@ function worktreePath(path) {
 function safeOpenWorktreePath(path) {
   if (path === "") {
     try {
-      const realCwd = realpathSync6(cwd);
+      const realCwd = realpathSync7(cwd);
       if (isGitInternalPath(realCwd))
         return null;
       return realCwd;
@@ -25411,7 +25624,7 @@ function safeOpenWorktreePath(path) {
   return safeWorktreePath2(path);
 }
 function parentRepoPath(path) {
-  const parent = dirname5(path);
+  const parent = dirname6(path);
   return parent === "." ? "" : parent;
 }
 function isoDate(ms) {
@@ -25469,6 +25682,21 @@ async function attachTreeEntryMetadata(target, entry) {
     return { ...entry, ...await directoryMetadata(target, entry.path) };
   if (entry.type !== "blob")
     return entry;
+  if (entry.is_symlink && target !== "worktree" && target !== "") {
+    const symlinkMeta = await gitSymlinkTargetMetadataAsync(target, entry.path, cwd);
+    if (symlinkMeta.symlink_target_type === "tree")
+      return {
+        ...entry,
+        ...symlinkMeta,
+        type: "tree",
+        ...await directoryMetadata(target, entry.path)
+      };
+    return {
+      ...entry,
+      ...symlinkMeta,
+      ...await fileMetadataForTarget(target, entry.path)
+    };
+  }
   return { ...entry, ...await fileMetadataForTarget(target, entry.path) };
 }
 async function readReadme(target, dirPath) {
@@ -25491,6 +25719,22 @@ async function readReadme(target, dirPath) {
   }
   return null;
 }
+function deletedTreeEntriesForPath(statusMap, basePath) {
+  const entries = [];
+  for (const [path, status] of statusMap) {
+    if (status !== "D")
+      continue;
+    if (basePath) {
+      if (!path.startsWith(`${basePath}/`))
+        continue;
+    }
+    const rel = basePath ? path.slice(basePath.length + 1) : path;
+    if (!rel || rel.includes("/"))
+      continue;
+    entries.push({ name: rel, path, type: "blob", status: "D" });
+  }
+  return entries;
+}
 async function handleTree(url) {
   const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
   const path = (url.searchParams.get("path") || "").replace(/^\/+|\/+$/g, "");
@@ -25517,12 +25761,21 @@ 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 withStatus = (entry) => {
+    const status = statusMap?.get(entry.path);
+    return status ? { ...entry, status } : entry;
+  };
+  const deletedEntries = !recursive && statusMap ? deletedTreeEntriesForPath(statusMap, path) : [];
   return json2({
     ref: target,
     path,
     project: basename3(cwd),
     branch: await currentBranchMetadata(),
-    entries: recursive ? entries : await Promise.all(entries.map((entry) => attachTreeEntryMetadata(target, entry))),
+    entries: recursive ? entries.map(withStatus) : [
+      ...await Promise.all(entries.map((entry) => attachTreeEntryMetadata(target, entry).then(withStatus))),
+      ...deletedEntries
+    ],
     readme: await readReadme(target, path),
     upload_enabled: uploadEnabled && (target === "worktree" || target === "")
   });
@@ -26218,7 +26471,7 @@ async function handleUploadFiles(req) {
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
     const target = join20(realDir, safeName);
-    if (relative7(realDir, dirname5(target)) !== "")
+    if (relative8(realDir, dirname6(target)) !== "")
       return text("invalid filename", 400);
     if (existsSync8(target))
       return text("file exists", 409);
@@ -26384,10 +26637,10 @@ async function restoreTrashPath(originalPath, trashPath) {
       return { ok: false, error: "trash item not found" };
     try {
       const trashRoot = join20(homedir3(), ".Trash");
-      const trashRelative = relative7(trashRoot, trashPath);
+      const trashRelative = relative8(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
-      mkdirSync4(dirname5(original), { recursive: true });
+      mkdirSync4(dirname6(original), { recursive: true });
       renameSync(trashPath, original);
       return { ok: true };
     } catch (error) {