@youtyan/code-viewer 0.6.9 → 0.6.10

package/dist/code-viewer.js

@@ -96,7 +96,7 @@ var init_sqlite_driver = __esm(() => {
 
 // web-src/server/json-store.ts
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 function isEnoent(err) {
   return err?.code === "ENOENT";
@@ -140,8 +140,15 @@ function createJsonFileStore(options) {
     }
     await mkdir(dirname(file), { recursive: true });
     const tmp = tmpPath(file);
-    await writeFile(tmp, content, "utf8");
-    await rename(tmp, file);
+    try {
+      await writeFile(tmp, content, "utf8");
+      await rename(tmp, file);
+    } catch (err) {
+      await unlink(tmp).catch(() => {
+        return;
+      });
+      throw err;
+    }
   }
   async function load(root) {
     const pendingWrite = queues.get(options.filePath(root));
@@ -841,6 +848,7 @@ function runSync(args, cwd, options = {}) {
     encoding: "buffer",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: options.timeout,
+    maxBuffer: options.maxBuffer ?? 64 * 1024 * 1024,
     killSignal: "SIGKILL"
   });
   return {
@@ -849,20 +857,6 @@ function runSync(args, cwd, options = {}) {
     stderr: appendProcessError(new TextDecoder().decode(proc.stderr || new Uint8Array), proc.error)
   };
 }
-function runBytesSync(args, cwd, options = {}) {
-  const proc = spawnSync(args[0], args.slice(1), {
-    cwd,
-    encoding: "buffer",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: options.timeout,
-    killSignal: "SIGKILL"
-  });
-  return {
-    code: proc.status ?? (proc.error ? 1 : 0),
-    stdout: new Uint8Array(proc.stdout || new Uint8Array),
-    stderr: appendProcessError(new TextDecoder().decode(proc.stderr || new Uint8Array), proc.error)
-  };
-}
 function spawnDetached(args) {
   const child = spawn(args[0], args.slice(1), {
     detached: true,
@@ -1035,10 +1029,13 @@ var init_runtime = () => {};
 
 // web-src/server/git.ts
 import {
+  closeSync,
   existsSync,
   lstatSync,
+  openSync,
   readdirSync,
   readFileSync,
+  readSync,
   statSync as statSync2
 } from "node:fs";
 import { join as join3 } from "node:path";
@@ -1061,11 +1058,6 @@ function run(args, cwd) {
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
 }
-function runBytes(args, cwd) {
-  return runBytesSync(resolveGitArgs(args), cwd, {
-    timeout: GIT_COMMAND_TIMEOUT_MS
-  });
-}
 function resolveGitArgs(args) {
   if (args[0] !== "git")
     return args;
@@ -1135,9 +1127,6 @@ function statusPorcelainForPath(path, cwd) {
 function show(ref, path, cwd) {
   return run(["git", "show", `${ref}:${path}`], cwd);
 }
-function showBytes(ref, path, cwd) {
-  return runBytes(["git", "show", `${ref}:${path}`], cwd);
-}
 function catFileBlobStream(oid, cwd) {
   return spawnStream(resolveGitArgs(["git", "cat-file", "blob", oid]), cwd);
 }
@@ -1961,21 +1950,19 @@ function listTreeResult(ref, path, cwd, options = {}) {
 function untrackedMeta(cwd) {
   return untracked(cwd).flatMap((path) => {
     const full = join3(cwd, path);
-    let binary = false;
-    let lines = 0;
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
     } catch {
       fileExists = false;
     }
+    let scan;
     if (fileExists) {
-      const data = readFileSync(full);
-      const probe = data.subarray(0, 8192);
-      binary = probe.includes(0);
-      if (!binary)
-        lines = data.toString("utf8").split(`
-`).length - 1;
+      try {
+        scan = scanFileBinaryAndNewlines(full);
+      } catch {
+        return [];
+      }
     } else {
       return [];
     }
@@ -1983,14 +1970,40 @@ function untrackedMeta(cwd) {
       {
         path,
         status: "A",
-        additions: binary ? 0 : lines,
+        additions: scan.binary ? 0 : scan.newlines,
         deletions: 0,
-        binary,
+        binary: scan.binary,
         untracked: true
       }
     ];
   });
 }
+function scanFileBinaryAndNewlines(full) {
+  const fd = openSync(full, "r");
+  const buffer = Buffer.allocUnsafe(64 * 1024);
+  let newlines = 0;
+  let inspected = 0;
+  try {
+    while (true) {
+      const read = readSync(fd, buffer, 0, buffer.length, null);
+      if (read <= 0)
+        break;
+      const binaryProbeBytes = Math.min(read, Math.max(0, 8192 - inspected));
+      for (let i = 0;i < binaryProbeBytes; i++) {
+        if (buffer[i] === 0)
+          return { binary: true, newlines: 0 };
+      }
+      inspected += read;
+      for (let i = 0;i < read; i++) {
+        if (buffer[i] === 10)
+          newlines++;
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return { binary: false, newlines };
+}
 function fileMetaResult(args, cwd, includeUntracked = false) {
   const ns = nameStatusResult(args, cwd);
   if (ns.error)
@@ -2052,13 +2065,17 @@ function untrackedFileDiff(extras, path, cwd) {
 function splitHunks(diffText) {
   if (!diffText)
     return { header: "", hunks: [] };
-  const first = diffText.startsWith("@@") ? 0 : diffText.indexOf(`
-@@`) + 1;
-  if (first <= 0)
+  const startsWithHunk = diffText.startsWith("@@");
+  const first = startsWithHunk ? 0 : diffText.indexOf(`
+@@`);
+  if (first < 0)
+    return { header: diffText, hunks: [] };
+  const hunkStart = startsWithHunk ? 0 : first + 1;
+  if (hunkStart >= diffText.length)
     return { header: diffText, hunks: [] };
-  const header = diffText.slice(0, first);
+  const header = diffText.slice(0, hunkStart);
   const hunks = [];
-  let cur = first;
+  let cur = hunkStart;
   while (cur < diffText.length) {
     const next = diffText.indexOf(`
 @@`, cur + 1);
@@ -7839,11 +7856,106 @@ function computeFuzzyMatch(query, path) {
     tier
   };
 }
-function rankFuzzyPaths(query, items) {
-  return items.map((item) => {
+function rankFuzzyPaths(query, items, limit) {
+  const bounded = Number.isInteger(limit) && limit !== undefined && 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 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 }));
+  }
+  const top = [];
+  for (const item of items) {
     const match = computeFuzzyMatch(query, item.path);
-    return match ? { item, score: match.score, ranges: match.ranges, tier: match.tier } : null;
-  }).filter((item) => item !== null).sort((a, b) => b.tier - a.tier || b.score - a.score || a.item.path.localeCompare(b.item.path)).map(({ item, score, ranges }) => ({ item, score, ranges }));
+    if (!match)
+      continue;
+    const ranked = {
+      item,
+      score: match.score,
+      ranges: match.ranges,
+      tier: match.tier
+    };
+    pushBoundedTop(top, ranked, bounded, compare);
+  }
+  return top.sort(compare).map(({ item, score, ranges }) => ({ item, score, ranges }));
+}
+function pushBoundedTop(heap, item, limit, compareBestFirst) {
+  const isWorse = (a, b) => compareBestFirst(a, b) > 0;
+  const siftUp = (index) => {
+    while (index > 0) {
+      const parent = Math.floor((index - 1) / 2);
+      if (!isWorse(heap[index], heap[parent]))
+        break;
+      [heap[index], heap[parent]] = [heap[parent], heap[index]];
+      index = parent;
+    }
+  };
+  const siftDown = (index) => {
+    while (true) {
+      const left = index * 2 + 1;
+      const right = left + 1;
+      let worst = index;
+      if (left < heap.length && isWorse(heap[left], heap[worst]))
+        worst = left;
+      if (right < heap.length && isWorse(heap[right], heap[worst]))
+        worst = right;
+      if (worst === index)
+        break;
+      [heap[index], heap[worst]] = [heap[worst], heap[index]];
+      index = worst;
+    }
+  };
+  if (heap.length < limit) {
+    heap.push(item);
+    siftUp(heap.length - 1);
+    return;
+  }
+  if (compareBestFirst(item, heap[0]) >= 0)
+    return;
+  heap[0] = item;
+  siftDown(0);
+}
+function rankGlobPathMatches(query, items, limit) {
+  const matchPath = createGlobPathMatcher(query);
+  if (!matchPath)
+    return [];
+  const bounded = Number.isInteger(limit) && limit !== undefined && 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 match = matchPath(item.path);
+      return match ? {
+        item,
+        score: match.score,
+        ranges: match.ranges,
+        mode: "glob"
+      } : null;
+    }).filter((item) => item !== null).sort(compare);
+  }
+  const top = [];
+  for (const item of items) {
+    const match = matchPath(item.path);
+    if (!match)
+      continue;
+    const ranked = {
+      item,
+      score: match.score,
+      ranges: match.ranges,
+      mode: "glob"
+    };
+    pushBoundedTop(top, ranked, bounded, compare);
+  }
+  return top.sort(compare);
+}
+function rankPathMatches(query, items, limit) {
+  if (isGlobPathQuery(query)) {
+    return rankGlobPathMatches(query, items, limit);
+  }
+  return rankFuzzyPaths(query, items, limit).map((item) => ({
+    ...item,
+    mode: "fuzzy"
+  }));
 }
 function isGlobPathQuery(query) {
   return /[*?]/.test(query.trim());
@@ -7887,49 +7999,37 @@ function globToRegExp(query) {
     return null;
   }
 }
-function globMatchPath(query, path) {
+function createGlobPathMatcher(query) {
   const regex = globToRegExp(query);
-  const baseStart = basenameStart(path);
-  const basename = path.slice(baseStart);
-  if (!regex || !regex.test(path) && (query.includes("/") || !regex.test(basename)))
+  if (!regex)
     return null;
   const literal = query.replace(/[*?[\]]+/g, " ").trim().split(/\s+/).filter(Boolean);
-  const ranges = [];
-  const lowerPath = path.toLowerCase();
-  for (const part of literal) {
-    const start = lowerPath.indexOf(part.toLowerCase());
-    if (start >= 0)
-      ranges.push({ start, end: start + part.length });
-  }
-  ranges.sort((a, b) => a.start - b.start || a.end - b.end);
-  const mergedRanges = [];
-  for (const range of ranges) {
-    const last = mergedRanges[mergedRanges.length - 1];
-    if (last && last.end >= range.start) {
-      last.end = Math.max(last.end, range.end);
-    } else {
-      mergedRanges.push({ ...range });
+  const suffix = query.replace(/^\*+/, "").toLowerCase();
+  return (path) => {
+    const baseStart = basenameStart(path);
+    const basename = path.slice(baseStart);
+    if (!regex.test(path) && (query.includes("/") || !regex.test(basename)))
+      return null;
+    const ranges = [];
+    const lowerPath = path.toLowerCase();
+    for (const part of literal) {
+      const start = lowerPath.indexOf(part.toLowerCase());
+      if (start >= 0)
+        ranges.push({ start, end: start + part.length });
+    }
+    ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+    const mergedRanges = [];
+    for (const range of ranges) {
+      const last = mergedRanges[mergedRanges.length - 1];
+      if (last && last.end >= range.start) {
+        last.end = Math.max(last.end, range.end);
+      } else {
+        mergedRanges.push({ ...range });
+      }
     }
-  }
-  const score = 1000 - Math.min(path.length, 200) + (path.slice(baseStart).toLowerCase().endsWith(query.replace(/^\*+/, "").toLowerCase()) ? 50 : 0);
-  return { score, ranges: mergedRanges };
-}
-function rankPathMatches(query, items) {
-  if (isGlobPathQuery(query)) {
-    return items.map((item) => {
-      const match = globMatchPath(query, item.path);
-      return match ? {
-        item,
-        score: match.score,
-        ranges: match.ranges,
-        mode: "glob"
-      } : null;
-    }).filter((item) => item !== null).sort((a, b) => b.score - a.score || a.item.path.localeCompare(b.item.path));
-  }
-  return rankFuzzyPaths(query, items).map((item) => ({
-    ...item,
-    mode: "fuzzy"
-  }));
+    const score = 1000 - Math.min(path.length, 200) + (path.slice(baseStart).toLowerCase().endsWith(suffix) ? 50 : 0);
+    return { score, ranges: mergedRanges };
+  };
 }
 
 // web-src/server/search.ts
@@ -8020,9 +8120,11 @@ function parseRgOutput(stdout, max, omitDirNames = [], excludeNames = []) {
   const matches = [];
   for (const line of stdout.split(`
 `)) {
-    if (!line || matches.length >= max)
+    if (!line)
       continue;
-    const parsed = /^(.*):(\d+):(\d+):(.*)$/.exec(line);
+    if (matches.length >= max)
+      break;
+    const parsed = /^(.*?):(\d+):(\d+):(.*)$/.exec(line);
     if (!parsed)
       continue;
     const path = parsed[1];
@@ -13308,10 +13410,10 @@ function hasControlCharacter(value) {
 
 // web-src/server/database/discovery.ts
 import {
-  closeSync,
+  closeSync as closeSync2,
   existsSync as existsSync6,
-  openSync,
-  readSync,
+  openSync as openSync2,
+  readSync as readSync2,
   realpathSync as realpathSync4,
   statSync as statSync4
 } from "node:fs";
@@ -13323,11 +13425,11 @@ function isSqliteFile(fullPath) {
     if (!stat2.isFile() || stat2.size < 16)
       return false;
     const buf = Buffer.alloc(16);
-    const fd = openSync(fullPath, "r");
+    const fd = openSync2(fullPath, "r");
     try {
-      readSync(fd, buf, 0, 16, 0);
+      readSync2(fd, buf, 0, 16, 0);
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
     return buf.toString("utf8", 0, 16) === SQLITE_MAGIC;
   } catch {
@@ -20643,6 +20745,21 @@ function rgAvailable(cwd) {
   rgAvailableCache = proc.code === 0;
   return rgAvailableCache;
 }
+async function rgAvailableAsync(cwd) {
+  if (rgAvailableCache !== null)
+    return rgAvailableCache;
+  const proc = await spawnTextAsync({
+    command: commandForExternal("rg"),
+    args: ["--version"],
+    cwd,
+    timeoutMs: 5000,
+    abortMessage: "rg version aborted",
+    timeoutMessage: "rg version timed out after 5000ms",
+    rejectOnError: false
+  });
+  rgAvailableCache = proc.code === 0;
+  return rgAvailableCache;
+}
 function isExcludedScopePath(path, excludeNames) {
   return path.split(/[\\/]+/).some((part) => excludeNames.some((name) => part.toLowerCase() === name.toLowerCase()));
 }
@@ -20744,6 +20861,44 @@ function grepWorktree(env, req) {
     matches
   };
 }
+async function grepWorktreeAsync(env, req) {
+  const paths = filterCallerPaths(env, req.paths);
+  if (await rgAvailableAsync(env.cwd)) {
+    const safePaths = paths.filter((path) => safeWorktreePath(env, path));
+    const args = buildRgArgs(req.query, req.max, safePaths, req.regex, env.omitDirNames, env.excludeNames);
+    const proc = await spawnTextAsync({
+      command: commandForExternal("rg"),
+      args: args.slice(1),
+      cwd: env.cwd,
+      timeoutMs: 5000,
+      abortMessage: "grep aborted",
+      timeoutMessage: "grep timed out after 5000ms",
+      rejectOnError: false
+    });
+    const matches2 = parseRgOutput(proc.stdout, req.max, env.omitDirNames, env.excludeNames).filter((match) => isSafePath(match.path) && !isGitInternalPath(match.path) && !isSkippableSearchPath(match.path, env.omitDirNames, env.excludeNames) && !!safeWorktreePath(env, match.path));
+    return {
+      ref: "worktree",
+      engine: "rg",
+      truncated: matches2.length >= req.max,
+      matches: matches2
+    };
+  }
+  if (req.regex) {
+    return {
+      ref: "worktree",
+      engine: "fallback",
+      truncated: false,
+      matches: []
+    };
+  }
+  const matches = grepWorktreeFallback(env, req.query, req.max, paths);
+  return {
+    ref: "worktree",
+    engine: "fallback",
+    truncated: matches.length >= req.max,
+    matches
+  };
+}
 function grepTreeRef(env, req) {
   const safePaths = filterCallerPaths(env, req.paths);
   const args = [
@@ -20772,6 +20927,40 @@ function grepTreeRef(env, req) {
     matches
   };
 }
+async function grepTreeRefAsync(env, req) {
+  const safePaths = filterCallerPaths(env, req.paths);
+  const args = [
+    "-c",
+    "core.quotepath=false",
+    "grep",
+    "-n",
+    "--column",
+    "-i",
+    req.regex ? "-E" : "-F",
+    "--no-color",
+    "-e",
+    req.query,
+    req.ref,
+    "--",
+    ...safePaths
+  ];
+  const proc = await spawnTextAsync({
+    command: commandForExternal("git"),
+    args,
+    cwd: env.cwd,
+    timeoutMs: 5000,
+    abortMessage: "git grep aborted",
+    timeoutMessage: "git grep timed out after 5000ms",
+    rejectOnError: false
+  });
+  const matches = parseGitGrepOutput(proc.stdout, req.ref, req.max, env.omitDirNames, env.excludeNames).slice(0, req.max);
+  return {
+    ref: req.ref,
+    engine: "git",
+    truncated: matches.length >= req.max,
+    matches
+  };
+}
 function grepRepo(env, req) {
   const isWorktree = req.ref === "worktree" || req.ref === "";
   if (!isWorktree) {
@@ -20800,6 +20989,34 @@ function grepRepo(env, req) {
   }
   return { ok: true, value: grepTreeRef(env, req) };
 }
+async function grepRepoAsync(env, req) {
+  const isWorktree = req.ref === "worktree" || req.ref === "";
+  if (!isWorktree) {
+    const refCheck = verifyTreeRefResult(req.ref, env.cwd);
+    if (refCheck.ok !== true) {
+      return {
+        ok: false,
+        error: refCheck.error,
+        status: refCheck.status
+      };
+    }
+  }
+  if (!req.query.trim()) {
+    return {
+      ok: true,
+      value: {
+        ref: req.ref,
+        engine: req.ref === "worktree" ? "fallback" : "git",
+        truncated: false,
+        matches: []
+      }
+    };
+  }
+  if (isWorktree) {
+    return { ok: true, value: await grepWorktreeAsync(env, req) };
+  }
+  return { ok: true, value: await grepTreeRefAsync(env, req) };
+}
 function listRepoFiles(env, ref, generation) {
   if (ref !== "worktree" && ref !== "") {
     const refCheck = verifyTreeRefResult(ref, env.cwd);
@@ -20829,6 +21046,7 @@ function listRepoFiles(env, ref, generation) {
 var rgAvailableCache = null;
 var init_search_service = __esm(() => {
   init_command_resolver();
+  init_spawn_runner();
   init_git();
   init_runtime();
   init_search();
@@ -22391,12 +22609,12 @@ var init_state_route = __esm(() => {
 // web-src/server/preview.ts
 var exports_preview = {};
 import {
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   constants as constants3,
   existsSync as existsSync8,
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync4,
-  openSync as openSync2,
+  openSync as openSync3,
   readFileSync as readFileSync9,
   realpathSync as realpathSync6,
   renameSync,
@@ -23076,9 +23294,15 @@ function handleFiles2(url) {
   if (result.ok !== true)
     return text(result.error, result.status ?? 400);
   fileListCache.set(key, { generation, body: result.value });
+  while (fileListCache.size > MAX_TIMED_CACHE_ENTRIES) {
+    const oldest = fileListCache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    fileListCache.delete(oldest);
+  }
   return json2(result.value);
 }
-function handleGrep(url) {
+async function handleGrep(url) {
   const query = url.searchParams.get("q") || "";
   const ref = url.searchParams.get("ref") || "worktree";
   const max = normalizeGrepMax(url.searchParams.get("max"));
@@ -23090,7 +23314,7 @@ function handleGrep(url) {
   const excludeNames = scopeExcludeNamesFromQuery(url);
   const paths = url.searchParams.getAll("path");
   const regex = url.searchParams.get("regex") === "1";
-  const result = grepRepo(currentSearchEnv(omitDirNames, excludeNames), {
+  const result = await grepRepoAsync(currentSearchEnv(omitDirNames, excludeNames), {
     query,
     ref,
     paths,
@@ -23269,16 +23493,16 @@ function handleFileDiff(url) {
     if (isUntracked) {
       const res = untrackedFileDiff(extras, path, cwd);
       diffText = res.stdout || "";
-      if (res.code !== 0) {
-        errText = res.stderr;
-        errStatus = res.status;
+      if (res.code !== 0 && !(res.code === 1 && diffText)) {
+        errText = res.stderr || "diff failed";
+        errStatus = res.status ?? 500;
       }
     } else {
       const res = fileDiffText([...extras, ...args], oldPath ? [oldPath, path] : path, cwd);
       diffText = res.stdout || "";
       if (res.code !== 0) {
-        errText = res.stderr;
-        errStatus = res.status;
+        errText = res.stderr || "diff failed";
+        errStatus = res.status ?? 500;
       }
     }
     if (!errText)
@@ -23454,6 +23678,7 @@ async function handleFileRange(url) {
     const full = safeWorktreePath2(path);
     if (!full)
       return text("no file", 404);
+    const responseGeneration = generation;
     const result = await collectIndexedWorktreeLineRange(full, start, end);
     const body = {
       path,
@@ -23463,10 +23688,11 @@ async function handleFileRange(url) {
       lines: result.lines,
       total: result.total,
       complete: result.complete,
-      generation
+      generation: responseGeneration
     };
     return json2(body);
   } else {
+    const responseGeneration = generation;
     const refCheck = verifyTreeRefResult(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
@@ -23487,34 +23713,64 @@ async function handleFileRange(url) {
       lines: result.lines,
       total: result.total,
       complete: result.complete,
-      generation
+      generation: responseGeneration
     };
     return json2(body);
   }
 }
-function handleRawFile(req, url) {
+async function handleRawFile(req, url) {
   const path = url.searchParams.get("path") || "";
   if (!safePath(path))
     return text("forbidden", 403);
   const ref = url.searchParams.get("ref") || "worktree";
-  let body;
   if (ref !== "worktree" && ref !== "") {
     const refCheck = verifyTreeRefResult(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
-    const size = rawFileSize(path, ref);
-    if (size == null)
+    const oid = objectId(ref, path, cwd);
+    if (oid.code !== 0 || !oid.oid)
       return text("not in ref", 404);
+    const sizeResult = objectByteSize(oid.oid, cwd);
+    if (sizeResult.code !== 0)
+      return text("cannot read ref", 500);
+    const size = sizeResult.size;
     const metadata = gitFileMetadata(ref, path, size);
+    const rangeResult = req.headers.get("range") ? parseHttpByteRange(req.headers.get("range"), size) : null;
+    if (rangeResult?.kind === "unsatisfiable") {
+      return new Response(null, {
+        status: 416,
+        headers: {
+          ...rawFileHeaders(path, { size, metadata }),
+          "Content-Range": `bytes */${size}`,
+          "Content-Length": "0"
+        }
+      });
+    }
+    if (rangeResult?.kind === "range") {
+      const range = rangeResult.range;
+      if (req.method === "HEAD") {
+        return new Response(null, {
+          status: 206,
+          headers: rawFileHeaders(path, { size, range, metadata })
+        });
+      }
+      const shown2 = catFileBlobStream(oid.oid, cwd);
+      const bytes = await collectByteRangeFromStream(shown2.stream, range.start, range.end + 1);
+      const code = await shown2.exited;
+      if (code !== 0)
+        return text("not in ref", 404);
+      const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+      return new Response(body, {
+        status: 206,
+        headers: rawFileHeaders(path, { size, range, metadata })
+      });
+    }
     if (req.method === "HEAD")
       return new Response(null, {
         headers: rawFileHeaders(path, { size, metadata })
       });
-    const res = showBytes(ref, path, cwd);
-    if (res.code !== 0)
-      return text("not in ref", 404);
-    body = res.stdout.buffer.slice(res.stdout.byteOffset, res.stdout.byteOffset + res.stdout.byteLength);
-    return new Response(body, {
+    const shown = catFileBlobStream(oid.oid, cwd);
+    return new Response(shown.stream, {
       headers: rawFileHeaders(path, { size, metadata })
     });
   } else {
@@ -23664,11 +23920,11 @@ async function handleUploadFiles(req) {
   const written = [];
   try {
     for (const upload of uploads) {
-      const fd = openSync2(upload.target, uploadOpenFlags(), 420);
+      const fd = openSync3(upload.target, uploadOpenFlags(), 420);
       try {
         writeFileSync2(fd, new Uint8Array(await upload.file.arrayBuffer()));
       } finally {
-        closeSync2(fd);
+        closeSync3(fd);
       }
       written.push(upload.target);
     }
@@ -24666,7 +24922,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/_files")
         return handleFiles2(url);
       if (url.pathname === "/_grep")
-        return handleGrep(url);
+        return await handleGrep(url);
       if (url.pathname === "/_commits")
         return handleRefCommits(url);
       if (url.pathname === "/_log")
@@ -24678,7 +24934,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/file_range")
         return handleFileRange(url);
       if (url.pathname === "/_file")
-        return handleRawFile(req, url);
+        return await handleRawFile(req, url);
       if (url.pathname === "/_open_path")
         return handleOpenPath(req);
       if (url.pathname === "/_trash_path")