@youtyan/code-viewer 0.2.6 → 0.2.7

package/dist/code-viewer.js

@@ -17,14 +17,97 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// web-src/server/json-store.ts
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function isEnoent(err) {
+  return err?.code === "ENOENT";
+}
+function tmpPath(file) {
+  return `${file}.tmp-${process.pid}-${Date.now()}-${randomBytes(4).toString("hex")}`;
+}
+async function backupInvalidFile(file, suffix) {
+  try {
+    await rename(file, `${file}.${suffix}-${Date.now()}`);
+  } catch {}
+}
+function createJsonFileStore(options) {
+  const queues = new Map;
+  const backupSuffix = options.backupSuffix ?? "corrupt";
+  const serialize = options.serialize ?? ((state) => `${JSON.stringify(state, null, 2)}
+`);
+  async function loadUnqueued(root) {
+    const file = options.filePath(root);
+    let raw;
+    try {
+      raw = await readFile(file, "utf8");
+    } catch (err) {
+      if (isEnoent(err))
+        return options.empty();
+      throw err;
+    }
+    try {
+      return options.sanitize(JSON.parse(raw));
+    } catch {
+      await backupInvalidFile(file, backupSuffix);
+      return options.empty();
+    }
+  }
+  async function saveUnqueued(root, state) {
+    const file = options.filePath(root);
+    const normalized = options.sanitize(state);
+    const content = serialize(normalized);
+    if (options.maxBytes !== undefined && Buffer.byteLength(content, "utf8") > options.maxBytes) {
+      throw new Error(options.sizeErrorMessage ?? "JSON state too large");
+    }
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = tmpPath(file);
+    await writeFile(tmp, content, "utf8");
+    await rename(tmp, file);
+  }
+  async function load(root) {
+    const pendingWrite = queues.get(options.filePath(root));
+    if (pendingWrite)
+      await pendingWrite.catch(() => {});
+    return loadUnqueued(root);
+  }
+  async function save(root, state) {
+    const file = options.filePath(root);
+    const previous = queues.get(file) ?? Promise.resolve();
+    const run = previous.catch(() => {}).then(() => saveUnqueued(root, state));
+    const queued = run.then(() => {}, () => {});
+    queues.set(file, queued);
+    try {
+      await run;
+    } finally {
+      if (queues.get(file) === queued)
+        queues.delete(file);
+    }
+  }
+  async function update(root, updater) {
+    const file = options.filePath(root);
+    const previous = queues.get(file) ?? Promise.resolve();
+    const run = previous.catch(() => {}).then(async () => {
+      const current = await loadUnqueued(root);
+      const updated = await updater(current);
+      await saveUnqueued(root, updated.state);
+      return updated.result;
+    });
+    const queued = run.then(() => {}, () => {});
+    queues.set(file, queued);
+    try {
+      return await run;
+    } finally {
+      if (queues.get(file) === queued)
+        queues.delete(file);
+    }
+  }
+  return { load, save, update };
+}
+var init_json_store = () => {};
+
 // web-src/server/annotations.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync
-} from "node:fs";
 import { join } from "node:path";
 function annotationsFilePath(root) {
   return join(root, CODE_VIEWER_DIR, ANNOTATIONS_FILE_NAME);
@@ -242,24 +325,11 @@ function normalizeAnnotationsState(raw) {
     sessions: sessions.map(normalizeSession).filter((session) => session !== null)
   };
 }
-function loadAnnotationsState(root) {
-  const file = annotationsFilePath(root);
-  if (!existsSync(file))
-    return emptyAnnotationsState();
-  try {
-    return normalizeAnnotationsState(JSON.parse(readFileSync(file, "utf8")));
-  } catch {
-    return emptyAnnotationsState();
-  }
+async function loadAnnotationsState(root) {
+  return annotationsStore.load(root);
 }
-function saveAnnotationsState(root, state) {
-  const dir = join(root, CODE_VIEWER_DIR);
-  mkdirSync(dir, { recursive: true });
-  const file = annotationsFilePath(root);
-  const tmp = `${file}.tmp-${process.pid}`;
-  writeFileSync(tmp, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-  renameSync(tmp, file);
+async function saveAnnotationsState(root, state) {
+  return annotationsStore.save(root, state);
 }
 function startAnnotationSession(state, title, now, id = makeAnnotationId("s")) {
   const session = {
@@ -484,9 +554,18 @@ function deleteAnnotationById(state, id) {
   }
   return { state, removed: null };
 }
-var CODE_VIEWER_DIR = ".code-viewer", ANNOTATIONS_FILE_NAME = "annotations.json", ANNOTATION_BODY_MAX_BYTES, ANNOTATION_TITLE_MAX_CHARS = 300;
+var CODE_VIEWER_DIR = ".code-viewer", ANNOTATIONS_FILE_NAME = "annotations.json", ANNOTATION_BODY_MAX_BYTES, ANNOTATION_TITLE_MAX_CHARS = 300, MAX_ANNOTATIONS_JSON_BYTES = 5000000, annotationsStore;
 var init_annotations = __esm(() => {
+  init_json_store();
   ANNOTATION_BODY_MAX_BYTES = 64 * 1024;
+  annotationsStore = createJsonFileStore({
+    filePath: annotationsFilePath,
+    empty: emptyAnnotationsState,
+    sanitize: normalizeAnnotationsState,
+    maxBytes: MAX_ANNOTATIONS_JSON_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "annotations state too large"
+  });
 });
 
 // web-src/server/runtime.ts
@@ -673,10 +752,10 @@ var init_runtime = () => {};
 
 // web-src/server/git.ts
 import {
-  existsSync as existsSync2,
+  existsSync,
   lstatSync,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync,
   statSync
 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -1120,7 +1199,7 @@ function omittedWorktreeDirectoryReason(name, omitDirNames) {
   return omitDirNames.has(name) ? "heavy" : undefined;
 }
 function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames) {
-  if (excludeNames.has(name.toLowerCase()) || isToolInternalPath(name))
+  if (excludeNames.has(name.toLowerCase()))
     return {
       name,
       path: "",
@@ -1182,7 +1261,7 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
       return;
     }
     for (const entry of entries) {
-      if (excludeNameSet.has(entry.name.toLowerCase()) || isToolInternalPath(entry.name))
+      if (excludeNameSet.has(entry.name.toLowerCase()))
         continue;
       const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
       const full = join2(dir, entry.name);
@@ -1287,12 +1366,12 @@ function untrackedMeta(cwd) {
     let lines = 0;
     let fileExists = false;
     try {
-      fileExists = existsSync2(full) && statSync(full).isFile();
+      fileExists = existsSync(full) && statSync(full).isFile();
     } catch {
       fileExists = false;
     }
     if (fileExists) {
-      const data = readFileSync2(full);
+      const data = readFileSync(full);
       const probe = data.subarray(0, 8192);
       binary = probe.includes(0);
       if (!binary)
@@ -1471,11 +1550,11 @@ var init_git = __esm(() => {
 // web-src/server/server-registry.ts
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
   unlinkSync,
-  writeFileSync as writeFileSync2
+  writeFileSync
 } from "node:fs";
 import { homedir } from "node:os";
 import { join as join3 } from "node:path";
@@ -1488,17 +1567,17 @@ function serverRegistryFilePath(root) {
 }
 function writeServerRegistry(entry) {
   try {
-    mkdirSync2(registryDir(), { recursive: true });
-    writeFileSync2(serverRegistryFilePath(entry.root), `${JSON.stringify(entry, null, 2)}
+    mkdirSync(registryDir(), { recursive: true });
+    writeFileSync(serverRegistryFilePath(entry.root), `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   } catch {}
 }
 function readServerRegistry(root) {
   const file = serverRegistryFilePath(root);
-  if (!existsSync3(file))
+  if (!existsSync2(file))
     return null;
   try {
-    const raw = JSON.parse(readFileSync3(file, "utf8"));
+    const raw = JSON.parse(readFileSync2(file, "utf8"));
     if (!raw || typeof raw !== "object")
       return null;
     const entry = raw;
@@ -1532,7 +1611,7 @@ __export(exports_annotate_cli, {
   ANNOTATE_HELP: () => ANNOTATE_HELP,
   ANNOTATE_AGENT_HELP: () => ANNOTATE_AGENT_HELP
 });
-import { readFileSync as readFileSync4, realpathSync } from "node:fs";
+import { readFileSync as readFileSync3, realpathSync } from "node:fs";
 function takeValue(argv, index, flag) {
   const value = argv[index + 1];
   if (value === undefined)
@@ -1961,7 +2040,7 @@ async function annotationBodyFromCommand(command) {
   let body = command.body;
   if (body === undefined && command.bodyFile !== undefined) {
     try {
-      body = readFileSync4(command.bodyFile, "utf8");
+      body = readFileSync3(command.bodyFile, "utf8");
     } catch {
       console.error(`could not read --body-file: ${command.bodyFile}`);
       process.exit(1);
@@ -2029,7 +2108,7 @@ async function runAnnotateCli(argv) {
     let sql = command.sql;
     if (sql === undefined && command.sqlFile !== undefined) {
       try {
-        sql = readFileSync4(command.sqlFile, "utf8");
+        sql = readFileSync3(command.sqlFile, "utf8");
       } catch {
         console.error(`could not read --sql-file: ${command.sqlFile}`);
         process.exit(1);
@@ -2098,7 +2177,7 @@ async function runAnnotateCli(argv) {
   if (command.kind === "edit") {
     let bodyText = command.body;
     if (command.bodyFile !== undefined)
-      bodyText = readFileSync4(command.bodyFile, "utf8");
+      bodyText = readFileSync3(command.bodyFile, "utf8");
     if (bodyText === undefined) {
       const stdin = await readStdin();
       if (stdin.trim())
@@ -2656,16 +2735,16 @@ var init_query_cli = __esm(() => {
 });
 
 // web-src/server/root.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname, join as join4, normalize } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname2, join as join4, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 function findRoot(start) {
   let current = start;
   for (let i = 0;i < 5; i++) {
-    if (existsSync4(join4(current, "package.json")) && existsSync4(join4(current, "web"))) {
+    if (existsSync3(join4(current, "package.json")) && existsSync3(join4(current, "web"))) {
       return normalize(current);
     }
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current)
       break;
     current = parent;
@@ -2674,7 +2753,7 @@ function findRoot(start) {
 }
 var ROOT;
 var init_root = __esm(() => {
-  ROOT = findRoot(dirname(fileURLToPath(import.meta.url)));
+  ROOT = findRoot(dirname2(fileURLToPath(import.meta.url)));
 });
 
 // web-src/server/skill-cli.ts
@@ -2686,7 +2765,7 @@ __export(exports_skill_cli, {
   SKILL_HELP: () => SKILL_HELP,
   AGENT_SKILL_DIRS: () => AGENT_SKILL_DIRS
 });
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "node:fs";
+import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join5, resolve } from "node:path";
 function parseAgentList(value) {
@@ -2743,7 +2822,7 @@ function parseSkillArgs(argv) {
   return { ok: true, args: { kind: "install", agents, global, cwd } };
 }
 function installSkill(args, deps) {
-  if (!existsSync5(join5(deps.sourceDir, "SKILL.md"))) {
+  if (!existsSync4(join5(deps.sourceDir, "SKILL.md"))) {
     return {
       ok: false,
       error: `bundled skill not found at ${deps.sourceDir}`
@@ -2753,9 +2832,9 @@ function installSkill(args, deps) {
   const results = [];
   for (const agent of args.agents) {
     const target = join5(base, AGENT_SKILL_DIRS[agent], "skills", SKILL_NAME);
-    const action = existsSync5(target) ? "updated" : "installed";
+    const action = existsSync4(target) ? "updated" : "installed";
     try {
-      mkdirSync3(target, { recursive: true });
+      mkdirSync2(target, { recursive: true });
       cpSync(deps.sourceDir, target, { recursive: true });
     } catch (error) {
       return { ok: false, error: String(error) };
@@ -3923,6 +4002,366 @@ function makeId(prefix) {
   return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
 }
 
+// web-src/server/state-store.ts
+import { join as join8 } from "node:path";
+function codeViewerPath(root, fileName) {
+  return join8(root, CODE_VIEWER_DIR2, fileName);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function optionalString(value, maxLen) {
+  if (typeof value !== "string")
+    return;
+  if (value.length === 0 || value.length > maxLen)
+    return;
+  if (value.includes("\x00"))
+    return;
+  return value;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : undefined;
+}
+function optionalNumber(value, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+function optionalFloat(value, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return Math.max(min, Math.min(max, value));
+}
+function optionalFontSize(value) {
+  return value === "compact" || value === "regular" || value === "large" || value === "xlarge" ? value : undefined;
+}
+function normalizeStringList(value, options) {
+  if (!Array.isArray(value))
+    return;
+  const out = [];
+  const seen = new Set;
+  const items = options.keepLast ? [...value].reverse() : value;
+  for (const item of items) {
+    if (out.length >= options.maxItems)
+      break;
+    if (typeof item !== "string")
+      continue;
+    const name = item.trim();
+    if (!name || name.length > options.maxLen || name.includes("\x00"))
+      continue;
+    if (options.pathSafe && (name.includes("/") || name.includes("\\") || name === "." || name === ".." || name === ".git")) {
+      continue;
+    }
+    if (seen.has(name))
+      continue;
+    seen.add(name);
+    out.push(name);
+  }
+  if (options.keepLast)
+    out.reverse();
+  return options.sort === false ? out : out.sort((a, b) => a.localeCompare(b));
+}
+function emptySettings() {
+  return { version: 1 };
+}
+function emptyViewState() {
+  return { version: 1, collapsedDirs: [], viewedFiles: [] };
+}
+function emptyDbUiState() {
+  return { version: 1, columnWidths: {} };
+}
+function sanitizeSettings(raw) {
+  if (!isRecord(raw))
+    return emptySettings();
+  const out = { version: 1 };
+  if (raw.layout === "side-by-side" || raw.layout === "line-by-line")
+    out.layout = raw.layout;
+  if (raw.theme === "light" || raw.theme === "dark")
+    out.theme = raw.theme;
+  if (raw.language === "en" || raw.language === "ja")
+    out.language = raw.language;
+  if (raw.sidebarView === "tree" || raw.sidebarView === "flat")
+    out.sidebarView = raw.sidebarView;
+  const sidebarWidth = optionalNumber(raw.sidebarWidth, 180, 900);
+  if (sidebarWidth !== undefined)
+    out.sidebarWidth = sidebarWidth;
+  const historyWidth = optionalNumber(raw.historyWidth, 220, 640);
+  if (historyWidth !== undefined)
+    out.historyWidth = historyWidth;
+  const sidebarHidden = optionalBoolean(raw.sidebarHidden);
+  if (sidebarHidden !== undefined)
+    out.sidebarHidden = sidebarHidden;
+  const sidebarFontSize = optionalFontSize(raw.sidebarFontSize);
+  if (sidebarFontSize)
+    out.sidebarFontSize = sidebarFontSize;
+  const codeFontSize = optionalFontSize(raw.codeFontSize);
+  if (codeFontSize)
+    out.codeFontSize = codeFontSize;
+  const syntaxHighlight = optionalBoolean(raw.syntaxHighlight);
+  if (syntaxHighlight !== undefined)
+    out.syntaxHighlight = syntaxHighlight;
+  const autoUpdate = optionalBoolean(raw.autoUpdate);
+  if (autoUpdate !== undefined)
+    out.autoUpdate = autoUpdate;
+  const queryHistoryPanelWidth = optionalNumber(raw.queryHistoryPanelWidth, 280, 800);
+  if (queryHistoryPanelWidth !== undefined)
+    out.queryHistoryPanelWidth = queryHistoryPanelWidth;
+  const annotationPanelOpen = optionalBoolean(raw.annotationPanelOpen);
+  if (annotationPanelOpen !== undefined)
+    out.annotationPanelOpen = annotationPanelOpen;
+  const annotationFollow = optionalBoolean(raw.annotationFollow);
+  if (annotationFollow !== undefined)
+    out.annotationFollow = annotationFollow;
+  const annotationMuted = optionalBoolean(raw.annotationMuted);
+  if (annotationMuted !== undefined)
+    out.annotationMuted = annotationMuted;
+  const annotationRate = optionalFloat(raw.annotationRate, 0.5, 2);
+  if (annotationRate !== undefined)
+    out.annotationRate = annotationRate;
+  const ignoreWhitespace = optionalBoolean(raw.ignoreWhitespace);
+  if (ignoreWhitespace !== undefined)
+    out.ignoreWhitespace = ignoreWhitespace;
+  const hideTests = optionalBoolean(raw.hideTests);
+  if (hideTests !== undefined)
+    out.hideTests = hideTests;
+  const scopeOmitDirs = normalizeStringList(raw.scopeOmitDirs, {
+    maxItems: 100,
+    maxLen: 64,
+    pathSafe: true
+  });
+  if (scopeOmitDirs)
+    out.scopeOmitDirs = scopeOmitDirs;
+  const scopeExcludeNames = normalizeStringList(raw.scopeExcludeNames, {
+    maxItems: 200,
+    maxLen: 128,
+    pathSafe: true
+  });
+  if (scopeExcludeNames)
+    out.scopeExcludeNames = scopeExcludeNames;
+  if (isRecord(raw.range)) {
+    const from = optionalString(raw.range.from, MAX_REF_LEN);
+    const to = optionalString(raw.range.to, MAX_REF_LEN);
+    if (from && to)
+      out.range = { from, to };
+  }
+  return out;
+}
+function mergeSettings(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  const raw = { ...current };
+  for (const [key, value] of Object.entries(patch)) {
+    if (key === "version")
+      continue;
+    if (value === null)
+      delete raw[key];
+    else
+      raw[key] = value;
+  }
+  return sanitizeSettings({ ...raw, version: 1 });
+}
+function sanitizeViewState(raw) {
+  if (!isRecord(raw))
+    return emptyViewState();
+  return {
+    version: 1,
+    collapsedDirs: normalizeStringList(raw.collapsedDirs, {
+      maxItems: MAX_VIEW_ITEMS,
+      maxLen: MAX_KEY_LEN,
+      keepLast: true,
+      sort: false
+    }) ?? [],
+    viewedFiles: normalizeStringList(raw.viewedFiles, {
+      maxItems: MAX_VIEW_ITEMS,
+      maxLen: MAX_KEY_LEN,
+      keepLast: true,
+      sort: false
+    }) ?? []
+  };
+}
+function mergeViewState(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  const base = sanitizeViewState({ ...current, version: 1 });
+  const collapsedDirs = new Set(base.collapsedDirs);
+  const viewedFiles = new Set(base.viewedFiles);
+  const addedCollapsedDirs = normalizeStringList(patch.addedCollapsedDirs, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    keepLast: true,
+    sort: false
+  });
+  for (const path of addedCollapsedDirs || [])
+    collapsedDirs.add(path);
+  const removedCollapsedDirs = normalizeStringList(patch.removedCollapsedDirs, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    sort: false
+  });
+  for (const path of removedCollapsedDirs || [])
+    collapsedDirs.delete(path);
+  const addedViewedFiles = normalizeStringList(patch.addedViewedFiles, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    keepLast: true,
+    sort: false
+  });
+  for (const path of addedViewedFiles || [])
+    viewedFiles.add(path);
+  const removedViewedFiles = normalizeStringList(patch.removedViewedFiles, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    sort: false
+  });
+  for (const path of removedViewedFiles || [])
+    viewedFiles.delete(path);
+  return sanitizeViewState({
+    version: 1,
+    collapsedDirs: [...collapsedDirs],
+    viewedFiles: [...viewedFiles]
+  });
+}
+function safeObjectKey(value) {
+  if (!value || value.length > MAX_KEY_LEN || value.includes("\x00"))
+    return null;
+  return value;
+}
+function sanitizeDbUiState(raw) {
+  if (!isRecord(raw) || !isRecord(raw.columnWidths))
+    return emptyDbUiState();
+  const columnWidths = {};
+  let dbCount = 0;
+  for (const [dbIdRaw, tablesRaw] of Object.entries(raw.columnWidths)) {
+    if (dbCount >= MAX_DB_UI_DBS)
+      break;
+    const dbId = safeObjectKey(dbIdRaw);
+    if (!dbId || !isRecord(tablesRaw))
+      continue;
+    const tables = {};
+    let tableCount = 0;
+    for (const [tableRaw, columnsRaw] of Object.entries(tablesRaw)) {
+      if (tableCount >= MAX_DB_UI_TABLES)
+        break;
+      const table = safeObjectKey(tableRaw);
+      if (!table || !isRecord(columnsRaw))
+        continue;
+      const columns = {};
+      let columnCount = 0;
+      for (const [columnRaw, widthRaw] of Object.entries(columnsRaw)) {
+        if (columnCount >= MAX_DB_UI_COLUMNS)
+          break;
+        const column = safeObjectKey(columnRaw);
+        const width = optionalNumber(widthRaw, 60, 1200);
+        if (!column || width === undefined)
+          continue;
+        columns[column] = width;
+        columnCount++;
+      }
+      if (Object.keys(columns).length === 0)
+        continue;
+      tables[table] = columns;
+      tableCount++;
+    }
+    if (Object.keys(tables).length === 0)
+      continue;
+    columnWidths[dbId] = tables;
+    dbCount++;
+  }
+  return { version: 1, columnWidths };
+}
+function mergeDbUiState(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  if (!isRecord(patch.columnWidths)) {
+    return sanitizeDbUiState({ ...current, ...patch, version: 1 });
+  }
+  const columnWidths = {
+    ...current.columnWidths
+  };
+  for (const [dbId, tablesRaw] of Object.entries(patch.columnWidths)) {
+    if (tablesRaw === null) {
+      delete columnWidths[dbId];
+      continue;
+    }
+    if (!isRecord(tablesRaw))
+      continue;
+    const tables = { ...columnWidths[dbId] || {} };
+    for (const [table, columnsRaw] of Object.entries(tablesRaw)) {
+      if (columnsRaw === null) {
+        delete tables[table];
+        continue;
+      }
+      if (!isRecord(columnsRaw))
+        continue;
+      const columns = { ...tables[table] || {} };
+      for (const [column, widthRaw] of Object.entries(columnsRaw)) {
+        if (widthRaw === null)
+          delete columns[column];
+        else
+          columns[column] = widthRaw;
+      }
+      tables[table] = columns;
+    }
+    columnWidths[dbId] = tables;
+  }
+  return sanitizeDbUiState({ ...current, ...patch, columnWidths, version: 1 });
+}
+async function loadAppSettingsState(root) {
+  return settingsStore.load(root);
+}
+async function patchAppSettingsState(root, patch) {
+  return settingsStore.update(root, (state) => {
+    const next = mergeSettings(state, patch);
+    return { state: next, result: next };
+  });
+}
+async function loadViewState(root) {
+  return viewStateStore.load(root);
+}
+async function patchViewState(root, patch) {
+  return viewStateStore.update(root, (state) => {
+    const next = mergeViewState(state, patch);
+    return { state: next, result: next };
+  });
+}
+async function loadDbUiState(root) {
+  return dbUiStore.load(root);
+}
+async function patchDbUiState(root, patch) {
+  return dbUiStore.update(root, (state) => {
+    const next = mergeDbUiState(state, patch);
+    return { state: next, result: next };
+  });
+}
+var CODE_VIEWER_DIR2 = ".code-viewer", SETTINGS_FILE_NAME = "settings.json", VIEW_STATE_FILE_NAME = "view-state.json", DB_UI_FILE_NAME = "db-ui.json", MAX_SETTINGS_BYTES = 200000, MAX_VIEW_STATE_BYTES = 1e6, MAX_DB_UI_BYTES = 1e6, MAX_REF_LEN = 1024, MAX_KEY_LEN = 2048, MAX_VIEW_ITEMS = 20000, MAX_DB_UI_DBS = 200, MAX_DB_UI_TABLES = 500, MAX_DB_UI_COLUMNS = 1000, settingsStore, viewStateStore, dbUiStore;
+var init_state_store = __esm(() => {
+  init_json_store();
+  settingsStore = createJsonFileStore({
+    filePath: (root) => codeViewerPath(root, SETTINGS_FILE_NAME),
+    empty: emptySettings,
+    sanitize: sanitizeSettings,
+    maxBytes: MAX_SETTINGS_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "settings state too large"
+  });
+  viewStateStore = createJsonFileStore({
+    filePath: (root) => codeViewerPath(root, VIEW_STATE_FILE_NAME),
+    empty: emptyViewState,
+    sanitize: sanitizeViewState,
+    maxBytes: MAX_VIEW_STATE_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "view state too large"
+  });
+  dbUiStore = createJsonFileStore({
+    filePath: (root) => codeViewerPath(root, DB_UI_FILE_NAME),
+    empty: emptyDbUiState,
+    sanitize: sanitizeDbUiState,
+    maxBytes: MAX_DB_UI_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "db UI state too large"
+  });
+});
+
 // web-src/server/database/adapters/abort.ts
 function abortError(message = "operation aborted") {
   const err = new Error(message);
@@ -5626,14 +6065,14 @@ var init_connection_pool = __esm(() => {
 // web-src/server/database/discovery.ts
 import {
   closeSync,
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   openSync,
   readSync,
   realpathSync as realpathSync3,
   statSync as statSync2
 } from "node:fs";
-import { lstat, open, readdir, readFile, stat } from "node:fs/promises";
-import { basename as basename2, join as join8, relative as relative2 } from "node:path";
+import { lstat, open, readdir, readFile as readFile2, stat } from "node:fs/promises";
+import { basename as basename2, join as join9, relative as relative2 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
     const stat2 = statSync2(fullPath);
@@ -5704,7 +6143,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
         return;
       if (omitSet.has(entry.toLowerCase()))
         continue;
-      const full = join8(dir, entry);
+      const full = join9(dir, entry);
       let entryStat;
       try {
         entryStat = await lstat(full);
@@ -5748,8 +6187,8 @@ function validateDbPath(cwd, dbPath) {
   const parts = dbPath.split(/[\\/]+/);
   if (parts.some((p) => p === ".." || p.toLowerCase() === ".git" || p.toLowerCase() === ".code-viewer"))
     return null;
-  const full = join8(cwd, dbPath);
-  if (!existsSync6(full))
+  const full = join9(cwd, dbPath);
+  if (!existsSync5(full))
     return null;
   let realCwd;
   let realFull;
@@ -5885,7 +6324,7 @@ function resolveEnvValue(raw, composeDirEnv = {}) {
 }
 async function readDotenvAsync(composeDir) {
   try {
-    const content = await readFile(join8(composeDir, ".env"), "utf-8");
+    const content = await readFile2(join9(composeDir, ".env"), "utf-8");
     return parseDotenvContent(content);
   } catch {
     return {};
@@ -6059,7 +6498,7 @@ function parseComposeContent(content, filepath, composeDir, cwd, composeDirEnv,
 async function parseComposeFileAsync(filepath, composeDir, cwd, results) {
   let content;
   try {
-    content = await readFile(filepath, "utf-8");
+    content = await readFile2(filepath, "utf-8");
   } catch {
     return;
   }
@@ -6105,7 +6544,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
     if (depth > MAX_SCAN_DEPTH)
       return;
     for (const filename of COMPOSE_FILENAMES) {
-      const filepath = join8(dir, filename);
+      const filepath = join9(dir, filename);
       if (await pathExistsAsync(filepath)) {
         await parseComposeFileAsync(filepath, dir, cwd, results);
         break;
@@ -6128,7 +6567,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
         return;
       if (omitSet.has(entry.toLowerCase()))
         continue;
-      const full = join8(dir, entry);
+      const full = join9(dir, entry);
       let entryStat;
       try {
         entryStat = await lstat(full);
@@ -6763,6 +7202,32 @@ function textError(message, status) {
     }
   });
 }
+async function jsonLoadResponse(load, logPrefix, errorMessage) {
+  try {
+    return json(await load());
+  } catch (err) {
+    console.error(`[code-viewer] ${logPrefix} error:`, err);
+    return textError(errorMessage, 500);
+  }
+}
+async function parseBoundedJsonBody(req, maxBytes, tooLargeMessage) {
+  const contentType = req.headers.get("content-type") || "";
+  if (!contentType.toLowerCase().startsWith("application/json")) {
+    return textError("unsupported media type", 415);
+  }
+  const contentLength = Number(req.headers.get("content-length") || "0");
+  if (contentLength > maxBytes)
+    return textError(tooLargeMessage, 413);
+  try {
+    const raw = await req.text();
+    if (Buffer.byteLength(raw, "utf8") > maxBytes) {
+      return textError(tooLargeMessage, 413);
+    }
+    return JSON.parse(raw);
+  } catch {
+    return textError("invalid JSON body", 400);
+  }
+}
 function waitForCallerAbort(promise, signal, message) {
   if (!signal)
     return promise;
@@ -6794,6 +7259,10 @@ function waitForCallerAbort(promise, signal, message) {
     });
   });
 }
+function isFilesystemAccessError(err) {
+  const code = err?.code;
+  return code === "EACCES" || code === "EBUSY" || code === "EIO" || code === "EISDIR" || code === "ENOSPC" || code === "ENOTDIR" || code === "EPERM" || code === "EROFS";
+}
 async function resolveDockerExplorerAsync(cwd, dbParam, kind, cache, openFn, omitDirNames, signal) {
   if (!dbParam)
     return textError("missing db parameter", 400);
@@ -6860,6 +7329,9 @@ function handleError(prefix, action, err) {
   if (isDockerComposeServiceUnavailableError(err)) {
     return textError(message, err.status);
   }
+  if (isFilesystemAccessError(err)) {
+    return textError(`failed to ${action}`, 500);
+  }
   return textError(`failed to ${action}: ${message}`, 500);
 }
 var DEFAULT_MAX_DOCKER_ADAPTER_CACHE = 8, DEFAULT_DOCKER_ADAPTER_IDLE_MS;
@@ -8657,13 +9129,9 @@ var init_handle_s3 = __esm(() => {
 });
 
 // web-src/server/database/query-history.ts
-import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function historyFilePath(root) {
-  return join9(root, CODE_VIEWER_DIR2, HISTORY_FILE_NAME);
-}
-function isEnoent(err) {
-  return err?.code === "ENOENT";
+  return join10(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
 }
 function emptyState() {
   return { version: 1, entries: [] };
@@ -8682,69 +9150,86 @@ function serializeHistoryState(state) {
   }
   return content;
 }
-async function backupCorruptHistoryFileAsync(file) {
-  try {
-    await rename(file, `${file}.corrupt-${Date.now()}`);
-  } catch {}
+function optionalString2(value, maxLen) {
+  if (typeof value !== "string")
+    return;
+  if (!value || value.length > maxLen || value.includes("\x00"))
+    return;
+  return value;
 }
-async function loadQueryHistoryAsync(cwd) {
-  const pendingWrite = historyWriteQueues.get(cwd);
-  if (pendingWrite) {
-    await pendingWrite.catch(() => {});
+function finiteNumber(value, min = 0) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return Math.max(min, Math.round(value));
+}
+function sanitizeDbValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
-  return loadQueryHistoryAsyncUnqueued(cwd);
+  return null;
 }
-async function loadQueryHistoryAsyncUnqueued(cwd) {
-  const file = historyFilePath(cwd);
-  let raw;
-  try {
-    raw = await readFile2(file, "utf8");
-  } catch (err) {
-    if (isEnoent(err))
-      return emptyState();
-    await backupCorruptHistoryFileAsync(file);
+function sanitizeRows(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.slice(0, MAX_PREVIEW_ROWS).map((row) => {
+    if (!Array.isArray(row))
+      return [];
+    return row.map(sanitizeDbValue);
+  });
+}
+function sanitizeEntry(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const entry = raw;
+  const id = optionalString2(entry.id, MAX_ID_LEN);
+  const dbId = optionalString2(entry.dbId, MAX_DB_ID_LEN);
+  const sql = optionalString2(entry.sql, MAX_SQL_LEN);
+  if (!id || !dbId || !sql)
+    return null;
+  const columns = Array.isArray(entry.columns) ? entry.columns.filter((col) => typeof col === "string" && !!col).map((col) => col.slice(0, MAX_COLUMN_LEN)).slice(0, MAX_COLUMNS) : [];
+  const rowsPreview = sanitizeRows(entry.rowsPreview);
+  const schema = optionalString2(entry.schema, MAX_SCHEMA_LEN);
+  const title = optionalString2(entry.title, MAX_TEXT_LEN);
+  const body = optionalString2(entry.body, MAX_TEXT_LEN);
+  return {
+    id,
+    dbId,
+    ...schema ? { schema } : {},
+    sql,
+    ...title ? { title } : {},
+    ...body ? { body } : {},
+    columns,
+    rowsPreview,
+    rowCount: finiteNumber(entry.rowCount) ?? rowsPreview.length,
+    savedRows: finiteNumber(entry.savedRows) ?? rowsPreview.length,
+    truncated: typeof entry.truncated === "boolean" ? entry.truncated : false,
+    elapsedMs: finiteNumber(entry.elapsedMs) ?? 0,
+    executedAt: optionalString2(entry.executedAt, 64) ?? new Date(0).toISOString(),
+    executedBy: entry.executedBy === "ai" ? "ai" : "user",
+    source: entry.source === "cli" ? "cli" : "browser"
+  };
+}
+function sanitizeHistoryState(raw) {
+  if (!raw || typeof raw !== "object")
     return emptyState();
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
-      await backupCorruptHistoryFileAsync(file);
-      return emptyState();
-    }
-    return parsed;
-  } catch (err) {
-    if (isEnoent(err))
-      return emptyState();
-    await backupCorruptHistoryFileAsync(file);
+  const entriesRaw = raw.entries;
+  if (!Array.isArray(entriesRaw))
     return emptyState();
+  const entries = [];
+  for (const entry of entriesRaw) {
+    if (entries.length >= MAX_ENTRIES2)
+      break;
+    const normalized = sanitizeEntry(entry);
+    if (normalized)
+      entries.push(normalized);
   }
+  return { version: 1, entries };
 }
-async function saveQueryHistoryAsync(cwd, state) {
-  const dir = join9(cwd, CODE_VIEWER_DIR2);
-  await mkdir(dir, { recursive: true });
-  const file = historyFilePath(cwd);
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const content = serializeHistoryState(state);
-  await writeFile(tmp, content, "utf8");
-  await rename(tmp, file);
+async function loadQueryHistoryAsync(cwd) {
+  return historyStore.load(cwd);
 }
 async function updateQueryHistoryAsync(cwd, updater) {
-  const previous = historyWriteQueues.get(cwd) ?? Promise.resolve();
-  const run2 = previous.catch(() => {}).then(async () => {
-    const current = await loadQueryHistoryAsyncUnqueued(cwd);
-    const updated = await updater(current);
-    await saveQueryHistoryAsync(cwd, updated.state);
-    return updated.result;
-  });
-  const queued = run2.then(() => {}, () => {});
-  historyWriteQueues.set(cwd, queued);
-  try {
-    return await run2;
-  } finally {
-    if (historyWriteQueues.get(cwd) === queued) {
-      historyWriteQueues.delete(cwd);
-    }
-  }
+  return historyStore.update(cwd, updater);
 }
 function clampPreviewRows(rows) {
   return rows.slice(0, MAX_PREVIEW_ROWS);
@@ -8780,15 +9265,23 @@ function clearQueryHistory(state, dbId, schema) {
     })
   };
 }
-var CODE_VIEWER_DIR2 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES = 1e6, historyWriteQueues;
+var CODE_VIEWER_DIR3 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES = 1e6, MAX_ID_LEN = 128, MAX_DB_ID_LEN = 2048, MAX_SCHEMA_LEN = 512, MAX_SQL_LEN = 64000, MAX_TEXT_LEN = 64000, MAX_COLUMN_LEN = 512, MAX_COLUMNS = 500, historyStore;
 var init_query_history = __esm(() => {
-  historyWriteQueues = new Map;
+  init_json_store();
+  historyStore = createJsonFileStore({
+    filePath: historyFilePath,
+    empty: emptyState,
+    sanitize: sanitizeHistoryState,
+    maxBytes: MAX_JSON_BYTES,
+    backupSuffix: "corrupt",
+    serialize: serializeHistoryState
+  });
 });
 
 // web-src/server/database/snapshot-store.ts
-import { createHash as createHash5, randomBytes } from "node:crypto";
-import { mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+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;
@@ -8805,7 +9298,7 @@ async function getSqliteClass2() {
   throw new Error("No SQLite driver available. Install better-sqlite3 or use the bun runtime.");
 }
 async function getStoreDb(cwd) {
-  const dbPath = join10(cwd, CODE_VIEWER_DIR3, SNAPSHOT_DB_NAME);
+  const dbPath = join11(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
     return storeDb;
   if (storeDb) {
@@ -8813,7 +9306,7 @@ async function getStoreDb(cwd) {
       storeDb.close();
     } catch {}
   }
-  mkdirSync4(join10(cwd, CODE_VIEWER_DIR3), { recursive: true });
+  mkdirSync3(join11(cwd, CODE_VIEWER_DIR4), { recursive: true });
   const DbClass = await getSqliteClass2();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
@@ -8826,7 +9319,7 @@ async function getStoreDb(cwd) {
   return storeDb;
 }
 function makeId2(prefix) {
-  return `${prefix}-${randomBytes(8).toString("hex")}`;
+  return `${prefix}-${randomBytes2(8).toString("hex")}`;
 }
 function hashPayload(payloadJson) {
   return createHash5("sha256").update(payloadJson).digest("hex");
@@ -9073,7 +9566,7 @@ async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit
   });
   return { rows, total };
 }
-var CODE_VIEWER_DIR3 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite", cachedDbClass2 = null, SCHEMA_SQL = `
+var CODE_VIEWER_DIR4 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite", cachedDbClass2 = null, SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS snapshots (
   id TEXT PRIMARY KEY,
   db_id TEXT NOT NULL,
@@ -9170,13 +9663,9 @@ var init_snapshot_runner = __esm(() => {
 });
 
 // web-src/server/database/tabs-store.ts
-import { mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function tabsFilePath(root) {
-  return join11(root, CODE_VIEWER_DIR4, TABS_FILE_NAME);
-}
-function isEnoent2(err) {
-  return err?.code === "ENOENT";
+  return join12(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
 }
 function emptyState2() {
   return { version: 1, tabs: [], activeTabId: null };
@@ -9244,6 +9733,31 @@ function sanitizeEs(v) {
     return;
   return out;
 }
+function sanitizeS3(v) {
+  if (!v || typeof v !== "object")
+    return;
+  const r = v;
+  const out = {};
+  const bucket = sanitizeOptionalString(r.bucket, MAX_S3_BUCKET_LEN);
+  if (bucket !== undefined)
+    out.bucket = bucket;
+  const prefix = sanitizeOptionalString(r.prefix, MAX_S3_KEY_LEN);
+  if (prefix !== undefined)
+    out.prefix = prefix;
+  const query = sanitizeOptionalString(r.query, MAX_S3_QUERY_LEN);
+  if (query !== undefined)
+    out.query = query;
+  if (r.mode === "prefix" || r.mode === "contains")
+    out.mode = r.mode;
+  if (r.sort === "key-asc" || r.sort === "updated-desc")
+    out.sort = r.sort;
+  const key = sanitizeOptionalString(r.key, MAX_S3_KEY_LEN);
+  if (key !== undefined)
+    out.key = key;
+  if (out.bucket === undefined && out.prefix === undefined && out.query === undefined && out.mode === undefined && out.sort === undefined && out.key === undefined)
+    return;
+  return out;
+}
 function sanitize(input) {
   if (!input || typeof input !== "object")
     return emptyState2();
@@ -9265,12 +9779,15 @@ function sanitize(input) {
     if (seenIds.has(id))
       continue;
     seenIds.add(id);
-    const dbId = sanitizeOptionalString(tab.dbId, MAX_DB_ID_LEN) ?? null;
+    const dbId = sanitizeOptionalString(tab.dbId, MAX_DB_ID_LEN2) ?? null;
     if (isToolInternalDbId(dbId))
       continue;
+    const schema = sanitizeOptionalString(tab.schema, MAX_SCHEMA_NAME_LEN);
     const table = sanitizeOptionalString(tab.table, MAX_TABLE_NAME_LEN) ?? null;
     const view = typeof tab.view === "string" && VALID_VIEWS.has(tab.view) ? tab.view : "data";
     const out = { id, dbId, table, view };
+    if (schema !== undefined)
+      out.schema = schema;
     const sqlDraft = sanitizeOptionalString(tab.sqlDraft, MAX_SQL_DRAFT_LEN);
     if (sqlDraft !== undefined)
       out.sqlDraft = sqlDraft;
@@ -9288,6 +9805,9 @@ function sanitize(input) {
     const es = sanitizeEs(tab.es);
     if (es !== undefined)
       out.es = es;
+    const s3 = sanitizeS3(tab.s3);
+    if (s3 !== undefined)
+      out.s3 = s3;
     tabs.push(out);
   }
   let activeTabId = sanitizeOptionalString(obj.activeTabId, MAX_TAB_ID_LEN) ?? null;
@@ -9297,69 +9817,14 @@ function sanitize(input) {
   return { version: 1, tabs, activeTabId };
 }
 async function loadTabsAsync(cwd) {
-  const pendingWrite = tabsWriteQueues.get(cwd);
-  if (pendingWrite) {
-    await pendingWrite.catch(() => {});
-  }
-  const file = tabsFilePath(cwd);
-  let raw;
-  try {
-    raw = await readFile3(file, "utf8");
-  } catch (err) {
-    if (isEnoent2(err))
-      return emptyState2();
-    await backupInvalidTabsFileAsync(file);
-    return emptyState2();
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || parsed.version !== 1) {
-      await backupInvalidTabsFileAsync(file);
-      return emptyState2();
-    }
-    return sanitize(parsed);
-  } catch (err) {
-    if (isEnoent2(err))
-      return emptyState2();
-    await backupInvalidTabsFileAsync(file);
-    return emptyState2();
-  }
-}
-async function backupInvalidTabsFileAsync(file) {
-  try {
-    await rename2(file, `${file}.bak-${Date.now()}`);
-  } catch {}
-}
-async function saveTabsAsyncUnqueued(cwd, state) {
-  const normalized = sanitize(state);
-  const dir = join11(cwd, CODE_VIEWER_DIR4);
-  await mkdir2(dir, { recursive: true });
-  const file = tabsFilePath(cwd);
-  const tmp = `${file}.${makeId(`tmp-${process.pid}`)}`;
-  const content = `${JSON.stringify(normalized, null, 2)}
-`;
-  if (Buffer.byteLength(content, "utf8") > MAX_JSON_BYTES2) {
-    throw new Error("tabs state too large");
-  }
-  await writeFile2(tmp, content, "utf8");
-  await rename2(tmp, file);
+  return tabsStore.load(cwd);
 }
 async function saveTabsAsync(cwd, state) {
-  const previous = tabsWriteQueues.get(cwd) ?? Promise.resolve();
-  const run2 = previous.catch(() => {}).then(() => saveTabsAsyncUnqueued(cwd, state));
-  const queued = run2.then(() => {}, () => {});
-  tabsWriteQueues.set(cwd, queued);
-  try {
-    await run2;
-  } finally {
-    if (tabsWriteQueues.get(cwd) === queued) {
-      tabsWriteQueues.delete(cwd);
-    }
-  }
+  return tabsStore.save(cwd, state);
 }
-var CODE_VIEWER_DIR4 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES2 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN = 2048, MAX_TABLE_NAME_LEN = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, tabsWriteQueues, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS;
+var CODE_VIEWER_DIR5 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES2 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN2 = 2048, MAX_SCHEMA_NAME_LEN = 512, MAX_TABLE_NAME_LEN = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, MAX_S3_BUCKET_LEN = 256, MAX_S3_KEY_LEN = 2048, MAX_S3_QUERY_LEN = 2048, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS, tabsStore;
 var init_tabs_store = __esm(() => {
-  tabsWriteQueues = new Map;
+  init_json_store();
   VALID_VIEWS = new Set([
     "data",
     "query",
@@ -9368,6 +9833,14 @@ var init_tabs_store = __esm(() => {
     "search",
     "snapshot"
   ]);
+  tabsStore = createJsonFileStore({
+    filePath: tabsFilePath,
+    empty: emptyState2,
+    sanitize,
+    maxBytes: MAX_JSON_BYTES2,
+    backupSuffix: "bak",
+    sizeErrorMessage: "tabs state too large"
+  });
 });
 
 // web-src/server/database/handle.ts
@@ -9396,7 +9869,7 @@ function sanitizeFilename(name) {
 function normalizeSchemaParam(value) {
   if (value === undefined || value === null || value === "")
     return;
-  if (value.length > MAX_SCHEMA_NAME_LEN) {
+  if (value.length > MAX_SCHEMA_NAME_LEN2) {
     return textError("invalid schema parameter", 400);
   }
   if (hasControlCharacter(value)) {
@@ -10355,6 +10828,23 @@ async function handleTabsPut(cwd, req) {
     return textError(`failed to save tabs: ${message}`, 500);
   }
 }
+async function handleDbUiGet(cwd) {
+  return jsonLoadResponse(() => loadDbUiState(cwd), "db UI", "failed to load db UI state");
+}
+async function handleDbUiPatch(cwd, req) {
+  const body = await parseBoundedJsonBody(req, MAX_DB_UI_BODY_BYTES, "db UI body too large");
+  if (body instanceof Response)
+    return body;
+  try {
+    return json(await patchDbUiState(cwd, body));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message === "db UI state too large")
+      return textError(message, 413);
+    console.error("[code-viewer] db UI error:", err);
+    return textError("failed to save db UI state", 500);
+  }
+}
 async function handleClose(cwd, req, omitDirNames) {
   const body = await parsePostJsonBody(req);
   if (body instanceof Response)
@@ -10517,11 +11007,17 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       methods: ["GET", "PUT", "POST"],
       sideEffect: (m) => m !== "GET",
       handler: () => method === "GET" ? handleTabsGet(cwd) : handleTabsPut(cwd, req)
+    },
+    "/_db/ui": {
+      methods: ["GET", "PATCH"],
+      sideEffect: (m) => m !== "GET",
+      handler: () => method === "GET" ? handleDbUiGet(cwd) : handleDbUiPatch(cwd, req)
     }
   }, sideEffectAllowed, wrapResponse, (err) => handleError("database", "handle database request", err));
 }
-var initialized = false, dockerAdapterCache, MAX_SCHEMA_NAME_LEN = 1024, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
+var initialized = false, dockerAdapterCache, MAX_SCHEMA_NAME_LEN2 = 1024, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_DB_UI_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
 var init_handle = __esm(() => {
+  init_state_store();
   init_docker();
   init_docker_utils();
   init_sqlite();
@@ -10575,25 +11071,87 @@ var init_handle = __esm(() => {
   };
 });
 
+// web-src/server/state-route.ts
+var exports_state_route = {};
+__export(exports_state_route, {
+  handleStateRoute: () => handleStateRoute
+});
+async function parseJsonBody(req) {
+  return parseBoundedJsonBody(req, MAX_STATE_PATCH_BODY_BYTES, "state body too large");
+}
+async function handleSettingsGet(cwd) {
+  return jsonLoadResponse(() => loadAppSettingsState(cwd), "state", "failed to load settings state");
+}
+async function handleSettingsPatch(cwd, req) {
+  const body = await parseJsonBody(req);
+  if (body instanceof Response)
+    return body;
+  try {
+    return json(await patchAppSettingsState(cwd, body));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message === "settings state too large")
+      return textError(message, 413);
+    console.error("[code-viewer] state error:", err);
+    return textError("failed to save settings state", 500);
+  }
+}
+async function handleViewGet(cwd) {
+  return jsonLoadResponse(() => loadViewState(cwd), "state", "failed to load view state");
+}
+async function handleViewPatch(cwd, req) {
+  const body = await parseJsonBody(req);
+  if (body instanceof Response)
+    return body;
+  try {
+    return json(await patchViewState(cwd, body));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message === "view state too large")
+      return textError(message, 413);
+    console.error("[code-viewer] state error:", err);
+    return textError("failed to save view state", 500);
+  }
+}
+async function handleStateRoute(req, url, cwd, sideEffectAllowed) {
+  return dispatchRoutes(req, url, {
+    "/_state/settings": {
+      methods: ["GET", "PATCH"],
+      sideEffect: (method) => method !== "GET",
+      handler: () => req.method === "GET" ? handleSettingsGet(cwd) : handleSettingsPatch(cwd, req)
+    },
+    "/_state/view": {
+      methods: ["GET", "PATCH"],
+      sideEffect: (method) => method !== "GET",
+      handler: () => req.method === "GET" ? handleViewGet(cwd) : handleViewPatch(cwd, req)
+    }
+  }, sideEffectAllowed, (res) => res, (err) => handleError("state", "handle state request", err));
+}
+var MAX_STATE_PATCH_BODY_BYTES = 1e6;
+var init_state_route = __esm(() => {
+  init_handle_shared();
+  init_state_store();
+});
+
 // web-src/server/preview.ts
 var exports_preview = {};
 import {
   closeSync as closeSync2,
   constants,
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   lstatSync as lstatSync4,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync4,
   openSync as openSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync4,
   realpathSync as realpathSync4,
-  renameSync as renameSync2,
+  renameSync,
   statSync as statSync3,
   unlinkSync as unlinkSync2,
   watch,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname2, extname as extname2, join as join12, relative as relative3 } from "node:path";
+import { basename as basename3, dirname as dirname3, extname as extname2, join as join13, relative as relative3 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -10734,10 +11292,10 @@ function staticFile(pathname) {
   const spec = map[pathname];
   if (!spec)
     return null;
-  const full = join12(WEB_ROOT, spec[0]);
-  if (!existsSync7(full))
+  const full = join13(WEB_ROOT, spec[0]);
+  if (!existsSync6(full))
     return text("not found", 404);
-  return new Response(readFileSync5(full), {
+  return new Response(readFileSync4(full), {
     headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
   });
 }
@@ -10968,8 +11526,8 @@ function parseScopeExcludeNamesQuery(value) {
   return normalizeScopeExcludeNames(names);
 }
 function loadProjectConfig() {
-  const full = join12(cwd, ".code-viewer.json");
-  if (!existsSync7(full))
+  const full = join13(cwd, ".code-viewer.json");
+  if (!existsSync6(full))
     return null;
   let realCwd;
   let realConfig;
@@ -10979,10 +11537,10 @@ function loadProjectConfig() {
   } catch {
     return null;
   }
-  if (dirname2(realConfig) !== realCwd || basename3(realConfig) !== ".code-viewer.json")
+  if (dirname3(realConfig) !== realCwd || basename3(realConfig) !== ".code-viewer.json")
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(realConfig, "utf8"));
+    const parsed = JSON.parse(readFileSync4(realConfig, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "version" in parsed && parsed.version !== 1)
       return null;
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
@@ -11033,8 +11591,8 @@ function safeWorktreePath(path) {
     return null;
   if (isGitInternalPath(path))
     return null;
-  const full = join12(cwd, path);
-  if (!existsSync7(full))
+  const full = join13(cwd, path);
+  if (!existsSync6(full))
     return null;
   let realCwd;
   let realFull;
@@ -11052,7 +11610,7 @@ function safeWorktreePath(path) {
   return realFull;
 }
 function worktreePath(path) {
-  return join12(cwd, path);
+  return join13(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -11068,7 +11626,7 @@ function safeOpenWorktreePath(path) {
   return safeWorktreePath(path);
 }
 function parentRepoPath(path) {
-  const parent = dirname2(path);
+  const parent = dirname3(path);
   return parent === "." ? "" : parent;
 }
 function isoDate(ms) {
@@ -11135,7 +11693,7 @@ function readReadme(target, dirPath) {
       if (!full)
         continue;
       try {
-        return { path, text: readFileSync5(full, "utf8") };
+        return { path, text: readFileSync4(full, "utf8") };
       } catch {
         continue;
       }
@@ -11256,7 +11814,7 @@ function grepWorktreeFallback(query, max, paths, omitDirNames, excludeNames) {
       continue;
     let data;
     try {
-      data = readFileSync5(full);
+      data = readFileSync4(full);
     } catch {
       continue;
     }
@@ -11792,10 +12350,10 @@ async function handleUploadFiles(req) {
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
-    const target = join12(realDir, safeName);
-    if (relative3(realDir, dirname2(target)) !== "")
+    const target = join13(realDir, safeName);
+    if (relative3(realDir, dirname3(target)) !== "")
       return text("invalid filename", 400);
-    if (existsSync7(target))
+    if (existsSync6(target))
       return text("file exists", 409);
     uploads.push({ file, name: safeName, target });
   }
@@ -11804,7 +12362,7 @@ async function handleUploadFiles(req) {
     for (const upload of uploads) {
       const fd = openSync2(upload.target, uploadOpenFlags(), 420);
       try {
-        writeFileSync3(fd, new Uint8Array(await upload.file.arrayBuffer()));
+        writeFileSync2(fd, new Uint8Array(await upload.file.arrayBuffer()));
       } finally {
         closeSync2(fd);
       }
@@ -11914,12 +12472,12 @@ function triggerUpdate(changedPaths) {
   sendSse("update", data);
 }
 function moveMacPathIntoTrash(path) {
-  const trashDir = join12(homedir3(), ".Trash");
+  const trashDir = join13(homedir3(), ".Trash");
   const base = basename3(path) || "code-viewer-trash-item";
-  const target = join12(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
+  const target = join13(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
   try {
-    mkdirSync5(trashDir, { recursive: true });
-    renameSync2(path, target);
+    mkdirSync4(trashDir, { recursive: true });
+    renameSync(path, target);
     return { ok: true, trashPath: target };
   } catch (error) {
     return { ok: false, error: String(error) };
@@ -11950,20 +12508,20 @@ function restoreTrashPath(originalPath, trashPath) {
   if (!parentFullPath)
     return { ok: false, error: "invalid restore target" };
   const original = worktreePath(originalPath);
-  if (existsSync7(original))
+  if (existsSync6(original))
     return { ok: false, error: "restore target exists" };
   if (trashPath) {
     if (process.platform !== "darwin")
       return { ok: false, error: "invalid trash handle" };
-    if (!existsSync7(trashPath))
+    if (!existsSync6(trashPath))
       return { ok: false, error: "trash item not found" };
     try {
-      const trashRoot = join12(homedir3(), ".Trash");
+      const trashRoot = join13(homedir3(), ".Trash");
       const trashRelative = relative3(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
-      mkdirSync5(dirname2(original), { recursive: true });
-      renameSync2(trashPath, original);
+      mkdirSync4(dirname3(original), { recursive: true });
+      renameSync(trashPath, original);
       return { ok: true };
     } catch (error) {
       return { ok: false, error: String(error) };
@@ -12108,11 +12666,11 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join12(parent, name);
-  if (existsSync7(target))
+  const target = join13(parent, name);
+  if (existsSync6(target))
     return text("already exists", 409);
   try {
-    mkdirSync5(target, { recursive: false });
+    mkdirSync4(target, { recursive: false });
   } catch (error) {
     if (error.code === "EEXIST")
       return text("already exists", 409);
@@ -12158,7 +12716,7 @@ function annotationSse(kind, sessionId, entryId) {
 }
 async function handleAnnotations(req) {
   if (req.method === "GET")
-    return json2(loadAnnotationsState(cwd));
+    return json2(await loadAnnotationsState(cwd));
   if (req.method !== "POST")
     return text("method not allowed", 405);
   if (!sideEffectRequestAllowed(req))
@@ -12182,8 +12740,8 @@ async function handleAnnotations(req) {
   const action = body.action;
   if (action === "start") {
     const title = typeof body.title === "string" ? body.title : "";
-    const started = startAnnotationSession(loadAnnotationsState(cwd), title, new Date().toISOString());
-    saveAnnotationsState(cwd, started.state);
+    const started = startAnnotationSession(await loadAnnotationsState(cwd), title, new Date().toISOString());
+    await saveAnnotationsState(cwd, started.state);
     annotationSse("start", started.session.id);
     return json2({ ok: true, session: started.session });
   }
@@ -12201,7 +12759,7 @@ async function handleAnnotations(req) {
       if (isGitInternalPath(path) || isCodeViewerInternalPath(path))
         return text("forbidden", 403);
     }
-    const result = addAnnotationEntry(loadAnnotationsState(cwd), {
+    const result = addAnnotationEntry(await loadAnnotationsState(cwd), {
       session_id: typeof body.session_id === "string" ? body.session_id : undefined,
       session_title: typeof body.session_title === "string" ? body.session_title : undefined,
       path,
@@ -12216,7 +12774,7 @@ async function handleAnnotations(req) {
     }, new Date().toISOString());
     if (result.ok === false)
       return text(result.error, 400);
-    saveAnnotationsState(cwd, result.state);
+    await saveAnnotationsState(cwd, result.state);
     annotationSse("add", result.session.id, result.entry.id);
     return json2({
       ok: true,
@@ -12230,14 +12788,14 @@ async function handleAnnotations(req) {
     const id = typeof body.id === "string" ? body.id : "";
     if (!id)
       return text("invalid id", 400);
-    const result = moveAnnotationEntry(loadAnnotationsState(cwd), id, {
+    const result = moveAnnotationEntry(await loadAnnotationsState(cwd), id, {
       before_id: typeof body.before_id === "string" ? body.before_id : undefined,
       after_id: typeof body.after_id === "string" ? body.after_id : undefined,
       position: typeof body.position === "number" ? body.position : undefined
     });
     if (result.ok === false)
       return text(result.error, 400);
-    saveAnnotationsState(cwd, result.state);
+    await saveAnnotationsState(cwd, result.state);
     annotationSse("update", result.session.id, result.entry.id);
     return json2({
       ok: true,
@@ -12249,9 +12807,9 @@ async function handleAnnotations(req) {
     const id = typeof body.id === "string" ? body.id : "";
     if (!id)
       return text("invalid id", 400);
-    const result = deleteAnnotationById(loadAnnotationsState(cwd), id);
+    const result = deleteAnnotationById(await loadAnnotationsState(cwd), id);
     if (result.removed) {
-      saveAnnotationsState(cwd, result.state);
+      await saveAnnotationsState(cwd, result.state);
       annotationSse("delete");
     }
     return json2({ ok: true, removed: result.removed });
@@ -12261,10 +12819,10 @@ async function handleAnnotations(req) {
     const title = typeof body.title === "string" ? body.title : "";
     if (!id)
       return text("invalid id", 400);
-    const result = renameAnnotationSession(loadAnnotationsState(cwd), id, title);
+    const result = renameAnnotationSession(await loadAnnotationsState(cwd), id, title);
     if (!result.renamed)
       return text("session not found", 404);
-    saveAnnotationsState(cwd, result.state);
+    await saveAnnotationsState(cwd, result.state);
     annotationSse("update", id);
     return json2({ ok: true });
   }
@@ -12272,18 +12830,18 @@ async function handleAnnotations(req) {
     const id = typeof body.id === "string" ? body.id : "";
     if (!id)
       return text("invalid id", 400);
-    const result = updateAnnotationEntry(loadAnnotationsState(cwd), id, {
+    const result = updateAnnotationEntry(await loadAnnotationsState(cwd), id, {
       title: typeof body.title === "string" ? body.title : undefined,
       body: typeof body.body === "string" ? body.body : undefined
     });
     if (result.ok === false)
       return text(result.error, 400);
-    saveAnnotationsState(cwd, result.state);
+    await saveAnnotationsState(cwd, result.state);
     annotationSse("update", undefined, id);
     return json2({ ok: true, entry: result.entry });
   }
   if (action === "clear") {
-    saveAnnotationsState(cwd, emptyAnnotationsState());
+    await saveAnnotationsState(cwd, emptyAnnotationsState());
     annotationSse("clear");
     return json2({ ok: true });
   }
@@ -12352,8 +12910,8 @@ var init_preview = __esm(async () => {
   init_search();
   init_server_registry();
   init_worktree_watcher();
-  WEB_ROOT = join12(ROOT, "web");
-  VERSION = JSON.parse(readFileSync5(join12(ROOT, "package.json"), "utf8")).version;
+  WEB_ROOT = join13(ROOT, "web");
+  VERSION = JSON.parse(readFileSync4(join13(ROOT, "package.json"), "utf8")).version;
   DEFAULT_ARGS = ["HEAD"];
   WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
   LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
@@ -12457,6 +13015,12 @@ var init_preview = __esm(async () => {
         if (dbResponse)
           return dbResponse;
       }
+      if (url.pathname.startsWith("/_state/")) {
+        const { handleStateRoute: handleStateRoute2 } = await Promise.resolve().then(() => (init_state_route(), exports_state_route));
+        const stateResponse = await handleStateRoute2(req, url, cwd, sideEffectRequestAllowed);
+        if (stateResponse)
+          return stateResponse;
+      }
       if (url.pathname === "/_annotations")
         return handleAnnotations(req);
       if (url.pathname === "/_refs")