@youtyan/code-viewer 0.3.0 → 0.4.0

package/dist/code-viewer.js

@@ -4768,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")
@@ -4875,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";
@@ -5124,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) {
@@ -5279,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);
@@ -5366,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);
@@ -5460,7 +5641,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 +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) {
@@ -5975,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;
@@ -5994,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 {
@@ -6019,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);
@@ -6045,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",
@@ -6145,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);
@@ -6157,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);
@@ -6173,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);
@@ -6241,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) {
@@ -6279,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);
     }
   };
 });
@@ -7055,6 +7305,7 @@ function getPrimaryKeyColumnsFromColumns(columns) {
 }
 var init_global_search = __esm(() => {
   init_serialize();
+  init_sql_utils();
 });
 
 // web-src/server/database/adapters/elasticsearch.ts
@@ -7254,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;
@@ -7327,6 +7610,8 @@ function createElasticsearchAdapter(config) {
     getMappingAsync,
     searchDocsAsync,
     getDocAsync,
+    writeDocAsync,
+    deleteDocAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     query,
@@ -7806,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, {
@@ -7825,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",
@@ -7843,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";
@@ -8364,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",
@@ -8371,6 +8742,11 @@ function createRedisAdapter(config) {
     listDatabasesAsync,
     listKeysAsync,
     getValueAsync,
+    setStringAsync,
+    createStringAsync,
+    setHashFieldAsync,
+    setListIndexAsync,
+    deleteKeyAsync,
     iterateForSnapshot,
     listSnapshotContainers,
     close() {}
@@ -8447,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, {
@@ -8461,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));
 }
@@ -8538,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()}`);
 }
@@ -8907,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 || {}
@@ -8921,7 +9378,7 @@ function createS3Adapter(config) {
         query,
         canonicalHeaders(headers),
         signedNames,
-        EMPTY_SHA256
+        payloadHash
       ].join(`
 `);
       const scope = `${dateStamp}/${config.region}/s3/aws4_request`;
@@ -8940,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");
         }
@@ -8954,6 +9414,7 @@ function createS3Adapter(config) {
       return fetch(url, {
         method: opts.method,
         headers: requestHeaders,
+        ...opts.body !== undefined ? { body: opts.body } : {},
         signal: transportSignal
       });
     }, deadline);
@@ -9036,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",
@@ -9044,7 +9531,9 @@ function createS3Adapter(config) {
     listObjects,
     headObject,
     getObjectText,
-    getObjectResponse
+    getObjectResponse,
+    putObjectAsync,
+    deleteObjectAsync
   };
 }
 async function s3ConfigFromDockerInfoAsync(info, signal) {
@@ -9447,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, {
@@ -9473,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));
 }
@@ -9639,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)
@@ -9664,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");
@@ -9923,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,
@@ -10153,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;
@@ -10343,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);
 }
@@ -10359,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) {
@@ -10451,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);
@@ -10494,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) {
@@ -10571,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) : [];
@@ -10586,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 = {
@@ -10805,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);
@@ -10826,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);
@@ -11248,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/")) {
@@ -11308,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,
@@ -11390,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();