@youtyan/code-viewer 0.6.9 → 0.7.0

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,19 +857,87 @@ 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"
+function runAsync(args, cwd, options = {}) {
+  return runBytesAsync(args, cwd, options).then((proc) => ({
+    code: proc.code,
+    stdout: new TextDecoder().decode(proc.stdout),
+    stderr: proc.stderr
+  }));
+}
+function runBytesAsync(args, cwd, options = {}) {
+  const maxBuffer = options.maxBuffer ?? 64 * 1024 * 1024;
+  return new Promise((resolve) => {
+    const proc = spawn(args[0], args.slice(1), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let timedOut = false;
+    let bufferExceeded = false;
+    let processError;
+    const killSignal = "SIGKILL";
+    const timer = options.timeout === undefined ? null : setTimeout(() => {
+      timedOut = true;
+      proc.kill(killSignal);
+    }, options.timeout);
+    const finish = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      let stderr = new TextDecoder().decode(concatBytes(stderrChunks));
+      if (timedOut) {
+        stderr = appendProcessError(stderr, new Error(`spawn ${args[0]} ETIMEDOUT`));
+      } else if (bufferExceeded) {
+        stderr = appendProcessError(stderr, new Error("stdout maxBuffer exceeded"));
+      } else {
+        stderr = appendProcessError(stderr, processError);
+      }
+      resolve({
+        code,
+        stdout: concatBytes(stdoutChunks),
+        stderr
+      });
+    };
+    const collect = (chunks, onBytes) => (chunk) => {
+      const bytes = new Uint8Array(chunk);
+      chunks.push(bytes);
+      onBytes(bytes.byteLength);
+      if (!bufferExceeded && (stdoutBytes > maxBuffer || stderrBytes > maxBuffer)) {
+        bufferExceeded = true;
+        proc.kill(killSignal);
+      }
+    };
+    proc.stdout?.on("data", collect(stdoutChunks, (length) => {
+      stdoutBytes += length;
+    }));
+    proc.stderr?.on("data", collect(stderrChunks, (length) => {
+      stderrBytes += length;
+    }));
+    proc.on("error", (err) => {
+      processError = err;
+    });
+    proc.on("close", (code) => {
+      finish(timedOut || bufferExceeded ? 1 : code ?? (processError ? 1 : 0));
+    });
   });
-  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 concatBytes(chunks) {
+  if (chunks.length === 0)
+    return new Uint8Array;
+  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
 }
 function spawnDetached(args) {
   const child = spawn(args[0], args.slice(1), {
@@ -1035,10 +1111,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,8 +1140,8 @@ function run(args, cwd) {
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
 }
-function runBytes(args, cwd) {
-  return runBytesSync(resolveGitArgs(args), cwd, {
+function runGitAsync(args, cwd) {
+  return runAsync(resolveGitArgs(args), cwd, {
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
 }
@@ -1089,6 +1168,10 @@ function runGitRefLookup(args, cwd) {
   const res = run(args, cwd);
   return res.code === 0 ? res.stdout.trimEnd() : null;
 }
+async function runGitRefLookupAsync(args, cwd) {
+  const res = await runGitAsync(args, cwd);
+  return res.code === 0 ? res.stdout.trimEnd() : null;
+}
 function repoRoot(cwd) {
   return runGitRefLookup(["git", "rev-parse", "--show-toplevel"], cwd);
 }
@@ -1107,14 +1190,17 @@ function repoRootResult(cwd) {
 function currentBranch(cwd) {
   return runGitRefLookup(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd);
 }
-function verifyCommit(ref, cwd) {
-  const res = run(["git", "rev-parse", "--verify", `${ref}^{commit}`], cwd);
+function currentBranchAsync(cwd) {
+  return runGitRefLookupAsync(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd);
+}
+async function verifyCommitAsync(ref, cwd) {
+  const res = await runGitAsync(["git", "rev-parse", "--verify", `${ref}^{commit}`], cwd);
   if (res.code === 0)
     return { ok: true, sha: res.stdout.trim() };
   return { ok: false, error: gitFailureMessage(res, "unknown ref") };
 }
-function statusPorcelainForPath(path, cwd) {
-  const res = run([
+async function statusPorcelainForPathAsync(path, cwd) {
+  const res = await runGitAsync([
     "git",
     "-c",
     "core.quotepath=false",
@@ -1135,66 +1221,63 @@ 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 showAsync(ref, path, cwd) {
+  return runGitAsync(["git", "show", `${ref}:${path}`], cwd);
 }
 function catFileBlobStream(oid, cwd) {
   return spawnStream(resolveGitArgs(["git", "cat-file", "blob", oid]), cwd);
 }
-function objectSize(ref, path, cwd) {
-  const res = run(["git", "cat-file", "-s", `${ref}:${path}`], cwd);
+async function objectSizeAsync(ref, path, cwd) {
+  const res = await runGitAsync(["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);
+async function objectByteSizeAsync(oid, cwd) {
+  const res = await runGitAsync(["git", "cat-file", "-s", oid], cwd);
   return {
     code: res.code,
     size: Number(res.stdout.trim()) || 0,
     stderr: res.stderr
   };
 }
-function lastCommitDateForPath(ref, path, cwd) {
+async function lastCommitDateForPathAsync(ref, path, cwd) {
   const args = ["git", "log", "-1", "--format=%cI", ref, "--", path];
-  const res = run(args, cwd);
+  const res = await runGitAsync(args, cwd);
   if (res.code !== 0)
     return null;
   return res.stdout.trim() || null;
 }
-function objectId(ref, path, cwd) {
-  const res = run(["git", "rev-parse", "--verify", `${ref}:${path}`], cwd);
+async function objectIdAsync(ref, path, cwd) {
+  const res = await runGitAsync(["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);
+  const type = await runGitAsync(["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) {
-  return verifyTreeRefResult(ref, cwd).ok;
-}
-function verifyTreeRefResult(ref, cwd) {
+async function verifyTreeRefResultAsync(ref, cwd) {
   if (!ref || ref === "worktree")
     return { ok: false, error: "invalid target", status: 400 };
   if (ref.startsWith("-"))
     return { ok: false, error: "invalid target", status: 400 };
-  const res = run(["git", "rev-parse", "--verify", `${ref}^{tree}`], cwd);
+  const res = await runGitAsync(["git", "rev-parse", "--verify", `${ref}^{tree}`], cwd);
   if (res.code === 0)
     return { ok: true };
   return { ok: false, ...gitFailureResult(res, "invalid target") };
 }
-function refsResult(cwd) {
+async function refsResultAsync(cwd) {
   const out = {
     branches: [],
     tags: [],
     commits: [],
     current: ""
   };
-  const branches = run([
+  const branches = await runGitAsync([
     "git",
     "for-each-ref",
     "--sort=-committerdate",
@@ -1214,7 +1297,7 @@ function refsResult(cwd) {
       out.branches.push({ name, when });
     }
   }
-  const tags = run([
+  const tags = await runGitAsync([
     "git",
     "for-each-ref",
     "--sort=-creatordate",
@@ -1233,7 +1316,7 @@ function refsResult(cwd) {
       out.tags.push({ name, when });
     }
   }
-  const commits = refCommitPageResult(cwd, {
+  const commits = await refCommitPageResultAsync(cwd, {
     query: "",
     max: DEFAULT_REF_COMMIT_LIMIT
   });
@@ -1241,7 +1324,7 @@ function refsResult(cwd) {
     return { refs: out, error: commits.error, status: commits.status };
   }
   out.commits = commits.commits;
-  out.current = currentBranch(cwd) || "";
+  out.current = await currentBranchAsync(cwd) || "";
   return { refs: out };
 }
 function clampCommitLimit(max) {
@@ -1295,22 +1378,22 @@ function mergeCommitResults(limit, ...groups) {
   }
   return merged;
 }
-function runCommitLogResult(cwd, args) {
-  const commits = run(args, cwd);
+async function runCommitLogResultAsync(cwd, args) {
+  const commits = await runGitAsync(args, cwd);
   if (commits.code === 0)
     return { commits: parseCommitLog(commits.stdout) };
   if (isCommandNotFoundResult("git", commits))
     return { commits: [], ...gitFailureResult(commits, "git log failed") };
   return { commits: [] };
 }
-function refCommitPageResult(cwd, options = {}) {
+async function refCommitPageResultAsync(cwd, options = {}) {
   const limit = clampCommitLimit(options.max ?? DEFAULT_REF_COMMIT_LIMIT);
   const skip = clampCommitSkip(options.skip ?? 0);
   const fetchLimit = limit + 1;
   const hashMatches = [];
   const trimmed = (options.query || "").trim().slice(0, 200).replace(/\0/g, "");
   if (skip === 0 && /^[0-9a-f]{4,40}$/i.test(trimmed)) {
-    const verified = run(["git", "rev-parse", "--verify", `${trimmed}^{commit}`], cwd);
+    const verified = await runGitAsync(["git", "rev-parse", "--verify", `${trimmed}^{commit}`], cwd);
     if (verified.code !== 0 && isCommandNotFoundResult("git", verified)) {
       return {
         commits: [],
@@ -1318,7 +1401,7 @@ function refCommitPageResult(cwd, options = {}) {
         ...gitFailureResult(verified, "unknown ref")
       };
     }
-    const single = run([
+    const single = await runGitAsync([
       "git",
       "log",
       "-z",
@@ -1338,7 +1421,7 @@ function refCommitPageResult(cwd, options = {}) {
     }
   }
   if (!trimmed) {
-    const result = runCommitLogResult(cwd, commitLogArgs(fetchLimit, skip));
+    const result = await runCommitLogResultAsync(cwd, commitLogArgs(fetchLimit, skip));
     if (result.error) {
       return {
         commits: [],
@@ -1353,11 +1436,19 @@ function refCommitPageResult(cwd, options = {}) {
       hasMore: commits.length > limit
     };
   }
-  const subjectMatches = runCommitLogResult(cwd, [
-    ...commitLogArgs(fetchLimit, skip),
-    "--regexp-ignore-case",
-    "--fixed-strings",
-    `--grep=${trimmed}`
+  const [subjectMatches, authorMatches] = await Promise.all([
+    runCommitLogResultAsync(cwd, [
+      ...commitLogArgs(fetchLimit, skip),
+      "--regexp-ignore-case",
+      "--fixed-strings",
+      `--grep=${trimmed}`
+    ]),
+    runCommitLogResultAsync(cwd, [
+      ...commitLogArgs(fetchLimit, skip),
+      "--regexp-ignore-case",
+      "--fixed-strings",
+      `--author=${trimmed}`
+    ])
   ]);
   if (subjectMatches.error) {
     return {
@@ -1367,12 +1458,6 @@ function refCommitPageResult(cwd, options = {}) {
       status: subjectMatches.status
     };
   }
-  const authorMatches = runCommitLogResult(cwd, [
-    ...commitLogArgs(fetchLimit, skip),
-    "--regexp-ignore-case",
-    "--fixed-strings",
-    `--author=${trimmed}`
-  ]);
   if (authorMatches.error) {
     return {
       commits: [],
@@ -1408,6 +1493,12 @@ function remoteWebUrl(cwd) {
     return null;
   return parseRemoteWebUrl(res.stdout.trim());
 }
+async function remoteWebUrlAsync(cwd) {
+  const res = await runGitAsync(["git", "remote", "get-url", "origin"], cwd);
+  if (res.code !== 0)
+    return null;
+  return parseRemoteWebUrl(res.stdout.trim());
+}
 function parseHistoryLog(stdout) {
   const parts = stdout.split("\x00");
   const commits = [];
@@ -1524,6 +1615,60 @@ function commitHistory(cwd, options) {
   const hasMore = parsed.length > limit;
   return { commits: hasMore ? parsed.slice(0, limit) : parsed, hasMore };
 }
+async function commitHistoryAsync(cwd, options) {
+  const ref = (options.ref || "HEAD").trim();
+  if (!ref || ref.startsWith("-") || ref.includes("\x00"))
+    return { commits: [], hasMore: false, error: "invalid ref" };
+  const verified = await runGitAsync(["git", "rev-parse", "--verify", `${ref}^{commit}`], cwd);
+  if (verified.code !== 0)
+    return {
+      commits: [],
+      hasMore: false,
+      ...gitFailureResult(verified, "unknown ref")
+    };
+  const skip = Math.max(0, Math.floor(options.skip) || 0);
+  const limit = Math.max(1, Math.min(Math.floor(options.limit) || 1, MAX_HISTORY_LIMIT));
+  const { filterArgs, pathspec, shaTerm } = historyQueryArgs(options.query || "");
+  const pathFilter = (options.path || "").trim();
+  const pathArgs = [];
+  if (pathFilter && !pathFilter.includes("\x00") && !pathFilter.startsWith("-")) {
+    if (!pathFilter.endsWith("/"))
+      pathArgs.push("--follow");
+    pathArgs.push("--", pathFilter);
+  }
+  const res = await runGitAsync([
+    "git",
+    "log",
+    "-z",
+    `--skip=${skip}`,
+    `--max-count=${limit + 1}`,
+    `--format=${HISTORY_FORMAT}`,
+    ...filterArgs,
+    verified.stdout.trim(),
+    ...pathspec,
+    ...pathArgs
+  ], cwd);
+  if (res.code !== 0)
+    return {
+      commits: [],
+      hasMore: false,
+      ...gitFailureResult(res, "git log failed")
+    };
+  let parsed = parseHistoryLog(res.stdout);
+  if (shaTerm && skip === 0) {
+    const bySha = await runGitAsync(["git", "rev-parse", "--verify", `${shaTerm}^{commit}`], cwd);
+    const sha = bySha.code === 0 ? bySha.stdout.trim() : "";
+    if (sha) {
+      const single = await runGitAsync(["git", "log", "-z", "-1", `--format=${HISTORY_FORMAT}`, sha], cwd);
+      if (single.code === 0) {
+        const hit = parseHistoryLog(single.stdout);
+        parsed = [...hit, ...parsed.filter((c) => c.sha !== sha)];
+      }
+    }
+  }
+  const hasMore = parsed.length > limit;
+  return { commits: hasMore ? parsed.slice(0, limit) : parsed, hasMore };
+}
 function nameStatusResult(args, cwd) {
   const res = run([
     "git",
@@ -1568,6 +1713,50 @@ function nameStatusResult(args, cwd) {
   }
   return { files };
 }
+async function nameStatusResultAsync(args, cwd) {
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    "--name-status",
+    "-z",
+    ...args
+  ], cwd);
+  if (res.code !== 0) {
+    return {
+      files: [],
+      error: gitFailureMessage(res, "git diff --name-status failed")
+    };
+  }
+  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 numstatZResult(args, cwd) {
   const res = run([
     "git",
@@ -1611,6 +1800,49 @@ function numstatZResult(args, cwd) {
   }
   return { files };
 }
+async function numstatZResultAsync(args, cwd) {
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    "--numstat",
+    "-z",
+    ...args
+  ], cwd);
+  if (res.code !== 0) {
+    return {
+      files: [],
+      error: gitFailureMessage(res, "git diff --numstat failed")
+    };
+  }
+  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 pathHasSegment(path, segment) {
   const target = segment.toLowerCase();
   return path.split(/[\\/]+/).some((part) => part.toLowerCase() === target);
@@ -1753,6 +1985,98 @@ function blame(cwd, options) {
   lines.sort((a, b) => a.lineNo - b.lineNo);
   return { lines, commits };
 }
+async function blameAsync(cwd, options) {
+  const path = options.path;
+  if (!path || path.includes("\x00") || path.startsWith("-")) {
+    return { lines: [], commits: {}, error: "invalid path" };
+  }
+  const normalized = normalizeBlameRef(options.ref, options.base);
+  const args = ["git", "blame", "--porcelain"];
+  if (normalized.base === "HEAD") {
+    if (normalized.ref.startsWith("-") || normalized.ref.includes("\x00"))
+      return { lines: [], commits: {}, error: "invalid ref" };
+    args.push(normalized.ref);
+  }
+  args.push("--", path);
+  const res = await runGitAsync(args, cwd);
+  if (res.code !== 0) {
+    if (isCommandNotFoundResult("git", res)) {
+      return {
+        lines: [],
+        commits: {},
+        error: commandNotFoundDetail("git"),
+        status: 503
+      };
+    }
+    if (normalized.base === "worktree") {
+      return syntheticUncommittedBlameFromWorktree(cwd, path);
+    }
+    return {
+      lines: [],
+      commits: {},
+      error: res.stderr.trim() || "blame failed"
+    };
+  }
+  const lines = [];
+  const commits = {};
+  const rawLines = res.stdout.split(`
+`);
+  let i = 0;
+  while (i < rawLines.length) {
+    const headerLine = rawLines[i];
+    if (!headerLine) {
+      i++;
+      continue;
+    }
+    const headerMatch = /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/.exec(headerLine);
+    if (!headerMatch) {
+      i++;
+      continue;
+    }
+    const sha = headerMatch[1];
+    const finalLine = Number(headerMatch[3]);
+    i++;
+    let commit = commits[sha];
+    if (!commit) {
+      commit = {
+        sha,
+        author: "",
+        authorMail: "",
+        authorTime: 0,
+        summary: "",
+        isUncommitted: sha === BLAME_ZERO_SHA
+      };
+      commits[sha] = commit;
+    }
+    while (i < rawLines.length && !rawLines[i].startsWith("\t")) {
+      const metaLine = rawLines[i++];
+      if (!metaLine)
+        continue;
+      const sp = metaLine.indexOf(" ");
+      const key = sp >= 0 ? metaLine.slice(0, sp) : metaLine;
+      const val = sp >= 0 ? metaLine.slice(sp + 1) : "";
+      if (key === "author" && !commit.author)
+        commit.author = val;
+      else if (key === "author-mail" && !commit.authorMail)
+        commit.authorMail = val.replace(/^</, "").replace(/>$/, "");
+      else if (key === "author-time" && !commit.authorTime)
+        commit.authorTime = Number(val) || 0;
+      else if (key === "summary" && !commit.summary)
+        commit.summary = val;
+    }
+    if (i < rawLines.length && rawLines[i].startsWith("\t"))
+      i++;
+    if (Number.isFinite(finalLine) && finalLine > 0) {
+      lines.push({
+        lineNo: finalLine,
+        sha,
+        isUncommitted: sha === BLAME_ZERO_SHA
+      });
+    }
+  }
+  lines.sort((a, b) => a.lineNo - b.lineNo);
+  return { lines, commits };
+}
 function untracked(cwd, path = "") {
   const args = ["git", "ls-files", "--others", "--exclude-standard"];
   if (path)
@@ -1763,6 +2087,16 @@ function untracked(cwd, path = "") {
   return res.stdout.split(`
 `).filter(Boolean).filter((entry) => !isToolInternalPath(entry));
 }
+async function untrackedAsync(cwd, path = "") {
+  const args = ["git", "ls-files", "--others", "--exclude-standard"];
+  if (path)
+    args.push("--", `${path}/`);
+  const res = await runGitAsync(args, cwd);
+  if (res.code !== 0)
+    return [];
+  return res.stdout.split(`
+`).filter(Boolean).filter((entry) => !isToolInternalPath(entry));
+}
 function normalizeTreePath(path) {
   return path.replace(/^\/+|\/+$/g, "");
 }
@@ -1790,6 +2124,18 @@ function worktreeSubmodulePaths(cwd) {
     return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
   }).filter(Boolean));
 }
+async function worktreeSubmodulePathsAsync(cwd) {
+  if (!existsSync(join3(cwd, ".gitmodules")))
+    return new Set;
+  const res = await runGitAsync(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
+  if (res.code !== 0)
+    return new Set;
+  return new Set(res.stdout.split(`
+`).map((line) => {
+    const split = line.indexOf(" ");
+    return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
+  }).filter(Boolean));
+}
 function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames, submodulePaths) {
   if (excludeNames.has(name.toLowerCase()))
     return {
@@ -1887,6 +2233,93 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
   walk(root, base, 0);
   return combineDirectAndRecursiveFiles(directEntries, fileEntries.sort((a, b) => a.path.localeCompare(b.path)));
 }
+async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
+  const base = normalizeTreePath(path);
+  const root = join3(cwd, base);
+  const omitDirNameSet = new Set(omitDirNames);
+  const excludeNameSet = new Set(excludeNames.map((name) => name.toLowerCase()));
+  const submodulePaths = await worktreeSubmodulePathsAsync(cwd);
+  let directEntries;
+  try {
+    const dirents = readdirSync(root, { withFileTypes: true });
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
+  } 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;
+  };
+  let visitedDirs = 0;
+  const yieldIfNeeded = async () => {
+    visitedDirs++;
+    if (visitedDirs % 25 === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  };
+  const walk = async (dir, prefix, depth) => {
+    if (truncated)
+      return;
+    if (depth >= WORKTREE_RECURSIVE_DEPTH_LIMIT)
+      return;
+    await yieldIfNeeded();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (excludeNameSet.has(entry.name.toLowerCase()))
+        continue;
+      const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const full = join3(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;
+        await walk(full, entryPath, depth + 1);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        if (!pushRecursiveEntry({
+          name: entry.name,
+          path: entryPath,
+          type: "blob"
+        }))
+          return;
+      }
+    }
+  };
+  await walk(root, base, 0);
+  return combineDirectAndRecursiveFiles(directEntries, fileEntries.sort((a, b) => a.path.localeCompare(b.path)));
+}
 function hasDotGitEntry(dir) {
   try {
     lstatSync(join3(dir, ".git"));
@@ -1924,6 +2357,35 @@ function gitTreeEntries(ref, path, cwd, recursive) {
     entries = sortTreeEntries(entries);
   return { code: 0, entries, stderr: "" };
 }
+async function gitTreeEntriesAsync(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 = await runGitAsync(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 [
@@ -1952,8 +2414,29 @@ function listTree(ref, path, cwd, options = {}) {
     stderr: ""
   };
 }
-function listTreeResult(ref, path, cwd, options = {}) {
-  const result = listTree(ref, path, cwd, options);
+async function listTreeAsync(ref, path, cwd, options = {}) {
+  const base = normalizeTreePath(path);
+  if (ref === "worktree") {
+    return {
+      code: 0,
+      entries: await worktreeFilesystemEntriesAsync(cwd, base, !!options.recursive, options.omitDirNames, options.excludeNames),
+      stderr: ""
+    };
+  }
+  const direct = await gitTreeEntriesAsync(ref, base, cwd, false);
+  if (direct.code !== 0 || !options.recursive)
+    return direct;
+  const recursive = await gitTreeEntriesAsync(ref, base, cwd, true);
+  if (recursive.code !== 0)
+    return recursive;
+  return {
+    code: 0,
+    entries: combineDirectAndRecursiveFiles(direct.entries, recursive.entries),
+    stderr: ""
+  };
+}
+async function listTreeResultAsync(ref, path, cwd, options = {}) {
+  const result = await listTreeAsync(ref, path, cwd, options);
   if (result.code === 0)
     return { entries: result.entries };
   return { entries: [], ...gitFailureResult(result, "git ls-tree failed") };
@@ -1961,21 +2444,51 @@ 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) {
+      try {
+        scan = scanFileBinaryAndNewlines(full);
+      } catch {
+        return [];
+      }
+    } else {
+      return [];
+    }
+    return [
+      {
+        path,
+        status: "A",
+        additions: scan.binary ? 0 : scan.newlines,
+        deletions: 0,
+        binary: scan.binary,
+        untracked: true
+      }
+    ];
+  });
+}
+async function untrackedMetaAsync(cwd) {
+  const paths = await untrackedAsync(cwd);
+  return paths.flatMap((path) => {
+    const full = join3(cwd, path);
+    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 +2496,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)
@@ -2012,6 +2551,27 @@ function fileMetaResult(args, cwd, includeUntracked = false) {
     files: includeUntracked ? files.concat(untrackedMeta(cwd)) : files
   };
 }
+async function fileMetaResultAsync(args, cwd, includeUntracked = false) {
+  const ns = await nameStatusResultAsync(args, cwd);
+  if (ns.error)
+    return { files: [], error: ns.error };
+  const nm = await numstatZResultAsync(args, cwd);
+  if (nm.error)
+    return { files: [], error: nm.error };
+  const byPath = new Map(nm.files.map((file) => [file.path, file]));
+  const files = ns.files.map((file) => {
+    const stats = byPath.get(file.path);
+    return {
+      ...file,
+      additions: stats?.additions || 0,
+      deletions: stats?.deletions || 0,
+      binary: stats?.binary || false
+    };
+  });
+  return {
+    files: includeUntracked ? files.concat(await untrackedMetaAsync(cwd)) : files
+  };
+}
 function fileDiffText(args, path, cwd) {
   const paths = Array.isArray(path) ? path : [path];
   const res = run([
@@ -2031,6 +2591,25 @@ function fileDiffText(args, path, cwd) {
   }
   return res;
 }
+async function fileDiffTextAsync(args, path, cwd) {
+  const paths = Array.isArray(path) ? path : [path];
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--find-renames",
+    ...args,
+    "--",
+    ...paths
+  ], cwd);
+  if (isCommandNotFoundResult("git", res)) {
+    return { ...res, stderr: commandNotFoundDetail("git"), status: 503 };
+  }
+  return res;
+}
 function untrackedFileDiff(extras, path, cwd) {
   const res = run([
     "git",
@@ -2049,16 +2628,38 @@ function untrackedFileDiff(extras, path, cwd) {
   }
   return res;
 }
+async function untrackedFileDiffAsync(extras, path, cwd) {
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-index",
+    ...extras,
+    "/dev/null",
+    path
+  ], cwd);
+  if (isCommandNotFoundResult("git", res)) {
+    return { ...res, stderr: commandNotFoundDetail("git"), status: 503 };
+  }
+  return res;
+}
 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);
@@ -3382,11 +3983,16 @@ __export(exports_file_cli, {
   sliceLines: () => sliceLines,
   safeWorktreePathFromRoot: () => safeWorktreePathFromRoot,
   runFileCli: () => runFileCli,
+  readShowTextAsync: () => readShowTextAsync,
   readShowText: () => readShowText,
   parseFileArgs: () => parseFileArgs,
+  buildFileShowReportAsync: () => buildFileShowReportAsync,
   buildFileShowReport: () => buildFileShowReport,
+  buildFileHistoryReportAsync: () => buildFileHistoryReportAsync,
   buildFileHistoryReport: () => buildFileHistoryReport,
+  buildFileDiffReportAsync: () => buildFileDiffReportAsync,
   buildFileDiffReport: () => buildFileDiffReport,
+  buildFileBlameReportAsync: () => buildFileBlameReportAsync,
   buildFileBlameReport: () => buildFileBlameReport,
   FILE_HISTORY_HARD_CAP: () => FILE_HISTORY_HARD_CAP,
   FILE_HELP: () => FILE_HELP,
@@ -3706,6 +4312,19 @@ function buildFileBlameReport(root, command) {
     result
   };
 }
+async function buildFileBlameReportAsync(root, command) {
+  const result = await blameAsync(root, {
+    path: command.path,
+    ref: command.ref,
+    base: command.base
+  });
+  return {
+    path: command.path,
+    ref: command.ref,
+    base: command.base,
+    result
+  };
+}
 function buildFileHistoryReport(root, command) {
   const result = commitHistory(root, {
     ref: command.ref,
@@ -3723,6 +4342,23 @@ function buildFileHistoryReport(root, command) {
     result
   };
 }
+async function buildFileHistoryReportAsync(root, command) {
+  const result = await commitHistoryAsync(root, {
+    ref: command.ref,
+    skip: command.skip,
+    limit: command.limit,
+    query: command.query,
+    path: command.path
+  });
+  return {
+    path: command.path,
+    ref: command.ref,
+    limit: command.limit,
+    skip: command.skip,
+    ...command.query !== undefined ? { query: command.query } : {},
+    result
+  };
+}
 function runBlame(root, command) {
   const report = buildFileBlameReport(root, command);
   if (command.json) {
@@ -3811,6 +4447,28 @@ function readShowText(root, command) {
     return { code: 1, stdout: "", stderr: "file not readable" };
   }
 }
+async function readShowTextAsync(root, command) {
+  if (command.ref !== "worktree" && command.ref !== "") {
+    return showAsync(command.ref, command.path, root);
+  }
+  const full = safeWorktreePathFromRoot(root, command.path);
+  if (!full) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "file not found or forbidden"
+    };
+  }
+  try {
+    const stat = statSync3(full);
+    if (!stat.isFile()) {
+      return { code: 1, stdout: "", stderr: "not a file" };
+    }
+    return { code: 0, stdout: readFileSync4(full, "utf8"), stderr: "" };
+  } catch {
+    return { code: 1, stdout: "", stderr: "file not readable" };
+  }
+}
 function buildFileShowReport(root, command) {
   const res = readShowText(root, command);
   if (res.code !== 0) {
@@ -3838,6 +4496,33 @@ function buildFileShowReport(root, command) {
 `)
   };
 }
+async function buildFileShowReportAsync(root, command) {
+  const res = await readShowTextAsync(root, command);
+  if (res.code !== 0) {
+    const detail = res.stderr.trim() || `git show exited with code ${res.code}`;
+    return {
+      path: command.path,
+      ref: command.ref,
+      ...command.start !== undefined ? { start: command.start } : {},
+      ...command.end !== undefined ? { end: command.end } : {},
+      totalLines: 0,
+      complete: false,
+      text: "",
+      error: detail
+    };
+  }
+  const sliced = sliceLines(res.stdout, command.start, command.end);
+  return {
+    path: command.path,
+    ref: command.ref,
+    ...command.start !== undefined ? { start: command.start } : {},
+    ...command.end !== undefined ? { end: command.end } : {},
+    totalLines: sliced.total,
+    complete: sliced.complete,
+    text: sliced.lines.join(`
+`)
+  };
+}
 function runShow(root, command) {
   const report = buildFileShowReport(root, command);
   if (report.error !== undefined) {
@@ -3920,6 +4605,64 @@ function buildFileDiffReport(root, command) {
     ...errText ? { error: errText } : {}
   };
 }
+async function buildFileDiffReportAsync(root, command) {
+  const base = {
+    path: command.path,
+    ...command.oldPath !== undefined ? { old_path: command.oldPath } : {},
+    from: command.untracked ? "/dev/null" : command.from,
+    to: command.to,
+    untracked: command.untracked,
+    ignore_ws: command.ignoreWs,
+    ignore_blank: command.ignoreBlank,
+    mode: command.mode,
+    max_hunks: command.mode === "preview" ? command.maxHunks : null,
+    max_lines: command.mode === "preview" ? command.maxLines : null,
+    diff: "",
+    hunk_count: 0,
+    rendered_hunk_count: 0,
+    line_count: 0,
+    truncated: false,
+    binary: false
+  };
+  if (!command.untracked && isSameWorktreeRange({ from: command.from, to: command.to })) {
+    return base;
+  }
+  const extras = [];
+  if (command.ignoreWs)
+    extras.push("-w");
+  if (command.ignoreBlank)
+    extras.push("--ignore-blank-lines");
+  let diffText = "";
+  let errText = "";
+  if (command.untracked) {
+    const res = await untrackedFileDiffAsync(extras, command.path, root);
+    diffText = res.stdout || "";
+    if (res.code !== 0)
+      errText = res.stderr.trim();
+  } else {
+    const args = [
+      ...extras,
+      ...buildFileDiffRangeArgs(command.from, command.to)
+    ];
+    const paths = command.oldPath !== undefined ? [command.oldPath, command.path] : command.path;
+    const res = await fileDiffTextAsync(args, paths, root);
+    diffText = res.stdout || "";
+    if (res.code !== 0)
+      errText = res.stderr.trim();
+  }
+  const truncated = command.mode === "preview" ? truncateToNHunks(diffText, command.maxHunks, command.maxLines) : truncateToNHunks(diffText, 1e9);
+  const previewTruncated = command.mode === "preview" && (truncated.totalHunks > truncated.renderedHunks || truncated.lineTruncated);
+  return {
+    ...base,
+    diff: truncated.text,
+    hunk_count: truncated.totalHunks,
+    rendered_hunk_count: truncated.renderedHunks,
+    line_count: truncated.lineCount,
+    truncated: previewTruncated,
+    binary: diffText.includes("Binary files"),
+    ...errText ? { error: errText } : {}
+  };
+}
 function runDiff(root, command) {
   const report = buildFileDiffReport(root, command);
   if (command.json) {
@@ -4406,8 +5149,8 @@ function buildGithubIssueViewArgs(options) {
     args.push("--repo", repo);
   return args;
 }
-function readGithubIssueList(options) {
-  const proc = runSync(buildGithubIssueListArgs(options), options.cwd, {
+async function readGithubIssueListAsync(options) {
+  const proc = await runAsync(buildGithubIssueListArgs(options), options.cwd, {
     timeout: 30000
   });
   if (proc.code !== 0) {
@@ -4420,8 +5163,8 @@ function readGithubIssueList(options) {
     throw new GithubIssueListError("failed to parse gh issue list output");
   }
 }
-function readGithubIssue(options) {
-  const proc = runSync(buildGithubIssueViewArgs(options), options.cwd, {
+async function readGithubIssueAsync(options) {
+  const proc = await runAsync(buildGithubIssueViewArgs(options), options.cwd, {
     timeout: 30000
   });
   if (proc.code !== 0) {
@@ -5075,7 +5818,7 @@ async function runJournalCli(argv) {
       console.error(commandConfig.error);
       process.exit(1);
     }
-    const issues = readGithubIssueList({
+    const issues = await readGithubIssueListAsync({
       cwd: root,
       repo: command.repo,
       labels: command.ghLabels,
@@ -5099,7 +5842,7 @@ async function runJournalCli(argv) {
       console.error(commandConfig.error);
       process.exit(1);
     }
-    const issue = readGithubIssue({
+    const issue = await readGithubIssueAsync({
       cwd: root,
       number: command.issueNumber,
       repo: command.repo
@@ -7839,11 +8582,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 +8725,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 +8846,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 +14136,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 +14151,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 {
@@ -13449,15 +14277,26 @@ function validateDbPath(cwd, dbPath) {
     return null;
   return realFull;
 }
-function serviceListIncludesS3(value) {
+function serviceListIncludesAwsService(value, service) {
   if (value === undefined || value.trim() === "")
     return true;
-  return value.split(/[,\s]+/).map((part) => part.trim().toLowerCase()).filter(Boolean).includes("s3");
+  return value.split(/[,\s]+/).map((part) => part.trim().toLowerCase()).filter(Boolean).includes(service);
+}
+function detectAwsKindsFromServices(services) {
+  const kinds = [];
+  if (serviceListIncludesAwsService(services, "s3"))
+    kinds.push("s3");
+  if (serviceListIncludesAwsService(services, "dynamodb"))
+    kinds.push("dynamodb");
+  return kinds;
+}
+function isLocalstackImage(image) {
+  return !!image && image.toLowerCase().includes("localstack/localstack");
 }
 function imageLooksLikeMinio(image) {
   return /(^|\/)minio(?::|\/|$)/.test(image.toLowerCase());
 }
-function detectDbKind(image, env = {}) {
+function detectDbKind(image, _env = {}) {
   const lower = image.toLowerCase();
   if (lower.includes("postgres"))
     return "postgresql";
@@ -13469,9 +14308,6 @@ function detectDbKind(image, env = {}) {
     return "elasticsearch";
   if (imageLooksLikeMinio(lower))
     return "s3";
-  if (lower.includes("localstack/localstack")) {
-    return serviceListIncludesS3(env.SERVICES) ? "s3" : null;
-  }
   return null;
 }
 function detectDbKindFromEnv(env) {
@@ -13484,10 +14320,33 @@ function detectDbKindFromEnv(env) {
   if (env.MINIO_ROOT_USER || env.MINIO_ROOT_PASSWORD || env.MINIO_ACCESS_KEY || env.MINIO_SECRET_KEY) {
     return "s3";
   }
-  if (env.SERVICES && serviceListIncludesS3(env.SERVICES))
-    return "s3";
   return null;
 }
+function detectDbKindsForService(image, env, containerPort, serviceName) {
+  if (isLocalstackImage(image) || env.SERVICES !== undefined) {
+    return detectAwsKindsFromServices(env.SERVICES);
+  }
+  const single = (image ? detectDbKind(image, env) : null) ?? detectDbKindFromEnv(env) ?? detectDbKindFromContainerPort(containerPort) ?? detectDbKindFromServiceName(serviceName);
+  return single ? [single] : [];
+}
+function dbKindDisplayName(kind) {
+  switch (kind) {
+    case "s3":
+      return "S3";
+    case "dynamodb":
+      return "DynamoDB";
+    case "redis":
+      return "Redis";
+    case "elasticsearch":
+      return "Elasticsearch";
+    case "postgresql":
+      return "PostgreSQL";
+    case "mysql":
+      return "MySQL";
+    case "sqlite":
+      return "SQLite";
+  }
+}
 function detectDbKindFromContainerPort(port) {
   switch (port) {
     case "3306":
@@ -13532,8 +14391,10 @@ function defaultPortFor(kind, image, env = {}) {
       return "9200";
     case "s3": {
       const lower = image?.toLowerCase() || "";
-      return lower.includes("localstack/localstack") || env.SERVICES !== undefined && serviceListIncludesS3(env.SERVICES) ? "4566" : "9000";
+      return lower.includes("localstack/localstack") || env.SERVICES !== undefined && serviceListIncludesAwsService(env.SERVICES, "s3") ? "4566" : "9000";
     }
+    case "dynamodb":
+      return "4566";
     default:
       return "";
   }
@@ -13620,7 +14481,7 @@ function parseComposePortMappings(serviceBlock, composeDirEnv = {}) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("-"))
       continue;
-    const value = resolveEnvValue(trimmed.slice(1).trim().replace(/^["']|["']$/g, "").split(/\s+#/)[0].split("/")[0].trim(), composeDirEnv);
+    const value = resolveEnvValue(trimmed.slice(1).trim(), composeDirEnv).split("/")[0].trim();
     if (!value || value.includes("target:"))
       continue;
     const parts = value.split(":");
@@ -13705,40 +14566,45 @@ function parseComposeContent(content, filepath, composeDir, cwd, composeDirEnv,
     const env = parseComposeEnv(svcBlock, composeDirEnv);
     const containerPort = parseComposeContainerPort(svcBlock);
     const profiled = /^\s+profiles:/m.test(svcBlock);
-    const kind = (image ? detectDbKind(image, env) : null) ?? detectDbKindFromEnv(env) ?? detectDbKindFromContainerPort(containerPort) ?? detectDbKindFromServiceName(svc.name);
-    if (!kind)
-      continue;
-    const defaultPort = defaultPortFor(kind, image, env);
-    const serviceContainerPort = kind === "s3" ? defaultPort : containerPort || defaultPort;
-    const publishedHostPort = parseComposeHostPortForContainer(svcBlock, serviceContainerPort, composeDirEnv) || parseComposeHostPortForContainer(svcBlock, defaultPort, composeDirEnv) || parseComposePorts(svcBlock, composeDirEnv);
-    const hostPort = kind === "s3" ? publishedHostPort || undefined : publishedHostPort || defaultPort;
-    const imageLabel = image ?? `build:${kind}`;
-    const id = isRoot ? `docker:${svc.name}` : `docker:${svc.name}@${encodeURIComponent(relDirSlash)}`;
-    const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
-    let label;
-    if (kind === "redis" || kind === "elasticsearch" || kind === "s3") {
-      const endpointLabel = hostPort ? `localhost:${hostPort}` : `container:${serviceContainerPort}`;
-      label = `${svc.name} (${imageLabel}, ${endpointLabel}${labelPath})`;
-    } else {
-      const dbName = env.POSTGRES_DB || env.MYSQL_DATABASE || env.MARIADB_DATABASE || svc.name;
-      const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
-      label = `${svc.name} (${imageLabel}, ${user}@localhost:${hostPort}/${dbName}${labelPath})`;
+    const kinds = detectDbKindsForService(image, env, containerPort, svc.name);
+    const isMultiKind = kinds.length > 1;
+    for (const kind of kinds) {
+      if (results.length >= MAX_DOCKER_SERVICES)
+        return;
+      const defaultPort = defaultPortFor(kind, image, env);
+      const serviceContainerPort = kind === "s3" || kind === "dynamodb" ? defaultPort : containerPort || defaultPort;
+      const publishedHostPort = parseComposeHostPortForContainer(svcBlock, serviceContainerPort, composeDirEnv) || parseComposeHostPortForContainer(svcBlock, defaultPort, composeDirEnv) || parseComposePorts(svcBlock, composeDirEnv);
+      const hostPort = kind === "s3" || kind === "dynamodb" ? publishedHostPort || undefined : publishedHostPort || defaultPort;
+      const imageLabel = image ?? `build:${kind}`;
+      const kindSuffix = isMultiKind ? `#${kind}` : "";
+      const id = isRoot ? `docker:${svc.name}${kindSuffix}` : `docker:${svc.name}@${encodeURIComponent(relDirSlash)}${kindSuffix}`;
+      const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
+      let label;
+      if (kind === "redis" || kind === "elasticsearch" || kind === "s3" || kind === "dynamodb") {
+        const endpointLabel = hostPort ? `localhost:${hostPort}` : `container:${serviceContainerPort}`;
+        const svcLabel = isMultiKind ? `${svc.name} / ${dbKindDisplayName(kind)}` : svc.name;
+        label = `${svcLabel} (${imageLabel}, ${endpointLabel}${labelPath})`;
+      } else {
+        const dbName = env.POSTGRES_DB || env.MYSQL_DATABASE || env.MARIADB_DATABASE || svc.name;
+        const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
+        label = `${svc.name} (${imageLabel}, ${user}@localhost:${hostPort}/${dbName}${labelPath})`;
+      }
+      results.push({
+        id,
+        path: isRoot ? filename : `${relDirSlash}/${filename}`,
+        name: label,
+        sizeBytes: 0,
+        kind,
+        serviceName: svc.name,
+        ...image ? { image } : {},
+        env,
+        composeDir,
+        relDirSlash,
+        ...hostPort ? { hostPort } : {},
+        containerPort: serviceContainerPort,
+        ...profiled ? { profiled: true } : {}
+      });
     }
-    results.push({
-      id,
-      path: isRoot ? filename : `${relDirSlash}/${filename}`,
-      name: label,
-      sizeBytes: 0,
-      kind,
-      serviceName: svc.name,
-      ...image ? { image } : {},
-      env,
-      composeDir,
-      relDirSlash,
-      ...hostPort ? { hostPort } : {},
-      containerPort: serviceContainerPort,
-      ...profiled ? { profiled: true } : {}
-    });
   }
 }
 async function parseComposeFileAsync(filepath, composeDir, cwd, results) {
@@ -13836,12 +14702,24 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   });
   return cloneDockerDiscoveryResult(results);
 }
+function isDbKind(value) {
+  return DB_KIND_VALUES.has(value);
+}
 function parseDockerDbId(dbId) {
   if (!dbId.startsWith("docker:"))
     return null;
   let rest = dbId.slice(7);
   if (!rest)
     return null;
+  let kind;
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx >= 0) {
+    const kindPart = rest.slice(hashIdx + 1);
+    if (!isDbKind(kindPart))
+      return null;
+    kind = kindPart;
+    rest = rest.slice(0, hashIdx);
+  }
   let database;
   const atIdx = rest.indexOf("@");
   if (atIdx >= 0) {
@@ -13865,7 +14743,8 @@ function parseDockerDbId(dbId) {
       return {
         serviceName,
         relDir,
-        database
+        database,
+        kind
       };
     } catch {
       return null;
@@ -13880,23 +14759,27 @@ function parseDockerDbId(dbId) {
     return null;
   if (!isSafeDockerDatabaseName(database))
     return null;
-  return { serviceName: rest, relDir: "", database };
+  return { serviceName: rest, relDir: "", database, kind };
 }
 function canonicalizeDockerDbId(dbId) {
   const parsed = parseDockerDbId(dbId);
   if (!parsed)
     return null;
   const database = parsed.database ? `:${parsed.database}` : "";
+  const kindSuffix = parsed.kind ? `#${parsed.kind}` : "";
   if (!parsed.relDir)
-    return `docker:${parsed.serviceName}${database}`;
-  return `docker:${parsed.serviceName}@${encodeURIComponent(parsed.relDir)}${database}`;
+    return `docker:${parsed.serviceName}${database}${kindSuffix}`;
+  return `docker:${parsed.serviceName}@${encodeURIComponent(parsed.relDir)}${database}${kindSuffix}`;
 }
 async function findDockerServiceByDbIdAsync(cwd, dbId, kind, omitDirNames, signal) {
   const parsed = parseDockerDbId(dbId);
   if (!parsed)
     return null;
+  if (kind && parsed.kind && parsed.kind !== kind)
+    return null;
+  const effectiveKind = parsed.kind ?? kind;
   const services = await discoverDockerDatabasesAsync(cwd, omitDirNames, signal);
-  return services.find((d) => d.serviceName === parsed.serviceName && d.relDirSlash === parsed.relDir && (!kind || d.kind === kind)) || null;
+  return services.find((d) => d.serviceName === parsed.serviceName && d.relDirSlash === parsed.relDir && (!effectiveKind || d.kind === effectiveKind)) || null;
 }
 function isSafeDockerServiceName(value) {
   return /^[A-Za-z0-9_-]+$/.test(value);
@@ -14031,7 +14914,7 @@ async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal
   const projects = await discoverSupabaseCliProjectsAsync(cwd, omitDirNames, signal);
   return projects.find((p) => p.projectId === parsed.projectId && p.relDirSlash === parsed.relDir) || null;
 }
-var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
+var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, DB_KIND_VALUES, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
 var init_discovery = __esm(() => {
   SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3", ".s3db"]);
   sqliteDiscoveryCache = new Map;
@@ -14042,6 +14925,15 @@ var init_discovery = __esm(() => {
     "compose.yaml"
   ];
   dockerDiscoveryCache = new Map;
+  DB_KIND_VALUES = new Set([
+    "sqlite",
+    "postgresql",
+    "mysql",
+    "redis",
+    "elasticsearch",
+    "s3",
+    "dynamodb"
+  ]);
   supabaseDiscoveryCache = new Map;
 });
 
@@ -15024,19 +15916,481 @@ async function searchTableAsync(adapter, table, columns, term, maxHits, includeN
           rowPreview: serializeDbRow(row)
         });
       }
-    } catch (err) {
-      if (isAbortLikeError(err, signal))
-        throw err;
-    }
+    } catch (err) {
+      if (isAbortLikeError(err, signal))
+        throw err;
+    }
+  }
+  return hits;
+}
+function getPrimaryKeyColumnsFromColumns(columns) {
+  return columns.filter((c) => c.primaryKey).map((c) => c.name);
+}
+var init_global_search = __esm(() => {
+  init_serialize();
+  init_sql_utils();
+});
+
+// web-src/server/database/adapters/dynamodb.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash5, createHmac as createHmac2 } from "node:crypto";
+function createDynamoDbRequestDeadline() {
+  const timeoutMs = dynamoDbRequestTimeoutMs;
+  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
+}
+function createDynamoDbDockerCurlDeadline() {
+  const timeoutMs = dynamoDbDockerCurlTimeoutMs;
+  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
+}
+function createDynamoDbTransportDeadline(config) {
+  return config.dockerContainerName ? createDynamoDbDockerCurlDeadline() : createDynamoDbRequestDeadline();
+}
+function dynamoDbTimeoutError(deadline) {
+  return new DynamoDbHttpError(503, `DynamoDB request timed out after ${deadline?.timeoutMs ?? dynamoDbRequestTimeoutMs}ms`);
+}
+function remainingDynamoDbTimeoutMs(deadline) {
+  if (!deadline)
+    return dynamoDbRequestTimeoutMs;
+  return Math.max(0, deadline.expiresAt - Date.now());
+}
+function hmac2(key, value) {
+  return createHmac2("sha256", key).update(value, "utf8").digest();
+}
+function sha2562(value) {
+  return createHash5("sha256").update(value, "utf8").digest("hex");
+}
+function amzDate2(date = new Date) {
+  const iso = date.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  return { dateStamp: iso.slice(0, 8), amzDate: iso };
+}
+function signingKey2(secret, dateStamp, region) {
+  const kDate = hmac2(`AWS4${secret}`, dateStamp);
+  const kRegion = hmac2(kDate, region);
+  const kService = hmac2(kRegion, "dynamodb");
+  return hmac2(kService, "aws4_request");
+}
+function compareCodeUnit2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function signedHeadersString2(headers) {
+  return Object.keys(headers).map((key) => key.toLowerCase()).sort(compareCodeUnit2).join(";");
+}
+function canonicalHeaders2(headers) {
+  return Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value.trim().replace(/\s+/g, " ")]).sort(([a], [b]) => compareCodeUnit2(a, b)).map(([key, value]) => `${key}:${value}
+`).join("");
+}
+function splitCurlHeadersAndBody2(bytes) {
+  const buffer = Buffer.from(bytes);
+  let idx = buffer.indexOf(`\r
+\r
+`);
+  let sepLen = 4;
+  if (idx < 0) {
+    idx = buffer.indexOf(`
+
+`);
+    sepLen = 2;
+  }
+  if (idx < 0)
+    return { headerText: "", body: bytes };
+  return {
+    headerText: buffer.subarray(0, idx).toString("utf8"),
+    body: new Uint8Array(buffer.subarray(idx + sepLen))
+  };
+}
+function responseFromCurlOutput2(bytes) {
+  const { headerText, body } = splitCurlHeadersAndBody2(bytes);
+  const headerBlocks = headerText.split(/\r?\n\r?\n/).map((block2) => block2.trim()).filter(Boolean);
+  const block = headerBlocks[headerBlocks.length - 1] || "";
+  const lines = block.split(/\r?\n/).filter(Boolean);
+  const statusMatch = lines[0]?.match(/^HTTP\/\S+\s+(\d+)/i);
+  const status = statusMatch ? Number(statusMatch[1]) : 502;
+  const headers = new Headers;
+  for (const line of lines.slice(1)) {
+    const idx = line.indexOf(":");
+    if (idx <= 0)
+      continue;
+    headers.append(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+  }
+  const arrayBuffer = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+  return new Response(arrayBuffer, { status, headers });
+}
+function curlConfigQuote2(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/[\r\n]+/g, " ")}"`;
+}
+function curlHeaderConfig2(headers) {
+  const lines = [];
+  headers.forEach((value, key) => {
+    lines.push(`header = ${curlConfigQuote2(`${key}: ${value}`)}`);
+  });
+  return `${lines.join(`
+`)}
+`;
+}
+function dockerCurlCommand2(opts) {
+  const shellScript = [
+    "set -eu",
+    'headers_file="$(mktemp)"',
+    'body_file="$(mktemp)"',
+    `trap 'rm -f "$headers_file" "$body_file"' EXIT`,
+    `while IFS= read -r line; do [ "$line" = "${DOCKER_CURL_BODY_MARKER}" ] && break; printf '%s\\n' "$line" >> "$headers_file"; done`,
+    'cat > "$body_file"',
+    `curl -sS -X POST -D - -o - -K "$headers_file" --data-binary "@$body_file" ${curlConfigQuote2(opts.url)}`
+  ].join(`
+`);
+  return {
+    args: ["exec", "-i", opts.containerName, "sh", "-c", shellScript],
+    input: Buffer.from(`${curlHeaderConfig2(opts.headers)}${DOCKER_CURL_BODY_MARKER}
+${opts.body}`, "utf8")
+  };
+}
+function guardedDynamoDbTransport(signal, operation, deadline) {
+  if (signal?.aborted) {
+    return Promise.reject(new DynamoDbHttpError(503, "DynamoDB HTTP transport aborted"));
+  }
+  const timeoutMs = remainingDynamoDbTimeoutMs(deadline);
+  if (timeoutMs <= 0)
+    return Promise.reject(dynamoDbTimeoutError(deadline));
+  const controller = new AbortController;
+  let timedOut = false;
+  let settled = false;
+  let timer;
+  let cleanupParent = () => {
+    return;
+  };
+  const abort = (err, reject) => {
+    if (settled)
+      return;
+    settled = true;
+    controller.abort(err);
+    reject(err);
+  };
+  const guarded = new Promise((resolve2, reject) => {
+    const onParentAbort = () => abort(new DynamoDbHttpError(503, "DynamoDB HTTP transport aborted"), reject);
+    if (signal) {
+      signal.addEventListener("abort", onParentAbort, { once: true });
+      cleanupParent = () => signal.removeEventListener("abort", onParentAbort);
+    }
+    timer = setTimeout(() => {
+      timedOut = true;
+      abort(dynamoDbTimeoutError(deadline), reject);
+    }, timeoutMs);
+    operation(controller.signal).then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve2(value);
+    }, (err) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timedOut) {
+        reject(dynamoDbTimeoutError(deadline));
+      } else if (signal?.aborted) {
+        reject(new DynamoDbHttpError(503, "DynamoDB HTTP transport aborted"));
+      } else {
+        reject(err);
+      }
+    });
+  });
+  return guarded.finally(() => {
+    if (timer)
+      clearTimeout(timer);
+    cleanupParent();
+  });
+}
+async function readStreamChunkWithTimeout2(reader, signal, deadline) {
+  return guardedDynamoDbTransport(signal, (transportSignal) => {
+    const cancelRead = () => {
+      reader.cancel(transportSignal.reason).catch(() => {
+        return;
+      });
+    };
+    if (transportSignal.aborted) {
+      cancelRead();
+    } else {
+      transportSignal.addEventListener("abort", cancelRead, { once: true });
+    }
+    return reader.read().finally(() => {
+      transportSignal.removeEventListener("abort", cancelRead);
+    });
+  }, deadline);
+}
+async function readResponseBytesWithTimeout2(res, signal, deadline) {
+  if (!res.body)
+    return new Uint8Array;
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await readStreamChunkWithTimeout2(reader, signal, deadline);
+      if (done)
+        break;
+      if (!value?.byteLength)
+        continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+  if (chunks.length === 1)
+    return chunks[0];
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function readResponseTextWithTimeout2(res, signal, deadline) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(await readResponseBytesWithTimeout2(res, signal, deadline));
+}
+async function dockerCurlFetch2(opts) {
+  const { args, input } = dockerCurlCommand2(opts);
+  if (spawnSyncImplIsTestOverride2) {
+    const proc2 = spawnSyncImpl4(dockerCommand(), args, {
+      encoding: "buffer",
+      input,
+      timeout: dynamoDbDockerCurlTimeoutMs,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if ((proc2.status ?? 1) !== 0) {
+      const stderr = new TextDecoder().decode(proc2.stderr || new Uint8Array).concat(proc2.error ? `
+${proc2.error.message}` : "").replace(/\s+/g, " ").trim();
+      throwIfDockerCommandUnavailableResult({
+        code: proc2.status ?? 1,
+        stderr
+      });
+      throw new DynamoDbHttpError(503, `DynamoDB HTTP transport failed via docker exec${stderr ? `: ${stderr.slice(0, 240)}` : ""}`);
+    }
+    return responseFromCurlOutput2(new Uint8Array(proc2.stdout || new Uint8Array));
+  }
+  if (opts.signal?.aborted) {
+    throw new DynamoDbHttpError(503, "DynamoDB HTTP transport aborted");
+  }
+  const proc = await spawnCollectAsync({
+    command: dockerCommand(),
+    args,
+    input,
+    timeoutMs: dynamoDbDockerCurlTimeoutMs,
+    signal: opts.signal,
+    abortMessage: "DynamoDB HTTP transport aborted",
+    timeoutMessage: `docker exec curl timed out after ${dynamoDbDockerCurlTimeoutMs}ms`,
+    rejectOnError: false
+  });
+  if (proc.code !== 0) {
+    const stderr = new TextDecoder().decode(proc.stderr).replace(/\s+/g, " ").trim();
+    throwIfDockerCommandUnavailableResult({ code: proc.code, stderr });
+    throw new DynamoDbHttpError(503, `DynamoDB HTTP transport failed via docker exec${stderr ? `: ${stderr.slice(0, 240)}` : ""}`);
+  }
+  return responseFromCurlOutput2(new Uint8Array(proc.stdout));
+}
+function sanitizeDynamoDbError(status, text) {
+  let message = "";
+  try {
+    const parsed = JSON.parse(text);
+    const type = typeof parsed.__type === "string" ? parsed.__type.split("#").pop() || parsed.__type : "";
+    const bodyMessage = typeof parsed.message === "string" ? parsed.message : typeof parsed.Message === "string" ? parsed.Message : "";
+    message = [type, bodyMessage].filter(Boolean).join(": ");
+  } catch {
+    message = text.replace(/\s+/g, " ").trim().slice(0, 240);
+  }
+  return new DynamoDbHttpError(status, `DynamoDB HTTP ${status}: ${message || "request failed"}`);
+}
+function assertTableName(tableName) {
+  if (!/^[A-Za-z0-9_.-]{3,255}$/.test(tableName)) {
+    throw new Error("invalid DynamoDB table name");
+  }
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function createDynamoDbAdapter(config) {
+  async function signedJsonRequest(action, body, signal, deadline = createDynamoDbTransportDeadline(config)) {
+    const requestBody = JSON.stringify(body);
+    const res = await guardedDynamoDbTransport(signal, (transportSignal) => {
+      const endpoint = new URL(config.endpoint);
+      const { dateStamp, amzDate: requestDate } = amzDate2();
+      const payloadHash = requestBody ? sha2562(requestBody) : EMPTY_SHA2562;
+      const headers = {
+        "content-type": DYNAMODB_JSON_CONTENT_TYPE,
+        host: endpoint.host,
+        "x-amz-content-sha256": payloadHash,
+        "x-amz-date": requestDate,
+        "x-amz-target": `DynamoDB_20120810.${action}`,
+        ...config.sessionToken ? { "x-amz-security-token": config.sessionToken } : {}
+      };
+      const signedNames = signedHeadersString2(headers);
+      const canonicalRequest = [
+        "POST",
+        "/",
+        "",
+        canonicalHeaders2(headers),
+        signedNames,
+        payloadHash
+      ].join(`
+`);
+      const scope = `${dateStamp}/${config.region}/dynamodb/aws4_request`;
+      const stringToSign = [
+        "AWS4-HMAC-SHA256",
+        requestDate,
+        scope,
+        sha2562(canonicalRequest)
+      ].join(`
+`);
+      const signature = createHmac2("sha256", signingKey2(config.secretAccessKey, dateStamp, config.region)).update(stringToSign, "utf8").digest("hex");
+      const requestHeaders = new Headers;
+      for (const [key, value] of Object.entries(headers)) {
+        if (key !== "host")
+          requestHeaders.set(key, value);
+      }
+      requestHeaders.set("Authorization", `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${scope}, SignedHeaders=${signedNames}, Signature=${signature}`);
+      const url = `${config.endpoint.replace(/\/$/, "")}/`;
+      if (config.dockerContainerName) {
+        return dockerCurlFetch2({
+          containerName: config.dockerContainerName,
+          url,
+          headers: requestHeaders,
+          body: requestBody,
+          signal: transportSignal
+        });
+      }
+      return fetch(url, {
+        method: "POST",
+        headers: requestHeaders,
+        body: requestBody,
+        signal: transportSignal
+      });
+    }, deadline);
+    const text = await readResponseTextWithTimeout2(res, signal, deadline);
+    if (!res.ok)
+      throw sanitizeDynamoDbError(res.status, text);
+    return text ? JSON.parse(text) : {};
   }
-  return hits;
+  async function listTablesAsync(opts) {
+    const body = {
+      ...opts?.limit ? { Limit: Math.min(100, Math.max(1, opts.limit)) } : {},
+      ...opts?.exclusiveStartTableName ? { ExclusiveStartTableName: opts.exclusiveStartTableName } : {}
+    };
+    const raw = await signedJsonRequest("ListTables", body, opts?.signal);
+    return {
+      tableNames: asStringArray(raw.TableNames),
+      ...typeof raw.LastEvaluatedTableName === "string" ? { lastEvaluatedTableName: raw.LastEvaluatedTableName } : {}
+    };
+  }
+  async function describeTableAsync(tableName, signal) {
+    assertTableName(tableName);
+    const raw = await signedJsonRequest("DescribeTable", { TableName: tableName }, signal);
+    return asObject(raw.Table);
+  }
+  async function scanAsync(opts) {
+    assertTableName(opts.tableName);
+    const raw = await signedJsonRequest("Scan", {
+      TableName: opts.tableName,
+      ...opts.limit ? { Limit: Math.min(1000, Math.max(1, opts.limit)) } : {},
+      ...opts.exclusiveStartKey ? { ExclusiveStartKey: opts.exclusiveStartKey } : {},
+      ...opts.indexName ? { IndexName: opts.indexName } : {},
+      ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
+      ...opts.filterExpression ? { FilterExpression: opts.filterExpression } : {},
+      ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
+      ...opts.expressionAttributeValues ? { ExpressionAttributeValues: opts.expressionAttributeValues } : {}
+    }, opts.signal);
+    return {
+      items: Array.isArray(raw.Items) ? raw.Items : [],
+      count: asNumber(raw.Count),
+      scannedCount: asNumber(raw.ScannedCount),
+      ...raw.LastEvaluatedKey ? { lastEvaluatedKey: asObject(raw.LastEvaluatedKey) } : {}
+    };
+  }
+  async function queryAsync(opts) {
+    assertTableName(opts.tableName);
+    const raw = await signedJsonRequest("Query", {
+      TableName: opts.tableName,
+      KeyConditionExpression: opts.keyConditionExpression,
+      ...opts.limit ? { Limit: Math.min(1000, Math.max(1, opts.limit)) } : {},
+      ...opts.exclusiveStartKey ? { ExclusiveStartKey: opts.exclusiveStartKey } : {},
+      ...opts.indexName ? { IndexName: opts.indexName } : {},
+      ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
+      ...opts.filterExpression ? { FilterExpression: opts.filterExpression } : {},
+      ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
+      ...opts.expressionAttributeValues ? { ExpressionAttributeValues: opts.expressionAttributeValues } : {},
+      ...opts.scanIndexForward !== undefined ? { ScanIndexForward: opts.scanIndexForward } : {}
+    }, opts.signal);
+    return {
+      items: Array.isArray(raw.Items) ? raw.Items : [],
+      count: asNumber(raw.Count),
+      scannedCount: asNumber(raw.ScannedCount),
+      ...raw.LastEvaluatedKey ? { lastEvaluatedKey: asObject(raw.LastEvaluatedKey) } : {}
+    };
+  }
+  async function getItemAsync(opts) {
+    assertTableName(opts.tableName);
+    const raw = await signedJsonRequest("GetItem", {
+      TableName: opts.tableName,
+      Key: opts.key,
+      ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
+      ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
+      ...opts.consistentRead !== undefined ? { ConsistentRead: opts.consistentRead } : {}
+    }, opts.signal);
+    return {
+      ...raw.Item ? { item: asObject(raw.Item) } : {},
+      ...raw.ConsumedCapacity ? { consumedCapacity: raw.ConsumedCapacity } : {}
+    };
+  }
+  return {
+    kind: "dynamodb",
+    model: "document",
+    close() {},
+    listTablesAsync,
+    describeTableAsync,
+    scanAsync,
+    queryAsync,
+    getItemAsync
+  };
 }
-function getPrimaryKeyColumnsFromColumns(columns) {
-  return columns.filter((c) => c.primaryKey).map((c) => c.name);
+async function dynamoDbConfigFromDockerInfoAsync(info, signal) {
+  const env = info.env;
+  const dockerContainerName = info.hostPort ? undefined : await resolveRunningComposeContainerNameOrThrowAsync(info.serviceName, info.composeDir, signal);
+  return {
+    endpoint: info.hostPort ? `http://localhost:${info.hostPort}` : `http://127.0.0.1:${info.containerPort}`,
+    ...dockerContainerName ? { dockerContainerName } : {},
+    region: env.AWS_REGION || env.AWS_DEFAULT_REGION || "us-east-1",
+    accessKeyId: env.AWS_ACCESS_KEY_ID || "test",
+    secretAccessKey: env.AWS_SECRET_ACCESS_KEY || "test",
+    ...env.AWS_SESSION_TOKEN ? { sessionToken: env.AWS_SESSION_TOKEN } : {}
+  };
 }
-var init_global_search = __esm(() => {
-  init_serialize();
-  init_sql_utils();
+async function openDynamoDbExplorerAsync(info, signal) {
+  return createDynamoDbAdapter(await dynamoDbConfigFromDockerInfoAsync(info, signal));
+}
+function isDynamoDbHttpError(err) {
+  return err instanceof DynamoDbHttpError;
+}
+var spawnSyncImpl4, spawnSyncImplIsTestOverride2 = false, DynamoDbHttpError, EMPTY_SHA2562 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", DEFAULT_DYNAMODB_REQUEST_TIMEOUT_MS = 5000, DEFAULT_DYNAMODB_DOCKER_CURL_TIMEOUT_MS = 30000, DYNAMODB_JSON_CONTENT_TYPE = "application/x-amz-json-1.0", DOCKER_CURL_BODY_MARKER = "__CODE_VIEWER_DYNAMODB_BODY__", dynamoDbRequestTimeoutMs, dynamoDbDockerCurlTimeoutMs;
+var init_dynamodb = __esm(() => {
+  init_docker_utils();
+  init_spawn_runner();
+  spawnSyncImpl4 = spawnSync5;
+  DynamoDbHttpError = class DynamoDbHttpError extends Error {
+    status;
+    constructor(status, message) {
+      super(message);
+      this.status = status;
+    }
+  };
+  dynamoDbRequestTimeoutMs = DEFAULT_DYNAMODB_REQUEST_TIMEOUT_MS;
+  dynamoDbDockerCurlTimeoutMs = DEFAULT_DYNAMODB_DOCKER_CURL_TIMEOUT_MS;
 });
 
 // web-src/server/database/handle-shared.ts
@@ -15339,6 +16693,247 @@ var init_handle_shared = __esm(() => {
   logQueue = Promise.resolve();
 });
 
+// web-src/server/database/handle-dynamodb.ts
+var exports_handle_dynamodb = {};
+__export(exports_handle_dynamodb, {
+  handleDynamoDbRoute: () => handleDynamoDbRoute,
+  closeDynamoDbAdapter: () => closeDynamoDbAdapter
+});
+function closeDynamoDbAdapter(dbId) {
+  dynamoDbAdapterCache.close(dbId);
+}
+function resolveDynamoDb(cwd, dbParam, signal, omitDirNames) {
+  return resolveDockerExplorerAsync(cwd, dbParam, "dynamodb", dynamoDbAdapterCache, (info) => openDynamoDbExplorerAsync(info), omitDirNames, signal);
+}
+function dynamoDbErrorResponse(err, action, signal) {
+  if (isAbortLikeError(err, signal)) {
+    return handleError("dynamodb", action, err, signal);
+  }
+  if (isDynamoDbHttpError(err))
+    return textError(err.message, err.status);
+  return handleError("dynamodb", action, err, signal);
+}
+function validateTableName(value) {
+  if (!value)
+    return textError("missing table parameter", 400);
+  if (value.length < 3 || value.length > MAX_TABLE_NAME_LEN || hasControlCharacter(value) || !/^[A-Za-z0-9_.-]+$/.test(value)) {
+    return textError("invalid table parameter", 400);
+  }
+  return value;
+}
+function validateOptionalText(value, name, maxLen = MAX_EXPRESSION_LEN) {
+  if (value === null || value === "")
+    return;
+  if (value.length > maxLen || hasControlCharacter(value)) {
+    return textError(`invalid ${name} parameter`, 400);
+  }
+  return value;
+}
+function parseLimit2(url, param, defaultValue) {
+  const raw = Number(url.searchParams.get(param) || defaultValue);
+  return Math.min(param === "limit" ? MAX_ITEMS_LIMIT : MAX_TABLES_LIMIT, Math.max(1, Number.isFinite(raw) ? raw : defaultValue));
+}
+function parseJsonParam(value, name) {
+  if (value === null || value === "")
+    return;
+  if (value.length > MAX_JSON_PARAM_LEN || hasControlCharacter(value)) {
+    return textError(`invalid ${name} parameter`, 400);
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return textError(`invalid ${name} parameter`, 400);
+  }
+}
+function parseKey(value, name) {
+  const parsed = parseJsonParam(value, name);
+  if (parsed instanceof Response)
+    return parsed;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return textError(`missing ${name} parameter`, 400);
+  }
+  return parsed;
+}
+function parseExpressionAttributeNames(url) {
+  const parsed = parseJsonParam(url.searchParams.get("expressionAttributeNames"), "expressionAttributeNames");
+  if (parsed instanceof Response || parsed === undefined)
+    return parsed;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || Object.values(parsed).some((value) => typeof value !== "string")) {
+    return textError("invalid expressionAttributeNames parameter", 400);
+  }
+  return parsed;
+}
+function parseExpressionAttributeValues(url) {
+  const parsed = parseJsonParam(url.searchParams.get("expressionAttributeValues"), "expressionAttributeValues");
+  if (parsed instanceof Response || parsed === undefined)
+    return parsed;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return textError("invalid expressionAttributeValues parameter", 400);
+  }
+  return parsed;
+}
+async function handleTables(req, cwd, url, omitDirNames) {
+  const r = await resolveDynamoDb(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  const exclusiveStartTableName = validateOptionalText(url.searchParams.get("exclusiveStartTableName"), "exclusiveStartTableName", MAX_TABLE_NAME_LEN);
+  if (exclusiveStartTableName instanceof Response)
+    return exclusiveStartTableName;
+  try {
+    const result = await r.explorer.listTablesAsync({
+      limit: parseLimit2(url, "tablesLimit", MAX_TABLES_LIMIT),
+      ...exclusiveStartTableName ? { exclusiveStartTableName } : {},
+      signal: req.signal
+    });
+    const body = { dbId: r.dbId, ...result };
+    return json(body);
+  } catch (err) {
+    return dynamoDbErrorResponse(err, "list dynamodb tables", req.signal);
+  }
+}
+async function handleTable(req, cwd, url, omitDirNames) {
+  const r = await resolveDynamoDb(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  const tableName = validateTableName(url.searchParams.get("table"));
+  if (tableName instanceof Response)
+    return tableName;
+  try {
+    const table = await r.explorer.describeTableAsync(tableName, req.signal);
+    const body = { dbId: r.dbId, table };
+    return json(body);
+  } catch (err) {
+    return dynamoDbErrorResponse(err, "describe dynamodb table", req.signal);
+  }
+}
+async function handleItems(req, cwd, url, omitDirNames) {
+  const r = await resolveDynamoDb(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  const tableName = validateTableName(url.searchParams.get("table"));
+  if (tableName instanceof Response)
+    return tableName;
+  const mode = url.searchParams.get("mode") || "scan";
+  if (mode !== "scan" && mode !== "query") {
+    return textError("invalid mode parameter", 400);
+  }
+  const exclusiveStartKey = parseJsonParam(url.searchParams.get("exclusiveStartKey"), "exclusiveStartKey");
+  if (exclusiveStartKey instanceof Response)
+    return exclusiveStartKey;
+  const expressionAttributeNames = parseExpressionAttributeNames(url);
+  if (expressionAttributeNames instanceof Response)
+    return expressionAttributeNames;
+  const expressionAttributeValues = parseExpressionAttributeValues(url);
+  if (expressionAttributeValues instanceof Response)
+    return expressionAttributeValues;
+  const indexName = validateOptionalText(url.searchParams.get("index"), "index");
+  if (indexName instanceof Response)
+    return indexName;
+  const projectionExpression = validateOptionalText(url.searchParams.get("projectionExpression"), "projectionExpression");
+  if (projectionExpression instanceof Response)
+    return projectionExpression;
+  const filterExpression = validateOptionalText(url.searchParams.get("filterExpression"), "filterExpression");
+  if (filterExpression instanceof Response)
+    return filterExpression;
+  const keyConditionExpression = validateOptionalText(url.searchParams.get("keyConditionExpression"), "keyConditionExpression");
+  if (keyConditionExpression instanceof Response)
+    return keyConditionExpression;
+  if (mode === "query" && !keyConditionExpression) {
+    return textError("missing keyConditionExpression parameter", 400);
+  }
+  try {
+    const common = {
+      tableName,
+      limit: parseLimit2(url, "limit", DEFAULT_ITEMS_LIMIT),
+      ...exclusiveStartKey ? { exclusiveStartKey } : {},
+      ...indexName ? { indexName } : {},
+      ...projectionExpression ? { projectionExpression } : {},
+      ...filterExpression ? { filterExpression } : {},
+      ...expressionAttributeNames ? { expressionAttributeNames } : {},
+      ...expressionAttributeValues ? { expressionAttributeValues } : {},
+      signal: req.signal
+    };
+    const result = mode === "query" ? await r.explorer.queryAsync({
+      ...common,
+      keyConditionExpression,
+      scanIndexForward: url.searchParams.get("scanIndexForward") !== "false"
+    }) : await r.explorer.scanAsync(common);
+    const body = {
+      dbId: r.dbId,
+      tableName,
+      mode,
+      ...result
+    };
+    return json(body);
+  } catch (err) {
+    return dynamoDbErrorResponse(err, "read dynamodb items", req.signal);
+  }
+}
+async function handleItem(req, cwd, url, omitDirNames) {
+  const r = await resolveDynamoDb(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  const tableName = validateTableName(url.searchParams.get("table"));
+  if (tableName instanceof Response)
+    return tableName;
+  const key = parseKey(url.searchParams.get("key"), "key");
+  if (key instanceof Response)
+    return key;
+  const expressionAttributeNames = parseExpressionAttributeNames(url);
+  if (expressionAttributeNames instanceof Response)
+    return expressionAttributeNames;
+  const projectionExpression = validateOptionalText(url.searchParams.get("projectionExpression"), "projectionExpression");
+  if (projectionExpression instanceof Response)
+    return projectionExpression;
+  try {
+    const result = await r.explorer.getItemAsync({
+      tableName,
+      key,
+      ...projectionExpression ? { projectionExpression } : {},
+      ...expressionAttributeNames ? { expressionAttributeNames } : {},
+      consistentRead: url.searchParams.get("consistentRead") === "true",
+      signal: req.signal
+    });
+    const body = {
+      dbId: r.dbId,
+      tableName,
+      key,
+      ...result
+    };
+    return json(body);
+  } catch (err) {
+    return dynamoDbErrorResponse(err, "read dynamodb item", req.signal);
+  }
+}
+async function handleDynamoDbRoute(req, url, cwd, sideEffectAllowed, omitDirNames) {
+  const wrap = createQueryStrippedLogger("dynamodb", req, url);
+  return dispatchRoutes(req, url, {
+    "/_db/dynamodb/tables": {
+      methods: ["GET"],
+      handler: () => handleTables(req, cwd, url, omitDirNames)
+    },
+    "/_db/dynamodb/table": {
+      methods: ["GET"],
+      handler: () => handleTable(req, cwd, url, omitDirNames)
+    },
+    "/_db/dynamodb/items": {
+      methods: ["GET"],
+      handler: () => handleItems(req, cwd, url, omitDirNames)
+    },
+    "/_db/dynamodb/item": {
+      methods: ["GET"],
+      handler: () => handleItem(req, cwd, url, omitDirNames)
+    }
+  }, sideEffectAllowed, wrap, (err) => handleError("dynamodb", "handle dynamodb request", err, req.signal));
+}
+var dynamoDbAdapterCache, DEFAULT_ITEMS_LIMIT = 100, MAX_ITEMS_LIMIT = 1000, MAX_TABLES_LIMIT = 100, MAX_TABLE_NAME_LEN = 255, MAX_EXPRESSION_LEN = 4096, MAX_JSON_PARAM_LEN;
+var init_handle_dynamodb = __esm(() => {
+  init_dynamodb();
+  init_handle_shared();
+  dynamoDbAdapterCache = createDockerAdapterCache();
+  MAX_JSON_PARAM_LEN = 64 * 1024;
+});
+
 // web-src/server/database/handle-elasticsearch.ts
 var exports_handle_elasticsearch = {};
 __export(exports_handle_elasticsearch, {
@@ -15804,7 +17399,7 @@ function validateKey(value) {
   }
   return value;
 }
-function validateOptionalText(value, name, maxLen) {
+function validateOptionalText2(value, name, maxLen) {
   if (!value)
     return "";
   if (value.length > maxLen || hasControlCharacter(value)) {
@@ -15812,7 +17407,7 @@ function validateOptionalText(value, name, maxLen) {
   }
   return value;
 }
-function parseLimit2(url) {
+function parseLimit3(url) {
   const raw = Number(url.searchParams.get("limit") || DEFAULT_OBJECT_LIMIT);
   return Math.min(MAX_OBJECT_LIMIT, Math.max(1, Number.isFinite(raw) ? raw : DEFAULT_OBJECT_LIMIT));
 }
@@ -15897,13 +17492,13 @@ async function handleObjects(cwd, req, url, omitDirNames) {
   const bucket = validateBucket(url.searchParams.get("bucket"));
   if (bucket instanceof Response)
     return bucket;
-  const prefix = validateOptionalText(url.searchParams.get("prefix"), "prefix", 2048);
+  const prefix = validateOptionalText2(url.searchParams.get("prefix"), "prefix", 2048);
   if (prefix instanceof Response)
     return prefix;
-  const search = validateOptionalText(url.searchParams.get("q"), "q", 512);
+  const search = validateOptionalText2(url.searchParams.get("q"), "q", 512);
   if (search instanceof Response)
     return search;
-  const token = validateOptionalText(url.searchParams.get("token"), "token", 4096);
+  const token = validateOptionalText2(url.searchParams.get("token"), "token", 4096);
   if (token instanceof Response)
     return token;
   const mode = parseMode(url);
@@ -15912,7 +17507,7 @@ async function handleObjects(cwd, req, url, omitDirNames) {
   const sort = parseSort2(url);
   if (sort instanceof Response)
     return sort;
-  const limit = parseLimit2(url);
+  const limit = parseLimit3(url);
   try {
     if (mode === "prefix") {
       const effectivePrefix = search || prefix;
@@ -16035,10 +17630,10 @@ async function handleFolder(cwd, req, url, omitDirNames) {
   const bucket = validateBucket(url.searchParams.get("bucket"));
   if (bucket instanceof Response)
     return bucket;
-  const prefix = validateOptionalText(url.searchParams.get("prefix"), "prefix", 2048);
+  const prefix = validateOptionalText2(url.searchParams.get("prefix"), "prefix", 2048);
   if (prefix instanceof Response)
     return prefix;
-  const token = validateOptionalText(url.searchParams.get("token"), "token", 4096);
+  const token = validateOptionalText2(url.searchParams.get("token"), "token", 4096);
   if (token instanceof Response)
     return token;
   try {
@@ -16386,7 +17981,7 @@ var init_query_history = __esm(() => {
 });
 
 // web-src/server/database/snapshot-store.ts
-import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join12 } from "node:path";
 async function getStoreDb(cwd) {
@@ -16417,7 +18012,7 @@ function makeId2(prefix) {
   return `${prefix}-${randomBytes2(8).toString("hex")}`;
 }
 function hashPayload(payloadJson) {
-  return createHash5("sha256").update(payloadJson).digest("hex");
+  return createHash6("sha256").update(payloadJson).digest("hex");
 }
 function hashLengthPrefixed(hasher, value) {
   hasher.update(`${Buffer.byteLength(value, "utf8")}:`);
@@ -16492,7 +18087,7 @@ async function addSnapshotTableRows(cwd, revisionId, rows) {
   db.exec("BEGIN");
   try {
     for (const row of rows) {
-      const rowKeyHash = createHash5("sha256").update(row.rowKeyJson).digest("hex");
+      const rowKeyHash = createHash6("sha256").update(row.rowKeyJson).digest("hex");
       const payloadHash = hashPayload(row.payloadJson);
       insertRow.run(revisionId, rowKeyHash, row.rowKeyJson, row.rowHash, payloadHash);
       insertPayload.run(payloadHash, row.payloadJson);
@@ -16506,7 +18101,7 @@ async function addSnapshotTableRows(cwd, revisionId, rows) {
   }
 }
 function computeRevisionTableHash(db, revisionId) {
-  const hasher = createHash5("sha256");
+  const hasher = createHash6("sha256");
   hashLengthPrefixed(hasher, `snapshot-table-v${SNAPSHOT_TABLE_HASH_VERSION}`);
   let rowCount = 0;
   let last;
@@ -17100,6 +18695,34 @@ function sanitizeS3(v) {
     return;
   return out;
 }
+function sanitizeDynamodb(v) {
+  if (!v || typeof v !== "object")
+    return;
+  const r = v;
+  const out = {};
+  const table = sanitizeOptionalString(r.table, MAX_DYNAMODB_TABLE_LEN);
+  if (table !== undefined)
+    out.table = table;
+  if (r.mode === "scan" || r.mode === "query")
+    out.mode = r.mode;
+  const keyConditionExpression = sanitizeOptionalString(r.keyConditionExpression, MAX_DYNAMODB_EXPRESSION_LEN);
+  if (keyConditionExpression !== undefined)
+    out.keyConditionExpression = keyConditionExpression;
+  const filterExpression = sanitizeOptionalString(r.filterExpression, MAX_DYNAMODB_EXPRESSION_LEN);
+  if (filterExpression !== undefined)
+    out.filterExpression = filterExpression;
+  const expressionAttributeValues = sanitizeOptionalString(r.expressionAttributeValues, MAX_DYNAMODB_ATTRIBUTE_VALUES_LEN);
+  if (expressionAttributeValues !== undefined)
+    out.expressionAttributeValues = expressionAttributeValues;
+  if (typeof r.scanIndexForward === "boolean")
+    out.scanIndexForward = r.scanIndexForward;
+  const itemKey = sanitizeOptionalString(r.itemKey, MAX_DYNAMODB_ITEM_KEY_LEN);
+  if (itemKey !== undefined)
+    out.itemKey = itemKey;
+  if (out.table === undefined && out.mode === undefined && out.keyConditionExpression === undefined && out.filterExpression === undefined && out.expressionAttributeValues === undefined && out.scanIndexForward === undefined && out.itemKey === undefined)
+    return;
+  return out;
+}
 function sanitize(input) {
   if (!input || typeof input !== "object")
     return emptyState2();
@@ -17125,7 +18748,7 @@ function sanitize(input) {
     if (isToolInternalDbId(dbId))
       continue;
     const schema = sanitizeOptionalString(tab.schema, MAX_SCHEMA_NAME_LEN);
-    const table = sanitizeOptionalString(tab.table, MAX_TABLE_NAME_LEN) ?? null;
+    const table = sanitizeOptionalString(tab.table, MAX_TABLE_NAME_LEN2) ?? null;
     const view = typeof tab.view === "string" && VALID_VIEWS.has(tab.view) ? tab.view : "data";
     const out = { id, dbId, table, view };
     if (schema !== undefined)
@@ -17156,6 +18779,9 @@ function sanitize(input) {
     const s3 = sanitizeS3(tab.s3);
     if (s3 !== undefined)
       out.s3 = s3;
+    const dynamodb = sanitizeDynamodb(tab.dynamodb);
+    if (dynamodb !== undefined)
+      out.dynamodb = dynamodb;
     tabs.push(out);
   }
   let activeTabId = sanitizeOptionalString(obj.activeTabId, MAX_TAB_ID_LEN) ?? null;
@@ -17170,7 +18796,7 @@ async function loadTabsAsync(cwd) {
 async function saveTabsAsync(cwd, state) {
   return tabsStore.save(cwd, state);
 }
-var CODE_VIEWER_DIR5 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES2 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN2 = 2048, MAX_SCHEMA_NAME_LEN = 512, MAX_TABLE_NAME_LEN = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, MAX_S3_BUCKET_LEN = 256, MAX_S3_KEY_LEN = 2048, MAX_S3_QUERY_LEN = 2048, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS, tabsStore;
+var CODE_VIEWER_DIR5 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES2 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN2 = 2048, MAX_SCHEMA_NAME_LEN = 512, MAX_TABLE_NAME_LEN2 = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, MAX_S3_BUCKET_LEN = 256, MAX_S3_KEY_LEN = 2048, MAX_S3_QUERY_LEN = 2048, MAX_DYNAMODB_TABLE_LEN = 255, MAX_DYNAMODB_EXPRESSION_LEN = 4096, MAX_DYNAMODB_ATTRIBUTE_VALUES_LEN = 16000, MAX_DYNAMODB_ITEM_KEY_LEN = 4096, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS, tabsStore;
 var init_tabs_store = __esm(() => {
   init_json_store();
   VALID_VIEWS = new Set([
@@ -17294,6 +18920,9 @@ async function resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal) {
     if (info.kind === "s3") {
       return textError("s3 services must use the /_db/s3/* routes", 400);
     }
+    if (info.kind === "dynamodb") {
+      return textError("dynamodb services must use the /_db/dynamodb/* routes", 400);
+    }
     const resolved2 = parsed.database ? { ...info, database: parsed.database } : info;
     const requestedSchema = normalizeSchemaParam(schemaParam);
     if (requestedSchema instanceof Response)
@@ -17537,7 +19166,7 @@ function groupFiltersByValue(filters) {
   }
   return grouped;
 }
-async function handleTable(cwd, url, omitDirNames, signal) {
+async function handleTable2(cwd, url, omitDirNames, signal) {
   const r = await resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"), signal);
   if (r instanceof Response)
     return r;
@@ -18528,6 +20157,10 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
     const { handleS3Route: handleS3Route2 } = await Promise.resolve().then(() => (init_handle_s3(), exports_handle_s3));
     return handleS3Route2(req, url, cwd, sideEffectAllowed, omitDirNames);
   }
+  if (url.pathname.startsWith("/_db/dynamodb/")) {
+    const { handleDynamoDbRoute: handleDynamoDbRoute2 } = await Promise.resolve().then(() => (init_handle_dynamodb(), exports_handle_dynamodb));
+    return handleDynamoDbRoute2(req, url, cwd, sideEffectAllowed, omitDirNames);
+  }
   const start = Date.now();
   const method = req.method;
   const wrapResponse = (res) => {
@@ -18551,7 +20184,7 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
     },
     "/_db/table": {
       methods: ["GET"],
-      handler: () => handleTable(cwd, url, omitDirNames, req.signal)
+      handler: () => handleTable2(cwd, url, omitDirNames, req.signal)
     },
     "/_db/table-count": {
       methods: ["GET"],
@@ -18666,6 +20299,7 @@ var init_handle = __esm(() => {
   init_connection_pool();
   init_discovery();
   init_global_search();
+  init_handle_dynamodb();
   init_handle_elasticsearch();
   init_handle_redis();
   init_handle_s3();
@@ -18695,7 +20329,8 @@ var init_handle = __esm(() => {
     },
     redis: closeRedisAdapter,
     elasticsearch: closeElasticsearchAdapter,
-    s3: closeS3Adapter
+    s3: closeS3Adapter,
+    dynamodb: closeDynamoDbAdapter
   };
   SNAPSHOT_DOCKER_SOURCE_REGISTRY = {
     redis: async (info, requestedContainers, signal) => {
@@ -20636,10 +22271,18 @@ var init_journal2 = __esm(() => {
 // web-src/server/search-service.ts
 import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
 import { join as join17, relative as relative6 } from "node:path";
-function rgAvailable(cwd) {
+async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
-  const proc = runSync([commandForExternal("rg"), "--version"], cwd);
+  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;
 }
@@ -20712,15 +22355,21 @@ function grepWorktreeFallback(env, query, max, paths) {
   }
   return matches;
 }
-function grepWorktree(env, req) {
+async function grepWorktreeAsync(env, req) {
   const paths = filterCallerPaths(env, req.paths);
-  if (rgAvailable(env.cwd)) {
+  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);
-    args[0] = commandForExternal("rg");
-    const proc = runSync(args, env.cwd, { timeout: 5000 });
-    const stdout = proc.stdout;
-    const matches2 = parseRgOutput(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));
+    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",
@@ -20744,10 +22393,9 @@ function grepWorktree(env, req) {
     matches
   };
 }
-function grepTreeRef(env, req) {
+async function grepTreeRefAsync(env, req) {
   const safePaths = filterCallerPaths(env, req.paths);
   const args = [
-    commandForExternal("git"),
     "-c",
     "core.quotepath=false",
     "grep",
@@ -20762,9 +22410,16 @@ function grepTreeRef(env, req) {
     "--",
     ...safePaths
   ];
-  const proc = runSync(args, env.cwd, { timeout: 5000 });
-  const stdout = proc.stdout;
-  const matches = parseGitGrepOutput(stdout, req.ref, req.max, env.omitDirNames, env.excludeNames).slice(0, req.max);
+  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",
@@ -20772,10 +22427,10 @@ function grepTreeRef(env, req) {
     matches
   };
 }
-function grepRepo(env, req) {
+async function grepRepoAsync(env, req) {
   const isWorktree = req.ref === "worktree" || req.ref === "";
   if (!isWorktree) {
-    const refCheck = verifyTreeRefResult(req.ref, env.cwd);
+    const refCheck = await verifyTreeRefResultAsync(req.ref, env.cwd);
     if (refCheck.ok !== true) {
       return {
         ok: false,
@@ -20796,13 +22451,13 @@ function grepRepo(env, req) {
     };
   }
   if (isWorktree) {
-    return { ok: true, value: grepWorktree(env, req) };
+    return { ok: true, value: await grepWorktreeAsync(env, req) };
   }
-  return { ok: true, value: grepTreeRef(env, req) };
+  return { ok: true, value: await grepTreeRefAsync(env, req) };
 }
-function listRepoFiles(env, ref, generation) {
+async function listRepoFilesAsync(env, ref, generation) {
   if (ref !== "worktree" && ref !== "") {
-    const refCheck = verifyTreeRefResult(ref, env.cwd);
+    const refCheck = await verifyTreeRefResultAsync(ref, env.cwd);
     if (refCheck.ok !== true) {
       return {
         ok: false,
@@ -20812,7 +22467,7 @@ function listRepoFiles(env, ref, generation) {
     }
   }
   const effectiveRef = ref || "worktree";
-  const tree = listTreeResult(effectiveRef, "", env.cwd, {
+  const tree = await listTreeResultAsync(effectiveRef, "", env.cwd, {
     recursive: true,
     omitDirNames: env.omitDirNames,
     excludeNames: env.excludeNames
@@ -20829,8 +22484,8 @@ 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();
 });
 
@@ -21434,7 +23089,7 @@ function validateMcpIntegerLimit(raw, fallback, min, max, flag) {
   }
   return { ok: true, value: raw };
 }
-function runFileShowTool(input, defaultCwd) {
+async function runFileShowTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const pathRaw = params.path;
   if (typeof pathRaw !== "string") {
@@ -21487,7 +23142,7 @@ function runFileShowTool(input, defaultCwd) {
     json: true
   };
   try {
-    const report = buildFileShowReport(resolved.root, command);
+    const report = await buildFileShowReportAsync(resolved.root, command);
     return {
       text: JSON.stringify(report, null, 2),
       isError: report.error !== undefined
@@ -21497,7 +23152,7 @@ function runFileShowTool(input, defaultCwd) {
     return { text: `file show failed: ${detail}`, isError: true };
   }
 }
-function runFileBlameTool(input, defaultCwd) {
+async function runFileBlameTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const pathRaw = params.path;
   if (typeof pathRaw !== "string") {
@@ -21534,7 +23189,7 @@ function runFileBlameTool(input, defaultCwd) {
     json: true
   };
   try {
-    const report = buildFileBlameReport(resolved.root, command);
+    const report = await buildFileBlameReportAsync(resolved.root, command);
     return {
       text: JSON.stringify(report, null, 2),
       isError: report.result.error !== undefined
@@ -21544,7 +23199,7 @@ function runFileBlameTool(input, defaultCwd) {
     return { text: `file blame failed: ${detail}`, isError: true };
   }
 }
-function runFileHistoryTool(input, defaultCwd) {
+async function runFileHistoryTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const pathRaw = params.path;
   if (typeof pathRaw !== "string") {
@@ -21597,7 +23252,7 @@ function runFileHistoryTool(input, defaultCwd) {
     json: true
   };
   try {
-    const report = buildFileHistoryReport(resolved.root, command);
+    const report = await buildFileHistoryReportAsync(resolved.root, command);
     return {
       text: JSON.stringify(report, null, 2),
       isError: report.result.error !== undefined
@@ -21607,7 +23262,7 @@ function runFileHistoryTool(input, defaultCwd) {
     return { text: `file history failed: ${detail}`, isError: true };
   }
 }
-function runFileDiffTool(input, defaultCwd) {
+async function runFileDiffTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const pathRaw = params.path;
   if (typeof pathRaw !== "string") {
@@ -21711,7 +23366,7 @@ function runFileDiffTool(input, defaultCwd) {
     json: true
   };
   try {
-    const report = buildFileDiffReport(resolved.root, command);
+    const report = await buildFileDiffReportAsync(resolved.root, command);
     return {
       text: JSON.stringify(report, null, 2),
       isError: report.error !== undefined
@@ -21721,7 +23376,7 @@ function runFileDiffTool(input, defaultCwd) {
     return { text: `file diff failed: ${detail}`, isError: true };
   }
 }
-function runSearchFilesTool(input, defaultCwd) {
+async function runSearchFilesTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const termRaw = params.term;
   if (typeof termRaw !== "string") {
@@ -21756,7 +23411,7 @@ function runSearchFilesTool(input, defaultCwd) {
     omitDirNames: [],
     excludeNames: DEFAULT_EXCLUDE_NAMES
   };
-  const listResult = listRepoFiles(env, refParsed.ref, 1);
+  const listResult = await listRepoFilesAsync(env, refParsed.ref, 1);
   if (listResult.ok !== true) {
     return { text: listResult.error, isError: true };
   }
@@ -21783,7 +23438,7 @@ function runSearchFilesTool(input, defaultCwd) {
   };
   return { text: JSON.stringify(payload, null, 2) };
 }
-function runSearchCodeTool(input, defaultCwd) {
+async function runSearchCodeTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const termRaw = params.term;
   if (typeof termRaw !== "string") {
@@ -21835,7 +23490,7 @@ function runSearchCodeTool(input, defaultCwd) {
     omitDirNames: [],
     excludeNames: DEFAULT_EXCLUDE_NAMES
   };
-  const result = grepRepo(env, {
+  const result = await grepRepoAsync(env, {
     query: termRaw,
     ref: refParsed.ref,
     paths,
@@ -22391,12 +24046,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,
@@ -22513,6 +24168,7 @@ Examples:
     process.exit(1);
   }
   const candidate = repoRoot(cwd);
+  cwdHasGitRepository = !!candidate;
   if (cwdWasExplicit) {
     if (candidate === cwd)
       cwd = candidate;
@@ -22728,23 +24384,23 @@ function fileToMeta(file, range, extraQs) {
     untracked: file.untracked || false
   };
 }
-function computePayload(extras, range, pathFilter = "") {
+async function computePayload(extras, range, pathFilter = "", responseGeneration = generation) {
   if (isSameWorktreeRange(range)) {
     return {
       files: [],
       totals: { files: 0, additions: 0, deletions: 0 },
       range: "worktree .. worktree",
       project: basename3(cwd),
-      branch: currentBranch(cwd) || undefined,
-      generation
+      branch: await currentBranchMetadata(),
+      generation: responseGeneration
     };
   }
   const { args, refs } = buildRangeArgs(range);
   const fullArgs = [...extras, ...args];
-  const metaResult = fileMetaResult(fullArgs, cwd, false);
+  const metaResult = await fileMetaResultAsync(fullArgs, cwd, false);
   const files = metaResult.files;
   if (!metaResult.error && includeUntracked(range, refs)) {
-    files.push(...untrackedMeta(cwd));
+    files.push(...await untrackedMetaAsync(cwd));
   }
   const filteredFiles = pathFilter ? files.filter((file) => file.path === pathFilter || file.old_path === pathFilter) : files;
   filteredFiles.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -22771,12 +24427,13 @@ function computePayload(extras, range, pathFilter = "") {
     totals,
     range: label || "HEAD",
     project: basename3(cwd),
-    branch: currentBranch(cwd) || undefined,
-    generation,
+    branch: await currentBranchMetadata(),
+    generation: responseGeneration,
     ...metaResult.error ? { error: metaResult.error } : {}
   };
 }
-function handleDiffJson(url) {
+async function handleDiffJson(url) {
+  const responseGeneration = generation;
   const extras = [];
   if (url.searchParams.get("ignore_ws") === "1")
     extras.push("-w");
@@ -22790,45 +24447,40 @@ function handleDiffJson(url) {
   if (path && !safePath(path))
     return text("invalid path", 400);
   const key = `${range.from}|${range.to}|${url.searchParams.get("ignore_ws") || ""}|${url.searchParams.get("ignore_blank") || ""}|${path}`;
-  if (url.searchParams.get("nocache") === "1") {
-    const payload2 = computePayload(extras, range, path);
-    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, {
+  const noCache = url.searchParams.get("nocache") === "1";
+  const cached = metaCache.get(key);
+  if (!noCache && cacheFresh(cached))
+    return new Response(cached.body, {
       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, {
+  const requestSequence = ++diffMetaRequestSequence;
+  latestDiffMetaRequest.set(key, requestSequence);
+  try {
+    const payload = await computePayload(extras, range, path, responseGeneration);
+    if (latestDiffMetaRequest.get(key) !== requestSequence || responseGeneration !== generation)
+      return json2(payload);
+    const sig = JSON.stringify({ ...payload, generation: undefined });
+    if (noCache && (!cached || cached.sig !== sig)) {
+      generation++;
+      payload.generation = generation;
+      metaCache.clear();
+      fileCache.clear();
+    }
+    const body = JSON.stringify(payload);
+    setTimedCacheEntry(metaCache, key, { body, sig });
+    return new Response(body, {
       headers: {
         "Content-Type": "application/json; charset=utf-8",
         "Cache-Control": "no-store"
       }
     });
-  const payload = computePayload(extras, range, path);
-  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"
-    }
-  });
+  } finally {
+    if (latestDiffMetaRequest.get(key) === requestSequence)
+      latestDiffMetaRequest.delete(key);
+  }
 }
 function safeRepoPath(path) {
   return path === "" || safePath(path);
@@ -22926,16 +24578,16 @@ function worktreeFileMetadata(path, knownSize) {
     return {};
   }
 }
-function gitFileMetadata(ref, path, knownSize) {
-  const size = knownSize ?? rawFileSize(path, ref);
-  const commitUpdatedAt = lastCommitDateForPath(ref, path, cwd) || undefined;
+async function gitFileMetadata(ref, path, knownSize) {
+  const size = knownSize ?? await rawFileSize(path, ref);
+  const commitUpdatedAt = await lastCommitDateForPathAsync(ref, path, cwd) || undefined;
   return {
     size: size == null ? undefined : size,
     updated_at: commitUpdatedAt,
     commit_updated_at: commitUpdatedAt
   };
 }
-function directoryMetadata(target, path) {
+async function directoryMetadata(target, path) {
   if (target === "worktree" || target === "") {
     const full = path === "" ? safeOpenWorktreePath("") : safeWorktreePath2(path);
     if (!full)
@@ -22950,22 +24602,22 @@ function directoryMetadata(target, path) {
       return {};
     }
   }
-  const commitUpdatedAt = lastCommitDateForPath(target, path || ".", cwd) || undefined;
+  const commitUpdatedAt = await lastCommitDateForPathAsync(target, path || ".", cwd) || undefined;
   return { updated_at: commitUpdatedAt, commit_updated_at: commitUpdatedAt };
 }
-function fileMetadataForTarget(target, path) {
+async function fileMetadataForTarget(target, path) {
   return target === "worktree" || target === "" ? worktreeFileMetadata(path) : gitFileMetadata(target, path);
 }
-function attachTreeEntryMetadata(target, entry) {
+async function attachTreeEntryMetadata(target, entry) {
   if (entry.type === "tree")
-    return { ...entry, ...directoryMetadata(target, entry.path) };
+    return { ...entry, ...await directoryMetadata(target, entry.path) };
   if (entry.type === "commit" && !entry.submodule && (target === "worktree" || target === ""))
-    return { ...entry, ...directoryMetadata(target, entry.path) };
+    return { ...entry, ...await directoryMetadata(target, entry.path) };
   if (entry.type !== "blob")
     return entry;
-  return { ...entry, ...fileMetadataForTarget(target, entry.path) };
+  return { ...entry, ...await fileMetadataForTarget(target, entry.path) };
 }
-function readReadme(target, dirPath) {
+async function readReadme(target, dirPath) {
   const candidates = ["README.md", "readme.md", "README.markdown", "README"];
   for (const name of candidates) {
     const path = dirPath ? `${dirPath}/${name}` : name;
@@ -22979,13 +24631,13 @@ function readReadme(target, dirPath) {
         continue;
       }
     }
-    const res = show(target, path, cwd);
+    const res = await showAsync(target, path, cwd);
     if (res.code === 0)
       return { path, text: res.stdout };
   }
   return null;
 }
-function handleTree(url) {
+async 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))
@@ -22993,7 +24645,7 @@ function handleTree(url) {
   if ((target === "worktree" || target === "") && isGitInternalPath(path))
     return text("forbidden", 403);
   if (target !== "worktree") {
-    const refCheck = verifyTreeRefResult(target, cwd);
+    const refCheck = await verifyTreeRefResultAsync(target, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
   }
@@ -23003,7 +24655,7 @@ function handleTree(url) {
   if (invalidScopeExcludeNamesQuery(url))
     return text("invalid exclude names", 400);
   const excludeNames = scopeExcludeNamesFromQuery(url);
-  const tree = listTreeResult(target, path, cwd, {
+  const tree = await listTreeResultAsync(target, path, cwd, {
     recursive,
     omitDirNames: scopeOmitDirNamesFromQuery(url),
     excludeNames
@@ -23015,17 +24667,17 @@ function handleTree(url) {
     ref: target,
     path,
     project: basename3(cwd),
-    branch: currentBranch(cwd) || undefined,
-    entries: recursive ? entries : entries.map((entry) => attachTreeEntryMetadata(target, entry)),
-    readme: readReadme(target, path),
+    branch: await currentBranchMetadata(),
+    entries: recursive ? entries : await Promise.all(entries.map((entry) => attachTreeEntryMetadata(target, entry))),
+    readme: await readReadme(target, path),
     upload_enabled: uploadEnabled && (target === "worktree" || target === "")
   });
 }
-function handleSettings() {
+async function handleSettings() {
   return json2({
     project: basename3(cwd),
-    branch: currentBranch(cwd) || undefined,
-    repo_web_url: remoteWebUrl(cwd),
+    branch: await currentBranchMetadata(),
+    repo_web_url: cwdHasGitRepository ? await remoteWebUrlAsync(cwd) : null,
     scope: {
       omit_dirs_effective: scopeOmitDirNames,
       omit_dirs_built_in: DEFAULT_WORKTREE_OMIT_DIR_NAMES,
@@ -23060,7 +24712,13 @@ function currentSearchEnv(omitOverride, excludeOverride) {
     excludeNames: excludeOverride ?? scopeExcludeNames
   };
 }
-function handleFiles2(url) {
+async function currentBranchMetadata() {
+  if (!cwdHasGitRepository)
+    return;
+  return await currentBranchAsync(cwd) || undefined;
+}
+async function handleFiles2(url) {
+  const responseGeneration = generation;
   const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
   if (invalidScopeOmitDirNamesQuery(url))
     return text("invalid omit dirs", 400);
@@ -23072,13 +24730,24 @@ function handleFiles2(url) {
   const cached = fileListCache.get(key);
   if (cached && cached.generation === generation)
     return json2(cached.body);
-  const result = listRepoFiles(currentSearchEnv(omitDirNames, excludeNames), target, generation);
+  const result = await listRepoFilesAsync(currentSearchEnv(omitDirNames, excludeNames), target, responseGeneration);
   if (result.ok !== true)
     return text(result.error, result.status ?? 400);
-  fileListCache.set(key, { generation, body: result.value });
+  if (responseGeneration !== generation)
+    return json2(result.value);
+  fileListCache.set(key, {
+    generation: responseGeneration,
+    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 +24759,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,
@@ -23101,25 +24770,26 @@ function handleGrep(url) {
     return text(result.error, result.status ?? 400);
   return json2(result.value);
 }
-function handleRefCommits(url) {
+async function handleRefCommits(url) {
   const query = url.searchParams.get("q") || "";
   const parsedMax = Number(url.searchParams.get("max") || "");
   const parsedSkip = Number(url.searchParams.get("skip") || "0");
   const max = Number.isFinite(parsedMax) && parsedMax > 0 ? parsedMax : undefined;
   const skip = Number.isFinite(parsedSkip) && parsedSkip > 0 ? parsedSkip : undefined;
-  const result = refCommitPageResult(cwd, { query, max, skip });
+  const result = await refCommitPageResultAsync(cwd, { query, max, skip });
   if (result.error)
     return text(result.error, result.status ?? 500);
   return json2({ commits: result.commits, hasMore: result.hasMore });
 }
-function handleLog(url) {
+async function handleLog(url) {
+  const responseGeneration = generation;
   const ref = url.searchParams.get("ref") || "HEAD";
   const skip = Number(url.searchParams.get("skip") || "0");
   const limit = Number(url.searchParams.get("limit") || "50");
   const path = url.searchParams.get("path") || "";
   if (path && !safePath(path))
     return text("invalid path", 400);
-  const result = commitHistory(cwd, {
+  const result = await commitHistoryAsync(cwd, {
     ref,
     skip: Number.isFinite(skip) ? skip : 0,
     limit: Number.isFinite(limit) ? limit : 50,
@@ -23132,7 +24802,7 @@ function handleLog(url) {
   let commits = result.commits;
   let hasWorktree = false;
   if (wantsWorktreeHead) {
-    const status = statusPorcelainForPath(path, cwd);
+    const status = await statusPorcelainForPathAsync(path, cwd);
     if (status.ok && status.stdout.length > 0) {
       const parts = status.stdout.split("\x00").filter(Boolean);
       if (parts.length > 0) {
@@ -23154,7 +24824,7 @@ function handleLog(url) {
   return json2({
     commits,
     hasMore: result.hasMore,
-    generation,
+    generation: responseGeneration,
     ...hasWorktree ? { hasWorktree: true } : {}
   });
 }
@@ -23177,7 +24847,8 @@ function rememberBlame(key, value) {
     blameCache.delete(oldest.value);
   }
 }
-function handleFileBlame(url) {
+async function handleFileBlame(url) {
+  const responseGeneration = generation;
   const path = url.searchParams.get("path") || "";
   if (!safePath(path))
     return text("invalid path", 400);
@@ -23192,7 +24863,7 @@ function handleFileBlame(url) {
   if (base === "worktree") {
     cacheKey = `worktree|${path}|${blamePathKey(path)}`;
   } else {
-    const resolved = verifyCommit(normalized.ref, cwd);
+    const resolved = await verifyCommitAsync(normalized.ref, cwd);
     if (resolved.ok === false) {
       const status = resolved.error === commandNotFoundDetail("git") ? 503 : 400;
       return text(resolved.error || "unknown ref", status);
@@ -23205,16 +24876,21 @@ function handleFileBlame(url) {
       blameCache.delete(cacheKey);
       blameCache.set(cacheKey, cached);
     }
-    return json2({ ...cached, base, ref, generation });
+    return json2({ ...cached, base, ref, generation: responseGeneration });
   }
-  const result = blame(cwd, { path, ref: normalized.ref, base });
+  const result = await blameAsync(cwd, {
+    path,
+    ref: normalized.ref,
+    base
+  });
   if (result.error && result.status)
     return text(result.error, result.status);
-  if (!result.error)
+  if (!result.error && responseGeneration === generation)
     rememberBlame(cacheKey, result);
-  return json2({ ...result, base, ref, generation });
+  return json2({ ...result, base, ref, generation: responseGeneration });
 }
-function handleFileDiff(url) {
+async function handleFileDiff(url) {
+  const responseGeneration = generation;
   const path = url.searchParams.get("path") || "";
   if (!safePath(path))
     return text("invalid path", 400);
@@ -23240,7 +24916,7 @@ function handleFileDiff(url) {
       line_count: 0,
       truncated: false,
       binary: false,
-      generation
+      generation: responseGeneration
     });
   }
   const { args } = buildRangeArgs(range);
@@ -23267,21 +24943,21 @@ function handleFileDiff(url) {
     diffText = cached.diffText;
   } else {
     if (isUntracked) {
-      const res = untrackedFileDiff(extras, path, cwd);
+      const res = await untrackedFileDiffAsync(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);
+      const res = await fileDiffTextAsync([...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)
+    if (!errText && responseGeneration === generation)
       setTimedCacheEntry(fileCache, cacheKey, { diffText });
   }
   if (errStatus)
@@ -23300,7 +24976,7 @@ function handleFileDiff(url) {
     truncated: mode === "preview" && (truncated.totalHunks > truncated.renderedHunks || truncated.lineTruncated),
     binary: diffText.includes("Binary files"),
     error: errText,
-    generation
+    generation: responseGeneration
   };
   return json2(body);
 }
@@ -23454,6 +25130,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,17 +25140,18 @@ async function handleFileRange(url) {
       lines: result.lines,
       total: result.total,
       complete: result.complete,
-      generation
+      generation: responseGeneration
     };
     return json2(body);
   } else {
-    const refCheck = verifyTreeRefResult(ref, cwd);
+    const responseGeneration = generation;
+    const refCheck = await verifyTreeRefResultAsync(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
-    const oid = objectId(ref, path, cwd);
+    const oid = await objectIdAsync(ref, path, cwd);
     if (oid.code !== 0 || !oid.oid)
       return text("not in ref", 404);
-    const size = objectByteSize(oid.oid, cwd);
+    const size = await objectByteSizeAsync(oid.oid, cwd);
     if (size.code !== 0)
       return text("cannot read ref", 500);
     const result = await collectIndexedGitBlobLineRange(path, oid.oid, size.size, start, end);
@@ -23487,41 +25165,71 @@ 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);
+    const refCheck = await verifyTreeRefResultAsync(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
-    const size = rawFileSize(path, ref);
-    if (size == null)
+    const oid = await objectIdAsync(ref, path, cwd);
+    if (oid.code !== 0 || !oid.oid)
       return text("not in ref", 404);
-    const metadata = gitFileMetadata(ref, path, size);
+    const sizeResult = await objectByteSizeAsync(oid.oid, cwd);
+    if (sizeResult.code !== 0)
+      return text("cannot read ref", 500);
+    const size = sizeResult.size;
+    const metadata = await 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 {
     const full = safeWorktreePath2(path);
     if (!full)
       return text("not found", 404);
-    const size = rawFileSize(path, ref);
+    const size = await rawFileSize(path, ref);
     if (size == null)
       return text("not found", 404);
     const metadata = worktreeFileMetadata(path, size);
@@ -23558,11 +25266,12 @@ function handleRawFile(req, url) {
     });
   }
 }
-function rawFileSize(path, ref) {
+async function rawFileSize(path, ref) {
   if (ref !== "worktree" && ref !== "") {
-    if (!verifyTreeRef(ref, cwd))
+    const refCheck = await verifyTreeRefResultAsync(ref, cwd);
+    if (refCheck.ok !== true)
       return null;
-    const res = objectSize(ref, path, cwd);
+    const res = await objectSizeAsync(ref, path, cwd);
     return res.code === 0 ? res.size : null;
   }
   const full = safeWorktreePath2(path);
@@ -23664,11 +25373,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);
     }
@@ -23787,13 +25496,13 @@ function moveMacPathIntoTrash(path) {
     return { ok: false, error: String(error) };
   }
 }
-function movePathToTrash(path) {
+async function movePathToTrash(path) {
   lstatSync5(path);
   if (process.platform === "darwin") {
     return moveMacPathIntoTrash(path);
   }
   if (process.platform === "win32") {
-    const res = runSync([
+    const res = await runAsync([
       "powershell.exe",
       "-NoProfile",
       "-NonInteractive",
@@ -23806,7 +25515,7 @@ function movePathToTrash(path) {
   }
   return { ok: false, error: "trash unsupported" };
 }
-function restoreTrashPath(originalPath, trashPath) {
+async function restoreTrashPath(originalPath, trashPath) {
   const parent = parentRepoPath(originalPath);
   const parentFullPath = safeOpenWorktreePath(parent);
   if (!parentFullPath)
@@ -23832,7 +25541,7 @@ function restoreTrashPath(originalPath, trashPath) {
     }
   }
   if (process.platform === "win32") {
-    const res = runSync([
+    const res = await runAsync([
       "powershell.exe",
       "-NoProfile",
       "-NonInteractive",
@@ -23915,7 +25624,7 @@ async function handleTrashPath(req) {
   const originalFullPath = safeWorktreePath2(path);
   if (!originalFullPath)
     return text("not found", 404);
-  const moved = movePathToTrash(worktreePath(path));
+  const moved = await movePathToTrash(worktreePath(path));
   if (!moved.ok)
     return text(moved.error || "trash failed", 500);
   const undo = {
@@ -24009,7 +25718,7 @@ async function handleRestoreTrash(req) {
     return text("invalid restore target", 400);
   if (isGitInternalPath(originalPath))
     return text("forbidden", 403);
-  const restored = restoreTrashPath(originalPath, trashPath || undefined);
+  const restored = await restoreTrashPath(originalPath, trashPath || undefined);
   if (!restored.ok)
     return text(restored.error || "undo failed", 409);
   triggerUpdate();
@@ -24143,7 +25852,7 @@ async function handleJournal(req) {
       const labels = bodyStringList(body, "labels");
       if (label)
         labels.push(label);
-      const issues = readGithubIssueList({
+      const issues = await readGithubIssueListAsync({
         cwd,
         repo: bodyString(body, "repo"),
         labels,
@@ -24547,7 +26256,7 @@ function restartWorktreeWatch() {
   }
   worktreeWatch = startScopedWorktreeWatch();
 }
-var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, commandOverrides, cwdWasExplicit = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX = 64, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, safePath, MCP_MAX_BODY_BYTES = 1048576, MCP_INSTRUCTIONS, JournalRequestError, isCodeViewerInternalPath, watchLimitReached = null, server, worktreeWatch = null, shuttingDown = false;
+var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, commandOverrides, cwdWasExplicit = false, cwdHasGitRepository = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX = 64, metaCache, diffMetaRequestSequence = 0, latestDiffMetaRequest, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, safePath, MCP_MAX_BODY_BYTES = 1048576, MCP_INSTRUCTIONS, JournalRequestError, isCodeViewerInternalPath, watchLimitReached = null, databaseHandleModule, server, worktreeWatch = null, shuttingDown = false;
 var init_preview = __esm(async () => {
   init_journal();
   init_routes();
@@ -24625,6 +26334,7 @@ var init_preview = __esm(async () => {
   fileCache = new Map;
   blameCache = new Map;
   metaCache = new Map;
+  latestDiffMetaRequest = new Map;
   fileListCache = new Map;
   lineIndexCache = new Map;
   blobLineIndexCache = new Map;
@@ -24641,6 +26351,7 @@ var init_preview = __esm(async () => {
   isCodeViewerInternalPath = isToolInternalPath;
   parseCli();
   applyPersistedSettings(await loadAppSettingsState(cwd));
+  databaseHandleModule = Promise.resolve().then(() => (init_handle(), exports_handle));
   server = await startServer({
     hostname: "127.0.0.1",
     port: listenPort,
@@ -24652,9 +26363,9 @@ var init_preview = __esm(async () => {
       if (staticResponse)
         return staticResponse;
       if (url.pathname === "/diff.json")
-        return handleDiffJson(url);
+        return await handleDiffJson(url);
       if (url.pathname === "/_settings")
-        return handleSettings();
+        return await handleSettings();
       if (url.pathname === "/_doctor")
         return handleDoctor({
           cwd,
@@ -24662,23 +26373,23 @@ var init_preview = __esm(async () => {
           listenPort
         });
       if (url.pathname === "/_tree")
-        return handleTree(url);
+        return await handleTree(url);
       if (url.pathname === "/_files")
-        return handleFiles2(url);
+        return await handleFiles2(url);
       if (url.pathname === "/_grep")
-        return handleGrep(url);
+        return await handleGrep(url);
       if (url.pathname === "/_commits")
-        return handleRefCommits(url);
+        return await handleRefCommits(url);
       if (url.pathname === "/_log")
-        return handleLog(url);
+        return await handleLog(url);
       if (url.pathname === "/_file_blame")
-        return handleFileBlame(url);
+        return await handleFileBlame(url);
       if (url.pathname === "/file_diff")
-        return handleFileDiff(url);
+        return await handleFileDiff(url);
       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")
@@ -24690,7 +26401,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/_upload_files")
         return handleUploadFiles(req);
       if (url.pathname.startsWith("/_db/")) {
-        const { handleDatabaseRoute: handleDatabaseRoute2 } = await Promise.resolve().then(() => (init_handle(), exports_handle));
+        const { handleDatabaseRoute: handleDatabaseRoute2 } = await databaseHandleModule;
         const dbResponse = await handleDatabaseRoute2(req, url, cwd, scopeOmitDirNames, sideEffectRequestAllowed, sendSse);
         if (dbResponse)
           return dbResponse;
@@ -24708,7 +26419,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/_annotations")
         return handleAnnotations(req);
       if (url.pathname === "/_refs") {
-        const result = refsResult(cwd);
+        const result = await refsResultAsync(cwd);
         if (result.error)
           return text(result.error, result.status ?? 500);
         return json2(result.refs);