@youtyan/code-viewer 0.1.15 → 0.1.17

package/dist/code-viewer.js

@@ -0,0 +1,2235 @@
+#!/usr/bin/env node
+
+// web-src/server/preview.ts
+import { closeSync, constants, existsSync as existsSync3, lstatSync as lstatSync3, openSync, readFileSync as readFileSync2, realpathSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname2, extname, join as join4, relative } from "node:path";
+
+// web-src/routes.ts
+var SPA_PATHS = ["/todif", "/todiff", "/file", "/help"];
+var APP_ENTRY_PATHS = ["/", "/index.html"];
+
+// web-src/server/cache.ts
+import { lstatSync } from "node:fs";
+import { join } from "node:path";
+var CACHE_TTL_MS = 1500;
+var MAX_TIMED_CACHE_ENTRIES = 200;
+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(join(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")}`;
+}
+
+// web-src/server/dev-assets.ts
+import { basename } from "node:path";
+function startDevAssetReload(options) {
+  if (!options.enabled)
+    return false;
+  const watched = new Set(options.watchedFiles);
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 150;
+  let timer = null;
+  options.watch(options.webRoot, { persistent: false }, (_event, filename) => {
+    if (!filename || !watched.has(basename(filename.toString())))
+      return;
+    if (timer)
+      clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      options.sendReload();
+    }, debounceMs);
+  });
+  return true;
+}
+
+// web-src/server/git.ts
+import { existsSync, lstatSync as lstatSync2, readdirSync, readFileSync } from "node:fs";
+
+// web-src/server/runtime.ts
+import { spawn, spawnSync } from "node:child_process";
+import { createReadStream, promises as fs } from "node:fs";
+import {
+  createServer
+} from "node:http";
+import { Readable } from "node:stream";
+function runSync(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 TextDecoder().decode(proc.stdout || new Uint8Array),
+    stderr: new TextDecoder().decode(proc.stderr || new Uint8Array)
+  };
+}
+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: new TextDecoder().decode(proc.stderr || new Uint8Array)
+  };
+}
+function spawnDetached(args) {
+  const child = spawn(args[0], args.slice(1), {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function spawnStream(args, cwd) {
+  const proc = spawn(args[0], args.slice(1), {
+    cwd,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return {
+    stream: Readable.toWeb(proc.stdout),
+    exited: new Promise((resolve) => proc.on("close", (code) => resolve(code ?? 1))),
+    kill: (signal) => proc.kill(signal)
+  };
+}
+function fileReadableStream(path) {
+  return Readable.toWeb(createReadStream(path));
+}
+function fileByteRangeResponseBody(path, start, endInclusive) {
+  return Readable.toWeb(createReadStream(path, { start, end: endInclusive }));
+}
+async function readFileTextRange(path, start, endExclusive) {
+  const length = Math.max(0, endExclusive - start);
+  if (length === 0)
+    return "";
+  const handle = await fs.open(path, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const result = await handle.read(buffer, 0, length, start);
+    return buffer.subarray(0, result.bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function startServer(options) {
+  const server = createServer(async (req, res) => {
+    try {
+      const request = nodeRequestToWeb(req, options.hostname, server.address());
+      const response = await options.fetch(request);
+      await writeWebResponse(res, response);
+    } catch {
+      if (!res.headersSent)
+        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("internal server error");
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.hostname, () => {
+      server.off("error", reject);
+      server.on("error", (error) => {
+        console.error("[code-viewer] server error:", error);
+      });
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : options.port;
+      resolve({ port });
+    });
+  });
+}
+function nodeRequestToWeb(req, hostname, address) {
+  const port = typeof address === "object" && address ? address.port : 0;
+  const host = req.headers.host || `${hostname}:${port}`;
+  const url = new URL(req.url || "/", `http://${host}`);
+  const headers = new Headers;
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        headers.append(key, item);
+    } else if (value !== undefined) {
+      headers.set(key, value);
+    }
+  }
+  const method = req.method || "GET";
+  const hasBody = method !== "GET" && method !== "HEAD";
+  return new Request(url, {
+    method,
+    headers,
+    body: hasBody ? Readable.toWeb(req) : undefined,
+    duplex: hasBody ? "half" : undefined
+  });
+}
+async function writeWebResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const body = Readable.fromWeb(response.body);
+    let settled = false;
+    const settle = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      fn();
+    };
+    body.on("error", (error) => settle(() => {
+      res.destroy(error);
+      reject(error);
+    }));
+    res.on("finish", () => settle(resolve));
+    res.on("close", () => settle(() => {
+      body.destroy();
+      resolve();
+    }));
+    body.pipe(res);
+  });
+}
+
+// web-src/server/git.ts
+import { join as join2 } from "node:path";
+var WORKTREE_RECURSIVE_DEPTH_LIMIT = 32;
+var WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000;
+var DEFAULT_WORKTREE_OMIT_DIR_NAMES = [
+  "node_modules",
+  ".venv",
+  "venv",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".astro",
+  ".vercel",
+  "dist",
+  "build",
+  "out",
+  "target",
+  ".gradle",
+  "__pycache__",
+  ".pytest_cache",
+  ".tox",
+  ".terraform",
+  ".idea",
+  ".vscode",
+  "vendor",
+  ".cache",
+  "coverage",
+  "DerivedData",
+  "Pods",
+  "bin",
+  "obj"
+];
+function run(args, cwd) {
+  return runSync(args, cwd);
+}
+function runBytes(args, cwd) {
+  return runBytesSync(args, cwd);
+}
+function repoRoot(cwd) {
+  const res = run(["git", "rev-parse", "--show-toplevel"], cwd);
+  return res.code === 0 ? res.stdout.trimEnd() : null;
+}
+function currentBranch(cwd) {
+  const res = run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  return res.code === 0 ? res.stdout.trimEnd() : null;
+}
+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(["git", "cat-file", "blob", oid], cwd);
+}
+function objectSize(ref, path, cwd) {
+  const res = run(["git", "cat-file", "-s", `${ref}:${path}`], cwd);
+  return { code: res.code, size: Number(res.stdout.trim()) || 0, stderr: res.stderr };
+}
+function objectByteSize(oid, cwd) {
+  const res = run(["git", "cat-file", "-s", oid], cwd);
+  return { code: res.code, size: Number(res.stdout.trim()) || 0, stderr: res.stderr };
+}
+function objectId(ref, path, cwd) {
+  const res = run(["git", "rev-parse", "--verify", `${ref}:${path}`], cwd);
+  const oid = res.stdout.trim();
+  if (res.code !== 0 || !oid)
+    return { code: res.code || 1, oid: "", stderr: res.stderr };
+  const type = run(["git", "cat-file", "-t", oid], cwd);
+  if (type.code !== 0 || type.stdout.trim() !== "blob")
+    return { code: 1, oid: "", stderr: type.stderr };
+  return { code: 0, oid, stderr: "" };
+}
+function verifyTreeRef(ref, cwd) {
+  if (!ref || ref === "worktree")
+    return false;
+  if (ref.startsWith("-"))
+    return false;
+  const res = run(["git", "rev-parse", "--verify", `${ref}^{tree}`], cwd);
+  return res.code === 0;
+}
+function refs(cwd) {
+  const out = { branches: [], tags: [], commits: [], current: "" };
+  const branches = run([
+    "git",
+    "for-each-ref",
+    "--sort=-committerdate",
+    "--format=%(refname:short)",
+    "refs/heads",
+    "refs/remotes"
+  ], cwd);
+  if (branches.code === 0) {
+    out.branches = branches.stdout.split(`
+`).filter((line) => line && line !== "origin/HEAD");
+  }
+  const tags = run(["git", "for-each-ref", "--sort=-creatordate", "--format=%(refname:short)", "refs/tags"], cwd);
+  if (tags.code === 0)
+    out.tags = tags.stdout.split(`
+`).filter(Boolean);
+  const commits = run(["git", "log", "-50", "--format=%h\t%s\t%an\t%ar"], cwd);
+  if (commits.code === 0)
+    out.commits = commits.stdout.split(`
+`).filter(Boolean);
+  out.current = currentBranch(cwd) || "";
+  return out;
+}
+function nameStatus(args, cwd) {
+  const res = run([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    "--name-status",
+    "-z",
+    ...args
+  ], cwd);
+  if (res.code !== 0)
+    return [];
+  const parts = res.stdout.split("\x00");
+  const files = [];
+  for (let i = 0;i < parts.length; ) {
+    const status = parts[i++];
+    if (!status)
+      break;
+    const kind = status[0];
+    if (kind === "R" || kind === "C") {
+      const oldPath = parts[i++] || "";
+      const path = parts[i++] || "";
+      if (path)
+        files.push({ status: kind, old_path: oldPath, path, similarity: Number(status.slice(1)) || undefined });
+    } else {
+      const path = parts[i++] || "";
+      if (path)
+        files.push({ status: kind, path });
+    }
+  }
+  return files;
+}
+function numstatZ(args, cwd) {
+  const res = run([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    "--numstat",
+    "-z",
+    ...args
+  ], cwd);
+  if (res.code !== 0)
+    return [];
+  const parts = res.stdout.split("\x00");
+  const files = [];
+  for (let i = 0;i < parts.length; ) {
+    const rec = parts[i++];
+    if (!rec)
+      break;
+    const match = rec.match(/^(\S+)\t(\S+)\t(.*)$/);
+    if (!match)
+      break;
+    const [, add, del, rest] = match;
+    const binary = add === "-" && del === "-";
+    const additions = binary ? 0 : Number(add) || 0;
+    const deletions = binary ? 0 : Number(del) || 0;
+    if (rest === "") {
+      const oldPath = parts[i++] || "";
+      const path = parts[i++] || "";
+      if (path)
+        files.push({ old_path: oldPath, path, additions, deletions, binary });
+    } else {
+      files.push({ path: rest, additions, deletions, binary });
+    }
+  }
+  return files;
+}
+function untracked(cwd, path = "") {
+  const args = ["git", "ls-files", "--others", "--exclude-standard"];
+  if (path)
+    args.push("--", `${path}/`);
+  const res = run(args, cwd);
+  return res.code === 0 ? res.stdout.split(`
+`).filter(Boolean) : [];
+}
+function normalizeTreePath(path) {
+  return path.replace(/^\/+|\/+$/g, "");
+}
+function sortTreeEntries(entries) {
+  return [...entries].sort((a, b) => {
+    if (a.type !== b.type)
+      return a.type === "tree" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function omittedWorktreeDirectoryReason(name, omitDirNames) {
+  if (name === ".git")
+    return "internal";
+  return omitDirNames.has(name) ? "heavy" : undefined;
+}
+function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames) {
+  const entryPath = base ? `${base}/${name}` : name;
+  const type = isDirectory ? hasDotGitEntry(join2(dir, name)) ? "commit" : "tree" : "blob";
+  const omittedReason = type === "tree" ? omittedWorktreeDirectoryReason(name, omitDirNames) : undefined;
+  return omittedReason ? {
+    name,
+    path: entryPath,
+    type,
+    children_omitted: true,
+    children_omitted_reason: omittedReason
+  } : { name, path: entryPath, type };
+}
+function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES) {
+  const base = normalizeTreePath(path);
+  const root = join2(cwd, base);
+  const omitDirNameSet = new Set(omitDirNames);
+  let directEntries;
+  try {
+    const dirents = readdirSync(root, { withFileTypes: true });
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet)));
+  } catch {
+    return [];
+  }
+  if (!recursive)
+    return directEntries;
+  const fileEntries = [];
+  let truncated = false;
+  const pushRecursiveEntry = (entry) => {
+    if (fileEntries.length >= WORKTREE_RECURSIVE_ENTRY_LIMIT) {
+      if (!truncated) {
+        fileEntries.push({
+          name: "more...",
+          path: "__code_viewer_truncated__",
+          type: "tree",
+          children_omitted: true,
+          children_omitted_reason: "truncated"
+        });
+        truncated = true;
+      }
+      return false;
+    }
+    fileEntries.push(entry);
+    return true;
+  };
+  const walk = (dir, prefix, depth) => {
+    if (truncated)
+      return;
+    if (depth >= WORKTREE_RECURSIVE_DEPTH_LIMIT)
+      return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
+        if (omittedReason) {
+          if (!pushRecursiveEntry({
+            name: entry.name,
+            path: entryPath,
+            type: "tree",
+            children_omitted: true,
+            children_omitted_reason: omittedReason
+          }))
+            return;
+          continue;
+        }
+        if (hasDotGitEntry(full))
+          continue;
+        walk(full, entryPath, depth + 1);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        if (!pushRecursiveEntry({ name: entry.name, path: entryPath, type: "blob" }))
+          return;
+      }
+    }
+  };
+  walk(root, base, 0);
+  return combineDirectAndRecursiveFiles(directEntries, fileEntries.sort((a, b) => a.path.localeCompare(b.path)));
+}
+function hasDotGitEntry(dir) {
+  try {
+    lstatSync2(join2(dir, ".git"));
+    return true;
+  } catch (err) {
+    return !!err && typeof err === "object" && "code" in err && err.code !== "ENOENT";
+  }
+}
+function gitTreeEntries(ref, path, cwd, recursive) {
+  const base = normalizeTreePath(path);
+  const args = ["git", "-c", "core.quotepath=false", "ls-tree"];
+  if (recursive)
+    args.push("-r");
+  args.push("-z", "--full-tree", ref, "--");
+  if (base)
+    args.push(`${base}/`);
+  const res = run(args, cwd);
+  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);
+  if (recursive)
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+  else
+    entries = sortTreeEntries(entries);
+  return { code: 0, entries, stderr: "" };
+}
+function combineDirectAndRecursiveFiles(directEntries, fileEntries) {
+  const seen = new Set(directEntries.map((entry) => entry.path));
+  return [
+    ...directEntries,
+    ...fileEntries.filter((entry) => !seen.has(entry.path))
+  ];
+}
+function worktreeFiles(cwd) {
+  return listTree("worktree", "", cwd, { recursive: true }).entries;
+}
+function listTree(ref, path, cwd, options = {}) {
+  const base = normalizeTreePath(path);
+  if (ref === "worktree") {
+    return { code: 0, entries: worktreeFilesystemEntries(cwd, base, !!options.recursive, options.omitDirNames), stderr: "" };
+  }
+  const direct = gitTreeEntries(ref, base, cwd, false);
+  if (direct.code !== 0 || !options.recursive)
+    return direct;
+  const recursive = gitTreeEntries(ref, base, cwd, true);
+  if (recursive.code !== 0)
+    return recursive;
+  return { code: 0, entries: combineDirectAndRecursiveFiles(direct.entries, recursive.entries), stderr: "" };
+}
+function untrackedMeta(cwd) {
+  return untracked(cwd).map((path) => {
+    const full = join2(cwd, path);
+    let binary = false;
+    let lines = 0;
+    if (existsSync(full)) {
+      const data = readFileSync(full);
+      const probe = data.subarray(0, 8192);
+      binary = probe.includes(0);
+      if (!binary)
+        lines = data.toString("utf8").split(`
+`).length - 1;
+    }
+    return { path, status: "A", additions: binary ? 0 : lines, deletions: 0, binary, untracked: true };
+  });
+}
+function fileMeta(args, cwd, includeUntracked = false) {
+  const ns = nameStatus(args, cwd);
+  const nm = numstatZ(args, cwd);
+  const byPath = new Map(nm.map((file) => [file.path, file]));
+  const files = ns.map((file) => {
+    const stats = byPath.get(file.path);
+    return {
+      ...file,
+      additions: stats?.additions || 0,
+      deletions: stats?.deletions || 0,
+      binary: stats?.binary || false
+    };
+  });
+  return includeUntracked ? files.concat(untrackedMeta(cwd)) : files;
+}
+function fileDiffText(args, path, cwd) {
+  const paths = Array.isArray(path) ? path : [path];
+  return run([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    ...args,
+    "--",
+    ...paths
+  ], cwd);
+}
+function untrackedFileDiff(extras, path, cwd) {
+  return run([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-index",
+    ...extras,
+    "/dev/null",
+    path
+  ], cwd);
+}
+function splitHunks(diffText) {
+  if (!diffText)
+    return { header: "", hunks: [] };
+  const first = diffText.startsWith("@@") ? 0 : diffText.indexOf(`
+@@`) + 1;
+  if (first <= 0)
+    return { header: diffText, hunks: [] };
+  const header = diffText.slice(0, first);
+  const hunks = [];
+  let cur = first;
+  while (cur < diffText.length) {
+    const next = diffText.indexOf(`
+@@`, cur + 1);
+    const end = next >= 0 ? next : diffText.length;
+    hunks.push(diffText.slice(cur, end));
+    if (next < 0)
+      break;
+    cur = next + 1;
+  }
+  return { header, hunks };
+}
+function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
+  const { header, hunks } = splitHunks(diffText);
+  if (hunks.length === 0) {
+    const lines = diffText.split(`
+`);
+    const lineTruncated2 = Number.isFinite(maxLines) && lines.length > maxLines;
+    const text2 = lineTruncated2 ? lines.slice(0, maxLines).join(`
+`) : diffText;
+    return {
+      text: text2,
+      totalHunks: 0,
+      renderedHunks: 0,
+      lineCount: (text2.match(/\n/g) || []).length,
+      lineTruncated: lineTruncated2
+    };
+  }
+  const maxHunks = Math.min(n, hunks.length);
+  const rendered = [];
+  let renderedHunks = 0;
+  let usedLines = (header.match(/\n/g) || []).length;
+  let lineTruncated = false;
+  for (let index = 0;index < maxHunks; index++) {
+    const hunk = hunks[index];
+    const lines = hunk.split(`
+`);
+    const separatorLines = rendered.length > 0 ? 1 : 0;
+    const remaining = maxLines - usedLines - separatorLines;
+    if (remaining <= 0) {
+      lineTruncated = true;
+      break;
+    }
+    if (Number.isFinite(maxLines) && lines.length > remaining) {
+      rendered.push(lines.slice(0, remaining).join(`
+`));
+      renderedHunks++;
+      lineTruncated = true;
+      break;
+    }
+    rendered.push(hunk);
+    renderedHunks++;
+    usedLines += separatorLines + lines.length;
+  }
+  const text = header + rendered.join(`
+`);
+  return {
+    text,
+    totalHunks: hunks.length,
+    renderedHunks,
+    lineCount: (text.match(/\n/g) || []).length,
+    lineTruncated
+  };
+}
+
+// web-src/server/range.ts
+function isSameWorktreeRange(range) {
+  return range.from === "worktree" && range.to === "worktree";
+}
+function parseHttpByteRange(header, size) {
+  if (!header)
+    return { kind: "invalid" };
+  if (size < 1)
+    return { kind: "unsatisfiable" };
+  const match = header.match(/^bytes=(\d*)-(\d*)$/);
+  if (!match)
+    return { kind: "invalid" };
+  const [, rawStart, rawEnd] = match;
+  if (!rawStart && !rawEnd)
+    return { kind: "invalid" };
+  let start;
+  let end;
+  if (!rawStart) {
+    const suffixLength = Number(rawEnd);
+    if (!Number.isSafeInteger(suffixLength) || suffixLength < 1)
+      return { kind: "unsatisfiable" };
+    start = Math.max(0, size - suffixLength);
+    end = size - 1;
+  } else {
+    start = Number(rawStart);
+    end = rawEnd ? Number(rawEnd) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end))
+      return { kind: "invalid" };
+    if (end >= size)
+      end = size - 1;
+  }
+  if (start < 0 || end < start || start >= size)
+    return { kind: "unsatisfiable" };
+  return { kind: "range", range: { start, end } };
+}
+async function collectLineRangeFromStream(stream, start, end) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  const lines = [];
+  let lineNo = 1;
+  let pending = "";
+  let hasMore = false;
+  const pushLine = (line) => {
+    if (line.endsWith("\r"))
+      line = line.slice(0, -1);
+    if (lineNo >= start && lineNo <= end)
+      lines.push(line);
+    else if (lineNo > end)
+      hasMore = true;
+    lineNo++;
+  };
+  while (!hasMore) {
+    const chunk = await reader.read();
+    if (chunk.done)
+      break;
+    pending += decoder.decode(chunk.value, { stream: true });
+    let newline = pending.indexOf(`
+`);
+    while (newline !== -1) {
+      pushLine(pending.slice(0, newline));
+      pending = pending.slice(newline + 1);
+      if (hasMore)
+        break;
+      newline = pending.indexOf(`
+`);
+    }
+  }
+  if (hasMore) {
+    try {
+      await reader.cancel();
+    } catch {}
+    return { lines, total: lineNo - 1, complete: false };
+  }
+  pending += decoder.decode();
+  if (pending.length > 0)
+    pushLine(pending);
+  if (hasMore)
+    return { lines, total: lineNo - 1, complete: false };
+  return { lines, total: Math.max(0, lineNo - 1), complete: true };
+}
+async function buildLineOffsetIndexFromStream(stream, size) {
+  const reader = stream.getReader();
+  const builder = createLineOffsetIndexBuilder(size);
+  let offset = 0;
+  let lastByte = -1;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done)
+      break;
+    const bytes = chunk.value;
+    for (let index = 0;index < bytes.length; index++) {
+      const byte = bytes[index];
+      if (byte === 10)
+        builder.push(offset + index);
+      lastByte = byte;
+    }
+    offset += bytes.length;
+  }
+  return builder.finish(offset, offset > 0 && lastByte !== 10);
+}
+async function collectByteRangeFromStream(stream, start, endExclusive) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let offset = 0;
+  let total = 0;
+  while (offset < endExclusive) {
+    const chunk = await reader.read();
+    if (chunk.done)
+      break;
+    const chunkStart = offset;
+    const chunkEnd = offset + chunk.value.byteLength;
+    if (chunkEnd > start && chunkStart < endExclusive) {
+      const sliceStart = Math.max(0, start - chunkStart);
+      const sliceEnd = Math.min(chunk.value.byteLength, endExclusive - chunkStart);
+      const slice = chunk.value.subarray(sliceStart, sliceEnd);
+      chunks.push(slice);
+      total += slice.byteLength;
+    }
+    offset = chunkEnd;
+  }
+  try {
+    await reader.cancel();
+  } catch {}
+  if (chunks.length === 1)
+    return chunks[0];
+  const bytes = new Uint8Array(total);
+  let writeOffset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, writeOffset);
+    writeOffset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function collectBytesWithLineOffsetIndexFromStream(stream, sizeHint) {
+  const reader = stream.getReader();
+  const builder = createLineOffsetIndexBuilder(sizeHint);
+  const chunks = [];
+  let offset = 0;
+  let lastByte = -1;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done)
+      break;
+    const bytes = chunk.value;
+    chunks.push(bytes);
+    for (let index = 0;index < bytes.length; index++) {
+      const byte = bytes[index];
+      if (byte === 10)
+        builder.push(offset + index);
+      lastByte = byte;
+    }
+    offset += bytes.length;
+  }
+  const collected = new Uint8Array(offset);
+  let writeOffset = 0;
+  for (const chunk of chunks) {
+    collected.set(chunk, writeOffset);
+    writeOffset += chunk.byteLength;
+  }
+  return {
+    bytes: collected,
+    index: builder.finish(offset, offset > 0 && lastByte !== 10)
+  };
+}
+function createLineOffsetIndexBuilder(size) {
+  const useFloat64 = size > 4294967295;
+  let capacity = 1024;
+  let length = 0;
+  let offsets = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
+  const grow = () => {
+    capacity *= 2;
+    const next = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
+    next.set(offsets);
+    offsets = next;
+  };
+  return {
+    push(offset) {
+      if (length >= capacity)
+        grow();
+      offsets[length++] = offset;
+    },
+    finish(totalSize, hasTrailingLine) {
+      return {
+        size: totalSize,
+        total: length + (hasTrailingLine ? 1 : 0),
+        newlines: offsets.slice(0, length)
+      };
+    }
+  };
+}
+function lineByteRangeForIndex(index, start, end) {
+  const normalizedStart = Math.max(1, Math.floor(start));
+  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
+  if (normalizedStart > index.total)
+    return null;
+  const lastLine = Math.min(normalizedEnd, index.total);
+  const byteStart = normalizedStart <= 1 ? 0 : index.newlines[normalizedStart - 2] + 1;
+  const byteEnd = lastLine <= index.newlines.length ? index.newlines[lastLine - 1] : index.size;
+  return { start: byteStart, endExclusive: byteEnd };
+}
+function collectLineRangeFromIndexedText(text, index, start, end) {
+  const normalizedStart = Math.max(1, Math.floor(start));
+  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
+  if (normalizedStart > index.total)
+    return { lines: [], total: index.total, complete: true };
+  const expectedLines = Math.min(normalizedEnd, index.total) - normalizedStart + 1;
+  const lines = text.length ? text.split(`
+`).map((line) => line.endsWith("\r") ? line.slice(0, -1) : line) : Array.from({ length: expectedLines }, () => "");
+  return { lines, total: index.total, complete: end >= index.total };
+}
+
+// web-src/server/root.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join3, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+function findRoot(start) {
+  let current = start;
+  for (let i = 0;i < 5; i++) {
+    if (existsSync2(join3(current, "package.json")) && existsSync2(join3(current, "web"))) {
+      return normalize(current);
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return normalize(join3(start, "..", ".."));
+}
+var ROOT = findRoot(dirname(fileURLToPath(import.meta.url)));
+
+// web-src/server/search.ts
+var GREP_DEFAULT_MAX = 200;
+var GREP_ABSOLUTE_MAX = 500;
+var GREP_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var FILE_SEARCH_ABSOLUTE_MAX = 50000;
+function normalizeGrepMax(value) {
+  const parsed = Number(value || "");
+  if (!Number.isInteger(parsed) || parsed <= 0)
+    return GREP_DEFAULT_MAX;
+  return Math.min(parsed, GREP_ABSOLUTE_MAX);
+}
+function isSkippableSearchPath(path, omitDirNames = []) {
+  const omitDirs = new Set(omitDirNames.map((name) => name.toLowerCase()));
+  return path.split(/[\\/]+/).some((part) => {
+    const lower = part.toLowerCase();
+    return lower === ".git" || omitDirs.has(lower);
+  });
+}
+function fixedStringLineMatches(path, text, query, max) {
+  const needle = query.toLowerCase();
+  if (!needle)
+    return [];
+  const matches = [];
+  const lines = text.split(`
+`);
+  for (let i = 0;i < lines.length && matches.length < max; i++) {
+    const line = lines[i];
+    const column = line.toLowerCase().indexOf(needle);
+    if (column < 0)
+      continue;
+    matches.push({
+      path,
+      line: i + 1,
+      column: column + 1,
+      preview: line.slice(0, 500)
+    });
+  }
+  return matches;
+}
+function buildFileSearchList(ref, generation, entries) {
+  const files = entries.filter((entry) => entry.type === "blob" || entry.type === "commit").slice(0, FILE_SEARCH_ABSOLUTE_MAX).map((entry) => ({ path: entry.path, type: entry.type }));
+  return {
+    ref,
+    generation,
+    files,
+    truncated: entries.length > FILE_SEARCH_ABSOLUTE_MAX
+  };
+}
+function buildRgArgs(query, max, paths, regex = false, omitDirNames = []) {
+  const safePaths = paths.length ? paths : ["."];
+  const omitGlobs = omitDirNames.flatMap((name) => ["--glob", `!${name}/**`, "--glob", `!**/${name}/**`]);
+  const args = [
+    "rg",
+    "--no-config",
+    "--line-number",
+    "--column",
+    "--no-heading",
+    "--color",
+    "never",
+    "--smart-case",
+    "--max-count",
+    String(max),
+    "--max-filesize",
+    "2M",
+    ...omitGlobs,
+    "-e",
+    query,
+    "--",
+    ...safePaths
+  ];
+  if (!regex)
+    args.splice(8, 0, "--fixed-strings");
+  return args;
+}
+function parseRgOutput(stdout, max, omitDirNames = []) {
+  const matches = [];
+  for (const line of stdout.split(`
+`)) {
+    if (!line || matches.length >= max)
+      continue;
+    const parsed = /^(.*):(\d+):(\d+):(.*)$/.exec(line);
+    if (!parsed)
+      continue;
+    const path = parsed[1];
+    const lineNo = Number(parsed[2]);
+    const column = Number(parsed[3]);
+    const preview = parsed[4];
+    if (!path || !lineNo || !column || isSkippableSearchPath(path, omitDirNames))
+      continue;
+    matches.push({ path, line: lineNo, column, preview: preview.slice(0, 500) });
+  }
+  return matches;
+}
+function parseGitGrepOutput(stdout, ref, max, omitDirNames = []) {
+  const prefix = `${ref}:`;
+  const normalized = stdout.split(`
+`).map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line).join(`
+`);
+  return parseRgOutput(normalized, max, omitDirNames);
+}
+
+// web-src/server/preview.ts
+var WEB_ROOT = join4(ROOT, "web");
+var VERSION = JSON.parse(readFileSync2(join4(ROOT, "package.json"), "utf8")).version;
+var DEFAULT_ARGS = ["HEAD"];
+var PREVIEW_HUNKS_DEFAULT = 3;
+var PREVIEW_LINES_DEFAULT = 1200;
+var WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
+var SIZE_SMALL = 2000;
+var SIZE_MEDIUM = 8000;
+var SIZE_LARGE = 20000;
+var LINE_INDEX_MIN_START = 1e4;
+var LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
+var BLOB_LINE_CACHE_MAX_BYTES = 128 * 1024 * 1024;
+var MAX_UPLOAD_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_UPLOAD_TOTAL_BYTES = 50 * 1024 * 1024;
+var MAX_UPLOAD_BODY_BYTES = MAX_UPLOAD_TOTAL_BYTES + 1024 * 1024;
+var MAX_UPLOAD_FILES = 50;
+var SAFE_UPLOAD_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".markdown",
+  ".json",
+  ".csv",
+  ".tsv",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".pdf",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".css",
+  ".scss",
+  ".html"
+]);
+var generation = 1;
+var cwd = repoRoot(process.cwd()) || process.cwd();
+var cliArgs = DEFAULT_ARGS;
+var listenPort = 0;
+var allowUpload = false;
+var uploadAllowedByCli = false;
+var scopeOmitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES;
+var scopeOmitDirCliOverride = null;
+var rgAvailableCache = null;
+var enc = new TextEncoder;
+var sseClients = new Set;
+var fileCache = new Map;
+var metaCache = new Map;
+var fileListCache = new Map;
+var lineIndexCache = new Map;
+var blobLineIndexCache = new Map;
+var blobBytesCache = new Map;
+var blobLineCacheBytes = 0;
+function parseCli() {
+  const rest = [];
+  for (let i = 2;i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === "--help" || arg === "-h") {
+      console.log(`code-viewer ${VERSION}
+
+Usage:
+  code-viewer [--cwd <repo>] [--port <port>] [--open] [git-diff-args...]
+
+Examples:
+  code-viewer --open
+  code-viewer --cwd /path/to/repo --open
+  code-viewer HEAD~1 HEAD
+  code-viewer --staged
+`);
+      process.exit(0);
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      process.exit(0);
+    } else if (arg === "--cwd") {
+      const next = process.argv[++i];
+      if (!next) {
+        console.error("--cwd requires a value");
+        process.exit(1);
+      }
+      try {
+        cwd = repoRoot(next) || realpathSync(next);
+      } catch {
+        console.error("--cwd must point to an existing directory");
+        process.exit(1);
+      }
+    } else if (arg === "--port") {
+      const next = process.argv[++i];
+      const parsed = Number(next);
+      if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        console.error("--port requires a TCP port number");
+        process.exit(1);
+      }
+      listenPort = parsed;
+    } else if (arg === "--open") {
+      setTimeout(() => openBrowser(`http://127.0.0.1:${server.port}/`), 0);
+    } else if (arg === "--allow-upload") {
+      allowUpload = true;
+      uploadAllowedByCli = true;
+    } else if (arg === "--scope-omit-dir") {
+      const next = process.argv[++i];
+      if (!next) {
+        console.error("--scope-omit-dir requires a directory name");
+        process.exit(1);
+      }
+      scopeOmitDirCliOverride = normalizeScopeOmitDirNames([...scopeOmitDirCliOverride || [], next]);
+    } else {
+      rest.push(arg);
+    }
+  }
+  if (rest.length)
+    cliArgs = rest;
+  if (!uploadAllowedByCli)
+    allowUpload = loadProjectConfigUploadEnabled();
+  const configScopeOmitDirs = loadProjectConfigScopeOmitDirs();
+  if (scopeOmitDirCliOverride) {
+    scopeOmitDirNames = scopeOmitDirCliOverride;
+  } else if (configScopeOmitDirs) {
+    scopeOmitDirNames = configScopeOmitDirs;
+  }
+}
+function json(data, init = {}) {
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store",
+      ...init.headers || {}
+    }
+  });
+}
+function text(body, status = 200) {
+  return new Response(body, {
+    status,
+    headers: { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" }
+  });
+}
+function requestAllowed(req) {
+  const host = req.headers.get("host") || "";
+  const origin = req.headers.get("origin");
+  const okHost = /^(127\.0\.0\.1|localhost|\[::1\]):\d+$/i.test(host);
+  const okOrigin = !origin || origin === "null" || /^http:\/\/(127\.0\.0\.1|localhost|\[::1\]):\d+$/i.test(origin);
+  return okHost && okOrigin;
+}
+function sideEffectRequestAllowed(req) {
+  const host = req.headers.get("host") || "";
+  const origin = req.headers.get("origin");
+  const fetchSite = req.headers.get("sec-fetch-site");
+  const requestedBy = req.headers.get("x-code-viewer-action");
+  return /^(127\.0\.0\.1|localhost|\[::1\]):\d+$/i.test(host) && origin === `http://${host}` && (!fetchSite || fetchSite === "same-origin") && requestedBy === "1";
+}
+function staticFile(pathname) {
+  const map = {
+    "/favicon.png": ["favicon.png", "image/png"],
+    "/style.css": ["style.css", "text/css; charset=utf-8"],
+    "/app.js": ["app.js", "application/javascript; charset=utf-8"],
+    "/mermaid.js": ["mermaid.js", "application/javascript; charset=utf-8"],
+    "/shiki.js": ["shiki.js", "application/javascript; charset=utf-8"],
+    "/vendor/diff2html/diff2html.min.css": ["vendor/diff2html/diff2html.min.css", "text/css; charset=utf-8"],
+    "/vendor/diff2html/diff2html-ui.min.js": ["vendor/diff2html/diff2html-ui.min.js", "application/javascript; charset=utf-8"],
+    "/vendor/highlight.js/highlight.min.js": ["vendor/highlight.js/highlight.min.js", "application/javascript; charset=utf-8"],
+    "/vendor/highlight.js/styles/github.min.css": ["vendor/highlight.js/styles/github.min.css", "text/css; charset=utf-8"],
+    "/vendor/highlight.js/styles/github-dark.min.css": ["vendor/highlight.js/styles/github-dark.min.css", "text/css; charset=utf-8"]
+  };
+  for (const spaPath of [...APP_ENTRY_PATHS, ...SPA_PATHS]) {
+    map[spaPath] = ["index.html", "text/html; charset=utf-8"];
+  }
+  const spec = map[pathname];
+  if (!spec)
+    return null;
+  const full = join4(WEB_ROOT, spec[0]);
+  if (!existsSync3(full))
+    return text("not found", 404);
+  return new Response(readFileSync2(full), {
+    headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
+  });
+}
+function buildRangeArgs(range) {
+  const refs2 = [];
+  if (range.from && range.from !== "worktree")
+    refs2.push(range.from);
+  if (range.to && range.to !== "worktree")
+    refs2.push(range.to);
+  return { args: refs2.length ? refs2 : cliArgs, refs: refs2 };
+}
+function includeUntracked(range, refs2) {
+  const toWorktree = !range.to || range.to === "worktree";
+  if (refs2.length > 0)
+    return toWorktree && refs2.length < 2;
+  return cliArgs.length === 0 || cliArgs.length === 1 && cliArgs[0] === "HEAD";
+}
+function guessMediaKind(path) {
+  const ext = extname(path).slice(1).toLowerCase();
+  if (["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "bmp", "ico"].includes(ext))
+    return "image";
+  if (["mp4", "webm", "mov"].includes(ext))
+    return "video";
+  if (["mp3", "wav", "ogg", "flac", "m4a", "aac", "opus"].includes(ext))
+    return "audio";
+  return null;
+}
+function classify(file) {
+  if (file.binary)
+    return "binary";
+  const total = (file.additions || 0) + (file.deletions || 0);
+  if (total <= SIZE_SMALL)
+    return "small";
+  if (total <= SIZE_MEDIUM)
+    return "medium";
+  if (total <= SIZE_LARGE)
+    return "large";
+  return "huge";
+}
+function estimateHeight(file, sizeClass) {
+  if (file.binary)
+    return 380;
+  if (sizeClass === "small")
+    return Math.min(800, ((file.additions || 0) + (file.deletions || 0) + 10) * 22);
+  return 140;
+}
+function buildQuery(params) {
+  const q = new URLSearchParams;
+  for (const key of Object.keys(params).sort()) {
+    const value = params[key];
+    if (value !== undefined && value !== null && value !== "")
+      q.set(key, String(value));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function fileToMeta(file, range, extraQs) {
+  const sizeClass = classify(file);
+  const q = { path: file.path, old_path: file.old_path, status: file.status, from: range.from, to: range.to, ...extraQs };
+  if (file.untracked)
+    Object.assign(q, { untracked: "1" });
+  const previewQ = { ...q, mode: "preview", max_hunks: PREVIEW_HUNKS_DEFAULT };
+  const previewUrl = sizeClass !== "small" ? `/file_diff${buildQuery(previewQ)}` : null;
+  return {
+    order: file.order,
+    key: `${file.status || "M"}\x00${file.old_path || ""}\x00${file.path}`,
+    path: file.path,
+    old_path: file.old_path,
+    display_path: file.path,
+    status: file.status || "M",
+    additions: file.additions || 0,
+    deletions: file.deletions || 0,
+    binary: file.binary || false,
+    media_kind: guessMediaKind(file.path),
+    size_class: sizeClass,
+    force_layout: sizeClass === "huge" ? "line-by-line" : undefined,
+    highlight: sizeClass === "small",
+    load_url: `/file_diff${buildQuery(q)}`,
+    preview_url: previewUrl,
+    estimated_height_px: estimateHeight(file, sizeClass),
+    untracked: file.untracked || false
+  };
+}
+function computePayload(extras, range) {
+  if (isSameWorktreeRange(range)) {
+    return {
+      files: [],
+      totals: { files: 0, additions: 0, deletions: 0 },
+      range: "worktree .. worktree",
+      project: basename2(cwd),
+      branch: currentBranch(cwd) || undefined,
+      generation
+    };
+  }
+  const { args, refs: refs2 } = buildRangeArgs(range);
+  const fullArgs = [...extras, ...args];
+  const files = fileMeta(fullArgs, cwd, false);
+  if (includeUntracked(range, refs2))
+    files.push(...untrackedMeta(cwd));
+  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  files.forEach((file, i) => {
+    file.order = i + 1;
+  });
+  const extraQs = {};
+  for (const e of extras) {
+    if (e === "-w" || e === "--ignore-all-space")
+      extraQs.ignore_ws = "1";
+    if (e === "--ignore-blank-lines")
+      extraQs.ignore_blank = "1";
+  }
+  const meta = files.map((file) => fileToMeta(file, range, extraQs));
+  const totals = meta.reduce((acc, file) => {
+    acc.additions += file.additions || 0;
+    acc.deletions += file.deletions || 0;
+    return acc;
+  }, { files: meta.length, additions: 0, deletions: 0 });
+  const toWorktree = !range.to || range.to === "worktree";
+  const label = refs2.length ? `${refs2.join(" .. ")}${toWorktree && refs2.length === 1 ? " .. worktree" : ""}` : cliArgs.join(" ");
+  return { files: meta, totals, range: label || "HEAD", project: basename2(cwd), branch: currentBranch(cwd) || undefined, generation };
+}
+function handleDiffJson(url) {
+  const extras = [];
+  if (url.searchParams.get("ignore_ws") === "1")
+    extras.push("-w");
+  if (url.searchParams.get("ignore_blank") === "1")
+    extras.push("--ignore-blank-lines");
+  const range = { from: url.searchParams.get("from") || "", to: url.searchParams.get("to") || "" };
+  const key = `${range.from}|${range.to}|${url.searchParams.get("ignore_ws") || ""}|${url.searchParams.get("ignore_blank") || ""}`;
+  if (url.searchParams.get("nocache") === "1") {
+    const payload2 = computePayload(extras, range);
+    const sig = JSON.stringify({ ...payload2, generation: undefined });
+    const cached2 = metaCache.get(key);
+    if (!cached2 || cached2.sig !== sig) {
+      generation++;
+      payload2.generation = generation;
+      metaCache.clear();
+      fileCache.clear();
+    }
+    const body2 = JSON.stringify(payload2);
+    setTimedCacheEntry(metaCache, key, { body: body2, sig });
+    return new Response(body2, { headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" } });
+  }
+  const cached = metaCache.get(key);
+  if (cacheFresh(cached))
+    return new Response(cached.body, { headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" } });
+  const payload = computePayload(extras, range);
+  const body = JSON.stringify(payload);
+  setTimedCacheEntry(metaCache, key, { body, sig: JSON.stringify({ ...payload, generation: undefined }) });
+  return new Response(body, { headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" } });
+}
+function safePath(path) {
+  if (!path || path.startsWith("/") || path.startsWith("\\") || path.includes("\x00"))
+    return false;
+  return !path.split(/[\\/]+/).includes("..");
+}
+function safeRepoPath(path) {
+  return path === "" || safePath(path);
+}
+function normalizeScopeOmitDirNames(names) {
+  if (!Array.isArray(names))
+    return [];
+  return [...new Set(names.filter((name) => typeof name === "string").map((name) => name.trim()).filter((name) => name && name.length <= 64 && !name.includes("/") && !name.includes("\\") && !name.includes("\x00") && name !== "." && name !== ".." && name !== ".git"))].sort((a, b) => a.localeCompare(b));
+}
+function parseScopeOmitDirNamesQuery(value) {
+  const names = value ? value.split(",") : [];
+  if (names.length > 100)
+    return null;
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name || name.length > 64 || name.includes("/") || name.includes("\\") || name.includes("\x00") || name === "." || name === ".." || name === ".git")
+      return null;
+  }
+  return normalizeScopeOmitDirNames(names);
+}
+function loadProjectConfig() {
+  const full = join4(cwd, ".code-viewer.json");
+  if (!existsSync3(full))
+    return null;
+  let realCwd;
+  let realConfig;
+  try {
+    realCwd = realpathSync(cwd);
+    realConfig = realpathSync(full);
+  } catch {
+    return null;
+  }
+  if (dirname2(realConfig) !== realCwd || basename2(realConfig) !== ".code-viewer.json")
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(realConfig, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "version" in parsed && parsed.version !== 1)
+      return null;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function loadProjectConfigUploadEnabled() {
+  const config = loadProjectConfig();
+  return config?.upload?.enabled === true;
+}
+function loadProjectConfigScopeOmitDirs() {
+  const config = loadProjectConfig();
+  if (!config?.scope || !Array.isArray(config.scope.omitDirs))
+    return null;
+  return normalizeScopeOmitDirNames(config.scope.omitDirs);
+}
+function scopeOmitDirNamesFromQuery(url) {
+  if (!url.searchParams.has("omit_dirs"))
+    return scopeOmitDirNames;
+  return parseScopeOmitDirNamesQuery(url.searchParams.get("omit_dirs") || "") || scopeOmitDirNames;
+}
+function invalidScopeOmitDirNamesQuery(url) {
+  return url.searchParams.has("omit_dirs") && !parseScopeOmitDirNamesQuery(url.searchParams.get("omit_dirs") || "");
+}
+function isGitInternalPath(path) {
+  return path.split(/[\\/]+/).some((part) => part.toLowerCase() === ".git");
+}
+function safeWorktreePath(path) {
+  if (!safePath(path))
+    return null;
+  if (isGitInternalPath(path))
+    return null;
+  const full = join4(cwd, path);
+  if (!existsSync3(full))
+    return null;
+  let realCwd;
+  let realFull;
+  try {
+    realCwd = realpathSync(cwd);
+    realFull = realpathSync(full);
+  } catch {
+    return null;
+  }
+  const rel = relative(realCwd, realFull);
+  if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
+    return null;
+  if (isGitInternalPath(rel))
+    return null;
+  return realFull;
+}
+function safeOpenWorktreePath(path) {
+  if (path === "") {
+    try {
+      const realCwd = realpathSync(cwd);
+      if (isGitInternalPath(realCwd))
+        return null;
+      return realCwd;
+    } catch {
+      return null;
+    }
+  }
+  return safeWorktreePath(path);
+}
+function parentRepoPath(path) {
+  const parent = dirname2(path);
+  return parent === "." ? "" : parent;
+}
+function readReadme(target, dirPath) {
+  const candidates = ["README.md", "readme.md", "README.markdown", "README"];
+  for (const name of candidates) {
+    const path = dirPath ? `${dirPath}/${name}` : name;
+    if (target === "worktree" || target === "") {
+      const full = safeWorktreePath(path);
+      if (!full)
+        continue;
+      try {
+        return { path, text: readFileSync2(full, "utf8") };
+      } catch {
+        continue;
+      }
+    }
+    const res = show(target, path, cwd);
+    if (res.code === 0)
+      return { path, text: res.stdout };
+  }
+  return null;
+}
+function handleTree(url) {
+  const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
+  const path = (url.searchParams.get("path") || "").replace(/^\/+|\/+$/g, "");
+  if (!safeRepoPath(path))
+    return text("invalid path", 400);
+  if ((target === "worktree" || target === "") && isGitInternalPath(path))
+    return text("forbidden", 403);
+  if (target !== "worktree" && !verifyTreeRef(target, cwd))
+    return text("invalid target", 400);
+  const recursive = url.searchParams.get("recursive") === "1";
+  if (invalidScopeOmitDirNamesQuery(url))
+    return text("invalid omit dirs", 400);
+  const entries = listTree(target, path, cwd, { recursive, omitDirNames: scopeOmitDirNamesFromQuery(url) }).entries;
+  return json({
+    ref: target,
+    path,
+    project: basename2(cwd),
+    branch: currentBranch(cwd) || undefined,
+    entries,
+    readme: readReadme(target, path),
+    upload_enabled: allowUpload && (target === "worktree" || target === "")
+  });
+}
+function handleSettings() {
+  return json({
+    project: basename2(cwd),
+    scope: {
+      omit_dirs_effective: scopeOmitDirNames,
+      omit_dirs_built_in: DEFAULT_WORKTREE_OMIT_DIR_NAMES,
+      max_entries: WORKTREE_RECURSIVE_ENTRY_LIMIT
+    }
+  });
+}
+function handleFiles(url) {
+  const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
+  if (target !== "worktree" && !verifyTreeRef(target, cwd))
+    return text("invalid target", 400);
+  if (invalidScopeOmitDirNamesQuery(url))
+    return text("invalid omit dirs", 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const key = `${target || "worktree"}\x00${omitDirNames.join("\x00")}`;
+  const cached = fileListCache.get(key);
+  if (cached && cached.generation === generation)
+    return json(cached.body);
+  const ref = target || "worktree";
+  const entries = listTree(ref, "", cwd, { recursive: true, omitDirNames }).entries;
+  const body = buildFileSearchList(ref, generation, entries);
+  fileListCache.set(key, { generation, body });
+  return json(body);
+}
+function parseGrepPaths(url, omitDirNames) {
+  return url.searchParams.getAll("path").filter((path) => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
+}
+function rgAvailable() {
+  if (rgAvailableCache !== null)
+    return rgAvailableCache;
+  const proc = runSync(["rg", "--version"], cwd);
+  rgAvailableCache = proc.code === 0;
+  return rgAvailableCache;
+}
+function grepWorktreeFallback(query, max, paths, omitDirNames) {
+  const candidates = paths.length ? paths : worktreeFiles(cwd).map((entry) => entry.path);
+  const matches = [];
+  for (const path of candidates) {
+    if (matches.length >= max)
+      break;
+    if (!safePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path, omitDirNames))
+      continue;
+    const full = safeWorktreePath(path);
+    if (!full)
+      continue;
+    let stat;
+    try {
+      stat = lstatSync3(full);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > GREP_MAX_FILE_BYTES)
+      continue;
+    let data;
+    try {
+      data = readFileSync2(full);
+    } catch {
+      continue;
+    }
+    if (data.subarray(0, 8192).includes(0))
+      continue;
+    matches.push(...fixedStringLineMatches(path, data.toString("utf8"), query, max - matches.length));
+  }
+  return matches;
+}
+function grepWorktree(query, max, paths, regex, omitDirNames) {
+  if (rgAvailable()) {
+    const safePaths = paths.filter((path) => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames) && safeWorktreePath(path));
+    const args = buildRgArgs(query, max, safePaths, regex, omitDirNames);
+    const proc = runSync(args, cwd, { timeout: 5000 });
+    const stdout = proc.stdout;
+    const matches2 = parseRgOutput(stdout, max, omitDirNames).filter((match) => safePath(match.path) && !isGitInternalPath(match.path) && !isSkippableSearchPath(match.path, omitDirNames) && !!safeWorktreePath(match.path));
+    return { ref: "worktree", engine: "rg", truncated: matches2.length >= max, matches: matches2 };
+  }
+  if (regex)
+    return { ref: "worktree", engine: "fallback", truncated: false, matches: [] };
+  const matches = grepWorktreeFallback(query, max, paths, omitDirNames);
+  return { ref: "worktree", engine: "fallback", truncated: matches.length >= max, matches };
+}
+function grepTreeRef(ref, query, max, paths, regex, omitDirNames) {
+  const safePaths = paths.filter((path) => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
+  const args = [
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "grep",
+    "-n",
+    "--column",
+    "-i",
+    regex ? "-E" : "-F",
+    "--no-color",
+    "-e",
+    query,
+    ref,
+    "--",
+    ...safePaths
+  ];
+  const proc = runSync(args, cwd, { timeout: 5000 });
+  const stdout = proc.stdout;
+  const matches = parseGitGrepOutput(stdout, ref, max, omitDirNames).slice(0, max);
+  return { ref, engine: "git", truncated: matches.length >= max, matches };
+}
+function handleGrep(url) {
+  const query = url.searchParams.get("q") || "";
+  const ref = url.searchParams.get("ref") || "worktree";
+  const max = normalizeGrepMax(url.searchParams.get("max"));
+  if (invalidScopeOmitDirNamesQuery(url))
+    return text("invalid omit dirs", 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const paths = parseGrepPaths(url, omitDirNames);
+  const regex = url.searchParams.get("regex") === "1";
+  if (!query.trim())
+    return json({ ref, engine: ref === "worktree" ? "fallback" : "git", truncated: false, matches: [] });
+  if (ref === "worktree" || ref === "")
+    return json(grepWorktree(query, max, paths, regex, omitDirNames));
+  if (!verifyTreeRef(ref, cwd))
+    return text("invalid target", 400);
+  return json(grepTreeRef(ref, query, max, paths, regex, omitDirNames));
+}
+function handleFileDiff(url) {
+  const path = url.searchParams.get("path") || "";
+  if (!safePath(path))
+    return text("invalid path", 400);
+  const extras = [];
+  if (url.searchParams.get("ignore_ws") === "1")
+    extras.push("-w");
+  if (url.searchParams.get("ignore_blank") === "1")
+    extras.push("--ignore-blank-lines");
+  const isUntracked = url.searchParams.get("untracked") === "1";
+  const range = { from: url.searchParams.get("from") || "", to: url.searchParams.get("to") || "" };
+  if (isSameWorktreeRange(range)) {
+    return json({
+      path,
+      old_path: url.searchParams.get("old_path") || "",
+      status: url.searchParams.get("status") || "",
+      mode: url.searchParams.get("mode") || "full",
+      diff: "",
+      hunk_count: 0,
+      rendered_hunk_count: 0,
+      line_count: 0,
+      truncated: false,
+      binary: false,
+      generation
+    });
+  }
+  const { args } = buildRangeArgs(range);
+  const oldPath = url.searchParams.get("old_path");
+  let cacheKey;
+  try {
+    cacheKey = fileDiffCacheKey({ path, oldPath, isUntracked, range, extras, args, cwd });
+  } catch {
+    return text("invalid diff range", 400);
+  }
+  const cached = fileCache.get(cacheKey);
+  let diffText;
+  let errText = "";
+  if (cacheFresh(cached)) {
+    diffText = cached.diffText;
+  } else {
+    if (isUntracked) {
+      diffText = untrackedFileDiff(extras, path, cwd).stdout || "";
+    } else {
+      const res = fileDiffText([...extras, ...args], oldPath ? [oldPath, path] : path, cwd);
+      diffText = res.stdout || "";
+      if (res.code !== 0)
+        errText = res.stderr;
+    }
+    setTimedCacheEntry(fileCache, cacheKey, { diffText });
+  }
+  const mode = url.searchParams.get("mode") || "full";
+  const truncated = mode === "preview" ? truncateToNHunks(diffText, Number(url.searchParams.get("max_hunks")) || PREVIEW_HUNKS_DEFAULT, Number(url.searchParams.get("max_lines")) || PREVIEW_LINES_DEFAULT) : truncateToNHunks(diffText, 1e9);
+  const body = {
+    path,
+    old_path: url.searchParams.get("old_path") || "",
+    status: url.searchParams.get("status") || "",
+    mode,
+    diff: truncated.text,
+    hunk_count: truncated.totalHunks,
+    rendered_hunk_count: truncated.renderedHunks,
+    line_count: truncated.lineCount,
+    truncated: mode === "preview" && (truncated.totalHunks > truncated.renderedHunks || truncated.lineTruncated),
+    binary: diffText.includes("Binary files"),
+    error: errText,
+    generation
+  };
+  return json(body);
+}
+function worktreeLineIndexSignature(full) {
+  try {
+    const stat = statSync(full);
+    return `size:${stat.size}|mtime:${stat.mtimeMs}|ctime:${stat.ctimeMs}|ino:${stat.ino || 0}`;
+  } catch {
+    return null;
+  }
+}
+async function getWorktreeLineIndex(full) {
+  const signature = worktreeLineIndexSignature(full);
+  if (!signature)
+    return null;
+  const cached = lineIndexCache.get(full);
+  if (cached?.signature === signature) {
+    lineIndexCache.delete(full);
+    lineIndexCache.set(full, cached);
+    return cached.index;
+  }
+  const stat = statSync(full);
+  if (stat.size > LINE_INDEX_MAX_FILE_BYTES)
+    return null;
+  const index = await buildLineOffsetIndexFromStream(fileReadableStream(full), stat.size);
+  lineIndexCache.delete(full);
+  lineIndexCache.set(full, { signature, index });
+  while (lineIndexCache.size > 32) {
+    const oldest = lineIndexCache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    lineIndexCache.delete(oldest);
+  }
+  return index;
+}
+function cachedBlobLineRange(cacheKey, start, end) {
+  const bytes = blobBytesCache.get(cacheKey);
+  const index = blobLineIndexCache.get(cacheKey);
+  if (!bytes || !index)
+    return null;
+  blobBytesCache.delete(cacheKey);
+  blobBytesCache.set(cacheKey, bytes);
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  const range = lineByteRangeForIndex(index, start, end);
+  const textValue = range ? new TextDecoder().decode(bytes.subarray(range.start, range.endExclusive)) : "";
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+function setBlobLineCache(cacheKey, bytes, index) {
+  setBlobLineIndexCache(cacheKey, index);
+  const existing = blobBytesCache.get(cacheKey);
+  if (existing)
+    blobLineCacheBytes -= existing.byteLength;
+  blobBytesCache.delete(cacheKey);
+  if (bytes.byteLength > BLOB_LINE_CACHE_MAX_BYTES)
+    return;
+  blobBytesCache.set(cacheKey, bytes);
+  blobLineCacheBytes += bytes.byteLength;
+  while (blobBytesCache.size > 16 || blobLineCacheBytes > BLOB_LINE_CACHE_MAX_BYTES) {
+    const oldest = blobBytesCache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    const evicted = blobBytesCache.get(oldest);
+    if (evicted)
+      blobLineCacheBytes -= evicted.byteLength;
+    blobBytesCache.delete(oldest);
+  }
+}
+function setBlobLineIndexCache(cacheKey, index) {
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  while (blobLineIndexCache.size > 128) {
+    const oldest = blobLineIndexCache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    blobLineIndexCache.delete(oldest);
+  }
+}
+async function collectGitBlobLineRangeWithIndex(cacheKey, oid, index, start, end) {
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  const range = lineByteRangeForIndex(index, start, end);
+  if (!range)
+    return collectLineRangeFromIndexedText("", index, start, end);
+  const shown = catFileBlobStream(oid, cwd);
+  const bytes = await collectByteRangeFromStream(shown.stream, range.start, range.endExclusive);
+  await shown.exited;
+  if (bytes.byteLength !== range.endExclusive - range.start)
+    return null;
+  const textValue = new TextDecoder().decode(bytes);
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+async function readGitBlobBytesWithIndex(oid, sizeHint) {
+  const shown = catFileBlobStream(oid, cwd);
+  const result = await collectBytesWithLineOffsetIndexFromStream(shown.stream, sizeHint);
+  const code = await shown.exited;
+  if (code !== 0)
+    return null;
+  return result;
+}
+async function collectGitBlobLineRangeFromStream(oid, start, end) {
+  const shown = catFileBlobStream(oid, cwd);
+  const result = await collectLineRangeFromStream(shown.stream, start, end);
+  const code = await shown.exited;
+  if (code !== 0 && result.complete)
+    return null;
+  return result;
+}
+async function collectIndexedGitBlobLineRange(path, oid, size, start, end) {
+  const cacheKey = `${oid}\x00${path}`;
+  const cached = cachedBlobLineRange(cacheKey, start, end);
+  if (cached)
+    return cached;
+  const cachedIndex = blobLineIndexCache.get(cacheKey);
+  if (cachedIndex)
+    return collectGitBlobLineRangeWithIndex(cacheKey, oid, cachedIndex, start, end);
+  if (start < LINE_INDEX_MIN_START) {
+    return collectGitBlobLineRangeFromStream(oid, start, end);
+  }
+  if (size > LINE_INDEX_MAX_FILE_BYTES)
+    return collectGitBlobLineRangeFromStream(oid, start, end);
+  const indexedBlob = await readGitBlobBytesWithIndex(oid, size);
+  if (!indexedBlob)
+    return null;
+  setBlobLineCache(cacheKey, indexedBlob.bytes, indexedBlob.index);
+  return cachedBlobLineRange(cacheKey, start, end) || collectGitBlobLineRangeWithIndex(cacheKey, oid, indexedBlob.index, start, end);
+}
+async function collectIndexedWorktreeLineRange(full, start, end) {
+  if (start < LINE_INDEX_MIN_START && !lineIndexCache.has(full)) {
+    return collectLineRangeFromStream(fileReadableStream(full), start, end);
+  }
+  const index = await getWorktreeLineIndex(full);
+  if (!index)
+    return collectLineRangeFromStream(fileReadableStream(full), start, end);
+  const range = lineByteRangeForIndex(index, start, end);
+  const textValue = range ? await readFileTextRange(full, range.start, range.endExclusive) : "";
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+async function handleFileRange(url) {
+  const path = url.searchParams.get("path") || "";
+  if (!safePath(path))
+    return text("invalid path", 400);
+  let start = Number(url.searchParams.get("start") || "1") || 1;
+  let end = Number(url.searchParams.get("end") || url.searchParams.get("endline") || "0") || 0;
+  if (start < 1)
+    start = 1;
+  if (end < start)
+    end = start;
+  const ref = url.searchParams.get("ref") || "worktree";
+  if (ref === "worktree" || ref === "") {
+    const full = safeWorktreePath(path);
+    if (!full)
+      return text("no file", 404);
+    const result = await collectIndexedWorktreeLineRange(full, start, end);
+    const body = { path, ref, start, end, lines: result.lines, total: result.total, complete: result.complete, generation };
+    return json(body);
+  } else {
+    if (!verifyTreeRef(ref, cwd))
+      return text("invalid ref", 400);
+    const oid = objectId(ref, path, cwd);
+    if (oid.code !== 0 || !oid.oid)
+      return text("not in ref", 404);
+    const size = objectByteSize(oid.oid, cwd);
+    if (size.code !== 0)
+      return text("cannot read ref", 500);
+    const result = await collectIndexedGitBlobLineRange(path, oid.oid, size.size, start, end);
+    if (!result)
+      return text("cannot read ref", 500);
+    const body = { path, ref, start, end, lines: result.lines, total: result.total, complete: result.complete, generation };
+    return json(body);
+  }
+}
+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 !== "") {
+    if (!verifyTreeRef(ref, cwd))
+      return text("invalid ref", 400);
+    const size = rawFileSize(path, ref);
+    if (size == null)
+      return text("not in ref", 404);
+    if (req.method === "HEAD")
+      return new Response(null, { headers: rawFileHeaders(path, size) });
+    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, { headers: rawFileHeaders(path, size) });
+  } else {
+    const full = safeWorktreePath(path);
+    if (!full)
+      return text("not found", 404);
+    const size = rawFileSize(path, ref);
+    if (size == null)
+      return text("not found", 404);
+    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), "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)
+        });
+      }
+      return new Response(fileByteRangeResponseBody(full, range.start, range.end), {
+        status: 206,
+        headers: rawFileHeaders(path, size, range)
+      });
+    }
+    if (req.method === "HEAD")
+      return new Response(null, { headers: rawFileHeaders(path, size) });
+    return new Response(fileReadableStream(full), { headers: rawFileHeaders(path, size) });
+  }
+}
+function rawFileSize(path, ref) {
+  if (ref !== "worktree" && ref !== "") {
+    if (!verifyTreeRef(ref, cwd))
+      return null;
+    const res = objectSize(ref, path, cwd);
+    return res.code === 0 ? res.size : null;
+  }
+  const full = safeWorktreePath(path);
+  if (!full)
+    return null;
+  try {
+    return statSync(full).size;
+  } catch {
+    return null;
+  }
+}
+function rawFileHeaders(path, size = null, range) {
+  const mime = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".pdf": "application/pdf",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".flac": "audio/flac",
+    ".m4a": "audio/mp4",
+    ".aac": "audio/aac",
+    ".opus": "audio/ogg"
+  };
+  const headers = {
+    "Content-Type": mime[extname(path).toLowerCase()] || "application/octet-stream",
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff",
+    "Content-Security-Policy": "sandbox",
+    "Accept-Ranges": "bytes"
+  };
+  if (range && size != null) {
+    headers["Content-Length"] = String(range.end - range.start + 1);
+    headers["Content-Range"] = `bytes ${range.start}-${range.end}/${size}`;
+  } else if (size != null) {
+    headers["Content-Length"] = String(size);
+  }
+  return headers;
+}
+function isForbiddenUploadName(name) {
+  const lower = name.toLowerCase();
+  return lower.startsWith(".") || lower === "package.json" || lower === "package-lock.json" || lower === "bun.lock" || lower === "bun.lockb" || lower === "yarn.lock" || lower === "pnpm-lock.yaml" || lower === "makefile" || lower === "dockerfile" || lower.endsWith(".dockerfile") || /^(tsconfig|jsconfig|bunfig|vercel|netlify|wrangler|next|vite|webpack|rollup|esbuild|astro|svelte|tailwind|postcss|babel|prettier|eslint)\./.test(lower) || lower.endsWith(".config.js") || lower.endsWith(".config.jsx") || lower.endsWith(".config.ts") || lower.endsWith(".config.tsx") || lower.endsWith(".config.mjs") || lower.endsWith(".config.cjs") || lower.includes("credential") || lower.includes("secret") || lower.endsWith(".exe") || lower.endsWith(".dll") || lower.endsWith(".dylib") || lower.endsWith(".so") || lower.endsWith(".sh") || lower.endsWith(".bash") || lower.endsWith(".zsh") || lower.endsWith(".fish") || lower.endsWith(".ps1") || lower.endsWith(".bat") || lower.endsWith(".cmd");
+}
+function safeUploadFileName(name) {
+  if (!name || name.includes("\x00") || name.includes("/") || name.includes("\\"))
+    return null;
+  if (name === "." || name === "..")
+    return null;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._ -]{0,180}$/.test(name))
+    return null;
+  if (isGitInternalPath(name) || isForbiddenUploadName(name))
+    return null;
+  if (!SAFE_UPLOAD_EXTENSIONS.has(extname(name).toLowerCase()))
+    return null;
+  return name;
+}
+function uploadOpenFlags() {
+  return constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0);
+}
+async function handleUploadFiles(req) {
+  if (!allowUpload)
+    return text("upload disabled", 403);
+  if (req.method !== "POST")
+    return text("method not allowed", 405);
+  if (!sideEffectRequestAllowed(req))
+    return text("forbidden", 403);
+  if (req.headers.get("content-encoding"))
+    return text("unsupported media type", 415);
+  const lengthHeader = req.headers.get("content-length");
+  if (!lengthHeader)
+    return text("content length required", 411);
+  const length = Number(lengthHeader);
+  if (!Number.isSafeInteger(length) || length < 0)
+    return text("invalid content length", 400);
+  if (length > MAX_UPLOAD_BODY_BYTES)
+    return text("upload too large", 413);
+  const contentType = req.headers.get("content-type") || "";
+  if (!/^multipart\/form-data;\s*boundary=/i.test(contentType))
+    return text("unsupported media type", 415);
+  let form;
+  try {
+    form = await req.formData();
+  } catch {
+    return text("invalid form data", 400);
+  }
+  const dir = String(form.get("dir") || "").replace(/^\/+|\/+$/g, "");
+  if (!safeRepoPath(dir))
+    return text("invalid dir", 400);
+  if (dir && isGitInternalPath(dir))
+    return text("forbidden", 403);
+  const realDir = safeOpenWorktreePath(dir);
+  if (!realDir)
+    return text("not found", 404);
+  const stats = statSync(realDir);
+  if (!stats.isDirectory())
+    return text("not a directory", 400);
+  const files = form.getAll("files").filter((item) => item instanceof File);
+  if (!files.length)
+    return text("no files", 400);
+  if (files.length > MAX_UPLOAD_FILES)
+    return text("too many files", 413);
+  let total = 0;
+  const names = new Set;
+  const uploads = [];
+  for (const file of files) {
+    const safeName = safeUploadFileName(file.name);
+    if (!safeName)
+      return text("invalid filename", 400);
+    const lowerName = safeName.toLowerCase();
+    if (names.has(lowerName))
+      return text("duplicate filename", 409);
+    names.add(lowerName);
+    if (file.size > MAX_UPLOAD_FILE_BYTES)
+      return text("file too large", 413);
+    total += file.size;
+    if (total > MAX_UPLOAD_TOTAL_BYTES)
+      return text("upload too large", 413);
+    const target = join4(realDir, safeName);
+    if (relative(realDir, dirname2(target)) !== "")
+      return text("invalid filename", 400);
+    if (existsSync3(target))
+      return text("file exists", 409);
+    uploads.push({ file, name: safeName, target });
+  }
+  const written = [];
+  try {
+    for (const upload of uploads) {
+      const fd = openSync(upload.target, uploadOpenFlags(), 420);
+      try {
+        writeFileSync(fd, new Uint8Array(await upload.file.arrayBuffer()));
+      } finally {
+        closeSync(fd);
+      }
+      written.push(upload.target);
+    }
+  } catch (error) {
+    for (const path of written) {
+      try {
+        unlinkSync(path);
+      } catch {}
+    }
+    if (error.code === "EEXIST")
+      return text("file exists", 409);
+    return text("upload failed", 500);
+  }
+  generation++;
+  fileCache.clear();
+  metaCache.clear();
+  sendSse("update");
+  return json({ ok: true, files: uploads.map((upload) => upload.name), generation });
+}
+function openOsPath(path) {
+  const cmd = process.platform === "darwin" ? ["open", "--", path] : process.platform === "win32" ? ["explorer.exe", path] : ["xdg-open", path];
+  spawnDetached(cmd);
+}
+async function handleOpenPath(req) {
+  if (req.method !== "POST")
+    return text("method not allowed", 405);
+  if (!sideEffectRequestAllowed(req))
+    return text("forbidden", 403);
+  const contentType = req.headers.get("content-type") || "";
+  if (!/^application\/json(?:;|$)/i.test(contentType))
+    return text("unsupported media type", 415);
+  const length = Number(req.headers.get("content-length") || "0");
+  if (length > 1024)
+    return text("payload too large", 413);
+  let body = {};
+  try {
+    const raw = await req.text();
+    if (raw.length > 1024)
+      return text("payload too large", 413);
+    body = JSON.parse(raw);
+  } catch {
+    return text("invalid json", 400);
+  }
+  const path = typeof body.path === "string" ? body.path.replace(/^\/+|\/+$/g, "") : "";
+  const kind = body.kind;
+  if (kind !== "directory" && kind !== "file-parent")
+    return text("invalid kind", 400);
+  if (kind === "file-parent" && !path)
+    return text("invalid path", 400);
+  if (!safeRepoPath(path))
+    return text("invalid path", 400);
+  if (path && isGitInternalPath(path))
+    return text("forbidden", 403);
+  const targetPath = kind === "file-parent" ? parentRepoPath(path) : path;
+  const target = safeOpenWorktreePath(targetPath);
+  if (!target)
+    return text("not found", 404);
+  const stats = statSync(target);
+  if (!stats.isDirectory())
+    return text("not a directory", 400);
+  openOsPath(target);
+  return json({ ok: true });
+}
+function sendSse(event, data = "tick") {
+  const payload = enc.encode(`event: ${event}
+data: ${data}
+
+`);
+  for (const client of [...sseClients]) {
+    try {
+      client.enqueue(payload);
+    } catch {
+      sseClients.delete(client);
+    }
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd.exe", "/c", "start", "", url] : ["xdg-open", url];
+  spawnDetached(cmd);
+}
+parseCli();
+var server = await startServer({
+  hostname: "127.0.0.1",
+  port: listenPort,
+  async fetch(req) {
+    if (!requestAllowed(req))
+      return text("forbidden", 403);
+    const url = new URL(req.url);
+    const staticResponse = staticFile(url.pathname);
+    if (staticResponse)
+      return staticResponse;
+    if (url.pathname === "/diff.json")
+      return handleDiffJson(url);
+    if (url.pathname === "/_settings")
+      return handleSettings();
+    if (url.pathname === "/_tree")
+      return handleTree(url);
+    if (url.pathname === "/_files")
+      return handleFiles(url);
+    if (url.pathname === "/_grep")
+      return handleGrep(url);
+    if (url.pathname === "/file_diff")
+      return handleFileDiff(url);
+    if (url.pathname === "/file_range")
+      return handleFileRange(url);
+    if (url.pathname === "/_file")
+      return handleRawFile(req, url);
+    if (url.pathname === "/_open_path")
+      return handleOpenPath(req);
+    if (url.pathname === "/_upload_files")
+      return handleUploadFiles(req);
+    if (url.pathname === "/_refs")
+      return json(refs(cwd));
+    if (url.pathname === "/refresh" && req.method === "POST") {
+      if (!sideEffectRequestAllowed(req))
+        return text("forbidden", 403);
+      generation++;
+      fileCache.clear();
+      metaCache.clear();
+      fileListCache.clear();
+      sendSse("update");
+      return json({ ok: true, generation });
+    }
+    if (url.pathname === "/events") {
+      let ctrl;
+      let keepalive;
+      return new Response(new ReadableStream({
+        start(controller) {
+          ctrl = controller;
+          sseClients.add(controller);
+          controller.enqueue(enc.encode(`event: open
+data: ok
+
+`));
+          keepalive = setInterval(() => {
+            try {
+              controller.enqueue(enc.encode(`: ping
+
+`));
+            } catch {
+              sseClients.delete(controller);
+              clearInterval(keepalive);
+            }
+          }, 15000);
+        },
+        cancel() {
+          if (ctrl)
+            sseClients.delete(ctrl);
+          if (keepalive)
+            clearInterval(keepalive);
+        }
+      }), {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache"
+        }
+      });
+    }
+    return text("not found", 404);
+  }
+});
+startDevAssetReload({
+  enabled: process.env.CODE_VIEWER_DEV === "1",
+  webRoot: WEB_ROOT,
+  watchedFiles: WATCHED_ASSET_FILES,
+  watch,
+  sendReload: () => sendSse("reload")
+});
+console.log(`GDP_LISTEN_URL=http://127.0.0.1:${server.port}/`);
+console.log(`git-diff-preview serving ${cwd}`);