@youtyan/code-viewer 0.2.11 → 0.4.0

package/dist/code-viewer.js

@@ -759,6 +759,16 @@ import {
   statSync
 } from "node:fs";
 import { join as join2 } from "node:path";
+function normalizeBlameRef(ref, base) {
+  const rawRef = ref || "worktree";
+  if (base === "worktree" && rawRef !== "worktree") {
+    return { base: "HEAD", ref: rawRef };
+  }
+  if (base === "HEAD" && rawRef === "worktree") {
+    return { base: "HEAD", ref: "HEAD" };
+  }
+  return { base, ref: rawRef };
+}
 function run(args, cwd) {
   return runSync(args, cwd);
 }
@@ -1063,6 +1073,13 @@ function commitHistory(cwd, options) {
   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 = run([
     "git",
     "log",
@@ -1072,7 +1089,8 @@ function commitHistory(cwd, options) {
     `--format=${HISTORY_FORMAT}`,
     ...filterArgs,
     verified.stdout.trim(),
-    ...pathspec
+    ...pathspec,
+    ...pathArgs
   ], cwd);
   if (res.code !== 0)
     return { commits: [], hasMore: false, error: "git log failed" };
@@ -1173,6 +1191,130 @@ function numstatZ(args, cwd) {
 function isToolInternalPath(path) {
   return path.split(/[\\/]+/).some((part) => part.toLowerCase() === ".code-viewer");
 }
+function syntheticUncommittedBlameFromWorktree(cwd, path) {
+  const filePath = join2(cwd, path);
+  try {
+    const stat = statSync(filePath);
+    if (!stat.isFile())
+      return { lines: [], commits: {}, error: "not a file" };
+    const text = readFileSync(filePath, "utf8");
+    const normalized = text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+    const lineCount = normalized.length ? normalized.endsWith(`
+`) ? normalized.length - 1 === 0 ? 1 : normalized.split(`
+`).length - 1 : normalized.split(`
+`).length : 1;
+    const lines = [];
+    for (let i = 1;i <= lineCount; i++) {
+      lines.push({ lineNo: i, sha: BLAME_ZERO_SHA, isUncommitted: true });
+    }
+    return {
+      lines,
+      commits: {
+        [BLAME_ZERO_SHA]: {
+          sha: BLAME_ZERO_SHA,
+          author: "Not Committed Yet",
+          authorMail: "",
+          authorTime: 0,
+          summary: "Working tree",
+          isUncommitted: true
+        }
+      },
+      isUntracked: true,
+      isSynthetic: true
+    };
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+      return { lines: [], commits: {}, error: "file not found" };
+    }
+    return { lines: [], commits: {}, error: "file not readable" };
+  }
+}
+function blame(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 = run(args, cwd);
+  if (res.code !== 0) {
+    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)
@@ -1509,7 +1651,7 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", DEFAULT_WORKTREE_OMIT_DIR_NAMES, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
+var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", DEFAULT_WORKTREE_OMIT_DIR_NAMES, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
 var init_git = __esm(() => {
   init_runtime();
   DEFAULT_WORKTREE_OMIT_DIR_NAMES = [
@@ -4016,12 +4158,41 @@ function sanitizeDbUiPrefs(raw) {
   }
   return Object.keys(out).length > 0 ? out : undefined;
 }
+function sanitizeDbUiExpandedTables(raw) {
+  if (!isRecord(raw))
+    return;
+  const out = {};
+  let scopeCount = 0;
+  for (const [scopeRaw, tablesRaw] of Object.entries(raw)) {
+    if (scopeCount >= MAX_DB_UI_EXPANDED_SCOPES)
+      break;
+    const scope = safeObjectKey(scopeRaw);
+    if (!scope)
+      continue;
+    const tables = normalizeStringList(tablesRaw, {
+      maxItems: MAX_DB_UI_TABLES,
+      maxLen: MAX_KEY_LEN,
+      sort: true
+    });
+    if (!tables || tables.length === 0)
+      continue;
+    out[scope] = tables;
+    scopeCount++;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
 function sanitizeDbUiState(raw) {
   if (!isRecord(raw))
     return emptyDbUiState();
   const prefs = sanitizeDbUiPrefs(raw.prefs);
+  const expandedTables = sanitizeDbUiExpandedTables(raw.expandedTables);
   if (!isRecord(raw.columnWidths)) {
-    return prefs ? { ...emptyDbUiState(), prefs } : emptyDbUiState();
+    const out2 = emptyDbUiState();
+    if (expandedTables)
+      out2.expandedTables = expandedTables;
+    if (prefs)
+      out2.prefs = prefs;
+    return out2;
   }
   const columnWidths = {};
   let dbCount = 0;
@@ -4062,6 +4233,8 @@ function sanitizeDbUiState(raw) {
     dbCount++;
   }
   const out = { version: 1, columnWidths };
+  if (expandedTables)
+    out.expandedTables = expandedTables;
   if (prefs)
     out.prefs = prefs;
   return out;
@@ -4079,12 +4252,30 @@ function mergeDbUiPrefs(current, patch) {
   }
   return Object.keys(next).length > 0 ? next : undefined;
 }
+function mergeDbUiExpandedTables(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  const next = { ...current ?? {} };
+  for (const [scope, tablesRaw] of Object.entries(patch)) {
+    if (tablesRaw === null) {
+      delete next[scope];
+      continue;
+    }
+    next[scope] = tablesRaw;
+  }
+  return sanitizeDbUiExpandedTables(next);
+}
 function mergeDbUiState(current, patch) {
   if (!isRecord(patch))
     return current;
   const mergedPrefs = "prefs" in patch ? mergeDbUiPrefs(current.prefs, patch.prefs) : current.prefs;
+  const mergedExpandedTables = "expandedTables" in patch ? mergeDbUiExpandedTables(current.expandedTables, patch.expandedTables) : current.expandedTables;
   if (!isRecord(patch.columnWidths)) {
     const merged = { ...current, version: 1 };
+    if (mergedExpandedTables)
+      merged.expandedTables = mergedExpandedTables;
+    else
+      delete merged.expandedTables;
     if (mergedPrefs)
       merged.prefs = mergedPrefs;
     else
@@ -4124,6 +4315,7 @@ function mergeDbUiState(current, patch) {
     ...current,
     ...patch,
     columnWidths,
+    expandedTables: mergedExpandedTables,
     prefs: mergedPrefs,
     version: 1
   });
@@ -4155,7 +4347,7 @@ async function patchDbUiState(root, patch) {
     return { state: next, result: next };
   });
 }
-var CODE_VIEWER_DIR2 = ".code-viewer", SETTINGS_FILE_NAME = "settings.json", VIEW_STATE_FILE_NAME = "view-state.json", DB_UI_FILE_NAME = "db-ui.json", MAX_SETTINGS_BYTES = 200000, MAX_VIEW_STATE_BYTES = 1e6, MAX_DB_UI_BYTES = 1e6, MAX_REF_LEN = 1024, MAX_KEY_LEN = 2048, MAX_VIEW_ITEMS = 20000, MAX_DB_UI_DBS = 200, MAX_DB_UI_TABLES = 500, MAX_DB_UI_COLUMNS = 1000, DB_UI_BOOL_PREF_KEYS, settingsStore, viewStateStore, dbUiStore;
+var CODE_VIEWER_DIR2 = ".code-viewer", SETTINGS_FILE_NAME = "settings.json", VIEW_STATE_FILE_NAME = "view-state.json", DB_UI_FILE_NAME = "db-ui.json", MAX_SETTINGS_BYTES = 200000, MAX_VIEW_STATE_BYTES = 1e6, MAX_DB_UI_BYTES = 1e6, MAX_REF_LEN = 1024, MAX_KEY_LEN = 2048, MAX_VIEW_ITEMS = 20000, MAX_DB_UI_DBS = 200, MAX_DB_UI_TABLES = 500, MAX_DB_UI_COLUMNS = 1000, MAX_DB_UI_EXPANDED_SCOPES = 500, DB_UI_BOOL_PREF_KEYS, settingsStore, viewStateStore, dbUiStore;
 var init_state_store = __esm(() => {
   init_json_store();
   DB_UI_BOOL_PREF_KEYS = ["s3TooltipEnabled", "inferFkRails"];
@@ -4576,52 +4768,37 @@ function serializeDbRow(row) {
 function serializeDbRows(rows) {
   return rows.map(serializeDbRow);
 }
+function coerceDbValue(value, columnType) {
+  if (value === null)
+    return null;
+  const t = (columnType || "").toLowerCase();
+  if (/bool/.test(t)) {
+    const v = value.trim().toLowerCase();
+    if (v === "")
+      return null;
+    if (v === "true" || v === "t" || v === "1")
+      return true;
+    if (v === "false" || v === "f" || v === "0")
+      return false;
+    return value;
+  }
+  if (/int|serial|real|floa|doub|numeric|decimal|number/.test(t)) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return null;
+    const n = Number(trimmed);
+    if (Number.isFinite(n) && String(n) === trimmed)
+      return n;
+    return value;
+  }
+  return value;
+}
 var MIN_SAFE, MAX_SAFE;
 var init_serialize = __esm(() => {
   MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
   MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
 });
 
-// web-src/server/database/sources/sql-snapshot.ts
-import { createHash as createHash2 } from "node:crypto";
-function normalizeRawValue(v) {
-  if (v === null)
-    return "\\N";
-  if (typeof v === "bigint")
-    return v.toString();
-  if (v instanceof Uint8Array) {
-    return `\\x${Buffer.from(v).toString("hex")}`;
-  }
-  return String(v);
-}
-function rowToPayloadJson(columns, row) {
-  const obj = {};
-  for (let i = 0;i < columns.length; i++) {
-    obj[columns[i]] = serializeDbValue(row[i]);
-  }
-  return JSON.stringify(obj);
-}
-function computeRowHash(columns, row) {
-  const parts = columns.map((_, i) => normalizeRawValue(row[i]));
-  return createHash2("sha256").update(parts.join("\t")).digest("hex");
-}
-function buildRowKeyJson(pkColumns, allColumns, row, rowIndex) {
-  if (pkColumns.length === 0) {
-    return JSON.stringify({ __rowIndex: rowIndex });
-  }
-  const keyObj = {};
-  for (const pk of pkColumns) {
-    const idx = allColumns.indexOf(pk);
-    if (idx >= 0)
-      keyObj[pk] = serializeDbValue(row[idx]);
-  }
-  return JSON.stringify(keyObj);
-}
-var SQL_SNAPSHOT_BATCH_SIZE = 500;
-var init_sql_snapshot = __esm(() => {
-  init_serialize();
-});
-
 // web-src/server/database/sql-utils.ts
 function sanitizeIdentifier(name, kind = "sqlite") {
   if (kind === "mysql")
@@ -4683,6 +4860,189 @@ function filterOrderByColumns(orderBy, columnNames) {
   const filtered = orderBy.filter((order) => validColumns.has(order.column));
   return filtered.length > 0 ? filtered : undefined;
 }
+function buildOrderClause(orderBy, kind = "sqlite") {
+  if (!orderBy?.length)
+    return "";
+  const parts = orderBy.map((o) => `${sanitizeIdentifier(o.column, kind)} ${o.direction === "desc" ? "DESC" : "ASC"}`);
+  return ` ORDER BY ${parts.join(", ")}`;
+}
+function useParamsFor(kind) {
+  return kind === "sqlite";
+}
+function placeValue(coerced, kind, useParams, params) {
+  if (useParams) {
+    params.push(typeof coerced === "boolean" ? coerced ? 1 : 0 : coerced);
+    return "?";
+  }
+  if (coerced === null)
+    return "NULL";
+  if (typeof coerced === "number")
+    return String(coerced);
+  if (typeof coerced === "boolean")
+    return coerced ? "TRUE" : "FALSE";
+  const text = coerced instanceof Uint8Array ? new TextDecoder().decode(coerced) : String(coerced);
+  return escapeSqlString(text, kind);
+}
+function coerceCell(cell, columnType) {
+  return coerceDbValue(cell.value, columnType);
+}
+function buildInsertSql(table, cells, columnTypes, kind) {
+  if (cells.length === 0) {
+    throw new Error("insert requires at least one column value");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const cols = cells.map((c) => sanitizeIdentifier(c.column, kind));
+  const placeholders = cells.map((c) => placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params));
+  const sql = `INSERT INTO ${sanitizeIdentifier(table, kind)} (${cols.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  return { sql, params };
+}
+function buildUpdateSql(table, set, pk, columnTypes, kind) {
+  if (set.length === 0) {
+    throw new Error("update requires at least one column to set");
+  }
+  if (pk.length === 0) {
+    throw new Error("update requires a primary key condition");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const setSql = set.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(", ");
+  const whereSql = pk.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(" AND ");
+  const sql = `UPDATE ${sanitizeIdentifier(table, kind)} SET ${setSql} WHERE ${whereSql}`;
+  return { sql, params };
+}
+function buildDeleteSql(table, pk, columnTypes, kind) {
+  if (pk.length === 0) {
+    throw new Error("delete requires a primary key condition");
+  }
+  const useParams = useParamsFor(kind);
+  const params = [];
+  const whereSql = pk.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(" AND ");
+  const sql = `DELETE FROM ${sanitizeIdentifier(table, kind)} WHERE ${whereSql}`;
+  return { sql, params };
+}
+var init_sql_utils = __esm(() => {
+  init_serialize();
+});
+
+// web-src/server/database/mutate.ts
+function assertCells(cells, label) {
+  if (!Array.isArray(cells)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const cell of cells) {
+    if (!cell || typeof cell !== "object" || typeof cell.column !== "string" || cell.value !== null && typeof cell.value !== "string") {
+      throw new Error(`${label} contains an invalid cell`);
+    }
+  }
+  return cells;
+}
+function buildMutationStatements(table, mutations, columns, kind) {
+  if (!Array.isArray(mutations) || mutations.length === 0) {
+    throw new Error("no mutations provided");
+  }
+  if (mutations.length > MAX_MUTATIONS) {
+    throw new Error(`too many mutations (max ${MAX_MUTATIONS})`);
+  }
+  const columnTypes = new Map(columns.map((c) => [c.name, c.type]));
+  const columnNames = new Set(columns.map((c) => c.name));
+  const pkColumns = columns.filter((c) => c.primaryKey).map((c) => c.name);
+  const pkNames = new Set(pkColumns);
+  const requireKnownColumns = (cells, label) => {
+    for (const cell of cells) {
+      if (!columnNames.has(cell.column)) {
+        throw new Error(`unknown column: ${cell.column}`);
+      }
+    }
+  };
+  const requirePrimaryKey = (pk) => {
+    if (pkColumns.length === 0) {
+      throw new Error("table has no primary key; row update/delete is not supported");
+    }
+    const provided = new Set(pk.map((c) => c.column));
+    for (const name of pkColumns) {
+      if (!provided.has(name)) {
+        throw new Error(`missing primary key column: ${name}`);
+      }
+    }
+    for (const cell of pk) {
+      if (!pkNames.has(cell.column)) {
+        throw new Error(`not a primary key column: ${cell.column}`);
+      }
+      if (cell.value === null) {
+        throw new Error(`primary key column cannot be null: ${cell.column}`);
+      }
+    }
+  };
+  const statements = [];
+  for (const mutation of mutations) {
+    if (!mutation || typeof mutation !== "object") {
+      throw new Error("invalid mutation");
+    }
+    if (mutation.kind === "insert") {
+      const values = assertCells(mutation.values, "insert values");
+      requireKnownColumns(values, "insert values");
+      statements.push(buildInsertSql(table, values, columnTypes, kind));
+    } else if (mutation.kind === "update") {
+      const pk = assertCells(mutation.pk, "update pk");
+      const values = assertCells(mutation.values, "update values");
+      requirePrimaryKey(pk);
+      requireKnownColumns(values, "update values");
+      statements.push(buildUpdateSql(table, values, pk, columnTypes, kind));
+    } else if (mutation.kind === "delete") {
+      const pk = assertCells(mutation.pk, "delete pk");
+      requirePrimaryKey(pk);
+      statements.push(buildDeleteSql(table, pk, columnTypes, kind));
+    } else {
+      throw new Error(`unknown mutation kind: ${mutation.kind}`);
+    }
+  }
+  return statements;
+}
+var MAX_MUTATIONS = 1000;
+var init_mutate = __esm(() => {
+  init_sql_utils();
+});
+
+// web-src/server/database/sources/sql-snapshot.ts
+import { createHash as createHash2 } from "node:crypto";
+function normalizeRawValue(v) {
+  if (v === null)
+    return "\\N";
+  if (typeof v === "bigint")
+    return v.toString();
+  if (v instanceof Uint8Array) {
+    return `\\x${Buffer.from(v).toString("hex")}`;
+  }
+  return String(v);
+}
+function rowToPayloadJson(columns, row) {
+  const obj = {};
+  for (let i = 0;i < columns.length; i++) {
+    obj[columns[i]] = serializeDbValue(row[i]);
+  }
+  return JSON.stringify(obj);
+}
+function computeRowHash(columns, row) {
+  const parts = columns.map((_, i) => normalizeRawValue(row[i]));
+  return createHash2("sha256").update(parts.join("\t")).digest("hex");
+}
+function buildRowKeyJson(pkColumns, allColumns, row, rowIndex) {
+  if (pkColumns.length === 0) {
+    return JSON.stringify({ __rowIndex: rowIndex });
+  }
+  const keyObj = {};
+  for (const pk of pkColumns) {
+    const idx = allColumns.indexOf(pk);
+    if (idx >= 0)
+      keyObj[pk] = serializeDbValue(row[idx]);
+  }
+  return JSON.stringify(keyObj);
+}
+var SQL_SNAPSHOT_BATCH_SIZE = 500;
+var init_sql_snapshot = __esm(() => {
+  init_serialize();
+});
 
 // web-src/server/database/adapters/spawn-runner.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -4932,6 +5292,24 @@ var init_docker_utils = __esm(() => {
   };
 });
 
+// web-src/server/database/adapters/sql-capture.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function recordSql(sql) {
+  const bucket = storage.getStore();
+  if (!bucket)
+    return;
+  bucket.sqls.push(sql);
+}
+async function captureSql(fn) {
+  const bucket = { sqls: [] };
+  const result = await storage.run(bucket, fn);
+  return { result, executedSql: bucket.sqls };
+}
+var storage;
+var init_sql_capture = __esm(() => {
+  storage = new AsyncLocalStorage;
+});
+
 // web-src/server/database/adapters/docker.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 function dockerDatabasesCacheKey(serviceName, kind, cwd) {
@@ -5087,6 +5465,7 @@ function execWithNodeSpawn(args, timeoutMs, signal) {
   });
 }
 async function execInContainerAsync(config, sql, timeoutMs = 1e4, signal) {
+  recordSql(sql);
   if (spawnSyncImpl2 !== spawnSync3)
     return execInContainer(config, sql, timeoutMs);
   const args = buildExecArgs(config, sql);
@@ -5174,12 +5553,6 @@ function parseTsvOutput(stdout, hasHeader, recordSeparator) {
   const rows = lines.map((line) => splitTsvLine(line, false));
   return { columns: [], rows };
 }
-function buildOrderClause(orderBy, kind) {
-  if (!orderBy?.length)
-    return "";
-  const parts = orderBy.map((o) => `${sanitizeIdentifier(o.column, kind)} ${o.direction === "desc" ? "DESC" : "ASC"}`);
-  return ` ORDER BY ${parts.join(", ")}`;
-}
 function isMysqlSpatialType(type) {
   const baseType = type.trim().toLowerCase().split(/[\s(]/, 1)[0];
   return MYSQL_SPATIAL_TYPES.has(baseType);
@@ -5268,9 +5641,12 @@ function createDockerAdapter(config) {
     const tableLiteral = table.replace(/'/g, "''");
     if (config.kind === "postgresql") {
       const schemaLiteral = postgresSchemaLiteral();
-      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END FROM information_schema.columns c LEFT JOIN (SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.table_name = kcu.table_name WHERE tc.table_schema = ${schemaLiteral} AND tc.table_name = '${tableLiteral}' AND tc.constraint_type = 'PRIMARY KEY') pk ON pk.column_name = c.column_name WHERE c.table_schema = ${schemaLiteral} AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
+      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END, COALESCE(d.description, '') FROM information_schema.columns c JOIN pg_namespace n ON n.nspname = c.table_schema JOIN pg_class cls ON cls.relnamespace = n.oid AND cls.relname = c.table_name LEFT JOIN pg_attribute a ON a.attrelid = cls.oid AND a.attname = c.column_name AND a.attnum > 0 AND NOT a.attisdropped LEFT JOIN pg_description d ON d.objoid = cls.oid AND d.objsubid = a.attnum LEFT JOIN (SELECT att.attname AS column_name FROM pg_index ix JOIN pg_class clp ON clp.oid = ix.indrelid JOIN pg_namespace nn ON nn.oid = clp.relnamespace JOIN pg_attribute att ON att.attrelid = ix.indrelid AND att.attnum = ANY(ix.indkey) WHERE ix.indisprimary AND nn.nspname = ${schemaLiteral} AND clp.relname = '${tableLiteral}') pk ON pk.column_name = c.column_name WHERE c.table_schema = ${schemaLiteral} AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
     }
-    return `SELECT column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${tableLiteral}' ORDER BY ordinal_position`;
+    return `SELECT column_name, column_type, is_nullable, column_default, column_key, column_comment FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${tableLiteral}' ORDER BY ordinal_position`;
+  }
+  function columnCommentFromInfoValue(value) {
+    return value ? value : null;
   }
   function columnsFromInfoRows(rows) {
     if (config.kind === "postgresql") {
@@ -5279,7 +5655,8 @@ function createDockerAdapter(config) {
         type: row[1],
         nullable: row[2] === "YES",
         primaryKey: row[4] === "YES",
-        defaultValue: row[3] === "" ? null : row[3]
+        defaultValue: row[3] === "" ? null : row[3],
+        comment: columnCommentFromInfoValue(row[5])
       }));
     }
     return rows.map((row) => ({
@@ -5287,7 +5664,8 @@ function createDockerAdapter(config) {
       type: row[1],
       nullable: row[2] === "YES",
       primaryKey: row[4] === "PRI",
-      defaultValue: row[3] === "NULL" ? null : row[3]
+      defaultValue: row[3] === "NULL" ? null : row[3],
+      comment: columnCommentFromInfoValue(row[5])
     }));
   }
   async function fetchColumnsAsyncUncached(table, signal) {
@@ -5386,10 +5764,10 @@ function createDockerAdapter(config) {
       let sql;
       if (config.kind === "postgresql") {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-        sql = `SELECT table_name, column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = ${postgresSchemaLiteral()} AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
+        sql = `SELECT c.table_name, c.column_name, c.data_type, c.is_nullable, c.column_default, COALESCE(d.description, '') FROM information_schema.columns c JOIN pg_namespace n ON n.nspname = c.table_schema JOIN pg_class cls ON cls.relnamespace = n.oid AND cls.relname = c.table_name LEFT JOIN pg_attribute a ON a.attrelid = cls.oid AND a.attname = c.column_name AND a.attnum > 0 AND NOT a.attisdropped LEFT JOIN pg_description d ON d.objoid = cls.oid AND d.objsubid = a.attnum WHERE c.table_schema = ${postgresSchemaLiteral()} AND c.table_name IN (${inList}) ORDER BY c.table_name, c.ordinal_position`;
       } else {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-        sql = `SELECT table_name, column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
+        sql = `SELECT table_name, column_name, column_type, is_nullable, column_default, column_key, column_comment FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
       }
       try {
         const queryResult = await execAsync(sql, signal);
@@ -5425,7 +5803,8 @@ function createDockerAdapter(config) {
               type: row[2],
               nullable: row[3] === "YES",
               primaryKey: pkCols.has(row[1]),
-              defaultValue: row[4] === "" ? null : row[4]
+              defaultValue: row[4] === "" ? null : row[4],
+              comment: columnCommentFromInfoValue(row[5])
             }));
           } else {
             cols = rows.map((row) => ({
@@ -5433,7 +5812,8 @@ function createDockerAdapter(config) {
               type: row[2],
               nullable: row[3] === "YES",
               primaryKey: row[5] === "PRI",
-              defaultValue: row[4] === "NULL" ? null : row[4]
+              defaultValue: row[4] === "NULL" ? null : row[4],
+              comment: columnCommentFromInfoValue(row[6])
             }));
           }
           columnCache.set(tbl, cols);
@@ -5526,12 +5906,7 @@ function createDockerAdapter(config) {
     async getFilteredTablePageWithMeta(table, options, signal) {
       const id = tableIdentifier(table);
       const columnsPromise = tableMetaCache.getColumns(table, () => fetchColumnsAsyncUncached(table, signal));
-      let columns;
-      try {
-        columns = await columnsPromise;
-      } catch (err) {
-        throw err;
-      }
+      const columns = await columnsPromise;
       const columnNames = columns.map((column) => column.name);
       const order = buildOrderClause(filterOrderByColumns(options.orderBy, columnNames), config.kind);
       const where = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), config.kind, filterExactColumns(options.exact, columnNames)).where;
@@ -5600,6 +5975,19 @@ function createDockerAdapter(config) {
         rowCount: Math.min(result.rows.length, maxRows)
       };
     },
+    async applyMutations(table, mutations, signal) {
+      const columns = await this.getColumnsAsync(table, signal);
+      if (columns.length === 0) {
+        throw new Error(`unknown table: ${table}`);
+      }
+      const statements = buildMutationStatements(table, mutations, columns, config.kind);
+      const body = statements.map((s) => s.sql).join(`;
+`);
+      const wrapped = config.kind === "postgresql" ? `BEGIN; SET LOCAL search_path = ${sanitizeIdentifier(currentPostgresSchema(), config.kind)}; ${body}; COMMIT` : `START TRANSACTION; ${body}; COMMIT`;
+      await execAsync(wrapped, signal);
+      this.invalidateTableMetaCache?.(table);
+      return { affected: statements.length };
+    },
     invalidateTableMetaCache(table) {
       tableMetaCache.invalidate(table);
       if (table) {
@@ -5781,9 +6169,12 @@ async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatab
 }
 var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES;
 var init_docker = __esm(() => {
+  init_mutate();
   init_sql_snapshot();
+  init_sql_utils();
   init_docker_utils();
   init_spawn_runner();
+  init_sql_capture();
   dockerDatabasesCache = new Map;
   dockerSchemasCache = new Map;
   spawnSyncImpl2 = spawnSync3;
@@ -5800,17 +6191,8 @@ var init_docker = __esm(() => {
   ]);
 });
 
-// web-src/server/database/adapters/sqlite.ts
-function safePrepare(db, sql) {
-  const stmt = db.prepare(sql);
-  if (typeof stmt.safeIntegers === "function") {
-    try {
-      stmt.safeIntegers(true);
-    } catch {}
-  }
-  return stmt;
-}
-async function getSqliteClass() {
+// web-src/server/database/sqlite-driver.ts
+async function loadSqliteClass() {
   if (cachedDbClass)
     return cachedDbClass;
   try {
@@ -5825,11 +6207,17 @@ async function getSqliteClass() {
   } catch {}
   throw new Error("No SQLite driver available. Install better-sqlite3 or use the bun runtime.");
 }
-function buildOrderClause2(orderBy) {
-  if (!orderBy?.length)
-    return "";
-  const parts = orderBy.map((o) => `${sanitizeIdentifier(o.column)} ${o.direction === "desc" ? "DESC" : "ASC"}`);
-  return ` ORDER BY ${parts.join(", ")}`;
+var cachedDbClass = null;
+
+// web-src/server/database/adapters/sqlite.ts
+function safePrepare(db, sql) {
+  const stmt = db.prepare(sql);
+  if (typeof stmt.safeIntegers === "function") {
+    try {
+      stmt.safeIntegers(true);
+    } catch {}
+  }
+  return stmt;
 }
 function queryRowsToResult(rows, columns) {
   const columnNames = rows.length > 0 ? Object.keys(rows[0]) : columns.map((c) => c.name);
@@ -5851,7 +6239,30 @@ function queryColumns(db, table) {
     defaultValue: row.dflt_value
   }));
 }
-function createSqliteAdapter(db) {
+function wrapDbWithSqlCapture(rawDb) {
+  return new Proxy(rawDb, {
+    get(target, prop, receiver) {
+      if (prop === "prepare") {
+        return (sql) => {
+          recordSql(sql);
+          return target.prepare(sql);
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function createSqliteAdapter(rawDb, openRawWriteDb) {
+  const db = wrapDbWithSqlCapture(rawDb);
+  let writeDb = null;
+  const getWriteDb = () => {
+    if (!openRawWriteDb) {
+      throw new Error("writes are not supported for this connection");
+    }
+    if (!writeDb)
+      writeDb = wrapDbWithSqlCapture(openRawWriteDb());
+    return writeDb;
+  };
   const adapter = {
     kind: "sqlite",
     model: "sql",
@@ -5951,7 +6362,7 @@ function createSqliteAdapter(db) {
       return this.getTableRowCounts(tables);
     },
     getTablePage(table, options) {
-      const order = buildOrderClause2(options.orderBy);
+      const order = buildOrderClause(options.orderBy);
       const sql = `SELECT * FROM ${sanitizeIdentifier(table)}${order} LIMIT ? OFFSET ?`;
       const rows = safePrepare(db, sql).all(options.limit, options.offset);
       const cols = queryColumns(db, table);
@@ -5963,7 +6374,7 @@ function createSqliteAdapter(db) {
     async getTablePageWithMeta(table, options) {
       const columns = queryColumns(db, table);
       const orderBy = filterOrderByColumns(options.orderBy, columns.map((column) => column.name));
-      const order = buildOrderClause2(orderBy);
+      const order = buildOrderClause(orderBy);
       const sql = `SELECT * FROM ${sanitizeIdentifier(table)}${order} LIMIT ? OFFSET ?`;
       const rows = safePrepare(db, sql).all(options.limit, options.offset);
       const result = queryRowsToResult(rows, columns);
@@ -5979,7 +6390,7 @@ function createSqliteAdapter(db) {
       const columns = queryColumns(db, table);
       const columnNames = columns.map((column) => column.name);
       const filter = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), "sqlite", filterExactColumns(options.exact, columnNames));
-      const order = buildOrderClause2(filterOrderByColumns(options.orderBy, columnNames));
+      const order = buildOrderClause(filterOrderByColumns(options.orderBy, columnNames));
       const tableId = sanitizeIdentifier(table);
       const whereClause = filter.where ? ` WHERE ${filter.where}` : "";
       const countRow = safePrepare(db, `SELECT COUNT(*) AS cnt FROM ${tableId}${whereClause}`).get(...filter.params);
@@ -6047,7 +6458,36 @@ function createSqliteAdapter(db) {
     async getTriggersAsync(table) {
       return this.getTriggers(table);
     },
+    async applyMutations(table, mutations) {
+      const columns = queryColumns(db, table);
+      if (columns.length === 0) {
+        throw new Error(`unknown table: ${table}`);
+      }
+      const statements = buildMutationStatements(table, mutations, columns, "sqlite");
+      const wdb = getWriteDb();
+      let affected = 0;
+      wdb.prepare("BEGIN").run();
+      try {
+        for (const stmt of statements) {
+          const result = wdb.prepare(stmt.sql).run(...stmt.params);
+          affected += result.changes ?? 0;
+        }
+        wdb.prepare("COMMIT").run();
+      } catch (err) {
+        try {
+          wdb.prepare("ROLLBACK").run();
+        } catch {}
+        throw err;
+      }
+      return { affected };
+    },
     close() {
+      if (writeDb) {
+        try {
+          writeDb.close();
+        } catch {}
+        writeDb = null;
+      }
       db.close();
     },
     async* iterateForSnapshot(table, signal) {
@@ -6085,14 +6525,18 @@ function createSqliteAdapter(db) {
   };
   return adapter;
 }
-var cachedDbClass = null, sqliteAdapterFactory;
+var sqliteAdapterFactory;
 var init_sqlite = __esm(() => {
+  init_mutate();
   init_sql_snapshot();
+  init_sql_utils();
+  init_sql_capture();
   sqliteAdapterFactory = {
     async open(path) {
-      const DbClass = await getSqliteClass();
+      const DbClass = await loadSqliteClass();
       const db = new DbClass(path, { readonly: true, create: false });
-      return createSqliteAdapter(db);
+      const openWriteDb = () => new DbClass(path);
+      return createSqliteAdapter(db, openWriteDb);
     }
   };
 });
@@ -6861,6 +7305,7 @@ function getPrimaryKeyColumnsFromColumns(columns) {
 }
 var init_global_search = __esm(() => {
   init_serialize();
+  init_sql_utils();
 });
 
 // web-src/server/database/adapters/elasticsearch.ts
@@ -7060,6 +7505,38 @@ function createElasticsearchAdapter(config) {
       primaryTerm: parsed._primary_term
     };
   }
+  function assertIndex(index) {
+    if (!index || index.includes("/") || index.includes("?")) {
+      throw new Error(`invalid index name: ${index}`);
+    }
+  }
+  async function writeDocAsync(opts) {
+    assertIndex(opts.index);
+    const idGiven = typeof opts.id === "string" && opts.id !== "";
+    let path;
+    let method;
+    if (idGiven && opts.create) {
+      path = `/${encodeURIComponent(opts.index)}/_create/${encodeURIComponent(opts.id)}`;
+      method = "PUT";
+    } else if (idGiven) {
+      path = `/${encodeURIComponent(opts.index)}/_doc/${encodeURIComponent(opts.id)}`;
+      method = "PUT";
+      if (opts.seqNo !== undefined && opts.primaryTerm !== undefined) {
+        path += `?if_seq_no=${opts.seqNo}&if_primary_term=${opts.primaryTerm}`;
+      }
+    } else {
+      path = `/${encodeURIComponent(opts.index)}/_doc`;
+      method = "POST";
+    }
+    const resp = await callJsonAsync(method, path, opts.source, "_doc write", opts.signal);
+    return { id: resp._id ?? opts.id ?? "", result: resp.result ?? "" };
+  }
+  async function deleteDocAsync(opts) {
+    assertIndex(opts.index);
+    if (!opts.id)
+      throw new Error("missing doc id");
+    await callJsonAsync("DELETE", `/${encodeURIComponent(opts.index)}/_doc/${encodeURIComponent(opts.id)}`, undefined, "_doc delete", opts.signal);
+  }
   async function* iterateForSnapshot(container, signal) {
     const { index, query: query2 } = parseEsSnapshotContainer(container);
     const PAGE = 1000;
@@ -7133,6 +7610,8 @@ function createElasticsearchAdapter(config) {
     getMappingAsync,
     searchDocsAsync,
     getDocAsync,
+    writeDocAsync,
+    deleteDocAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     query,
@@ -7612,6 +8091,51 @@ async function handleMapping(req, cwd, url, omitDirNames) {
     return handleError("elasticsearch", "read elasticsearch mapping", err);
   }
 }
+async function handleWrite(req, cwd, omitDirNames) {
+  const parsed = await parseBoundedJsonBody(req, 4 * 1024 * 1024, "payload too large");
+  if (parsed instanceof Response)
+    return parsed;
+  const body = parsed;
+  if (typeof body.db !== "string" || body.db === "") {
+    return textError("missing db", 400);
+  }
+  if (typeof body.index !== "string" || body.index === "") {
+    return textError("missing index", 400);
+  }
+  const id = typeof body.id === "string" ? body.id : undefined;
+  const r = await resolveEs(cwd, body.db, req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  try {
+    if (body.op === "delete") {
+      if (!id)
+        return textError("missing id", 400);
+      await r.explorer.deleteDocAsync({
+        index: body.index,
+        id,
+        signal: req.signal
+      });
+      return json({ ok: true });
+    }
+    if (body.source === null || typeof body.source !== "object" || Array.isArray(body.source)) {
+      return textError("source must be a JSON object", 400);
+    }
+    const seqNo = typeof body.seqNo === "number" ? body.seqNo : undefined;
+    const primaryTerm = typeof body.primaryTerm === "number" ? body.primaryTerm : undefined;
+    const result = await r.explorer.writeDocAsync({
+      index: body.index,
+      id,
+      source: body.source,
+      seqNo,
+      primaryTerm,
+      create: body.op === "create",
+      signal: req.signal
+    });
+    return json({ ok: true, id: result.id, result: result.result });
+  } catch (err) {
+    return handleError("elasticsearch", "write elasticsearch doc", err);
+  }
+}
 async function handleElasticsearchRoute(req, url, cwd, sideEffectAllowed, omitDirNames) {
   const wrap = createQueryStrippedLogger("elasticsearch", req, url);
   return dispatchRoutes(req, url, {
@@ -7631,6 +8155,11 @@ async function handleElasticsearchRoute(req, url, cwd, sideEffectAllowed, omitDi
       methods: ["GET"],
       handler: () => handleDoc(req, cwd, url, omitDirNames)
     },
+    "/_db/elasticsearch/write": {
+      methods: ["POST"],
+      sideEffect: true,
+      handler: () => handleWrite(req, cwd, omitDirNames)
+    },
     "/_db/elasticsearch/search": {
       methods: ["GET", "POST"],
       sideEffect: (m) => m === "POST",
@@ -7649,6 +8178,7 @@ var init_handle_elasticsearch = __esm(() => {
 var exports_redis = {};
 __export(exports_redis, {
   openRedisExplorerAsync: () => openRedisExplorerAsync,
+  createRedisAdapter: () => createRedisAdapter,
   canonicalizeRedisSnapshotContainer: () => canonicalizeRedisSnapshotContainer
 });
 import { createHash as createHash3 } from "node:crypto";
@@ -8170,6 +8700,41 @@ function createRedisAdapter(config) {
   async function listSnapshotContainers() {
     return [];
   }
+  async function runWriteAsync(args, signal) {
+    const res = await execRedisCliAsync(config, args, 1e4, signal);
+    if (res.code !== 0) {
+      throw new Error(res.stderr.trim() || res.stdout.trim() || "redis command failed");
+    }
+    const out = res.stdout.trim();
+    if (/^\(error\)/i.test(out) || /^ERR\b/i.test(out)) {
+      throw new Error(out);
+    }
+  }
+  async function setStringAsync(opts) {
+    await runWriteAsync(["-n", String(opts.db), "SET", opts.key, opts.value], opts.signal);
+  }
+  async function createStringAsync(opts) {
+    const res = await execRedisCliAsync(config, ["-n", String(opts.db), "SET", opts.key, opts.value, "NX"], 1e4, opts.signal);
+    if (res.code !== 0) {
+      throw new Error(res.stderr.trim() || res.stdout.trim() || "redis command failed");
+    }
+    const out = res.stdout.trim();
+    if (/^\(error\)/i.test(out) || /^ERR\b/i.test(out)) {
+      throw new Error(out);
+    }
+    if (!/\bOK\b/i.test(out)) {
+      throw new Error(`key already exists: ${opts.key}`);
+    }
+  }
+  async function setHashFieldAsync(opts) {
+    await runWriteAsync(["-n", String(opts.db), "HSET", opts.key, opts.field, opts.value], opts.signal);
+  }
+  async function setListIndexAsync(opts) {
+    await runWriteAsync(["-n", String(opts.db), "LSET", opts.key, String(opts.index), opts.value], opts.signal);
+  }
+  async function deleteKeyAsync(opts) {
+    await runWriteAsync(["-n", String(opts.db), "DEL", opts.key], opts.signal);
+  }
   return {
     kind: "redis",
     model: "kv",
@@ -8177,6 +8742,11 @@ function createRedisAdapter(config) {
     listDatabasesAsync,
     listKeysAsync,
     getValueAsync,
+    setStringAsync,
+    createStringAsync,
+    setHashFieldAsync,
+    setListIndexAsync,
+    deleteKeyAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     close() {}
@@ -8253,6 +8823,78 @@ async function handleKeys(req, cwd, url, omitDirNames) {
     return handleError("redis", "list redis keys", err);
   }
 }
+async function handleWrite2(req, cwd, omitDirNames) {
+  const parsed = await parseBoundedJsonBody(req, 1024 * 1024, "payload too large");
+  if (parsed instanceof Response)
+    return parsed;
+  const body = parsed;
+  if (typeof body.db !== "string" || body.db === "") {
+    return textError("missing db", 400);
+  }
+  const dbIndex = Number(body.dbIndex);
+  if (!Number.isInteger(dbIndex) || dbIndex < 0 || dbIndex > 15) {
+    return textError("dbIndex must be an integer in 0..15", 400);
+  }
+  if (typeof body.key !== "string" || body.key === "") {
+    return textError("missing key", 400);
+  }
+  const op = body.op;
+  const value = typeof body.value === "string" ? body.value : "";
+  const r = await resolveRedis(cwd, body.db, req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  try {
+    if (op === "setString") {
+      await r.explorer.setStringAsync({
+        db: dbIndex,
+        key: body.key,
+        value,
+        signal: req.signal
+      });
+    } else if (op === "createString") {
+      await r.explorer.createStringAsync({
+        db: dbIndex,
+        key: body.key,
+        value,
+        signal: req.signal
+      });
+    } else if (op === "setHashField") {
+      if (typeof body.field !== "string" || body.field === "") {
+        return textError("missing field", 400);
+      }
+      await r.explorer.setHashFieldAsync({
+        db: dbIndex,
+        key: body.key,
+        field: body.field,
+        value,
+        signal: req.signal
+      });
+    } else if (op === "setListIndex") {
+      const index = Number(body.index);
+      if (!Number.isInteger(index) || index < 0) {
+        return textError("index must be a non-negative integer", 400);
+      }
+      await r.explorer.setListIndexAsync({
+        db: dbIndex,
+        key: body.key,
+        index,
+        value,
+        signal: req.signal
+      });
+    } else if (op === "delete") {
+      await r.explorer.deleteKeyAsync({
+        db: dbIndex,
+        key: body.key,
+        signal: req.signal
+      });
+    } else {
+      return textError(`unknown op: ${String(op)}`, 400);
+    }
+    return json({ ok: true });
+  } catch (err) {
+    return handleError("redis", "write redis value", err);
+  }
+}
 async function handleRedisRoute(req, url, cwd, sideEffectAllowed, omitDirNames) {
   const wrap = createQueryStrippedLogger("redis", req, url);
   return dispatchRoutes(req, url, {
@@ -8267,6 +8909,11 @@ async function handleRedisRoute(req, url, cwd, sideEffectAllowed, omitDirNames)
     "/_db/redis/value": {
       methods: ["GET"],
       handler: () => handleValue(req, cwd, url, omitDirNames)
+    },
+    "/_db/redis/write": {
+      methods: ["POST"],
+      sideEffect: true,
+      handler: () => handleWrite2(req, cwd, omitDirNames)
     }
   }, sideEffectAllowed, wrap, (err) => handleError("redis", "handle redis request", err));
 }
@@ -8344,6 +8991,9 @@ function hmac(key, value) {
 function sha256(value) {
   return createHash4("sha256").update(value, "utf8").digest("hex");
 }
+function sha256Bytes(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
 function encodeRfc3986(value) {
   return encodeURIComponent(value).replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`);
 }
@@ -8713,9 +9363,10 @@ function createS3Adapter(config) {
       const path = buildPath(opts.bucket, opts.key);
       const query = canonicalQuery(opts.query);
       const url = `${config.endpoint.replace(/\/$/, "")}${path}${query ? `?${query}` : ""}`;
+      const payloadHash = opts.body ? sha256Bytes(opts.body) : EMPTY_SHA256;
       const headers = {
         host: endpoint.host,
-        "x-amz-content-sha256": EMPTY_SHA256,
+        "x-amz-content-sha256": payloadHash,
         "x-amz-date": requestDate,
         ...config.sessionToken ? { "x-amz-security-token": config.sessionToken } : {},
         ...opts.headers || {}
@@ -8727,7 +9378,7 @@ function createS3Adapter(config) {
         query,
         canonicalHeaders(headers),
         signedNames,
-        EMPTY_SHA256
+        payloadHash
       ].join(`
 `);
       const scope = `${dateStamp}/${config.region}/s3/aws4_request`;
@@ -8746,6 +9397,9 @@ function createS3Adapter(config) {
       }
       requestHeaders.set("Authorization", `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${scope}, SignedHeaders=${signedNames}, Signature=${signature}`);
       if (config.dockerContainerName) {
+        if (opts.body !== undefined) {
+          throw new S3HttpError(503, "S3 object writes require a published host port (docker-exec transport cannot stream a request body)");
+        }
         if (opts.method === "GET" && opts.key && !opts.headers?.range && !opts.headers?.Range) {
           throw new S3HttpError(503, "S3 raw streaming requires a published host port or a ranged request");
         }
@@ -8760,6 +9414,7 @@ function createS3Adapter(config) {
       return fetch(url, {
         method: opts.method,
         headers: requestHeaders,
+        ...opts.body !== undefined ? { body: opts.body } : {},
         signal: transportSignal
       });
     }, deadline);
@@ -8842,6 +9497,32 @@ function createS3Adapter(config) {
       headers: rawObjectHeaders(opts.key, res)
     });
   }
+  async function putObjectAsync(opts) {
+    const deadline = createS3TransportDeadline(config);
+    const res = await signedFetch({
+      method: "PUT",
+      bucket: opts.bucket,
+      key: opts.key,
+      body: opts.body,
+      headers: opts.contentType ? { "content-type": opts.contentType } : undefined,
+      signal: opts.signal
+    }, deadline);
+    if (!res.ok) {
+      throw sanitizeS3Error(res.status, await readResponseTextWithTimeout(res, opts.signal, deadline));
+    }
+  }
+  async function deleteObjectAsync(opts) {
+    const deadline = createS3TransportDeadline(config);
+    const res = await signedFetch({
+      method: "DELETE",
+      bucket: opts.bucket,
+      key: opts.key,
+      signal: opts.signal
+    }, deadline);
+    if (!res.ok) {
+      throw sanitizeS3Error(res.status, await readResponseTextWithTimeout(res, opts.signal, deadline));
+    }
+  }
   return {
     kind: "s3",
     model: "object",
@@ -8850,7 +9531,9 @@ function createS3Adapter(config) {
     listObjects,
     headObject,
     getObjectText,
-    getObjectResponse
+    getObjectResponse,
+    putObjectAsync,
+    deleteObjectAsync
   };
 }
 async function s3ConfigFromDockerInfoAsync(info, signal) {
@@ -9253,6 +9936,60 @@ async function handleRaw(cwd, req, url, omitDirNames) {
     return s3ErrorResponse(err, "stream s3 object");
   }
 }
+async function handleWrite3(req, cwd, omitDirNames) {
+  const parsed = await parseBoundedJsonBody(req, 8 * 1024 * 1024, "payload too large");
+  if (parsed instanceof Response)
+    return parsed;
+  const body = parsed;
+  if (typeof body.db !== "string" || body.db === "") {
+    return textError("missing db", 400);
+  }
+  const bucket = validateBucket(typeof body.bucket === "string" ? body.bucket : null);
+  if (bucket instanceof Response)
+    return bucket;
+  const key = validateKey(typeof body.key === "string" ? body.key : null);
+  if (key instanceof Response)
+    return key;
+  const r = await resolveS3(cwd, body.db, req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  try {
+    if (body.op === "delete") {
+      await r.explorer.deleteObjectAsync({
+        bucket,
+        key,
+        signal: req.signal
+      });
+      return json({ ok: true });
+    }
+    if (body.op === "create") {
+      let exists = false;
+      try {
+        await r.explorer.headObject({ bucket, key, signal: req.signal });
+        exists = true;
+      } catch (err) {
+        if (isS3HttpError(err) && err.status === 404)
+          exists = false;
+        else
+          throw err;
+      }
+      if (exists)
+        return textError(`object already exists: ${key}`, 409);
+    }
+    const content = typeof body.content === "string" ? body.content : "";
+    const contentType = typeof body.contentType === "string" && body.contentType ? body.contentType : "application/octet-stream";
+    await r.explorer.putObjectAsync({
+      bucket,
+      key,
+      body: new TextEncoder().encode(content),
+      contentType,
+      signal: req.signal
+    });
+    return json({ ok: true });
+  } catch (err) {
+    return handleError("s3", "write s3 object", err);
+  }
+}
 async function handleS3Route(req, url, cwd, sideEffectAllowed, omitDirNames) {
   const wrap = createQueryStrippedLogger("s3", req, url);
   return dispatchRoutes(req, url, {
@@ -9279,6 +10016,11 @@ async function handleS3Route(req, url, cwd, sideEffectAllowed, omitDirNames) {
     "/_db/s3/raw": {
       methods: ["GET", "HEAD"],
       handler: () => handleRaw(cwd, req, url, omitDirNames)
+    },
+    "/_db/s3/write": {
+      methods: ["POST"],
+      sideEffect: true,
+      handler: () => handleWrite3(req, cwd, omitDirNames)
     }
   }, sideEffectAllowed, wrap, (err) => handleError("s3", "handle s3 request", err));
 }
@@ -9445,21 +10187,6 @@ var init_query_history = __esm(() => {
 import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join11 } from "node:path";
-async function getSqliteClass2() {
-  if (cachedDbClass2)
-    return cachedDbClass2;
-  try {
-    const mod = await import("bun:sqlite");
-    cachedDbClass2 = mod.Database;
-    return cachedDbClass2;
-  } catch {}
-  try {
-    const mod = await Function('return import("better-sqlite3")')();
-    cachedDbClass2 = mod.default || mod;
-    return cachedDbClass2;
-  } catch {}
-  throw new Error("No SQLite driver available. Install better-sqlite3 or use the bun runtime.");
-}
 async function getStoreDb(cwd) {
   const dbPath = join11(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
@@ -9470,7 +10197,7 @@ async function getStoreDb(cwd) {
     } catch {}
   }
   mkdirSync3(join11(cwd, CODE_VIEWER_DIR4), { recursive: true });
-  const DbClass = await getSqliteClass2();
+  const DbClass = await loadSqliteClass();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
   storeDb.exec("PRAGMA journal_mode=WAL");
@@ -9729,7 +10456,7 @@ async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit
   });
   return { rows, total };
 }
-var CODE_VIEWER_DIR4 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite", cachedDbClass2 = null, SCHEMA_SQL = `
+var CODE_VIEWER_DIR4 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite", SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS snapshots (
   id TEXT PRIMARY KEY,
   db_id TEXT NOT NULL,
@@ -9959,6 +10686,9 @@ function sanitize(input) {
     const historyHeight = sanitizeCssSize(tab.historyHeight);
     if (historyHeight !== undefined)
       out.historyHeight = historyHeight;
+    if (tab.activeHistoryTab === "log" || tab.activeHistoryTab === "history") {
+      out.activeHistoryTab = tab.activeHistoryTab;
+    }
     const sidebarWidth = sanitizeCssSize(tab.sidebarWidth);
     if (sidebarWidth !== undefined)
       out.sidebarWidth = sidebarWidth;
@@ -10149,11 +10879,13 @@ async function handleSchemas(cwd, url, omitDirNames, signal) {
     const body2 = { dbId: r.dbId, schemas: [] };
     return json(body2);
   }
-  const schemas = await listDockerSchemasAsync(r.docker.serviceName, "postgresql", r.docker.env, r.docker.composeDir, r.docker.database, signal);
+  const docker = r.docker;
+  const { result: schemas, executedSql } = await captureSql(() => listDockerSchemasAsync(docker.serviceName, "postgresql", docker.env, docker.composeDir, docker.database, signal));
   const body = {
     dbId: r.dbId,
     schemas: schemas.map((name) => ({ name })),
-    selectedSchema: r.schema
+    selectedSchema: r.schema,
+    executedSql
   };
   return json(body);
 }
@@ -10165,37 +10897,41 @@ async function handleSchema(cwd, url, omitDirNames, signal) {
   const linkedAbort = createLinkedAbortController(signal);
   try {
     const adapter = await getAdapter(r, cwd, signal);
-    const db = asAsync(adapter);
-    const tables = await db.tables(linkedAbort.signal);
-    const tableNames = tables.filter((t) => t.type === "table").map((t) => t.name);
-    const countMapPromise = db.tableRowCounts(tableNames, linkedAbort.signal);
-    const indexesPromise = db.indexes(linkedAbort.signal);
-    const foreignKeysPromise = db.foreignKeys(linkedAbort.signal);
-    const columnsMapPromise = includeColumns ? db.columnsMulti(tableNames, linkedAbort.signal) : Promise.resolve(null);
-    const schemaPromises = [
-      countMapPromise,
-      indexesPromise,
-      foreignKeysPromise,
-      columnsMapPromise
-    ];
-    const [countMap, indexes, foreignKeys, colsMap] = await Promise.all(schemaPromises).catch(async (err) => {
-      linkedAbort.abort();
-      await Promise.allSettled(schemaPromises);
-      throw err;
+    const { result, executedSql } = await captureSql(async () => {
+      const db = asAsync(adapter);
+      const tables = await db.tables(linkedAbort.signal);
+      const tableNames = tables.filter((t) => t.type === "table").map((t) => t.name);
+      const countMapPromise = db.tableRowCounts(tableNames, linkedAbort.signal);
+      const indexesPromise = db.indexes(linkedAbort.signal);
+      const foreignKeysPromise = db.foreignKeys(linkedAbort.signal);
+      const columnsMapPromise = includeColumns ? db.columnsMulti(tableNames, linkedAbort.signal) : Promise.resolve(null);
+      const schemaPromises = [
+        countMapPromise,
+        indexesPromise,
+        foreignKeysPromise,
+        columnsMapPromise
+      ];
+      const [countMap, indexes, foreignKeys, colsMap] = await Promise.all(schemaPromises).catch(async (err) => {
+        linkedAbort.abort();
+        await Promise.allSettled(schemaPromises);
+        throw err;
+      });
+      return { tables, countMap, indexes, foreignKeys, colsMap };
     });
-    const tablesWithCount = tables.map((t) => ({
+    const tablesWithCount = result.tables.map((t) => ({
       ...t,
-      rowCount: t.type === "table" ? countMap.get(t.name) ?? 0 : null
+      rowCount: t.type === "table" ? result.countMap.get(t.name) ?? 0 : null
     }));
     const body = {
       dbId: r.dbId,
       ...r.schema ? { schema: r.schema } : {},
       tables: tablesWithCount,
-      indexes,
-      foreignKeys
+      indexes: result.indexes,
+      foreignKeys: result.foreignKeys,
+      executedSql
     };
-    if (colsMap) {
-      body.columnsMap = Object.fromEntries(colsMap);
+    if (result.colsMap) {
+      body.columnsMap = Object.fromEntries(result.colsMap);
     }
     return json(body);
   } catch (err) {
@@ -10257,36 +10993,17 @@ async function handleTable(cwd, url, omitDirNames, signal) {
   const exact = parseExactConditions(url);
   try {
     const adapter = await getAdapter(r, cwd, signal);
-    if (filters.length > 0 || exact.length > 0) {
-      const meta2 = await adapter.getFilteredTablePageWithMeta(table, {
-        offset,
-        limit,
-        orderBy,
-        grouped: groupFiltersByValue(filters),
-        ...exact.length > 0 ? { exact } : {}
-      }, signal);
-      const colNames2 = new Set(meta2.columns.map((c) => c.name));
-      if (sortCol && !colNames2.has(sortCol)) {
-        return textError(`invalid sort column: ${sortCol}`, 400);
-      }
-      const body2 = {
-        dbId: r.dbId,
-        ...r.schema ? { schema: r.schema } : {},
-        table,
-        columns: meta2.columns,
-        rows: serializeDbRows(meta2.rows),
-        totalRows: meta2.totalRows,
-        offset,
-        limit,
-        hasMore: offset + meta2.rowCount < meta2.totalRows
-      };
-      return json(body2);
-    }
-    const meta = await adapter.getTablePageWithMeta(table, {
+    const { result: meta, executedSql } = await captureSql(() => filters.length > 0 || exact.length > 0 ? adapter.getFilteredTablePageWithMeta(table, {
+      offset,
+      limit,
+      orderBy,
+      grouped: groupFiltersByValue(filters),
+      ...exact.length > 0 ? { exact } : {}
+    }, signal) : adapter.getTablePageWithMeta(table, {
       offset,
       limit,
       orderBy
-    }, signal);
+    }, signal));
     const colNames = new Set(meta.columns.map((c) => c.name));
     if (sortCol && !colNames.has(sortCol)) {
       return textError(`invalid sort column: ${sortCol}`, 400);
@@ -10300,7 +11017,8 @@ async function handleTable(cwd, url, omitDirNames, signal) {
       totalRows: meta.totalRows,
       offset,
       limit,
-      hasMore: offset + meta.rowCount < meta.totalRows
+      hasMore: offset + meta.rowCount < meta.totalRows,
+      executedSql
     };
     return json(body);
   } catch (err) {
@@ -10377,8 +11095,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
   const start = Date.now();
   try {
     const adapter = await getAdapter(r, cwd, req.signal);
-    const db = asAsync(adapter);
-    const result = await db.readonlyQuery(body.sql, undefined, maxRows, req.signal);
+    const { result, executedSql } = await captureSql(() => asAsync(adapter).readonlyQuery(body.sql ?? "", undefined, maxRows, req.signal));
     const elapsed = Date.now() - start;
     const serializedRows = serializeDbRows(result.rows);
     const inferredColumns = result.columns.length === 0 && result.rows.length === 0 ? await inferEmptyQueryColumns(adapter, body.sql, r.schema, req.signal) : [];
@@ -10392,7 +11109,8 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
       rows: serializedRows,
       rowCount: result.rowCount,
       truncated: result.rowCount >= maxRows,
-      elapsedMs: elapsed
+      elapsedMs: elapsed,
+      executedSql
     };
     if (body.saveHistory) {
       const entry = {
@@ -10611,13 +11329,13 @@ async function handleColumns(cwd, url, omitDirNames, signal) {
     return textError("missing table parameter", 400);
   try {
     const adapter = await getAdapter(r, cwd, signal);
-    const db = asAsync(adapter);
-    const columns = await db.columns(table, signal);
+    const { result: columns, executedSql } = await captureSql(() => asAsync(adapter).columns(table, signal));
     return json({
       dbId: r.dbId,
       ...r.schema ? { schema: r.schema } : {},
       table,
-      columns
+      columns,
+      executedSql
     });
   } catch (err) {
     return handleError("database", "get columns", err);
@@ -10632,17 +11350,21 @@ async function handleDdl(cwd, url, omitDirNames, signal) {
     return textError("missing table parameter", 400);
   try {
     const adapter = await getAdapter(r, cwd, signal);
-    const db = asAsync(adapter);
-    const [sql, triggers] = await Promise.all([
-      db.createStatement(table, signal),
-      db.triggers(table, signal)
-    ]);
+    const { result, executedSql } = await captureSql(async () => {
+      const db = asAsync(adapter);
+      const [sql, triggers] = await Promise.all([
+        db.createStatement(table, signal),
+        db.triggers(table, signal)
+      ]);
+      return { sql, triggers };
+    });
     return json({
       dbId: r.dbId,
       ...r.schema ? { schema: r.schema } : {},
       table,
-      sql,
-      triggers
+      sql: result.sql,
+      triggers: result.triggers,
+      executedSql
     });
   } catch (err) {
     return handleError("database", "get DDL", err);
@@ -11054,6 +11776,48 @@ async function handleClose(cwd, req, omitDirNames) {
   }
   return json({ ok: true });
 }
+async function handleMutate(cwd, req, omitDirNames) {
+  const parsed = await parseBoundedJsonBody(req, 1048576, "payload too large");
+  if (parsed instanceof Response)
+    return parsed;
+  const body = parsed;
+  if (typeof body.db !== "string" || body.db === "") {
+    return textError("missing db", 400);
+  }
+  if (typeof body.table !== "string" || body.table === "") {
+    return textError("missing table", 400);
+  }
+  if (!Array.isArray(body.mutations) || body.mutations.length === 0) {
+    return textError("missing mutations", 400);
+  }
+  const schemaParam = typeof body.schema === "string" ? body.schema : undefined;
+  const r = await resolveDb(cwd, body.db, omitDirNames, schemaParam, req.signal);
+  if (r instanceof Response)
+    return r;
+  const adapter = await getAdapter(r, cwd, req.signal);
+  if (!adapter.applyMutations) {
+    return textError("writes are not supported for this datastore", 400);
+  }
+  try {
+    const tableName = body.table;
+    const { result, executedSql } = await captureSql(() => adapter.applyMutations?.(tableName, body.mutations, req.signal) ?? Promise.reject(new Error("applyMutations not supported")));
+    adapter.invalidateTableMetaCache?.(tableName);
+    const response = {
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table: tableName,
+      affected: result.affected,
+      executedSql
+    };
+    return json(response);
+  } catch (err) {
+    if (isAbortLikeError(err, req.signal)) {
+      return textError("mutation aborted", 503);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return textError(message, 400);
+  }
+}
 async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowed, sendSse) {
   ensureInit();
   if (url.pathname.startsWith("/_db/redis/")) {
@@ -11114,6 +11878,11 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       sideEffect: true,
       handler: () => handleQuery(cwd, req, sendSse, omitDirNames)
     },
+    "/_db/mutate": {
+      methods: ["POST"],
+      sideEffect: true,
+      handler: () => handleMutate(cwd, req, omitDirNames)
+    },
     "/_db/close": {
       methods: ["POST"],
       sideEffect: true,
@@ -11196,6 +11965,7 @@ var init_handle = __esm(() => {
   init_state_store();
   init_docker();
   init_docker_utils();
+  init_sql_capture();
   init_sqlite();
   init_connection_pool();
   init_discovery();
@@ -11607,7 +12377,7 @@ function fileToMeta(file, range, extraQs) {
     untracked: file.untracked || false
   };
 }
-function computePayload(extras, range) {
+function computePayload(extras, range, pathFilter = "") {
   if (isSameWorktreeRange(range)) {
     return {
       files: [],
@@ -11623,8 +12393,9 @@ function computePayload(extras, range) {
   const files = fileMeta(fullArgs, cwd, false);
   if (includeUntracked(range, refs2))
     files.push(...untrackedMeta(cwd));
-  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  files.forEach((file, i) => {
+  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);
+  filteredFiles.forEach((file, i) => {
     file.order = i + 1;
   });
   const extraQs = {};
@@ -11634,7 +12405,7 @@ function computePayload(extras, range) {
     if (e === "--ignore-blank-lines")
       extraQs.ignore_blank = "1";
   }
-  const meta = files.map((file) => fileToMeta(file, range, extraQs));
+  const meta = filteredFiles.map((file) => fileToMeta(file, range, extraQs));
   const totals = meta.reduce((acc, file) => {
     acc.additions += file.additions || 0;
     acc.deletions += file.deletions || 0;
@@ -11661,9 +12432,12 @@ function handleDiffJson(url) {
     from: url.searchParams.get("from") || "",
     to: url.searchParams.get("to") || ""
   };
-  const key = `${range.from}|${range.to}|${url.searchParams.get("ignore_ws") || ""}|${url.searchParams.get("ignore_blank") || ""}`;
+  const path = url.searchParams.get("path") || "";
+  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);
+    const payload2 = computePayload(extras, range, path);
     const sig = JSON.stringify({ ...payload2, generation: undefined });
     const cached2 = metaCache.get(key);
     if (!cached2 || cached2.sig !== sig) {
@@ -11689,7 +12463,7 @@ function handleDiffJson(url) {
         "Cache-Control": "no-store"
       }
     });
-  const payload = computePayload(extras, range);
+  const payload = computePayload(extras, range, path);
   const body = JSON.stringify(payload);
   setTimedCacheEntry(metaCache, key, {
     body,
@@ -12106,15 +12880,109 @@ function handleLog(url) {
   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, {
     ref,
     skip: Number.isFinite(skip) ? skip : 0,
     limit: Number.isFinite(limit) ? limit : 50,
-    query: url.searchParams.get("q") || ""
+    query: url.searchParams.get("q") || "",
+    ...path ? { path } : {}
   });
   if (result.error)
     return text(result.error, 400);
-  return json2({ commits: result.commits, hasMore: result.hasMore });
+  const wantsWorktreeHead = path && skip === 0 && (ref === "worktree" || url.searchParams.get("worktree") === "1");
+  let commits = result.commits;
+  let hasWorktree = false;
+  if (wantsWorktreeHead) {
+    const status = runSync([
+      "git",
+      "-c",
+      "core.quotepath=false",
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=normal",
+      "--",
+      path
+    ], cwd);
+    if (status.code === 0 && status.stdout.length > 0) {
+      const parts = status.stdout.split("\x00").filter(Boolean);
+      if (parts.length > 0) {
+        hasWorktree = true;
+        commits = [
+          {
+            sha: "worktree",
+            subject: "未コミット変更 (Working tree)",
+            author: "",
+            when: "",
+            parents: [],
+            body: ""
+          },
+          ...commits
+        ];
+      }
+    }
+  }
+  return json2({
+    commits,
+    hasMore: result.hasMore,
+    generation,
+    ...hasWorktree ? { hasWorktree: true } : {}
+  });
+}
+function blamePathKey(p) {
+  try {
+    const st = statSync3(join13(cwd, p));
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return "missing";
+  }
+}
+function rememberBlame(key, value) {
+  if (blameCache.has(key))
+    blameCache.delete(key);
+  blameCache.set(key, value);
+  while (blameCache.size > BLAME_CACHE_MAX) {
+    const oldest = blameCache.keys().next();
+    if (oldest.done)
+      break;
+    blameCache.delete(oldest.value);
+  }
+}
+function handleFileBlame(url) {
+  const path = url.searchParams.get("path") || "";
+  if (!safePath(path))
+    return text("invalid path", 400);
+  const ref = url.searchParams.get("ref") || "worktree";
+  if (!ref || ref.startsWith("-") || ref.includes("\x00"))
+    return text("invalid ref", 400);
+  const rawBase = url.searchParams.get("base");
+  const requestedBase = rawBase === "HEAD" ? "HEAD" : rawBase === "worktree" ? "worktree" : ref === "worktree" ? "worktree" : "HEAD";
+  const normalized = normalizeBlameRef(ref, requestedBase);
+  const { base } = normalized;
+  let cacheKey;
+  if (base === "worktree") {
+    cacheKey = `worktree|${path}|${blamePathKey(path)}`;
+  } else {
+    const resolved = runSync(["git", "rev-parse", "--verify", `${normalized.ref}^{commit}`], cwd);
+    if (resolved.code !== 0)
+      return text("unknown ref", 400);
+    cacheKey = `HEAD|${path}|${resolved.stdout.trim()}`;
+  }
+  const cached = blameCache.get(cacheKey);
+  if (cached) {
+    if (blameCache.has(cacheKey)) {
+      blameCache.delete(cacheKey);
+      blameCache.set(cacheKey, cached);
+    }
+    return json2({ ...cached, base, ref, generation });
+  }
+  const result = blame(cwd, { path, ref: normalized.ref, base });
+  if (!result.error)
+    rememberBlame(cacheKey, result);
+  return json2({ ...result, base, ref, generation });
 }
 function handleFileDiff(url) {
   const path = url.searchParams.get("path") || "";
@@ -13123,7 +13991,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, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, rgAvailableCache = null, enc, sseClients, sseKeepalives, fileCache, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, 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, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, rgAvailableCache = null, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX = 64, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, isCodeViewerInternalPath, watchLimitReached = null, server, worktreeWatch = null, shuttingDown = false;
 var init_preview = __esm(async () => {
   init_routes();
   init_annotations();
@@ -13191,6 +14059,7 @@ var init_preview = __esm(async () => {
   sseClients = new Set;
   sseKeepalives = new Map;
   fileCache = new Map;
+  blameCache = new Map;
   metaCache = new Map;
   fileListCache = new Map;
   lineIndexCache = new Map;
@@ -13223,6 +14092,8 @@ var init_preview = __esm(async () => {
         return handleRefCommits(url);
       if (url.pathname === "/_log")
         return handleLog(url);
+      if (url.pathname === "/_file_blame")
+        return handleFileBlame(url);
       if (url.pathname === "/file_diff")
         return handleFileDiff(url);
       if (url.pathname === "/file_range")