@youtyan/code-viewer 0.13.1 → 0.15.0

package/dist/code-viewer.js

@@ -128,6 +128,79 @@ var init_id = __esm({
   }
 });
 
+// web-src/core/history.ts
+function parseHistoryLineRange(value) {
+  const match = /^(\d+)-(\d+)$/.exec(value || "");
+  if (!match) return void 0;
+  const a = Number(match[1]);
+  const b = Number(match[2]);
+  if (!(a > 0) || !(b > 0)) return void 0;
+  return { start: Math.min(a, b), end: Math.max(a, b) };
+}
+function formatHistoryLineRange(range) {
+  return `${range.start}-${range.end}`;
+}
+function tokenizeHistoryQuery(raw) {
+  const tokens = [];
+  const known = new Set(HISTORY_QUERY_PREFIXES);
+  for (const match of raw.trim().matchAll(/(?:([A-Za-z-]+):)?("([^"]*)"|(\S+))/g)) {
+    const prefix = (match[1] || "").toLowerCase();
+    const value = match[3] !== void 0 ? match[3] : match[4] ?? "";
+    if (!prefix) {
+      if (value === "no-merges") {
+        tokens.push({ kind: "merges", value: "no" });
+        continue;
+      }
+      if (value.endsWith(":") && known.has(value.slice(0, -1).toLowerCase()))
+        continue;
+      if (value) tokens.push({ kind: "text", value });
+      continue;
+    }
+    if (!known.has(prefix)) {
+      tokens.push({ kind: "text", value: `${match[1]}:${value}` });
+      continue;
+    }
+    if (!value) continue;
+    switch (prefix) {
+      case "author":
+      case "path":
+      case "code":
+        tokens.push({ kind: prefix, value });
+        break;
+      case "since":
+      case "after":
+        tokens.push({ kind: "since", value });
+        break;
+      case "until":
+      case "before":
+        tokens.push({ kind: "until", value });
+        break;
+      case "merges":
+        if (value === "no" || value === "only")
+          tokens.push({ kind: "merges", value });
+        else tokens.push({ kind: "text", value: `merges:${value}` });
+        break;
+    }
+  }
+  return tokens;
+}
+var HISTORY_QUERY_PREFIXES, DAY_MS;
+var init_history = __esm({
+  "web-src/core/history.ts"() {
+    HISTORY_QUERY_PREFIXES = [
+      "author",
+      "path",
+      "since",
+      "after",
+      "until",
+      "before",
+      "code",
+      "merges"
+    ];
+    DAY_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // web-src/core/shell.ts
 function isShellSessionId(value) {
   return typeof value === "string" && /^shell-[0-9a-z]{6,}$/.test(value);
@@ -201,14 +274,14 @@ function buildRoute(route) {
     }
     case "file":
       if (route.view === "blob") {
-        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=blob" + (route.preview ? "&preview=1" : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=blob" + (route.preview ? "&preview=1" : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.line && route.hl ? `&hl=${encodeURIComponent(route.hl)}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
       }
       if (route.view === "blame") {
         const ref = route.ref || "worktree";
         return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(ref) + "&view=blame" + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
       }
       if (route.view === "history") {
-        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=history" + (route.commit ? `&commit=${encodeURIComponent(route.commit)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=history" + (route.commit ? `&commit=${encodeURIComponent(route.commit)}` : "") + (route.compare ? `&compare=${encodeURIComponent(route.compare)}` : "") + (route.q ? `&q=${encodeURIComponent(route.q)}` : "") + (route.lines ? `&lines=${encodeURIComponent(formatHistoryLineRange(route.lines))}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
       }
       return "/file?path=" + encodeURIComponent(route.path) + "&ref=" + encodeURIComponent(route.ref || "worktree") + "&from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
     case "diff":
@@ -232,7 +305,12 @@ function buildRoute(route) {
     case "history": {
       const params = new URLSearchParams();
       if (route.ref && route.ref !== "HEAD") params.set("ref", route.ref);
+      if (route.path) params.set("path", route.path);
+      if (route.path && route.lines)
+        params.set("lines", formatHistoryLineRange(route.lines));
       if (route.commit) params.set("commit", route.commit);
+      if (route.compare) params.set("compare", route.compare);
+      if (route.q) params.set("q", route.q);
       const qs = params.toString();
       return `/history${qs ? `?${qs}` : ""}`;
     }
@@ -265,6 +343,7 @@ function buildRoute(route) {
 var SPA_PATHS, APP_ENTRY_PATHS;
 var init_routes = __esm({
   "web-src/core/routes.ts"() {
+    init_history();
     init_shell();
     init_tools();
     SPA_PATHS = [
@@ -1667,8 +1746,17 @@ async function readFileTextRange(path, start, endExclusive) {
 }
 function startServer(options) {
   const server2 = createServer(async (req, res) => {
+    const abort = new AbortController();
+    res.on("close", () => {
+      if (!res.writableFinished) abort.abort();
+    });
     try {
-      const request = nodeRequestToWeb(req, options.hostname, server2.address());
+      const request = nodeRequestToWeb(
+        req,
+        options.hostname,
+        server2.address(),
+        abort.signal
+      );
       const response = await options.fetch(request);
       await writeWebResponse(res, response);
     } catch (error) {
@@ -1719,7 +1807,7 @@ function startServer(options) {
     });
   });
 }
-function nodeRequestToWeb(req, hostname, address) {
+function nodeRequestToWeb(req, hostname, address, signal) {
   const port = typeof address === "object" && address ? address.port : 0;
   const host = req.headers.host || `${hostname}:${port}`;
   const url = new URL(req.url || "/", `http://${host}`);
@@ -1737,7 +1825,8 @@ function nodeRequestToWeb(req, hostname, address) {
     method,
     headers,
     body: hasBody ? Readable.toWeb(req) : void 0,
-    duplex: hasBody ? "half" : void 0
+    duplex: hasBody ? "half" : void 0,
+    signal
   });
 }
 async function writeWebResponse(res, response) {
@@ -2383,6 +2472,31 @@ async function remoteWebUrlAsync(cwd2) {
   if (res.code !== 0) return null;
   return parseRemoteWebUrl(res.stdout.trim());
 }
+function parseHistoryDecorations(raw) {
+  const refs = [];
+  for (const part of raw.split(",")) {
+    const item = part.trim();
+    if (!item) continue;
+    if (item === "HEAD") {
+      refs.push({ name: "HEAD", kind: "head" });
+      continue;
+    }
+    if (item.startsWith("HEAD -> ")) {
+      refs.push({
+        name: item.slice("HEAD -> ".length),
+        kind: "branch",
+        head: true
+      });
+      continue;
+    }
+    if (item.startsWith("tag: ")) {
+      refs.push({ name: item.slice("tag: ".length), kind: "tag" });
+      continue;
+    }
+    refs.push({ name: item, kind: "branch" });
+  }
+  return refs;
+}
 function parseHistoryLog(stdout) {
   const parts = stdout.split("\0");
   const commits = [];
@@ -2396,6 +2510,7 @@ function parseHistoryLog(stdout) {
     const author = parts[index++] || "";
     const when = parts[index++] || "";
     const parentsRaw = (parts[index++] || "").trim();
+    const decorations = (parts[index++] || "").trim();
     const body = (parts[index++] || "").trim();
     if (sha)
       commits.push({
@@ -2404,7 +2519,8 @@ function parseHistoryLog(stdout) {
         author,
         when,
         parents: parentsRaw ? parentsRaw.split(/\s+/) : [],
-        body
+        body,
+        refs: parseHistoryDecorations(decorations)
       });
   }
   return commits;
@@ -2412,37 +2528,125 @@ function parseHistoryLog(stdout) {
 function historyQueryArgs(query) {
   const trimmed = query.trim().slice(0, 200).replace(/\0/g, "");
   if (!trimmed) return { filterArgs: [], pathspec: [], shaTerm: "" };
-  const prefixed = /^(author|path):(.*)$/.exec(trimmed);
-  if (prefixed) {
-    const term = prefixed[2].trim();
-    if (!term) return { filterArgs: [], pathspec: [], shaTerm: "" };
-    if (prefixed[1] === "author") {
-      return {
-        filterArgs: [
-          "--regexp-ignore-case",
-          "--fixed-strings",
-          `--author=${term}`
-        ],
-        pathspec: [],
-        shaTerm: ""
-      };
+  const filterArgs = [];
+  const pathspec = [];
+  const texts = [];
+  let needsTextFlags = false;
+  for (const token of tokenizeHistoryQuery(trimmed)) {
+    switch (token.kind) {
+      case "text":
+        texts.push(token.value);
+        break;
+      case "author":
+        needsTextFlags = true;
+        filterArgs.push(`--author=${token.value}`);
+        break;
+      case "path":
+        pathspec.push(`:(icase)*${token.value}*`);
+        break;
+      case "since":
+        filterArgs.push(`--since=${token.value}`);
+        break;
+      case "until":
+        filterArgs.push(`--until=${token.value}`);
+        break;
+      case "code":
+        filterArgs.push(`-S${token.value}`);
+        break;
+      case "merges":
+        filterArgs.push(token.value === "no" ? "--no-merges" : "--merges");
+        break;
     }
-    return {
-      filterArgs: [],
-      pathspec: ["--", `:(icase)*${term}*`],
-      shaTerm: ""
-    };
   }
+  const phrase = texts.join(" ");
+  if (phrase) {
+    needsTextFlags = true;
+    filterArgs.push(`--grep=${phrase}`);
+  }
+  if (needsTextFlags)
+    filterArgs.unshift("--regexp-ignore-case", "--fixed-strings");
   return {
-    filterArgs: [
-      "--regexp-ignore-case",
-      "--fixed-strings",
-      `--grep=${trimmed}`
-    ],
-    pathspec: [],
-    shaTerm: /^[0-9a-f]{4,40}$/i.test(trimmed) ? trimmed : ""
+    filterArgs,
+    pathspec,
+    shaTerm: texts.length === 1 && /^[0-9a-f]{4,40}$/i.test(texts[0]) ? texts[0] : ""
   };
 }
+async function fileRevisionNeighborsAsync(cwd2, options) {
+  const path = options.path.trim();
+  if (!path || path.includes("\0") || path.startsWith("-"))
+    return { previous: null, next: null, error: "invalid path" };
+  const rawRef = (options.ref || "HEAD").trim();
+  const ref = rawRef === "worktree" ? "HEAD" : rawRef;
+  if (!ref || ref.startsWith("-") || ref.includes("\0"))
+    return { previous: null, next: null, error: "invalid ref" };
+  const verified = await runGitAsync(
+    ["git", "rev-parse", "--verify", `${ref}^{commit}`],
+    cwd2
+  );
+  if (verified.code !== 0)
+    return {
+      previous: null,
+      next: null,
+      ...gitFailureResult(verified, "unknown ref")
+    };
+  const sha = verified.stdout.trim();
+  const older = await runGitAsync(
+    ["git", "log", "--format=%H", "--max-count=2", sha, "--", path],
+    cwd2
+  );
+  if (older.code !== 0)
+    return {
+      previous: null,
+      next: null,
+      ...gitFailureResult(older, "git log failed")
+    };
+  const olderShas = older.stdout.split("\n").filter(Boolean);
+  const previous = olderShas[0] && olderShas[0] !== sha ? olderShas[0] : olderShas[1] ?? null;
+  const newer = await runGitAsync(
+    ["git", "log", "--format=%H", `${sha}..HEAD`, "--", path],
+    cwd2
+  );
+  if (newer.code !== 0)
+    return {
+      previous: null,
+      next: null,
+      ...gitFailureResult(newer, "git log failed")
+    };
+  const newerShas = newer.stdout.split("\n").filter(Boolean);
+  const next = newerShas.length ? newerShas[newerShas.length - 1] : null;
+  return { previous, next };
+}
+async function commitAuthorsAsync(cwd2, ref) {
+  const target = (ref || "HEAD").trim();
+  if (!target || target.startsWith("-") || target.includes("\0"))
+    return { authors: [], error: "invalid ref" };
+  const verified = await runGitAsync(
+    ["git", "rev-parse", "--verify", `${target}^{commit}`],
+    cwd2
+  );
+  if (verified.code !== 0)
+    return { authors: [], ...gitFailureResult(verified, "unknown ref") };
+  const res = await runGitAsync(
+    [
+      "git",
+      "log",
+      "--format=%an",
+      `--max-count=${MAX_HISTORY_AUTHOR_SCAN}`,
+      verified.stdout.trim()
+    ],
+    cwd2
+  );
+  if (res.code !== 0)
+    return { authors: [], ...gitFailureResult(res, "git log failed") };
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of res.stdout.split("\n")) {
+    const name = line.trim();
+    if (!name) continue;
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  const authors = [...counts.entries()].map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  return { authors };
+}
 async function commitHistoryAsync(cwd2, options) {
   const ref = (options.ref || "HEAD").trim();
   if (!ref || ref.startsWith("-") || ref.includes("\0"))
@@ -2466,10 +2670,13 @@ async function commitHistoryAsync(cwd2, options) {
     options.query || ""
   );
   const pathFilter = (options.path || "").trim();
-  const pathArgs = [];
-  if (pathFilter && !pathFilter.includes("\0") && !pathFilter.startsWith("-")) {
-    if (!pathFilter.endsWith("/")) pathArgs.push("--follow");
-    pathArgs.push("--", pathFilter);
+  const safePathFilter = pathFilter && !pathFilter.includes("\0") && !pathFilter.startsWith("-") ? pathFilter : "";
+  const lineRange = options.lines && safePathFilter && !safePathFilter.endsWith("/") ? options.lines : void 0;
+  const specs = lineRange ? [] : [...pathspec];
+  let follow = false;
+  if (safePathFilter && !lineRange) {
+    specs.push(safePathFilter);
+    follow = !safePathFilter.endsWith("/") && specs.length === 1;
   }
   const res = await runGitAsync(
     [
@@ -2480,9 +2687,12 @@ async function commitHistoryAsync(cwd2, options) {
       `--max-count=${limit + 1}`,
       `--format=${HISTORY_FORMAT}`,
       ...filterArgs,
+      ...follow ? ["--follow"] : [],
+      // -L prints patches by default; -s keeps the output to the headers
+      // our parser expects.
+      ...lineRange ? [`-L${lineRange.start},${lineRange.end}:${safePathFilter}`, "-s"] : [],
       verified.stdout.trim(),
-      ...pathspec,
-      ...pathArgs
+      ...specs.length ? ["--", ...specs] : []
     ],
     cwd2
   );
@@ -3258,10 +3468,11 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA, WORKTREE_RECURSIVE_DEPTH_LIMIT, WORKTREE_RECURSIVE_ENTRY_LIMIT, DEFAULT_REF_COMMIT_LIMIT, MAX_REF_COMMIT_LIMIT, COMMIT_FORMAT, ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS, repoStatusMapCache, STATUS_PORCELAIN_ARGS, HISTORY_FORMAT, MAX_HISTORY_LIMIT, LS_TREE_SYMLINK_MODE, untrackedScanCache, UNTRACKED_SCAN_CONCURRENCY;
+var BLAME_ZERO_SHA, WORKTREE_RECURSIVE_DEPTH_LIMIT, WORKTREE_RECURSIVE_ENTRY_LIMIT, DEFAULT_REF_COMMIT_LIMIT, MAX_REF_COMMIT_LIMIT, COMMIT_FORMAT, ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS, repoStatusMapCache, STATUS_PORCELAIN_ARGS, HISTORY_FORMAT, MAX_HISTORY_LIMIT, MAX_HISTORY_AUTHOR_SCAN, LS_TREE_SYMLINK_MODE, untrackedScanCache, UNTRACKED_SCAN_CONCURRENCY;
 var init_git = __esm({
   "web-src/server/git.ts"() {
     init_error_detail();
+    init_history();
     init_worktree();
     init_cache();
     init_command_resolver();
@@ -3333,8 +3544,9 @@ var init_git = __esm({
       // would make git enumerate every file under it on each poll.
       "--untracked-files=normal"
     ];
-    HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b";
+    HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%D%x00%b";
     MAX_HISTORY_LIMIT = 200;
+    MAX_HISTORY_AUTHOR_SCAN = 5e3;
     LS_TREE_SYMLINK_MODE = "120000";
     untrackedScanCache = /* @__PURE__ */ new Map();
     UNTRACKED_SCAN_CONCURRENCY = 8;
@@ -5305,8 +5517,12 @@ blame options:
 history options:
   --limit <n>     1..${FILE_HISTORY_HARD_CAP} (default: ${FILE_DEFAULT_HISTORY_LIMIT}).
   --skip <n>      Non-negative. Used to paginate.
-  --query <text>  git log filter passed verbatim to git.commitHistory
-                  (supports the "author:" / "path:" prefixes the browser uses).
+  --query <text>  git log filter, same syntax as the browser history filter:
+                  free words match the message ("quoted" keeps spaces),
+                  author:<name>, path:<part>, since:/after:<date>,
+                  until:/before:<date>, code:<text> (git log -S),
+                  merges:no (or no-merges), merges:only. Kinds AND together;
+                  a lone 4-40 hex word also tries a sha prefix.
 
 show options:
   --start <line>  1-indexed start line (inclusive). Requires --end.
@@ -5370,6 +5586,7 @@ Diff Viewer views.
   code-viewer file blame --path src/sample.ts --base HEAD --json
   code-viewer file history --path src/sample.ts --limit 10 --json
   code-viewer file history --path src/sample.ts --query "author:tester" --json
+  code-viewer file history --path src/sample.ts --query "since:2024-01-01 code:handler merges:no" --json
   code-viewer file show --path src/sample.ts --json
   code-viewer file show --path src/sample.ts --start 100 --end 150 --json
   code-viewer file show --path src/sample.ts --ref main --json
@@ -9289,21 +9506,25 @@ function computeFuzzyMatch(query, path) {
     tier
   };
 }
-function rankFuzzyPaths(query, items, limit) {
+function rankFuzzyPaths(query, items, limit, stats) {
   const bounded = Number.isInteger(limit) && limit !== void 0 && limit > 0 ? Math.floor(limit) : 0;
   const compare = (a, b) => b.tier - a.tier || b.score - a.score || a.item.path.localeCompare(b.item.path);
   if (!bounded) {
-    return items.map((item) => {
+    const ranked = items.map((item) => {
       const match = computeFuzzyMatch(query, item.path);
       return match ? { item, score: match.score, ranges: match.ranges, tier: match.tier } : null;
     }).filter(
       (item) => item !== null
     ).sort(compare).map(({ item, score, ranges }) => ({ item, score, ranges }));
+    if (stats) stats.total = ranked.length;
+    return ranked;
   }
   const top = [];
+  let total = 0;
   for (const item of items) {
     const match = computeFuzzyMatch(query, item.path);
     if (!match) continue;
+    total++;
     const ranked = {
       item,
       score: match.score,
@@ -9312,6 +9533,7 @@ function rankFuzzyPaths(query, items, limit) {
     };
     pushBoundedTop(top, ranked, bounded, compare);
   }
+  if (stats) stats.total = total;
   return top.sort(compare).map(({ item, score, ranges }) => ({ item, score, ranges }));
 }
 function pushBoundedTop(heap, item, limit, compareBestFirst) {
@@ -9346,13 +9568,16 @@ function pushBoundedTop(heap, item, limit, compareBestFirst) {
   heap[0] = item;
   siftDown(0);
 }
-function rankGlobPathMatches(query, items, limit) {
+function rankGlobPathMatches(query, items, limit, stats) {
   const matchPath = createGlobPathMatcher(query);
-  if (!matchPath) return [];
+  if (!matchPath) {
+    if (stats) stats.total = 0;
+    return [];
+  }
   const bounded = Number.isInteger(limit) && limit !== void 0 && limit > 0 ? Math.floor(limit) : 0;
   const compare = (a, b) => b.score - a.score || a.item.path.localeCompare(b.item.path);
   if (!bounded) {
-    return items.map((item) => {
+    const ranked = items.map((item) => {
       const match = matchPath(item.path);
       return match ? {
         item,
@@ -9361,11 +9586,15 @@ function rankGlobPathMatches(query, items, limit) {
         mode: "glob"
       } : null;
     }).filter((item) => item !== null).sort(compare);
+    if (stats) stats.total = ranked.length;
+    return ranked;
   }
   const top = [];
+  let total = 0;
   for (const item of items) {
     const match = matchPath(item.path);
     if (!match) continue;
+    total++;
     const ranked = {
       item,
       score: match.score,
@@ -9374,13 +9603,14 @@ function rankGlobPathMatches(query, items, limit) {
     };
     pushBoundedTop(top, ranked, bounded, compare);
   }
+  if (stats) stats.total = total;
   return top.sort(compare);
 }
-function rankPathMatches(query, items, limit) {
+function rankPathMatches(query, items, limit, stats) {
   if (isGlobPathQuery(query)) {
-    return rankGlobPathMatches(query, items, limit);
+    return rankGlobPathMatches(query, items, limit, stats);
   }
-  return rankFuzzyPaths(query, items, limit).map((item) => ({
+  return rankFuzzyPaths(query, items, limit, stats).map((item) => ({
     ...item,
     mode: "fuzzy"
   }));
@@ -9399,8 +9629,13 @@ function globToRegExp(query) {
     const ch = pattern[i];
     if (ch === "*") {
       if (pattern[i + 1] === "*") {
-        source += ".*";
-        i++;
+        if (pattern[i + 2] === "/") {
+          source += "(?:.*/)?";
+          i += 2;
+        } else {
+          source += ".*";
+          i++;
+        }
       } else {
         source += "[^/]*";
       }
@@ -9426,6 +9661,9 @@ function globToRegExp(query) {
     return null;
   }
 }
+function globMatchPath(query, path) {
+  return createGlobPathMatcher(query)?.(path) ?? null;
+}
 function createGlobPathMatcher(query) {
   const regex = globToRegExp(query);
   if (!regex) return null;
@@ -9475,14 +9713,31 @@ function isSkippableSearchPath(path, omitDirNames = [], excludeNames = []) {
     return lower === ".git" || lower === ".code-viewer" || omitDirs.matches(part) || excluded.matches(part);
   });
 }
-function fixedStringLineMatches(path, text2, query, max) {
-  const needle = query.toLowerCase();
-  if (!needle) return [];
+function isWordBoundary(line, start, end) {
+  const before = start > 0 ? line[start - 1] : "";
+  const after = end < line.length ? line[end] : "";
+  return !WORD_CHAR_RE.test(before) && !WORD_CHAR_RE.test(after);
+}
+function fixedStringColumn(line, query, options = {}) {
+  if (!query) return -1;
+  const haystack = options.caseSensitive ? line : line.toLowerCase();
+  const needle = options.caseSensitive ? query : query.toLowerCase();
+  let from = 0;
+  for (; ; ) {
+    const column = haystack.indexOf(needle, from);
+    if (column < 0) return -1;
+    if (!options.wholeWord || isWordBoundary(line, column, column + needle.length))
+      return column;
+    from = column + 1;
+  }
+}
+function fixedStringLineMatches(path, text2, query, max, options = {}) {
+  if (!query) return [];
   const matches = [];
   const lines = text2.split("\n");
   for (let i = 0; i < lines.length && matches.length < max; i++) {
     const line = lines[i];
-    const column = line.toLowerCase().indexOf(needle);
+    const column = fixedStringColumn(line, query, options);
     if (column < 0) continue;
     matches.push({
       path,
@@ -9505,8 +9760,12 @@ function buildFileSearchList(ref, generation2, entries) {
     truncated: entries.length > FILE_SEARCH_ABSOLUTE_MAX
   };
 }
-function buildRgArgs(query, max, paths, regex = false, omitDirNames = [], excludeNames = [], excludeTests = false) {
+function buildRgArgs(query, max, paths, regex = false, omitDirNames = [], excludeNames = [], excludeTests = false, options = {}) {
   const safePaths = paths.length ? paths : ["."];
+  const includeGlobs = (options.pathGlobs ?? []).flatMap((pattern) => [
+    "--glob",
+    pattern
+  ]);
   const omitGlobs = omitDirNames.flatMap((name) => [
     "--glob",
     `!${name}/**`,
@@ -9556,12 +9815,14 @@ function buildRgArgs(query, max, paths, regex = false, omitDirNames = [], exclud
     "--with-filename",
     "--color",
     "never",
-    "--smart-case",
+    options.caseSensitive ? "--case-sensitive" : "--ignore-case",
+    ...options.wholeWord ? ["--word-regexp"] : [],
     ...matchMode,
     "--max-count",
     String(max),
     "--max-filesize",
     "2M",
+    ...includeGlobs,
     ...omitGlobs,
     ...excludeGlobs,
     ...testGlobs,
@@ -9633,7 +9894,7 @@ function parseGitGrepOutput(stdout, ref, max, omitDirNames = [], excludeNames =
     includePath
   );
 }
-var GREP_DEFAULT_MAX, GREP_ABSOLUTE_MAX, GREP_MAX_FILE_BYTES, FILE_SEARCH_ABSOLUTE_MAX, DEFAULT_EXCLUDE_NAMES;
+var GREP_DEFAULT_MAX, GREP_ABSOLUTE_MAX, GREP_MAX_FILE_BYTES, FILE_SEARCH_ABSOLUTE_MAX, DEFAULT_EXCLUDE_NAMES, WORD_CHAR_RE;
 var init_search = __esm({
   "web-src/server/search.ts"() {
     init_name_pattern();
@@ -9642,6 +9903,7 @@ var init_search = __esm({
     GREP_MAX_FILE_BYTES = 2 * 1024 * 1024;
     FILE_SEARCH_ABSOLUTE_MAX = 5e4;
     DEFAULT_EXCLUDE_NAMES = [".DS_Store"];
+    WORD_CHAR_RE = /[\p{L}\p{N}_]/u;
   }
 });
 
@@ -9735,11 +9997,13 @@ function parseSearchArgs(argv) {
     return { ok: false, error: "--term must be a single line" };
   }
   if (subcommand === "files") {
-    if (flags.has("--regex")) {
-      return {
-        ok: false,
-        error: "search files does not accept --regex"
-      };
+    for (const codeOnly of ["--regex", "--case-sensitive", "--word"]) {
+      if (flags.has(codeOnly)) {
+        return {
+          ok: false,
+          error: `search files does not accept ${codeOnly}`
+        };
+      }
     }
     if (paths.length > 0) {
       return {
@@ -9780,6 +10044,8 @@ function parseSearchArgs(argv) {
         ref: options.get("--ref"),
         paths,
         regex: flags.has("--regex"),
+        caseSensitive: flags.has("--case-sensitive"),
+        wholeWord: flags.has("--word"),
         max: parsedMax.value,
         json: flags.has("--json")
       },
@@ -9795,6 +10061,8 @@ function buildGrepPath(command) {
   if (command.ref) params.set("ref", command.ref);
   if (command.max !== void 0) params.set("max", String(command.max));
   if (command.regex) params.set("regex", "1");
+  if (command.caseSensitive) params.set("case", "1");
+  if (command.wholeWord) params.set("word", "1");
   for (const path of command.paths) params.append("path", path);
   return `/_grep?${params.toString()}`;
 }
@@ -9925,7 +10193,8 @@ var init_search_cli = __esm({
 
 Usage:
   code-viewer search code --term <text> [--ref <ref>] [--path <path>...]
-                          [--regex] [--max <n>] [--json]
+                          [--regex] [--case-sensitive] [--word]
+                          [--max <n>] [--json]
                           [--cwd <dir>] [--server <url>] [--bin <name>=<path>]
   code-viewer search files --term <pattern> [--ref <ref>] [--max <n>] [--json]
                            [--cwd <dir>] [--server <url>] [--bin <name>=<path>]
@@ -9946,8 +10215,12 @@ Common options:
   --help, -h        Show this help.
 
 search code only:
-  --path <path>     Restrict the search to a sub-path. Repeatable.
+  --path <path>     Restrict the search to a file, a directory, or a glob
+                    such as "src/**/*.ts". Repeatable.
   --regex           Treat --term as an extended regex instead of a fixed string.
+  --case-sensitive  Match case. Default: case-insensitive on every engine.
+  --word            Match whole words only (rg -w / git grep -w; the
+                    fallback scanner applies the same boundary rule).
 
 search files:
   --term auto-switches between fuzzy and glob matching:
@@ -9995,6 +10268,8 @@ environments. Results are NOT persisted on the server; this is a pure read.
   code-viewer search code --term "TODO" --json
   code-viewer search code --term "fn handler" --regex --json
   code-viewer search code --term "config" --path src --path tests --json
+  code-viewer search code --term "Token" --case-sensitive --word --json
+  code-viewer search code --term "config" --path "src/**/*.ts" --json
   code-viewer search code --term "release" --ref main --json
 
   code-viewer search files --term "sample"
@@ -10053,6 +10328,10 @@ Parse failures and unreachable servers exit 1.
 - search code: engine=fallback with regex=true returns zero matches by
   design — the fallback path does not support regex. Install ripgrep or
   use a fixed string instead.
+- search code: matching is case-insensitive on every engine unless you
+  pass --case-sensitive; --word requires the hit to sit on word
+  boundaries. --path accepts globs ("src/**/*.ts", "*.md") as well as
+  files and directories.
 - search files: --term containing * or ? triggers glob mode (e.g.
   "src/**/*.test.ts"). Bare words use fuzzy ranking (e.g. "auth",
   "userId"). The /_files list is shared with the browser Ctrl+K palette,
@@ -10064,7 +10343,7 @@ Parse failures and unreachable servers exit 1.
 `;
     VALUE_FLAGS3 = /* @__PURE__ */ new Set(["--term", "--ref", "--max"]);
     REPEATABLE_VALUE_FLAGS = /* @__PURE__ */ new Set(["--path"]);
-    BOOL_FLAGS3 = /* @__PURE__ */ new Set(["--regex", "--json"]);
+    BOOL_FLAGS3 = /* @__PURE__ */ new Set(["--regex", "--case-sensitive", "--word", "--json"]);
   }
 });
 
@@ -17529,6 +17808,8 @@ var init_keymap = __esm({
       "previous-hunk",
       "goto-diff",
       "goto-history",
+      "history-next-commit",
+      "history-previous-commit",
       "goto-repo",
       "toggle-terminal-panel",
       "toggle-sidebar",
@@ -17719,6 +18000,11 @@ function sanitizeSettings(raw) {
   if (hideTests !== void 0) out.hideTests = hideTests;
   const grepRegex = optionalBoolean(raw.grepRegex);
   if (grepRegex !== void 0) out.grepRegex = grepRegex;
+  const grepCaseSensitive = optionalBoolean(raw.grepCaseSensitive);
+  if (grepCaseSensitive !== void 0)
+    out.grepCaseSensitive = grepCaseSensitive;
+  const grepWholeWord = optionalBoolean(raw.grepWholeWord);
+  if (grepWholeWord !== void 0) out.grepWholeWord = grepWholeWord;
   const grepGroupByFile = optionalBoolean(raw.grepGroupByFile);
   if (grepGroupByFile !== void 0) out.grepGroupByFile = grepGroupByFile;
   const grepPaletteWidth = optionalNumber(
@@ -17748,6 +18034,13 @@ function sanitizeSettings(raw) {
     sort: false
   });
   if (fileSelectionHistory) out.fileSelectionHistory = fileSelectionHistory;
+  const recentRefs = normalizeStringList(raw.recentRefs, {
+    maxItems: MAX_RECENT_REFS,
+    maxLen: MAX_REF_LEN,
+    keepLast: true,
+    sort: false
+  });
+  if (recentRefs) out.recentRefs = recentRefs;
   const scopeOmitDirs = normalizeStringList(raw.scopeOmitDirs, {
     maxItems: 100,
     maxLen: 64,
@@ -18126,7 +18419,7 @@ async function loadToolsState(root) {
 async function patchToolsState(root, patch) {
   return patchJsonState(toolsStore, root, patch, mergeToolsState);
 }
-var CODE_VIEWER_DIR2, SETTINGS_FILE_NAME, VIEW_STATE_FILE_NAME, DB_UI_FILE_NAME, TOOLS_FILE_NAME, MAX_SETTINGS_BYTES, MAX_VIEW_STATE_BYTES, MAX_DB_UI_BYTES, MAX_TOOL_DRAFT_LEN, MAX_TOOLS_BYTES, MAX_REF_LEN, MAX_KEY_LEN, MAX_VIEW_ITEMS, MAX_GREP_SELECTION_HISTORY_ITEMS, MAX_DB_UI_DBS, MAX_DB_UI_TABLES, MAX_DB_UI_COLUMNS, MAX_DB_UI_EXPANDED_SCOPES, DB_UI_BOOL_PREF_KEYS, settingsStore, viewStateStore, dbUiStore, toolsStore;
+var CODE_VIEWER_DIR2, SETTINGS_FILE_NAME, VIEW_STATE_FILE_NAME, DB_UI_FILE_NAME, TOOLS_FILE_NAME, MAX_SETTINGS_BYTES, MAX_VIEW_STATE_BYTES, MAX_DB_UI_BYTES, MAX_TOOL_DRAFT_LEN, MAX_TOOLS_BYTES, MAX_REF_LEN, MAX_KEY_LEN, MAX_VIEW_ITEMS, MAX_GREP_SELECTION_HISTORY_ITEMS, MAX_RECENT_REFS, MAX_DB_UI_DBS, MAX_DB_UI_TABLES, MAX_DB_UI_COLUMNS, MAX_DB_UI_EXPANDED_SCOPES, DB_UI_BOOL_PREF_KEYS, settingsStore, viewStateStore, dbUiStore, toolsStore;
 var init_state_store = __esm({
   "web-src/server/state-store.ts"() {
     init_keymap();
@@ -18149,6 +18442,7 @@ var init_state_store = __esm({
     MAX_KEY_LEN = 2048;
     MAX_VIEW_ITEMS = 2e4;
     MAX_GREP_SELECTION_HISTORY_ITEMS = 100;
+    MAX_RECENT_REFS = 8;
     MAX_DB_UI_DBS = 200;
     MAX_DB_UI_TABLES = 500;
     MAX_DB_UI_COLUMNS = 1e3;
@@ -27708,6 +28002,7 @@ function isTestFilePath(path) {
 var TEST_FILE_PATH_RE;
 var init_file_filter = __esm({
   "web-src/core/file-filter.ts"() {
+    init_fuzzy_search();
     TEST_FILE_PATH_RE = /(^|[/_.])(test|spec|__tests__)([/_.]|$)/i;
   }
 });
@@ -27763,16 +28058,65 @@ function filterCallerPaths(env, paths, excludeTests) {
     (path) => isSafePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, env.omitDirNames, env.excludeNames) && (!excludeTests || !isTestFilePath(path))
   );
 }
-async function grepWorktreeFallback(env, query, max, paths, excludeTests) {
-  const candidates = paths.length ? paths : (await listTreeAsync("worktree", "", env.cwd, {
-    recursive: true,
-    omitDirNames: env.omitDirNames,
-    excludeNames: env.excludeNames
-  })).entries.map((entry) => entry.path);
+function splitCallerPaths(env, paths, excludeTests) {
+  const plain = [];
+  const globs = [];
+  for (const path of paths) {
+    if (!isSafePath(path) || isGitInternalPath(path)) continue;
+    if (isGlobPathQuery(path)) {
+      globs.push(path);
+      continue;
+    }
+    if (isSkippableSearchPath(path, env.omitDirNames, env.excludeNames) || excludeTests && isTestFilePath(path))
+      continue;
+    plain.push(path);
+  }
+  return { plain, globs };
+}
+function matchesAnyGlob(path, globs) {
+  return globs.length === 0 || globs.some((glob) => !!globMatchPath(glob, path));
+}
+async function fallbackCandidatePaths(env, paths) {
+  if (paths.length === 0) {
+    const tree = await listTreeAsync("worktree", "", env.cwd, {
+      recursive: true,
+      omitDirNames: env.omitDirNames,
+      excludeNames: env.excludeNames
+    });
+    return tree.entries.map((entry) => entry.path);
+  }
+  const candidates = [];
+  for (const path of paths) {
+    const full = safeWorktreePath(env, path);
+    if (!full) continue;
+    let stat4;
+    try {
+      stat4 = await lstat2(full);
+    } catch {
+      continue;
+    }
+    if (!stat4.isDirectory()) {
+      candidates.push(path);
+      continue;
+    }
+    const tree = await listTreeAsync("worktree", path, env.cwd, {
+      recursive: true,
+      omitDirNames: env.omitDirNames,
+      excludeNames: env.excludeNames
+    });
+    for (const entry of tree.entries) {
+      if (entry.type === "blob") candidates.push(entry.path);
+    }
+  }
+  return candidates;
+}
+async function grepWorktreeFallback(env, query, max, paths, globs, excludeTests, options, signal) {
+  const candidates = await fallbackCandidatePaths(env, paths);
   const matches = [];
   for (const path of candidates) {
     if (matches.length >= max) break;
-    if (!isSafePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path, env.omitDirNames, env.excludeNames) || excludeTests && isTestFilePath(path))
+    throwIfAborted(signal, "grep aborted");
+    if (!isSafePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path, env.omitDirNames, env.excludeNames) || excludeTests && isTestFilePath(path) || !matchesAnyGlob(path, globs))
       continue;
     const full = safeWorktreePath(env, path);
     if (!full) continue;
@@ -27796,16 +28140,24 @@ async function grepWorktreeFallback(env, query, max, paths, excludeTests) {
         path,
         data.toString("utf8"),
         query,
-        max - matches.length
+        max - matches.length,
+        options
       )
     );
   }
   return matches;
 }
+function matchOptions(req) {
+  return {
+    caseSensitive: req.caseSensitive === true,
+    wholeWord: req.wholeWord === true
+  };
+}
 async function grepWorktreeAsync(env, req) {
   const excludeTests = req.excludeTests === true;
-  const paths = filterCallerPaths(env, req.paths, excludeTests);
-  if (req.paths.length > 0 && paths.length === 0) {
+  const { plain, globs } = splitCallerPaths(env, req.paths, excludeTests);
+  const paths = filterCallerPaths(env, plain, excludeTests);
+  if (req.paths.length > 0 && paths.length === 0 && globs.length === 0) {
     return {
       ref: "worktree",
       engine: "fallback",
@@ -27815,7 +28167,7 @@ async function grepWorktreeAsync(env, req) {
   }
   if (await rgAvailableAsync(env.cwd)) {
     const safePaths = paths.filter((path) => safeWorktreePath(env, path));
-    if (req.paths.length > 0 && safePaths.length === 0) {
+    if (plain.length > 0 && safePaths.length === 0) {
       return {
         ref: "worktree",
         engine: "rg",
@@ -27830,13 +28182,15 @@ async function grepWorktreeAsync(env, req) {
       req.regex,
       env.omitDirNames,
       env.excludeNames,
-      excludeTests
+      excludeTests,
+      { ...matchOptions(req), pathGlobs: globs }
     );
     const proc = await spawnTextAsync({
       command: commandForExternal("rg"),
       args: args.slice(1),
       cwd: env.cwd,
       timeoutMs: 5e3,
+      signal: req.signal,
       abortMessage: "grep aborted",
       timeoutMessage: "grep timed out after 5000ms",
       rejectOnError: false
@@ -27874,7 +28228,10 @@ async function grepWorktreeAsync(env, req) {
     req.query,
     req.max,
     paths,
-    excludeTests
+    globs,
+    excludeTests,
+    matchOptions(req),
+    req.signal
   );
   return {
     ref: "worktree",
@@ -27885,8 +28242,9 @@ async function grepWorktreeAsync(env, req) {
 }
 async function grepTreeRefAsync(env, req) {
   const excludeTests = req.excludeTests === true;
-  const safePaths = filterCallerPaths(env, req.paths, excludeTests);
-  if (req.paths.length > 0 && safePaths.length === 0) {
+  const { plain, globs } = splitCallerPaths(env, req.paths, excludeTests);
+  const safePaths = filterCallerPaths(env, plain, excludeTests);
+  if (req.paths.length > 0 && safePaths.length === 0 && globs.length === 0) {
     return {
       ref: req.ref,
       engine: "git",
@@ -27894,26 +28252,35 @@ async function grepTreeRefAsync(env, req) {
       matches: []
     };
   }
+  const options = matchOptions(req);
+  const pathspecs = [
+    ...safePaths,
+    ...globs.map(
+      (glob) => glob.includes("/") ? `:(glob)${glob}` : `:(glob)**/${glob}`
+    )
+  ];
   const args = [
     "-c",
     "core.quotepath=false",
     "grep",
     "-n",
     "--column",
-    "-i",
+    ...options.caseSensitive ? [] : ["-i"],
+    ...options.wholeWord ? ["-w"] : [],
     req.regex ? "-E" : "-F",
     "--no-color",
     "-e",
     req.query,
     req.ref,
     "--",
-    ...safePaths
+    ...pathspecs
   ];
   const proc = await spawnTextAsync({
     command: commandForExternal("git"),
     args,
     cwd: env.cwd,
     timeoutMs: 5e3,
+    signal: req.signal,
     abortMessage: "git grep aborted",
     timeoutMessage: "git grep timed out after 5000ms",
     rejectOnError: false
@@ -27993,7 +28360,9 @@ var rgAvailableCache;
 var init_search_service = __esm({
   "web-src/server/search-service.ts"() {
     init_file_filter();
+    init_fuzzy_search();
     init_command_resolver();
+    init_abort();
     init_spawn_runner();
     init_git();
     init_name_pattern();
@@ -29512,7 +29881,7 @@ function defaultMcpTools(options = {}) {
     {
       name: "code_viewer_file_history",
       title: "code-viewer file history",
-      description: "Returns the same JSON payload `code-viewer file history --json` emits: path, ref, limit, skip, optional query, and result (commits with sha/author/when/subject, hasMore, optional error). Read-only. ref defaults to 'HEAD'. Follows renames for file paths. Use `query` for the same 'author:' / 'path:' / sha-prefix filters the browser history view accepts.",
+      description: "Returns the same JSON payload `code-viewer file history --json` emits: path, ref, limit, skip, optional query, and result (commits with sha/author/when/subject/refs, hasMore, optional error). Read-only. ref defaults to 'HEAD'. Follows renames for file paths. `query` uses the browser history filter syntax: free words (message), author:<name>, path:<part>, since:/after:<date>, until:/before:<date>, code:<text> (git log -S), merges:no / merges:only; kinds AND together and a lone hex word tries a sha prefix.",
       inputSchema: {
         type: "object",
         properties: {
@@ -29537,7 +29906,7 @@ function defaultMcpTools(options = {}) {
           },
           query: {
             type: "string",
-            description: "Optional git log filter, passed verbatim to commitHistory. Supports the 'author:' and 'path:' prefixes the browser history view uses. Single-line, no NUL."
+            description: "Optional git log filter in the browser history syntax: free words, author:<name>, path:<part>, since:/after:<date>, until:/before:<date>, code:<text>, merges:no|only. Single-line, no NUL."
           },
           cwd: {
             type: "string",
@@ -29666,12 +30035,20 @@ function defaultMcpTools(options = {}) {
           paths: {
             type: "array",
             items: { type: "string" },
-            description: "Optional list of repo-relative paths to restrict the search to. Unsafe paths are dropped silently."
+            description: "Optional list of repo-relative files, directories, or globs (e.g. 'src/**/*.ts') to restrict the search to. Unsafe paths are dropped silently."
           },
           regex: {
             type: "boolean",
             description: "Treat `term` as an extended regex instead of a fixed string. Defaults to false."
           },
+          caseSensitive: {
+            type: "boolean",
+            description: "Match case. Defaults to false (case-insensitive on every engine)."
+          },
+          wholeWord: {
+            type: "boolean",
+            description: "Match whole words only (rg -w / git grep -w semantics). Defaults to false."
+          },
           max: {
             type: "integer",
             minimum: 1,
@@ -30574,6 +30951,14 @@ async function runSearchCodeTool(input, defaultCwd, generation2) {
     return { text: "regex must be a boolean", isError: true };
   }
   const regex = regexRaw === true;
+  const caseSensitiveRaw = params.caseSensitive;
+  if (caseSensitiveRaw !== void 0 && typeof caseSensitiveRaw !== "boolean") {
+    return { text: "caseSensitive must be a boolean", isError: true };
+  }
+  const wholeWordRaw = params.wholeWord;
+  if (wholeWordRaw !== void 0 && typeof wholeWordRaw !== "boolean") {
+    return { text: "wholeWord must be a boolean", isError: true };
+  }
   const maxParsed = validateMcpIntegerLimit(
     params.max,
     GREP_DEFAULT_MAX,
@@ -30598,6 +30983,8 @@ async function runSearchCodeTool(input, defaultCwd, generation2) {
     ref: refParsed.ref,
     paths,
     regex,
+    caseSensitive: caseSensitiveRaw === true,
+    wholeWord: wholeWordRaw === true,
     max: maxParsed.value
   });
   if (result.ok !== true) {
@@ -33172,7 +33559,9 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
     files.push(...untracked.files);
     metaError = untracked.error;
   }
-  const filteredFiles = pathFilter ? files.filter(
+  const filteredFiles = pathFilter ? pathFilter.endsWith("/") ? files.filter(
+    (file) => file.path.startsWith(pathFilter) || (file.old_path ?? "").startsWith(pathFilter)
+  ) : files.filter(
     (file) => file.path === pathFilter || file.old_path === pathFilter
   ) : files;
   filteredFiles.sort(
@@ -33578,7 +33967,7 @@ async function handleFiles2(url) {
   }
   return json2(result.value);
 }
-async function handleGrep(url) {
+async function handleGrep(url, signal) {
   const responseGeneration = generation;
   const query = url.searchParams.get("q") || "";
   const ref = url.searchParams.get("ref") || "worktree";
@@ -33591,17 +33980,26 @@ async function handleGrep(url) {
   const paths = url.searchParams.getAll("path");
   const regex = url.searchParams.get("regex") === "1";
   const excludeTests = url.searchParams.get("exclude_tests") === "1";
-  const result = await grepRepoAsync(
-    currentSearchEnv(omitDirNames, excludeNames),
-    {
+  const caseSensitive = url.searchParams.get("case") === "1";
+  const wholeWord = url.searchParams.get("word") === "1";
+  let result;
+  try {
+    result = await grepRepoAsync(currentSearchEnv(omitDirNames, excludeNames), {
       query,
       ref,
       paths,
       regex,
       max,
-      excludeTests
-    }
-  );
+      excludeTests,
+      caseSensitive,
+      wholeWord,
+      signal
+    });
+  } catch (err) {
+    if (isAbortLikeError(err, signal))
+      return text("client closed request", 499);
+    throw err;
+  }
   if (result.ok !== true) return text(result.error, result.status ?? 400);
   return json2({ ...result.value, generation: responseGeneration });
 }
@@ -33615,6 +34013,27 @@ async function handleRefCommits(url) {
   if (result.error) return text(result.error, result.status ?? 500);
   return json2({ commits: result.commits, hasMore: result.hasMore });
 }
+async function handleFileRevisions(url) {
+  const responseGeneration = generation;
+  const path = url.searchParams.get("path") || "";
+  if (!path || !safePath(path)) return text("invalid path", 400);
+  if (isGitInternalPath(path)) return text("forbidden", 403);
+  const ref = url.searchParams.get("ref") || "HEAD";
+  const result = await fileRevisionNeighborsAsync(cwd, { path, ref });
+  if (result.error) return text(result.error, result.status ?? 400);
+  return json2({
+    previous: result.previous,
+    next: result.next,
+    generation: responseGeneration
+  });
+}
+async function handleAuthors(url) {
+  const responseGeneration = generation;
+  const ref = url.searchParams.get("ref") || "HEAD";
+  const result = await commitAuthorsAsync(cwd, ref);
+  if (result.error) return text(result.error, result.status ?? 400);
+  return json2({ authors: result.authors, generation: responseGeneration });
+}
 async function handleLog(url) {
   const responseGeneration = generation;
   const ref = url.searchParams.get("ref") || "HEAD";
@@ -33622,12 +34041,14 @@ async function handleLog(url) {
   const limit = Number(url.searchParams.get("limit") || "50");
   const path = url.searchParams.get("path") || "";
   if (path && !safePath(path)) return text("invalid path", 400);
+  const lines = parseHistoryLineRange(url.searchParams.get("lines"));
   const result = await commitHistoryAsync(cwd, {
     ref,
     skip: Number.isFinite(skip) ? skip : 0,
     limit: Number.isFinite(limit) ? limit : 50,
     query: url.searchParams.get("q") || "",
-    ...path ? { path } : {}
+    ...path ? { path } : {},
+    ...path && lines ? { lines } : {}
   });
   if (result.error) return text(result.error, result.status ?? 400);
   const wantsWorktreeHead = path && skip === 0 && (ref === "worktree" || url.searchParams.get("worktree") === "1");
@@ -33646,7 +34067,8 @@ async function handleLog(url) {
             author: "",
             when: "",
             parents: [],
-            body: ""
+            body: "",
+            refs: []
           },
           ...commits
         ];
@@ -34983,11 +35405,13 @@ var init_preview = __esm({
   async "web-src/server/preview.ts"() {
     init_directory_name();
     init_error_detail();
+    init_history();
     init_journal();
     init_routes();
     init_annotations();
     init_cache();
     init_command_resolver();
+    init_abort();
     init_dev_assets();
     init_doctor();
     init_file_upload();
@@ -35124,9 +35548,12 @@ var init_preview = __esm({
           });
         if (url.pathname === "/_tree") return await handleTree(url);
         if (url.pathname === "/_files") return await handleFiles2(url);
-        if (url.pathname === "/_grep") return await handleGrep(url);
+        if (url.pathname === "/_grep") return await handleGrep(url, req.signal);
         if (url.pathname === "/_commits") return await handleRefCommits(url);
         if (url.pathname === "/_log") return await handleLog(url);
+        if (url.pathname === "/_authors") return await handleAuthors(url);
+        if (url.pathname === "/_file_revisions")
+          return await handleFileRevisions(url);
         if (url.pathname === "/_file_blame") return await handleFileBlame(url);
         if (url.pathname === "/file_diff") return await handleFileDiff(url);
         if (url.pathname === "/file_range") return handleFileRange(url);