@youtyan/code-viewer 0.6.0 → 0.6.2

package/dist/code-viewer.js

@@ -1438,7 +1438,19 @@ function omittedWorktreeDirectoryReason(name, omitDirNames) {
     return "internal";
   return omitDirNames.has(name) ? "heavy" : undefined;
 }
-function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames) {
+function worktreeSubmodulePaths(cwd) {
+  if (!existsSync(join2(cwd, ".gitmodules")))
+    return new Set;
+  const res = run(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
+  if (res.code !== 0)
+    return new Set;
+  return new Set(res.stdout.split(`
+`).map((line) => {
+    const split = line.indexOf(" ");
+    return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
+  }).filter(Boolean));
+}
+function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames, submodulePaths) {
   if (excludeNames.has(name.toLowerCase()))
     return {
       name,
@@ -1448,23 +1460,24 @@ function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, exc
   const entryPath = base ? `${base}/${name}` : name;
   const type = isDirectory ? hasDotGitEntry(join2(dir, name)) ? "commit" : "tree" : "blob";
   const omittedReason = type === "tree" ? omittedWorktreeDirectoryReason(name, omitDirNames) : undefined;
+  const submodule = type === "commit" && submodulePaths.has(entryPath) ? true : undefined;
+  const baseEntry = submodule ? { name, path: entryPath, type, submodule } : { name, path: entryPath, type };
   return omittedReason ? {
-    name,
-    path: entryPath,
-    type,
+    ...baseEntry,
     children_omitted: true,
     children_omitted_reason: omittedReason
-  } : { name, path: entryPath, type };
+  } : baseEntry;
 }
 function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
   const root = join2(cwd, base);
   const omitDirNameSet = new Set(omitDirNames);
   const excludeNameSet = new Set(excludeNames.map((name) => name.toLowerCase()));
+  const submodulePaths = worktreeSubmodulePaths(cwd);
   let directEntries;
   try {
     const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet)).filter((entry) => entry.path));
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
   } catch {
     return [];
   }
@@ -3765,6 +3778,93 @@ Default (non --json) output:
   ]);
 });
 
+// web-src/core/routes.ts
+function assertNever(value) {
+  throw new Error(`unhandled route: ${JSON.stringify(value)}`);
+}
+function formatLineTarget(line) {
+  return typeof line === "number" ? String(line) : `${line.start}-${line.end}`;
+}
+function buildRoute(route) {
+  switch (route.screen) {
+    case "repo": {
+      const params = new URLSearchParams;
+      if (route.ref && route.ref !== "worktree")
+        params.set("ref", route.ref);
+      if (route.path)
+        params.set("path", route.path);
+      const qs = params.toString();
+      return `/${qs ? `?${qs}` : ""}`;
+    }
+    case "file":
+      if (route.view === "blob") {
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=blob" + (route.preview ? "&preview=1" : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
+      }
+      if (route.view === "blame") {
+        const ref = route.ref || "worktree";
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(ref) + "&view=blame" + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+      }
+      if (route.view === "history") {
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=history" + (route.commit ? `&commit=${encodeURIComponent(route.commit)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+      }
+      return "/file?path=" + encodeURIComponent(route.path) + "&ref=" + encodeURIComponent(route.ref || "worktree") + "&from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
+    case "diff":
+      return "/todif?from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree") + (route.path ? `&path=${encodeURIComponent(route.path)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+    case "help": {
+      const params = new URLSearchParams;
+      if (route.lang && route.lang !== "en")
+        params.set("lang", route.lang);
+      if (route.section && route.section !== "overview")
+        params.set("section", route.section);
+      const qs = params.toString();
+      return `/help${qs ? `?${qs}` : ""}`;
+    }
+    case "history": {
+      const params = new URLSearchParams;
+      if (route.ref && route.ref !== "HEAD")
+        params.set("ref", route.ref);
+      if (route.commit)
+        params.set("commit", route.commit);
+      const qs = params.toString();
+      return `/history${qs ? `?${qs}` : ""}`;
+    }
+    case "database": {
+      const params = new URLSearchParams;
+      if (route.db)
+        params.set("db", route.db);
+      if (route.schema)
+        params.set("schema", route.schema);
+      if (route.table)
+        params.set("table", route.table);
+      if (route.tab)
+        params.set("tab", route.tab);
+      if (route.diffBefore)
+        params.set("diffBefore", route.diffBefore);
+      if (route.diffAfter)
+        params.set("diffAfter", route.diffAfter);
+      const qs = params.toString();
+      return `/database${qs ? `?${qs}` : ""}`;
+    }
+    case "unknown":
+      return "/todif?from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree");
+    default:
+      return assertNever(route);
+  }
+}
+var SPA_PATHS, APP_ENTRY_PATHS;
+var init_routes = __esm(() => {
+  SPA_PATHS = [
+    "/todif",
+    "/todiff",
+    "/file",
+    "/help",
+    "/history",
+    "/database",
+    "/doctor"
+  ];
+  APP_ENTRY_PATHS = ["/", "/index.html"];
+});
+
 // web-src/server/query-cli.ts
 var exports_query_cli = {};
 __export(exports_query_cli, {
@@ -5149,6 +5249,18 @@ function buildSnapshotPollCommand(serverUrl, db, schema) {
   const schemaArg = schema ? ` --schema ${shellSingleQuote(schema)}` : "";
   return `${cli} snapshot list --db ${shellSingleQuote(db)}${schemaArg} --json`;
 }
+function buildSnapshotDiffUrl(serverUrl, dbId, schema, beforeId, afterId) {
+  const path = buildRoute({
+    screen: "database",
+    db: dbId,
+    schema,
+    tab: "snapshot",
+    diffBefore: beforeId,
+    diffAfter: afterId,
+    range: { from: "", to: "" }
+  });
+  return new URL(path, serverUrl).toString();
+}
 function buildDiffRowsCommand(serverUrl, before, after, table) {
   const cli = `code-viewer query --server ${shellSingleQuote(serverUrl)}`;
   return `${cli} diff rows --before ${shellSingleQuote(before)} ` + `--after ${shellSingleQuote(after)} --table ${shellSingleQuote(table)} --json`;
@@ -5301,6 +5413,7 @@ async function runDiffTables(serverUrl, command) {
   const body = await requestJson(serverUrl, `/_db/snapshot/diff/tables${qs}`, "GET", undefined, "diff tables");
   const enriched = {
     ...body,
+    diffUrl: buildSnapshotDiffUrl(serverUrl, body.dbId, body.schema, body.beforeId, body.afterId),
     tables: body.tables.map((t) => ({
       ...t,
       diffRowsCommand: buildDiffRowsCommand(serverUrl, body.beforeId, body.afterId, t.tableName)
@@ -5312,8 +5425,10 @@ async function runDiffTables(serverUrl, command) {
   }
   if (!enriched.tables.length) {
     console.log("no tables in diff");
+    console.log(`# view in browser: ${enriched.diffUrl}`);
     return;
   }
+  console.log(`# view in browser: ${enriched.diffUrl}`);
   for (const t of enriched.tables) {
     const cov = t.coverage === "both" ? "" : `  (${t.coverage})`;
     console.log(`${t.tableName}  +${t.insertedCount} ~${t.updatedCount} -${t.deletedCount} =${t.unchangedCount}${cov}`);
@@ -5570,10 +5685,13 @@ no separate stored diff entity, so you always pass both snapshot ids.
    code-viewer query snapshot list --db app.db --json
 
 5. View the diff (per-table summary, then per-row detail). diff tables
-   prints each per-table summary line plus a paste-safe "# diff rows: ..."
-   hint right below it, and --json adds a diffRowsCommand field to each
-   tables[] element, so you can drill into row detail without rebuilding
-   the command yourself:
+   prints a "# view in browser: <url>" hint up top (opens the same diff in
+   the human's browser, Database > Snapshot tab), then each per-table
+   summary line plus a paste-safe "# diff rows: ..." hint right below it.
+   --json adds the same browser link as a diffUrl field and a
+   diffRowsCommand field on each tables[] element, so you can hand the
+   human a direct link or drill into row detail without rebuilding the
+   command yourself:
    code-viewer query diff tables --before snap-abc123 --after snap-def456 --json
    code-viewer query diff rows  --before snap-abc123 --after snap-def456 \\
        --table users --json
@@ -5760,10 +5878,13 @@ object bytes (text-shaped objects are previewable via \`s3 text\`).
 - diff tables: human-readable lines (default) plus a paste-safe
   "# diff rows: code-viewer query --server '<url>' diff rows --before '<id>'
   --after '<id>' --table '<table>' --json" comment line right below each table,
-  so AI/human can drill into row detail without rebuilding the command. With
-  --json the full /_db/snapshot/diff/tables payload is emitted and each
-  tables[] element gains an additive diffRowsCommand field with the same
-  literal. server URL / snapshot ids / table names are POSIX single-quoted.
+  so AI/human can drill into row detail without rebuilding the command. A
+  "# view in browser: <url>" hint is printed once up top — opens the same
+  before/after comparison in the human's browser (Database > Snapshot tab).
+  With --json the full /_db/snapshot/diff/tables payload is emitted, the
+  top-level diffUrl field carries the same browser link, and each tables[]
+  element gains an additive diffRowsCommand field with the same literal.
+  server URL / snapshot ids / table names are POSIX single-quoted.
 - snapshot create: prints "snapshot started" immediately with the snapshotId.
   The no-wait output also includes a paste-safe poll command that pins
   --server '<url>' and single-quotes db/schema so AI/human paste does not
@@ -5843,6 +5964,7 @@ object bytes (text-shaped objects are previewable via \`s3 text\`).
   server only scans text-like columns (faster, cheaper).
 `, VALUE_FLAGS2, BOOL_FLAGS2, DEFAULT_SEARCH_TIMEOUT_SEC = 60, DEFAULT_SNAPSHOT_WAIT_TIMEOUT_SEC = 120, REDIS_ACTION_ALLOWLIST, NON_REDIS_SUBCOMMAND_ALLOWLIST, ES_ACTION_ALLOWLIST, S3_ACTION_ALLOWLIST;
 var init_query_cli = __esm(() => {
+  init_routes();
   init_cli_helpers();
   init_cli_helpers();
   VALUE_FLAGS2 = new Set([
@@ -10039,6 +10161,11 @@ var init_source_meta = __esm(() => {
     "conf",
     "env",
     "properties",
+    "rules",
+    "rule",
+    "prompt",
+    "prompts",
+    "instructions",
     "gitignore",
     "dockerignore",
     "editorconfig",
@@ -11775,6 +11902,15 @@ function parseDockerDbId(dbId) {
     return null;
   return { serviceName: rest, relDir: "", database };
 }
+function canonicalizeDockerDbId(dbId) {
+  const parsed = parseDockerDbId(dbId);
+  if (!parsed)
+    return null;
+  const database = parsed.database ? `:${parsed.database}` : "";
+  if (!parsed.relDir)
+    return `docker:${parsed.serviceName}${database}`;
+  return `docker:${parsed.serviceName}@${encodeURIComponent(parsed.relDir)}${database}`;
+}
 async function findDockerServiceByDbIdAsync(cwd, dbId, kind, omitDirNames, signal) {
   const parsed = parseDockerDbId(dbId);
   if (!parsed)
@@ -12194,6 +12330,9 @@ function sanitizeSettings(raw) {
   const annotationPanelOpen = optionalBoolean(raw.annotationPanelOpen);
   if (annotationPanelOpen !== undefined)
     out.annotationPanelOpen = annotationPanelOpen;
+  const annotationPanelWidth = optionalNumber(raw.annotationPanelWidth, 260, 720);
+  if (annotationPanelWidth !== undefined)
+    out.annotationPanelWidth = annotationPanelWidth;
   const annotationFollow = optionalBoolean(raw.annotationFollow);
   if (annotationFollow !== undefined)
     out.annotationFollow = annotationFollow;
@@ -14175,6 +14314,9 @@ async function getStoreDb(cwd) {
   try {
     storeDb.exec("ALTER TABLE snapshots ADD COLUMN schema_name TEXT");
   } catch {}
+  try {
+    storeDb.exec("ALTER TABLE snapshot_tables ADD COLUMN revision_id TEXT");
+  } catch {}
   return storeDb;
 }
 function makeId2(prefix) {
@@ -14183,32 +14325,163 @@ function makeId2(prefix) {
 function hashPayload(payloadJson) {
   return createHash5("sha256").update(payloadJson).digest("hex");
 }
+function hashLengthPrefixed(hasher, value) {
+  hasher.update(`${Buffer.byteLength(value, "utf8")}:`);
+  hasher.update(value);
+  hasher.update(`
+`);
+}
+function deleteOrphanPayloads(db) {
+  db.prepare(`DELETE FROM snapshot_payloads
+     WHERE NOT EXISTS (
+       SELECT 1 FROM snapshot_rows
+       WHERE snapshot_rows.payload_hash = snapshot_payloads.payload_hash
+     )
+     AND NOT EXISTS (
+       SELECT 1 FROM snapshot_table_revision_rows
+       WHERE snapshot_table_revision_rows.payload_hash = snapshot_payloads.payload_hash
+     )`).run();
+}
+function dockerDbIdFilterValues(dbId) {
+  const values = [dbId];
+  const canonical = canonicalizeDockerDbId(dbId);
+  if (canonical)
+    values.push(canonical);
+  const parsed = parseDockerDbId(dbId);
+  if (parsed?.relDir) {
+    const database = parsed.database ? `:${parsed.database}` : "";
+    values.push(`docker:${parsed.serviceName}@${parsed.relDir}${database}`);
+  }
+  return [...new Set(values)];
+}
+function getSnapshotScopeRow(db, snapshotId) {
+  const row = db.prepare("SELECT db_id, COALESCE(schema_name, 'public') AS schema_name FROM snapshots WHERE id = ?").get(snapshotId);
+  if (!row)
+    throw new Error(`snapshot not found: ${snapshotId}`);
+  return { dbId: row.db_id, schema: row.schema_name };
+}
 async function createSnapshot(cwd, dbId, kind, tables, note, schema) {
   const db = await getStoreDb(cwd);
   const id = makeId2("snap");
-  db.prepare("INSERT INTO snapshots (id, db_id, schema_name, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, dbId, schema ?? null, kind, note, new Date().toISOString(), "running");
+  const storedDbId = canonicalizeDockerDbId(dbId) ?? dbId;
+  db.prepare("INSERT INTO snapshots (id, db_id, schema_name, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, storedDbId, schema ?? null, kind, note, new Date().toISOString(), "running");
   for (const t of tables) {
     db.prepare("INSERT INTO snapshot_tables (snapshot_id, table_name) VALUES (?, ?)").run(id, t);
   }
   return id;
 }
-async function addSnapshotTableData(cwd, snapshotId, tableName, pkColumns, rows) {
+async function beginSnapshotTableRevision(cwd, snapshotId, tableName, pkColumns) {
+  const db = await getStoreDb(cwd);
+  const id = makeId2("rev");
+  const scope = getSnapshotScopeRow(db, snapshotId);
+  db.exec("BEGIN");
+  try {
+    db.prepare("INSERT OR IGNORE INTO snapshot_tables (snapshot_id, table_name) VALUES (?, ?)").run(snapshotId, tableName);
+    db.prepare(`INSERT INTO snapshot_table_revisions
+       (id, source_snapshot_id, db_id, schema_name, table_name, row_count, table_hash, hash_version, pk_columns_json, status, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, snapshotId, scope.dbId, scope.schema, tableName, 0, "", SNAPSHOT_TABLE_HASH_VERSION, JSON.stringify(pkColumns), "building", new Date().toISOString());
+    db.exec("COMMIT");
+  } catch (err) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw err;
+  }
+  return id;
+}
+async function addSnapshotTableRows(cwd, revisionId, rows) {
+  if (rows.length === 0)
+    return;
   const db = await getStoreDb(cwd);
-  const tableHasher = createHash5("sha256");
-  const insertRow = db.prepare("INSERT OR IGNORE INTO snapshot_rows (snapshot_id, table_name, row_key_hash, row_key_json, row_hash, payload_hash) VALUES (?, ?, ?, ?, ?, ?)");
+  const insertRow = db.prepare("INSERT OR IGNORE INTO snapshot_table_revision_rows (revision_id, row_key_hash, row_key_json, row_hash, payload_hash) VALUES (?, ?, ?, ?, ?)");
   const insertPayload = db.prepare("INSERT OR IGNORE INTO snapshot_payloads (payload_hash, payload_json) VALUES (?, ?)");
-  const updateTable = db.prepare("UPDATE snapshot_tables SET row_count = ?, table_hash = ?, pk_columns_json = ? WHERE snapshot_id = ? AND table_name = ?");
   db.exec("BEGIN");
   try {
     for (const row of rows) {
       const rowKeyHash = createHash5("sha256").update(row.rowKeyJson).digest("hex");
       const payloadHash = hashPayload(row.payloadJson);
-      tableHasher.update(row.rowHash);
-      insertRow.run(snapshotId, tableName, rowKeyHash, row.rowKeyJson, row.rowHash, payloadHash);
+      insertRow.run(revisionId, rowKeyHash, row.rowKeyJson, row.rowHash, payloadHash);
       insertPayload.run(payloadHash, row.payloadJson);
     }
-    const tableHash = tableHasher.digest("hex");
-    updateTable.run(rows.length, tableHash, JSON.stringify(pkColumns), snapshotId, tableName);
+    db.exec("COMMIT");
+  } catch (err) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw err;
+  }
+}
+function computeRevisionTableHash(db, revisionId) {
+  const hasher = createHash5("sha256");
+  hashLengthPrefixed(hasher, `snapshot-table-v${SNAPSHOT_TABLE_HASH_VERSION}`);
+  let rowCount = 0;
+  let last;
+  for (;; ) {
+    const rows = last ? db.prepare(`SELECT row_key_hash, row_key_json, row_hash, payload_hash
+             FROM snapshot_table_revision_rows
+             WHERE revision_id = ?
+               AND (row_key_hash > ? OR (row_key_hash = ? AND row_key_json > ?))
+             ORDER BY row_key_hash, row_key_json
+             LIMIT ?`).all(revisionId, last.row_key_hash, last.row_key_hash, last.row_key_json, SNAPSHOT_REVISION_HASH_BATCH_SIZE) : db.prepare(`SELECT row_key_hash, row_key_json, row_hash, payload_hash
+             FROM snapshot_table_revision_rows
+             WHERE revision_id = ?
+             ORDER BY row_key_hash, row_key_json
+             LIMIT ?`).all(revisionId, SNAPSHOT_REVISION_HASH_BATCH_SIZE);
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      hashLengthPrefixed(hasher, row.row_key_hash);
+      hashLengthPrefixed(hasher, row.row_key_json);
+      hashLengthPrefixed(hasher, row.row_hash);
+      hashLengthPrefixed(hasher, row.payload_hash);
+      rowCount++;
+      last = {
+        row_key_hash: row.row_key_hash,
+        row_key_json: row.row_key_json
+      };
+    }
+    if (rows.length < SNAPSHOT_REVISION_HASH_BATCH_SIZE)
+      break;
+  }
+  return {
+    rowCount,
+    tableHash: `${SNAPSHOT_TABLE_HASH_PREFIX}${hasher.digest("hex")}`
+  };
+}
+async function finalizeSnapshotTableRevision(cwd, snapshotId, tableName, revisionId) {
+  const db = await getStoreDb(cwd);
+  const revision = db.prepare(`SELECT db_id, schema_name, table_name, pk_columns_json
+       FROM snapshot_table_revisions
+       WHERE id = ?`).get(revisionId);
+  if (!revision)
+    throw new Error(`snapshot table revision not found: ${revisionId}`);
+  const { rowCount, tableHash } = computeRevisionTableHash(db, revisionId);
+  const existing = db.prepare(`SELECT id
+       FROM snapshot_table_revisions
+       WHERE id != ?
+         AND db_id = ?
+         AND schema_name = ?
+         AND table_name = ?
+         AND hash_version = ?
+         AND table_hash = ?
+         AND row_count = ?
+         AND pk_columns_json = ?
+         AND status = 'done'
+       ORDER BY created_at ASC
+       LIMIT 1`).get(revisionId, revision.db_id, revision.schema_name, revision.table_name, SNAPSHOT_TABLE_HASH_VERSION, tableHash, rowCount, revision.pk_columns_json);
+  const adoptedRevisionId = existing?.id ?? revisionId;
+  db.exec("BEGIN");
+  try {
+    if (existing) {
+      db.prepare("DELETE FROM snapshot_table_revisions WHERE id = ?").run(revisionId);
+    } else {
+      db.prepare(`UPDATE snapshot_table_revisions
+         SET row_count = ?, table_hash = ?, status = 'done', source_snapshot_id = NULL
+         WHERE id = ?`).run(rowCount, tableHash, revisionId);
+    }
+    db.prepare(`UPDATE snapshot_tables
+       SET row_count = ?, table_hash = ?, pk_columns_json = ?, revision_id = ?
+       WHERE snapshot_id = ? AND table_name = ?`).run(rowCount, tableHash, revision.pk_columns_json, adoptedRevisionId, snapshotId, tableName);
     db.exec("COMMIT");
   } catch (err) {
     try {
@@ -14220,7 +14493,18 @@ async function addSnapshotTableData(cwd, snapshotId, tableName, pkColumns, rows)
 async function finalizeSnapshot(cwd, snapshotId, error) {
   const db = await getStoreDb(cwd);
   if (error) {
-    db.prepare("UPDATE snapshots SET status = 'error', error_message = ? WHERE id = ?").run(error, snapshotId);
+    db.exec("BEGIN");
+    try {
+      db.prepare("DELETE FROM snapshot_table_revisions WHERE source_snapshot_id = ? AND status = 'building'").run(snapshotId);
+      deleteOrphanPayloads(db);
+      db.prepare("UPDATE snapshots SET status = 'error', error_message = ? WHERE id = ?").run(error, snapshotId);
+      db.exec("COMMIT");
+    } catch (err) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+      throw err;
+    }
   } else {
     db.prepare("UPDATE snapshots SET status = 'done' WHERE id = ?").run(snapshotId);
   }
@@ -14230,8 +14514,9 @@ async function listSnapshots(cwd, dbId, schema) {
   const conditions = [];
   const params = [];
   if (dbId) {
-    conditions.push("db_id = ?");
-    params.push(dbId);
+    const dbIdValues = dockerDbIdFilterValues(dbId);
+    conditions.push(dbIdValues.length === 1 ? "db_id = ?" : `db_id IN (${dbIdValues.map(() => "?").join(", ")})`);
+    params.push(...dbIdValues);
   }
   if (schema !== undefined) {
     conditions.push("COALESCE(schema_name, 'public') = ?");
@@ -14264,11 +14549,14 @@ async function deleteSnapshot(cwd, snapshotId) {
   db.exec("BEGIN");
   try {
     db.prepare("DELETE FROM snapshots WHERE id = ?").run(snapshotId);
-    db.prepare(`DELETE FROM snapshot_payloads
-       WHERE NOT EXISTS (
-         SELECT 1 FROM snapshot_rows
-         WHERE snapshot_rows.payload_hash = snapshot_payloads.payload_hash
-       )`).run();
+    db.prepare(`DELETE FROM snapshot_table_revisions
+       WHERE status = 'done'
+         AND NOT EXISTS (
+           SELECT 1 FROM snapshot_tables
+           WHERE snapshot_tables.revision_id = snapshot_table_revisions.id
+         )`).run();
+    db.prepare("DELETE FROM snapshot_table_revisions WHERE source_snapshot_id = ? AND status = 'building'").run(snapshotId);
+    deleteOrphanPayloads(db);
     db.exec("COMMIT");
   } catch (err) {
     try {
@@ -14278,15 +14566,22 @@ async function deleteSnapshot(cwd, snapshotId) {
   }
 }
 function getSnapshotScope(db, snapshotId) {
-  const row = db.prepare("SELECT db_id, COALESCE(schema_name, 'public') AS schema_name FROM snapshots WHERE id = ?").get(snapshotId);
-  if (!row)
-    throw new Error(`snapshot not found: ${snapshotId}`);
-  return { dbId: row.db_id, schema: row.schema_name };
+  return getSnapshotScopeRow(db, snapshotId);
+}
+async function getSnapshotScopeById(cwd, snapshotId) {
+  const db = await getStoreDb(cwd);
+  const scope = getSnapshotScope(db, snapshotId);
+  return {
+    dbId: canonicalizeDockerDbId(scope.dbId) ?? scope.dbId,
+    schema: scope.schema
+  };
 }
 function assertSameSnapshotScope(db, beforeId, afterId) {
   const before = getSnapshotScope(db, beforeId);
   const after = getSnapshotScope(db, afterId);
-  if (before.dbId !== after.dbId || before.schema !== after.schema) {
+  const beforeDbId = canonicalizeDockerDbId(before.dbId) ?? before.dbId;
+  const afterDbId = canonicalizeDockerDbId(after.dbId) ?? after.dbId;
+  if (beforeDbId !== afterDbId || before.schema !== after.schema) {
     throw new Error(`cannot compare snapshots from different database/schema (${before.dbId}:${before.schema} vs ${after.dbId}:${after.schema})`);
   }
 }
@@ -14338,16 +14633,16 @@ async function computeDiffTables(cwd, beforeId, afterId) {
       continue;
     }
     const insertedCount = db.prepare(`SELECT COUNT(*) AS cnt
-           FROM snapshot_rows a
-           LEFT JOIN snapshot_rows b ON b.snapshot_id = ? AND b.table_name = ? AND b.row_key_hash = a.row_key_hash
+           FROM snapshot_rows_resolved a
+           LEFT JOIN snapshot_rows_resolved b ON b.snapshot_id = ? AND b.table_name = ? AND b.row_key_hash = a.row_key_hash
            WHERE a.snapshot_id = ? AND a.table_name = ? AND b.row_key_hash IS NULL`).get(beforeId, table, afterId, table).cnt;
     const deletedCount = db.prepare(`SELECT COUNT(*) AS cnt
-           FROM snapshot_rows b
-           LEFT JOIN snapshot_rows a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
+           FROM snapshot_rows_resolved b
+           LEFT JOIN snapshot_rows_resolved a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
            WHERE b.snapshot_id = ? AND b.table_name = ? AND a.row_key_hash IS NULL`).get(afterId, table, beforeId, table).cnt;
     const updatedCount = db.prepare(`SELECT COUNT(*) AS cnt
-           FROM snapshot_rows b
-           INNER JOIN snapshot_rows a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
+           FROM snapshot_rows_resolved b
+           INNER JOIN snapshot_rows_resolved a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
            WHERE b.snapshot_id = ? AND b.table_name = ? AND b.row_hash != a.row_hash`).get(afterId, table, beforeId, table).cnt;
     const unchangedCount = b.row_count - deletedCount - updatedCount;
     results.push({
@@ -14373,8 +14668,8 @@ async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit
   assertSameSnapshotScope(db, beforeId, afterId);
   const allDiffRows = [];
   const inserted = db.prepare(`SELECT a.row_key_json, a.payload_hash
-       FROM snapshot_rows a
-       LEFT JOIN snapshot_rows b ON b.snapshot_id = ? AND b.table_name = ? AND b.row_key_hash = a.row_key_hash
+       FROM snapshot_rows_resolved a
+       LEFT JOIN snapshot_rows_resolved b ON b.snapshot_id = ? AND b.table_name = ? AND b.row_key_hash = a.row_key_hash
        WHERE a.snapshot_id = ? AND a.table_name = ? AND b.row_key_hash IS NULL
        ORDER BY a.row_key_json`).all(beforeId, table, afterId, table);
   for (const r of inserted) {
@@ -14386,8 +14681,8 @@ async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit
     });
   }
   const deleted = db.prepare(`SELECT b.row_key_json, b.payload_hash
-       FROM snapshot_rows b
-       LEFT JOIN snapshot_rows a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
+       FROM snapshot_rows_resolved b
+       LEFT JOIN snapshot_rows_resolved a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
        WHERE b.snapshot_id = ? AND b.table_name = ? AND a.row_key_hash IS NULL
        ORDER BY b.row_key_json`).all(afterId, table, beforeId, table);
   for (const r of deleted) {
@@ -14399,8 +14694,8 @@ async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit
     });
   }
   const updated = db.prepare(`SELECT b.row_key_json, b.payload_hash AS before_ph, a.payload_hash AS after_ph
-       FROM snapshot_rows b
-       INNER JOIN snapshot_rows a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
+       FROM snapshot_rows_resolved b
+       INNER JOIN snapshot_rows_resolved a ON a.snapshot_id = ? AND a.table_name = ? AND a.row_key_hash = b.row_key_hash
        WHERE b.snapshot_id = ? AND b.table_name = ? AND b.row_hash != a.row_hash
        ORDER BY b.row_key_json`).all(afterId, table, beforeId, table);
   for (const r of updated) {
@@ -14454,10 +14749,45 @@ CREATE TABLE IF NOT EXISTS snapshot_tables (
   row_count INTEGER NOT NULL DEFAULT 0,
   table_hash TEXT NOT NULL DEFAULT '',
   pk_columns_json TEXT NOT NULL DEFAULT '[]',
+  revision_id TEXT,
   PRIMARY KEY (snapshot_id, table_name),
-  FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE
+  FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE,
+  FOREIGN KEY (revision_id) REFERENCES snapshot_table_revisions(id)
+);
+
+CREATE TABLE IF NOT EXISTS snapshot_table_revisions (
+  id TEXT PRIMARY KEY,
+  source_snapshot_id TEXT,
+  db_id TEXT NOT NULL,
+  schema_name TEXT NOT NULL,
+  table_name TEXT NOT NULL,
+  row_count INTEGER NOT NULL DEFAULT 0,
+  table_hash TEXT NOT NULL DEFAULT '',
+  hash_version INTEGER NOT NULL DEFAULT 2,
+  pk_columns_json TEXT NOT NULL DEFAULT '[]',
+  status TEXT NOT NULL DEFAULT 'building',
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_snapshot_table_revisions_lookup
+  ON snapshot_table_revisions(db_id, schema_name, table_name, hash_version, table_hash, row_count, pk_columns_json, status);
+
+CREATE TABLE IF NOT EXISTS snapshot_table_revision_rows (
+  revision_id TEXT NOT NULL,
+  row_key_hash TEXT NOT NULL,
+  row_key_json TEXT NOT NULL,
+  row_hash TEXT NOT NULL,
+  payload_hash TEXT NOT NULL,
+  PRIMARY KEY (revision_id, row_key_hash),
+  FOREIGN KEY (revision_id) REFERENCES snapshot_table_revisions(id) ON DELETE CASCADE
 );
 
+CREATE INDEX IF NOT EXISTS idx_snapshot_table_revision_rows_revision_key
+  ON snapshot_table_revision_rows(revision_id, row_key_hash);
+
+CREATE INDEX IF NOT EXISTS idx_snapshot_table_revision_rows_payload_hash
+  ON snapshot_table_revision_rows(payload_hash);
+
 CREATE TABLE IF NOT EXISTS snapshot_rows (
   snapshot_id TEXT NOT NULL,
   table_name TEXT NOT NULL,
@@ -14475,14 +14805,40 @@ CREATE TABLE IF NOT EXISTS snapshot_payloads (
 );
 
 -- deleteSnapshot の orphan cleanup (snapshot_payloads を残さない) は
--- snapshot_rows.payload_hash で逆引きする。index が無いと
--- snapshot_payloads 件数 × snapshot_rows 全件の相関スキャンになる。
+-- legacy rows と revision rows の payload_hash で逆引きする。index が無いと
+-- snapshot_payloads 件数 × rows 全件の相関スキャンになる。
 CREATE INDEX IF NOT EXISTS idx_snapshot_rows_payload_hash
   ON snapshot_rows(payload_hash);
 
-`, storeDb = null, storeDbPath = null;
+DROP VIEW IF EXISTS snapshot_rows_resolved;
+
+CREATE VIEW snapshot_rows_resolved AS
+  SELECT
+    st.snapshot_id AS snapshot_id,
+    st.table_name AS table_name,
+    rr.row_key_hash AS row_key_hash,
+    rr.row_key_json AS row_key_json,
+    rr.row_hash AS row_hash,
+    rr.payload_hash AS payload_hash
+  FROM snapshot_tables st
+  INNER JOIN snapshot_table_revision_rows rr
+    ON rr.revision_id = st.revision_id
+  WHERE st.revision_id IS NOT NULL
+  UNION ALL
+  SELECT
+    snapshot_id,
+    table_name,
+    row_key_hash,
+    row_key_json,
+    row_hash,
+    payload_hash
+  FROM snapshot_rows;
+
+`, storeDb = null, storeDbPath = null, SNAPSHOT_TABLE_HASH_VERSION = 2, SNAPSHOT_TABLE_HASH_PREFIX, SNAPSHOT_REVISION_HASH_BATCH_SIZE = 1000;
 var init_snapshot_store = __esm(() => {
+  init_discovery();
   init_sqlite_driver();
+  SNAPSHOT_TABLE_HASH_PREFIX = `v${SNAPSHOT_TABLE_HASH_VERSION}:`;
 });
 
 // web-src/server/database/sources/types.ts
@@ -14505,7 +14861,6 @@ async function runSnapshot(cwd, source, dbId, containers, note, onProgress, opti
       const container = containers[i];
       throwIfAborted(options.signal, "snapshot cancelled");
       onProgress?.({ container, done: false, index: i, total });
-      const collected = [];
       let pkColumns = [];
       if (snapshotSource.model === "sql") {
         try {
@@ -14517,16 +14872,28 @@ async function runSnapshot(cwd, source, dbId, containers, note, onProgress, opti
         }
       }
       throwIfAborted(options.signal, "snapshot cancelled");
+      const revisionId = await beginSnapshotTableRevision(cwd, snapshotId, container, pkColumns);
+      const pendingRows = [];
+      const flushRows = async () => {
+        if (pendingRows.length === 0)
+          return;
+        const rows = pendingRows.splice(0, pendingRows.length);
+        await addSnapshotTableRows(cwd, revisionId, rows);
+      };
       for await (const item of snapshotSource.iterateForSnapshot(container, options.signal)) {
         throwIfAborted(options.signal, "snapshot cancelled");
-        collected.push({
+        pendingRows.push({
           rowKeyJson: item.keyJson,
           rowHash: item.rowHash,
           payloadJson: item.payloadJson
         });
+        if (pendingRows.length >= SNAPSHOT_FLUSH_THRESHOLD) {
+          await flushRows();
+        }
       }
       throwIfAborted(options.signal, "snapshot cancelled");
-      await addSnapshotTableData(cwd, snapshotId, container, pkColumns, collected);
+      await flushRows();
+      await finalizeSnapshotTableRevision(cwd, snapshotId, container, revisionId);
     }
     await finalizeSnapshot(cwd, snapshotId);
     onProgress?.({ container: "", done: true, index: total, total });
@@ -15083,6 +15450,38 @@ async function handleTable(cwd, url, omitDirNames, signal) {
     return handleError("database", "read table", err, signal);
   }
 }
+async function handleTableCount(cwd, url, omitDirNames, signal) {
+  const r = await resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"), signal);
+  if (r instanceof Response)
+    return r;
+  const table = url.searchParams.get("table");
+  if (!table)
+    return textError("missing table parameter", 400);
+  try {
+    const adapter = await getAdapter(r, cwd, signal);
+    const { result, executedSql } = await captureSql(async () => {
+      const db = asAsync(adapter);
+      const tables = await db.tables(signal);
+      const entry = tables.find((candidate) => candidate.name === table);
+      if (!entry)
+        throw new Error(`unknown table: ${table}`);
+      if (entry.type !== "table")
+        return { rowCount: null };
+      const counts = await db.tableRowCounts([table], signal);
+      return { rowCount: counts.get(table) ?? null };
+    });
+    const body = {
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table,
+      rowCount: result.rowCount,
+      executedSql
+    };
+    return json(body);
+  } catch (err) {
+    return handleError("database", "read table count", err, signal);
+  }
+}
 function makeHistoryId() {
   return makeId("qh");
 }
@@ -15821,7 +16220,14 @@ async function handleDiffTables(cwd, url) {
     return textError("missing before or after parameter", 400);
   try {
     const tables = await computeDiffTables(cwd, beforeId, afterId);
-    return json({ beforeId, afterId, tables });
+    const scope = await getSnapshotScopeById(cwd, beforeId);
+    return json({
+      beforeId,
+      afterId,
+      dbId: scope.dbId,
+      schema: scope.schema,
+      tables
+    });
   } catch (err) {
     return handleError("database", "compute diff", err);
   }
@@ -16004,6 +16410,10 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       methods: ["GET"],
       handler: () => handleTable(cwd, url, omitDirNames, req.signal)
     },
+    "/_db/table-count": {
+      methods: ["GET"],
+      handler: () => handleTableCount(cwd, url, omitDirNames, req.signal)
+    },
     "/_db/columns": {
       methods: ["GET"],
       handler: () => handleColumns(cwd, url, omitDirNames, req.signal)
@@ -17288,21 +17698,6 @@ function normalizeNewDirectoryName(name) {
   return trimmed;
 }
 
-// web-src/core/routes.ts
-var SPA_PATHS, APP_ENTRY_PATHS;
-var init_routes = __esm(() => {
-  SPA_PATHS = [
-    "/todif",
-    "/todiff",
-    "/file",
-    "/help",
-    "/history",
-    "/database",
-    "/doctor"
-  ];
-  APP_ENTRY_PATHS = ["/", "/index.html"];
-});
-
 // web-src/server/cache.ts
 import { lstatSync as lstatSync3 } from "node:fs";
 import { join as join14 } from "node:path";
@@ -19637,6 +20032,8 @@ function fileMetadataForTarget(target, path) {
 function attachTreeEntryMetadata(target, entry) {
   if (entry.type === "tree")
     return { ...entry, ...directoryMetadata(target, entry.path) };
+  if (entry.type === "commit" && !entry.submodule && (target === "worktree" || target === ""))
+    return { ...entry, ...directoryMetadata(target, entry.path) };
   if (entry.type !== "blob")
     return entry;
   return { ...entry, ...fileMetadataForTarget(target, entry.path) };