@youtyan/code-viewer 0.3.0 → 0.4.1

package/dist/code-viewer.js

@@ -3888,10 +3888,260 @@ var init_search = __esm(() => {
   DEFAULT_EXCLUDE_NAMES = [".DS_Store"];
 });
 
+// web-src/server/worktree-watcher.ts
+import {
+  lstatSync as lstatSync3,
+  readdirSync as nodeReaddirSync,
+  watch as nodeWatch
+} from "node:fs";
+import { join as join7, relative } from "node:path";
+function normalizeRelativePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isInsideRoot(root, path) {
+  const rel = relative(root, path).replace(/\\/g, "/");
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
+}
+function startWorktreeUpdateWatch(options) {
+  const watch = options.watch || nodeWatch;
+  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
+  const isDirectory = options.isDirectory || ((path) => {
+    try {
+      return lstatSync3(path).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const directorySignature = options.directorySignature || ((path) => {
+    try {
+      const stats = lstatSync3(path);
+      if (!stats.isDirectory())
+        return null;
+      return `${stats.dev}:${stats.ino}`;
+    } catch {
+      return null;
+    }
+  });
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 250;
+  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
+  const watchers = new Map;
+  const signatures = new Map;
+  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
+  const initialScanQueue = [];
+  let initialScanTimer = null;
+  const pendingPathInspections = new Map;
+  let pathInspectionTimer = null;
+  let timer = null;
+  const pendingChangedPaths = new Set;
+  let watchLimitReported = false;
+  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative(options.root, dir));
+  const ignoredDirectory = (dir) => {
+    const rel = directoryRelativePath(dir);
+    return Boolean(rel && ignored(rel));
+  };
+  const scheduleUpdate = (changedPath) => {
+    if (changedPath)
+      pendingChangedPaths.add(changedPath);
+    if (timer)
+      clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      const paths = pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
+      pendingChangedPaths.clear();
+      options.onUpdate(paths);
+    }, debounceMs);
+  };
+  const reportWatchLimit = () => {
+    if (watchLimitReported)
+      return;
+    watchLimitReported = true;
+    options.onWatchLimit?.(maxWatchedDirectories);
+    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
+  };
+  const closeSubtree = (dir) => {
+    for (const [watchedDir, watcher] of [...watchers]) {
+      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
+        continue;
+      try {
+        watcher.close?.();
+      } catch {}
+      watchers.delete(watchedDir);
+      signatures.delete(watchedDir);
+    }
+  };
+  const closeAll = () => {
+    if (initialScanTimer) {
+      clearTimer(initialScanTimer);
+      initialScanTimer = null;
+    }
+    if (pathInspectionTimer) {
+      clearTimer(pathInspectionTimer);
+      pathInspectionTimer = null;
+    }
+    initialScanQueue.length = 0;
+    pendingPathInspections.clear();
+    for (const watcher of [...watchers.values()]) {
+      try {
+        watcher.close?.();
+      } catch {}
+    }
+    watchers.clear();
+    signatures.clear();
+  };
+  const readChildDirectories = (dir) => {
+    let entries;
+    try {
+      entries = readDirs(dir);
+    } catch (error) {
+      options.onError?.(error);
+      return [];
+    }
+    const children = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const child = join7(dir, entry.name);
+      if (ignoredDirectory(child))
+        continue;
+      children.push(child);
+    }
+    return children;
+  };
+  const processInitialScanQueue = () => {
+    initialScanTimer = null;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+      return;
+    }
+    const next = initialScanQueue.shift();
+    if (next)
+      watchDirectory(next, true);
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+    }
+    if (initialScanQueue.length)
+      initialScanTimer = setTimer(processInitialScanQueue, 50);
+  };
+  const queueInitialChildren = (dir) => {
+    const remaining = maxWatchedDirectories - watchers.size;
+    if (remaining <= 0) {
+      reportWatchLimit();
+      return;
+    }
+    const children = readChildDirectories(dir);
+    if (children.length > remaining)
+      reportWatchLimit();
+    initialScanQueue.push(...children.slice(0, remaining));
+    if (!initialScanTimer)
+      initialScanTimer = setTimer(processInitialScanQueue, 5000);
+  };
+  const processChangedPath = (changed, fullChangedPath) => {
+    const known = watchers.has(fullChangedPath);
+    if (isDirectory(fullChangedPath)) {
+      if (known) {
+        const signature = directorySignature(fullChangedPath);
+        if (signature && signature !== signatures.get(fullChangedPath)) {
+          closeSubtree(fullChangedPath);
+          watchDirectory(fullChangedPath, initialScanAsync);
+        }
+        scheduleUpdate(changed);
+        return;
+      }
+      watchDirectory(fullChangedPath, initialScanAsync);
+    } else if (known) {
+      closeSubtree(fullChangedPath);
+    }
+    scheduleUpdate(changed);
+  };
+  const processPathInspections = () => {
+    pathInspectionTimer = null;
+    const entries = [...pendingPathInspections];
+    pendingPathInspections.clear();
+    for (const [changed, fullChangedPath] of entries) {
+      processChangedPath(changed, fullChangedPath);
+    }
+  };
+  const queuePathInspection = (changed, fullChangedPath) => {
+    pendingPathInspections.set(changed, fullChangedPath);
+    if (!pathInspectionTimer)
+      pathInspectionTimer = setTimer(processPathInspections, 25);
+  };
+  const watchDirectory = (dir, initialScan = false) => {
+    if (watchers.has(dir))
+      return;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    const rel = directoryRelativePath(dir);
+    if (rel && ignored(rel))
+      return;
+    try {
+      const watcher = watch(dir, { persistent: false }, (_event, filename) => {
+        if (!filename) {
+          scheduleUpdate();
+          return;
+        }
+        const changed = normalizeRelativePath(join7(rel, filename.toString()));
+        if (ignored(changed))
+          return;
+        const fullChangedPath = join7(options.root, changed);
+        if (!isInsideRoot(options.root, fullChangedPath))
+          return;
+        if (initialScanAsync) {
+          queuePathInspection(changed, fullChangedPath);
+          return;
+        }
+        processChangedPath(changed, fullChangedPath);
+      }) || {};
+      watchers.set(dir, watcher);
+      const signature = directorySignature(dir);
+      if (signature)
+        signatures.set(dir, signature);
+      watcher.on?.("error", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+      watcher.on?.("close", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+    } catch (error) {
+      options.onError?.(error);
+      return;
+    }
+    if (initialScanAsync && initialScan) {
+      queueInitialChildren(dir);
+      return;
+    }
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    for (const child of readChildDirectories(dir))
+      watchDirectory(child);
+  };
+  watchDirectory(options.root, true);
+  return { started: watchers.size > 0, close: closeAll };
+}
+var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 1024, MIN_WORKTREE_WATCH_DIRECTORY_LIMIT = 1, MAX_WORKTREE_WATCH_DIRECTORY_LIMIT = 65536;
+var init_worktree_watcher = __esm(() => {
+  init_search();
+});
+
 // web-src/server/state-store.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function codeViewerPath(root, fileName) {
-  return join7(root, CODE_VIEWER_DIR2, fileName);
+  return join8(root, CODE_VIEWER_DIR2, fileName);
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -4029,6 +4279,9 @@ function sanitizeSettings(raw) {
   });
   if (scopeExcludeNames)
     out.scopeExcludeNames = scopeExcludeNames;
+  const scopeWatchLimit = optionalNumber(raw.scopeWatchLimit, MIN_WORKTREE_WATCH_DIRECTORY_LIMIT, MAX_WORKTREE_WATCH_DIRECTORY_LIMIT);
+  if (scopeWatchLimit !== undefined)
+    out.scopeWatchLimit = scopeWatchLimit;
   const uploadEnabled = optionalBoolean(raw.uploadEnabled);
   if (uploadEnabled !== undefined)
     out.uploadEnabled = uploadEnabled;
@@ -4350,6 +4603,7 @@ async function patchDbUiState(root, patch) {
 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();
+  init_worktree_watcher();
   DB_UI_BOOL_PREF_KEYS = ["s3TooltipEnabled", "inferFkRails"];
   settingsStore = createJsonFileStore({
     filePath: (root) => codeViewerPath(root, SETTINGS_FILE_NAME),
@@ -4377,256 +4631,6 @@ var init_state_store = __esm(() => {
   });
 });
 
-// web-src/server/worktree-watcher.ts
-import {
-  lstatSync as lstatSync3,
-  readdirSync as nodeReaddirSync,
-  watch as nodeWatch
-} from "node:fs";
-import { join as join8, relative } from "node:path";
-function normalizeRelativePath(path) {
-  return path.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-function isInsideRoot(root, path) {
-  const rel = relative(root, path).replace(/\\/g, "/");
-  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
-}
-function startWorktreeUpdateWatch(options) {
-  const watch = options.watch || nodeWatch;
-  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
-  const isDirectory = options.isDirectory || ((path) => {
-    try {
-      return lstatSync3(path).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  const directorySignature = options.directorySignature || ((path) => {
-    try {
-      const stats = lstatSync3(path);
-      if (!stats.isDirectory())
-        return null;
-      return `${stats.dev}:${stats.ino}`;
-    } catch {
-      return null;
-    }
-  });
-  const setTimer = options.setTimeoutFn || setTimeout;
-  const clearTimer = options.clearTimeoutFn || clearTimeout;
-  const debounceMs = options.debounceMs ?? 250;
-  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
-  const watchers = new Map;
-  const signatures = new Map;
-  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
-  const initialScanQueue = [];
-  let initialScanTimer = null;
-  const pendingPathInspections = new Map;
-  let pathInspectionTimer = null;
-  let timer = null;
-  const pendingChangedPaths = new Set;
-  let watchLimitReported = false;
-  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
-  const directoryRelativePath = (dir) => normalizeRelativePath(relative(options.root, dir));
-  const ignoredDirectory = (dir) => {
-    const rel = directoryRelativePath(dir);
-    return Boolean(rel && ignored(rel));
-  };
-  const scheduleUpdate = (changedPath) => {
-    if (changedPath)
-      pendingChangedPaths.add(changedPath);
-    if (timer)
-      clearTimer(timer);
-    timer = setTimer(() => {
-      timer = null;
-      const paths = pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
-      pendingChangedPaths.clear();
-      options.onUpdate(paths);
-    }, debounceMs);
-  };
-  const reportWatchLimit = () => {
-    if (watchLimitReported)
-      return;
-    watchLimitReported = true;
-    options.onWatchLimit?.(maxWatchedDirectories);
-    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
-  };
-  const closeSubtree = (dir) => {
-    for (const [watchedDir, watcher] of [...watchers]) {
-      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
-        continue;
-      try {
-        watcher.close?.();
-      } catch {}
-      watchers.delete(watchedDir);
-      signatures.delete(watchedDir);
-    }
-  };
-  const closeAll = () => {
-    if (initialScanTimer) {
-      clearTimer(initialScanTimer);
-      initialScanTimer = null;
-    }
-    if (pathInspectionTimer) {
-      clearTimer(pathInspectionTimer);
-      pathInspectionTimer = null;
-    }
-    initialScanQueue.length = 0;
-    pendingPathInspections.clear();
-    for (const watcher of [...watchers.values()]) {
-      try {
-        watcher.close?.();
-      } catch {}
-    }
-    watchers.clear();
-    signatures.clear();
-  };
-  const readChildDirectories = (dir) => {
-    let entries;
-    try {
-      entries = readDirs(dir);
-    } catch (error) {
-      options.onError?.(error);
-      return [];
-    }
-    const children = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const child = join8(dir, entry.name);
-      if (ignoredDirectory(child))
-        continue;
-      children.push(child);
-    }
-    return children;
-  };
-  const processInitialScanQueue = () => {
-    initialScanTimer = null;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-      return;
-    }
-    const next = initialScanQueue.shift();
-    if (next)
-      watchDirectory(next, true);
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-    }
-    if (initialScanQueue.length)
-      initialScanTimer = setTimer(processInitialScanQueue, 50);
-  };
-  const queueInitialChildren = (dir) => {
-    const remaining = maxWatchedDirectories - watchers.size;
-    if (remaining <= 0) {
-      reportWatchLimit();
-      return;
-    }
-    const children = readChildDirectories(dir);
-    if (children.length > remaining)
-      reportWatchLimit();
-    initialScanQueue.push(...children.slice(0, remaining));
-    if (!initialScanTimer)
-      initialScanTimer = setTimer(processInitialScanQueue, 5000);
-  };
-  const processChangedPath = (changed, fullChangedPath) => {
-    const known = watchers.has(fullChangedPath);
-    if (isDirectory(fullChangedPath)) {
-      if (known) {
-        const signature = directorySignature(fullChangedPath);
-        if (signature && signature !== signatures.get(fullChangedPath)) {
-          closeSubtree(fullChangedPath);
-          watchDirectory(fullChangedPath, initialScanAsync);
-        }
-        scheduleUpdate(changed);
-        return;
-      }
-      watchDirectory(fullChangedPath, initialScanAsync);
-    } else if (known) {
-      closeSubtree(fullChangedPath);
-    }
-    scheduleUpdate(changed);
-  };
-  const processPathInspections = () => {
-    pathInspectionTimer = null;
-    const entries = [...pendingPathInspections];
-    pendingPathInspections.clear();
-    for (const [changed, fullChangedPath] of entries) {
-      processChangedPath(changed, fullChangedPath);
-    }
-  };
-  const queuePathInspection = (changed, fullChangedPath) => {
-    pendingPathInspections.set(changed, fullChangedPath);
-    if (!pathInspectionTimer)
-      pathInspectionTimer = setTimer(processPathInspections, 25);
-  };
-  const watchDirectory = (dir, initialScan = false) => {
-    if (watchers.has(dir))
-      return;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
-    }
-    const rel = directoryRelativePath(dir);
-    if (rel && ignored(rel))
-      return;
-    try {
-      const watcher = watch(dir, { persistent: false }, (_event, filename) => {
-        if (!filename) {
-          scheduleUpdate();
-          return;
-        }
-        const changed = normalizeRelativePath(join8(rel, filename.toString()));
-        if (ignored(changed))
-          return;
-        const fullChangedPath = join8(options.root, changed);
-        if (!isInsideRoot(options.root, fullChangedPath))
-          return;
-        if (initialScanAsync) {
-          queuePathInspection(changed, fullChangedPath);
-          return;
-        }
-        processChangedPath(changed, fullChangedPath);
-      }) || {};
-      watchers.set(dir, watcher);
-      const signature = directorySignature(dir);
-      if (signature)
-        signatures.set(dir, signature);
-      watcher.on?.("error", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
-      });
-      watcher.on?.("close", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
-      });
-    } catch (error) {
-      options.onError?.(error);
-      return;
-    }
-    if (initialScanAsync && initialScan) {
-      queueInitialChildren(dir);
-      return;
-    }
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
-    }
-    for (const child of readChildDirectories(dir))
-      watchDirectory(child);
-  };
-  watchDirectory(options.root, true);
-  return { started: watchers.size > 0, close: closeAll };
-}
-var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 1024, MIN_WORKTREE_WATCH_DIRECTORY_LIMIT = 1, MAX_WORKTREE_WATCH_DIRECTORY_LIMIT = 65536;
-var init_worktree_watcher = __esm(() => {
-  init_search();
-});
-
 // web-src/core/control-chars.ts
 function hasControlCharacter(value) {
   for (const ch of value) {
@@ -4768,52 +4772,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")
@@ -4875,6 +4864,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";
@@ -5124,6 +5296,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) {
@@ -5279,6 +5469,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);
@@ -5366,12 +5557,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);
@@ -5460,7 +5645,7 @@ 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, 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 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, column_comment FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${tableLiteral}' ORDER BY ordinal_position`;
   }
@@ -5794,6 +5979,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) {
@@ -5975,9 +6173,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;
@@ -5994,17 +6195,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 {
@@ -6019,11 +6211,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);
@@ -6045,7 +6243,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",
@@ -6145,7 +6366,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);
@@ -6157,7 +6378,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);
@@ -6173,7 +6394,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);
@@ -6241,7 +6462,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) {
@@ -6279,14 +6529,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);
     }
   };
 });
@@ -7055,6 +7309,7 @@ function getPrimaryKeyColumnsFromColumns(columns) {
 }
 var init_global_search = __esm(() => {
   init_serialize();
+  init_sql_utils();
 });
 
 // web-src/server/database/adapters/elasticsearch.ts
@@ -7254,6 +7509,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;
@@ -7327,6 +7614,8 @@ function createElasticsearchAdapter(config) {
     getMappingAsync,
     searchDocsAsync,
     getDocAsync,
+    writeDocAsync,
+    deleteDocAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     query,
@@ -7806,6 +8095,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, {
@@ -7825,6 +8159,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",
@@ -7843,6 +8182,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";
@@ -8364,6 +8704,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",
@@ -8371,6 +8746,11 @@ function createRedisAdapter(config) {
     listDatabasesAsync,
     listKeysAsync,
     getValueAsync,
+    setStringAsync,
+    createStringAsync,
+    setHashFieldAsync,
+    setListIndexAsync,
+    deleteKeyAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     close() {}
@@ -8447,6 +8827,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, {
@@ -8461,6 +8913,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));
 }
@@ -8538,6 +8995,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()}`);
 }
@@ -8907,9 +9367,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 || {}
@@ -8921,7 +9382,7 @@ function createS3Adapter(config) {
         query,
         canonicalHeaders(headers),
         signedNames,
-        EMPTY_SHA256
+        payloadHash
       ].join(`
 `);
       const scope = `${dateStamp}/${config.region}/s3/aws4_request`;
@@ -8940,6 +9401,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");
         }
@@ -8954,6 +9418,7 @@ function createS3Adapter(config) {
       return fetch(url, {
         method: opts.method,
         headers: requestHeaders,
+        ...opts.body !== undefined ? { body: opts.body } : {},
         signal: transportSignal
       });
     }, deadline);
@@ -9036,6 +9501,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",
@@ -9044,7 +9535,9 @@ function createS3Adapter(config) {
     listObjects,
     headObject,
     getObjectText,
-    getObjectResponse
+    getObjectResponse,
+    putObjectAsync,
+    deleteObjectAsync
   };
 }
 async function s3ConfigFromDockerInfoAsync(info, signal) {
@@ -9447,6 +9940,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, {
@@ -9473,6 +10020,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));
 }
@@ -9639,21 +10191,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)
@@ -9664,7 +10201,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");
@@ -9923,7 +10460,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,
@@ -10153,6 +10690,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;
@@ -10343,11 +10883,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);
 }
@@ -10359,37 +10901,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) {
@@ -10451,36 +10997,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);
@@ -10494,7 +11021,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) {
@@ -10571,8 +11099,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) : [];
@@ -10586,7 +11113,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 = {
@@ -10805,13 +11333,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);
@@ -10826,17 +11354,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);
@@ -11248,6 +11780,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/")) {
@@ -11308,6 +11882,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,
@@ -11390,6 +11969,7 @@ var init_handle = __esm(() => {
   init_state_store();
   init_docker();
   init_docker_utils();
+  init_sql_capture();
   init_sqlite();
   init_connection_pool();
   init_discovery();