@youtyan/code-viewer 0.2.5 → 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)
@@ -1458,6 +1537,9 @@ var init_git = __esm(() => {
     "vendor",
     ".cache",
     "coverage",
+    "tmp",
+    "log",
+    "storage",
     "DerivedData",
     "Pods",
     "bin",
@@ -1468,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";
@@ -1485,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;
@@ -1529,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)
@@ -1958,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);
@@ -2026,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);
@@ -2095,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())
@@ -2653,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;
@@ -2671,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
@@ -2683,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) {
@@ -2740,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}`
@@ -2750,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) };
@@ -3681,14 +3763,23 @@ function startWorktreeUpdateWatch(options) {
   const setTimer = options.setTimeoutFn || setTimeout;
   const clearTimer = options.clearTimeoutFn || clearTimeout;
   const debounceMs = options.debounceMs ?? 250;
+  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
   const watchers = new Map;
   const signatures = new Map;
   const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
   const initialScanQueue = [];
   let initialScanTimer = null;
+  const pendingPathInspections = new Map;
+  let pathInspectionTimer = null;
   let timer = null;
   const pendingChangedPaths = new Set;
+  let watchLimitReported = false;
   const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative(options.root, dir));
+  const ignoredDirectory = (dir) => {
+    const rel = directoryRelativePath(dir);
+    return Boolean(rel && ignored(rel));
+  };
   const scheduleUpdate = (changedPath) => {
     if (changedPath)
       pendingChangedPaths.add(changedPath);
@@ -3701,6 +3792,12 @@ function startWorktreeUpdateWatch(options) {
       options.onUpdate(paths);
     }, debounceMs);
   };
+  const reportWatchLimit = () => {
+    if (watchLimitReported)
+      return;
+    watchLimitReported = true;
+    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
+  };
   const closeSubtree = (dir) => {
     for (const [watchedDir, watcher] of [...watchers]) {
       if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
@@ -3717,7 +3814,12 @@ function startWorktreeUpdateWatch(options) {
       clearTimer(initialScanTimer);
       initialScanTimer = null;
     }
+    if (pathInspectionTimer) {
+      clearTimer(pathInspectionTimer);
+      pathInspectionTimer = null;
+    }
     initialScanQueue.length = 0;
+    pendingPathInspections.clear();
     for (const watcher of [...watchers.values()]) {
       try {
         watcher.close?.();
@@ -3738,27 +3840,82 @@ function startWorktreeUpdateWatch(options) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      children.push(join7(dir, entry.name));
+      const child = join7(dir, entry.name);
+      if (ignoredDirectory(child))
+        continue;
+      children.push(child);
     }
     return children;
   };
   const processInitialScanQueue = () => {
     initialScanTimer = null;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+      return;
+    }
     const next = initialScanQueue.shift();
     if (next)
       watchDirectory(next, true);
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+    }
     if (initialScanQueue.length)
       initialScanTimer = setTimer(processInitialScanQueue, 50);
   };
   const queueInitialChildren = (dir) => {
-    initialScanQueue.push(...readChildDirectories(dir));
+    const remaining = maxWatchedDirectories - watchers.size;
+    if (remaining <= 0) {
+      reportWatchLimit();
+      return;
+    }
+    const children = readChildDirectories(dir);
+    if (children.length > remaining)
+      reportWatchLimit();
+    initialScanQueue.push(...children.slice(0, remaining));
     if (!initialScanTimer)
       initialScanTimer = setTimer(processInitialScanQueue, 5000);
   };
+  const processChangedPath = (changed, fullChangedPath) => {
+    const known = watchers.has(fullChangedPath);
+    if (isDirectory(fullChangedPath)) {
+      if (known) {
+        const signature = directorySignature(fullChangedPath);
+        if (signature && signature !== signatures.get(fullChangedPath)) {
+          closeSubtree(fullChangedPath);
+          watchDirectory(fullChangedPath, initialScanAsync);
+        }
+        scheduleUpdate(changed);
+        return;
+      }
+      watchDirectory(fullChangedPath, initialScanAsync);
+    } else if (known) {
+      closeSubtree(fullChangedPath);
+    }
+    scheduleUpdate(changed);
+  };
+  const processPathInspections = () => {
+    pathInspectionTimer = null;
+    const entries = [...pendingPathInspections];
+    pendingPathInspections.clear();
+    for (const [changed, fullChangedPath] of entries) {
+      processChangedPath(changed, fullChangedPath);
+    }
+  };
+  const queuePathInspection = (changed, fullChangedPath) => {
+    pendingPathInspections.set(changed, fullChangedPath);
+    if (!pathInspectionTimer)
+      pathInspectionTimer = setTimer(processPathInspections, 25);
+  };
   const watchDirectory = (dir, initialScan = false) => {
     if (watchers.has(dir))
       return;
-    const rel = normalizeRelativePath(relative(options.root, dir));
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    const rel = directoryRelativePath(dir);
     if (rel && ignored(rel))
       return;
     try {
@@ -3773,22 +3930,11 @@ function startWorktreeUpdateWatch(options) {
         const fullChangedPath = join7(options.root, changed);
         if (!isInsideRoot(options.root, fullChangedPath))
           return;
-        const known = watchers.has(fullChangedPath);
-        if (isDirectory(fullChangedPath)) {
-          if (known) {
-            const signature2 = directorySignature(fullChangedPath);
-            if (signature2 && signature2 !== signatures.get(fullChangedPath)) {
-              closeSubtree(fullChangedPath);
-              watchDirectory(fullChangedPath);
-            }
-            scheduleUpdate(changed);
-            return;
-          }
-          watchDirectory(fullChangedPath);
-        } else if (known) {
-          closeSubtree(fullChangedPath);
+        if (initialScanAsync) {
+          queuePathInspection(changed, fullChangedPath);
+          return;
         }
-        scheduleUpdate(changed);
+        processChangedPath(changed, fullChangedPath);
       }) || {};
       watchers.set(dir, watcher);
       const signature = directorySignature(dir);
@@ -3814,12 +3960,17 @@ function startWorktreeUpdateWatch(options) {
       queueInitialChildren(dir);
       return;
     }
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
     for (const child of readChildDirectories(dir))
       watchDirectory(child);
   };
   watchDirectory(options.root, true);
   return { started: watchers.size > 0, close: closeAll };
 }
+var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 256;
 var init_worktree_watcher = __esm(() => {
   init_search();
 });
@@ -3851,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);
@@ -5554,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);
@@ -5632,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);
@@ -5676,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;
@@ -5813,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 {};
@@ -5855,7 +6366,7 @@ function parseComposeEnv(serviceBlock, composeDirEnv = {}) {
   }
   return env;
 }
-function parseComposePortMappings(serviceBlock) {
+function parseComposePortMappings(serviceBlock, composeDirEnv = {}) {
   const portsMatch = serviceBlock.match(/^[ \t]+ports:\s*\n((?:[ \t]+- [^\n]+\n?)*)/m);
   if (!portsMatch)
     return [];
@@ -5865,26 +6376,45 @@ function parseComposePortMappings(serviceBlock) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("-"))
       continue;
-    const value = trimmed.slice(1).trim().replace(/^["']|["']$/g, "").split(/\s+#/)[0].split("/")[0].trim();
+    const value = resolveEnvValue(trimmed.slice(1).trim().replace(/^["']|["']$/g, "").split(/\s+#/)[0].split("/")[0].trim(), composeDirEnv);
     if (!value || value.includes("target:"))
       continue;
     const parts = value.split(":");
     const container = parts.pop()?.trim() || "";
     const host = parts.pop()?.trim() || "";
-    if (!/^\d+$/.test(container))
+    const containerPorts = expandPortRange(container);
+    const hostPorts = host ? expandPortRange(host) : [];
+    if (!containerPorts)
       continue;
-    if (host && !/^\d+$/.test(host))
+    if (host && (!hostPorts || hostPorts.length !== containerPorts.length)) {
       continue;
-    mappings.push({ host, container });
+    }
+    for (let i = 0;i < containerPorts.length; i++) {
+      mappings.push({
+        host: hostPorts ? (hostPorts[i] ?? "").toString() : "",
+        container: containerPorts[i].toString()
+      });
+    }
   }
   return mappings;
 }
-function parseComposePorts(serviceBlock) {
-  const first = parseComposePortMappings(serviceBlock).find((m) => m.host);
+function expandPortRange(value) {
+  const match = value.match(/^(\d+)(?:-(\d+))?$/);
+  if (!match)
+    return null;
+  const start = Number(match[1]);
+  const end = Number(match[2] || match[1]);
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 1 || end > 65535 || end < start) {
+    return null;
+  }
+  return Array.from({ length: end - start + 1 }, (_, idx) => start + idx);
+}
+function parseComposePorts(serviceBlock, composeDirEnv = {}) {
+  const first = parseComposePortMappings(serviceBlock, composeDirEnv).find((m) => m.host);
   return first?.host || null;
 }
-function parseComposeHostPortForContainer(serviceBlock, containerPort) {
-  const found = parseComposePortMappings(serviceBlock).find((m) => m.container === containerPort && m.host);
+function parseComposeHostPortForContainer(serviceBlock, containerPort, composeDirEnv = {}) {
+  const found = parseComposePortMappings(serviceBlock, composeDirEnv).find((m) => m.container === containerPort && m.host);
   return found?.host || null;
 }
 function parseComposeContainerPort(serviceBlock) {
@@ -5935,7 +6465,7 @@ function parseComposeContent(content, filepath, composeDir, cwd, composeDirEnv,
       continue;
     const defaultPort = defaultPortFor(kind, image, env);
     const serviceContainerPort = kind === "s3" ? defaultPort : containerPort || defaultPort;
-    const publishedHostPort = parseComposeHostPortForContainer(svcBlock, serviceContainerPort) || parseComposeHostPortForContainer(svcBlock, defaultPort) || parseComposePorts(svcBlock);
+    const publishedHostPort = parseComposeHostPortForContainer(svcBlock, serviceContainerPort, composeDirEnv) || parseComposeHostPortForContainer(svcBlock, defaultPort, composeDirEnv) || parseComposePorts(svcBlock, composeDirEnv);
     const hostPort = kind === "s3" ? publishedHostPort || undefined : publishedHostPort || defaultPort;
     const imageLabel = image ?? `build:${kind}`;
     const id = isRoot ? `docker:${svc.name}` : `docker:${svc.name}@${encodeURIComponent(relDirSlash)}`;
@@ -5968,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;
   }
@@ -6014,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;
@@ -6037,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);
@@ -6672,6 +7202,67 @@ 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;
+  if (signal.aborted)
+    return Promise.reject(abortError(message));
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(abortError(message));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve2(value);
+    }, (err) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(err);
+    });
+  });
+}
+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);
@@ -6681,10 +7272,26 @@ async function resolveDockerExplorerAsync(cwd, dbParam, kind, cache, openFn, omi
   const parsed = parseDockerDbId(dbParam);
   if (!parsed)
     return textError("invalid docker db id", 400);
-  const info = await findDockerServiceByDbIdAsync(cwd, dbParam, kind, omitDirNames, signal);
+  let info;
+  try {
+    info = await findDockerServiceByDbIdAsync(cwd, dbParam, kind, omitDirNames, signal);
+  } catch (err) {
+    if (isAbortLikeError(err, signal)) {
+      return textError(`${kind} lookup aborted`, 503);
+    }
+    throw err;
+  }
   if (!info)
     return textError(`${kind} service not found`, 404);
-  const explorer = await cache.getOrOpenAsync(dbParam, () => openFn(info));
+  let explorer;
+  try {
+    explorer = await waitForCallerAbort(cache.getOrOpenAsync(dbParam, () => openFn(info)), signal, `${kind} open aborted`);
+  } catch (err) {
+    if (isAbortLikeError(err, signal)) {
+      return textError(`${kind} open aborted`, 503);
+    }
+    throw err;
+  }
   return { dbId: dbParam, explorer };
 }
 async function dispatchRoutes(req, url, routes, sideEffectAllowed, wrap = (res) => res, handleRouteError) {
@@ -6722,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;
@@ -7591,6 +8201,31 @@ function s3ObjectName(key) {
 // web-src/server/database/adapters/s3.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash4, createHmac } from "node:crypto";
+function createS3RequestDeadline() {
+  const timeoutMs = s3RequestTimeoutMs;
+  return {
+    expiresAt: Date.now() + timeoutMs,
+    timeoutMs
+  };
+}
+function createS3DockerCurlDeadline() {
+  const timeoutMs = s3DockerCurlTimeoutMs;
+  return {
+    expiresAt: Date.now() + timeoutMs,
+    timeoutMs
+  };
+}
+function createS3TransportDeadline(config) {
+  return config.dockerContainerName ? createS3DockerCurlDeadline() : createS3RequestDeadline();
+}
+function s3TimeoutError(deadline) {
+  return new S3HttpError(503, `S3 request timed out after ${deadline?.timeoutMs ?? s3RequestTimeoutMs}ms`);
+}
+function remainingS3TimeoutMs(deadline) {
+  if (!deadline)
+    return s3RequestTimeoutMs;
+  return Math.max(0, deadline.expiresAt - Date.now());
+}
 function hmac(key, value) {
   return createHmac("sha256", key).update(value, "utf8").digest();
 }
@@ -7725,13 +8360,139 @@ function dockerCurlCommand(opts) {
     input: Buffer.from(curlHeaderConfig(opts.headers), "utf8")
   };
 }
+function guardedS3Transport(signal, operation, deadline) {
+  if (signal?.aborted) {
+    return Promise.reject(new S3HttpError(503, "S3 HTTP transport aborted"));
+  }
+  const timeoutMs = remainingS3TimeoutMs(deadline);
+  if (timeoutMs <= 0) {
+    return Promise.reject(s3TimeoutError(deadline));
+  }
+  const controller = new AbortController;
+  let timedOut = false;
+  let settled = false;
+  let timer;
+  let cleanupParent = () => {};
+  const abort = (err, reject) => {
+    if (settled)
+      return;
+    settled = true;
+    controller.abort(err);
+    reject(err);
+  };
+  const guarded = new Promise((resolve2, reject) => {
+    const onParentAbort = () => abort(new S3HttpError(503, "S3 HTTP transport aborted"), reject);
+    if (signal) {
+      signal.addEventListener("abort", onParentAbort, { once: true });
+      cleanupParent = () => signal.removeEventListener("abort", onParentAbort);
+    }
+    timer = setTimeout(() => {
+      timedOut = true;
+      abort(s3TimeoutError(deadline), reject);
+    }, timeoutMs);
+    operation(controller.signal).then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve2(value);
+    }, (err) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timedOut) {
+        reject(s3TimeoutError(deadline));
+      } else if (signal?.aborted) {
+        reject(new S3HttpError(503, "S3 HTTP transport aborted"));
+      } else {
+        reject(err);
+      }
+    });
+  });
+  return guarded.finally(() => {
+    if (timer)
+      clearTimeout(timer);
+    cleanupParent();
+  });
+}
+async function readStreamChunkWithTimeout(reader, signal, deadline) {
+  return guardedS3Transport(signal, (transportSignal) => {
+    const cancelRead = () => {
+      reader.cancel(transportSignal.reason).catch(() => {});
+    };
+    if (transportSignal.aborted) {
+      cancelRead();
+    } else {
+      transportSignal.addEventListener("abort", cancelRead, { once: true });
+    }
+    return reader.read().finally(() => {
+      transportSignal.removeEventListener("abort", cancelRead);
+    });
+  }, deadline);
+}
+async function readResponseBytesWithTimeout(res, signal, deadline) {
+  if (!res.body)
+    return new Uint8Array;
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await readStreamChunkWithTimeout(reader, signal, deadline);
+      if (done)
+        break;
+      if (!value?.byteLength)
+        continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+  if (chunks.length === 1)
+    return chunks[0];
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function readResponseTextWithTimeout(res, signal, deadline) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(await readResponseBytesWithTimeout(res, signal, deadline));
+}
+function timeoutReadableStream(body, signal) {
+  if (!body)
+    return null;
+  const reader = body.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await readStreamChunkWithTimeout(reader, signal);
+        if (done) {
+          controller.close();
+          return;
+        }
+        if (value)
+          controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
 async function dockerCurlFetch(opts) {
   const { args, input } = dockerCurlCommand(opts);
   if (spawnSyncImplIsTestOverride) {
     const proc2 = spawnSyncImpl3("docker", args, {
       encoding: "buffer",
       input,
-      timeout: 30000,
+      timeout: s3DockerCurlTimeoutMs,
       stdio: ["pipe", "pipe", "pipe"]
     });
     if ((proc2.status ?? 1) !== 0) {
@@ -7747,10 +8508,10 @@ async function dockerCurlFetch(opts) {
     command: "docker",
     args,
     input,
-    timeoutMs: 30000,
+    timeoutMs: s3DockerCurlTimeoutMs,
     signal: opts.signal,
     abortMessage: "S3 HTTP transport aborted",
-    timeoutMessage: "docker exec curl timed out"
+    timeoutMessage: `docker exec curl timed out after ${s3DockerCurlTimeoutMs}ms`
   });
   if (proc.code !== 0) {
     const stderr = new TextDecoder().decode(proc.stderr).replace(/\s+/g, " ").trim();
@@ -7824,73 +8585,77 @@ function parseObjects(xml) {
   };
 }
 function createS3Adapter(config) {
-  async function signedFetch(opts) {
-    const endpoint = new URL(config.endpoint);
-    const { dateStamp, amzDate: requestDate } = amzDate();
-    const path = buildPath(opts.bucket, opts.key);
-    const query = canonicalQuery(opts.query);
-    const url = `${config.endpoint.replace(/\/$/, "")}${path}${query ? `?${query}` : ""}`;
-    const headers = {
-      host: endpoint.host,
-      "x-amz-content-sha256": EMPTY_SHA256,
-      "x-amz-date": requestDate,
-      ...config.sessionToken ? { "x-amz-security-token": config.sessionToken } : {},
-      ...opts.headers || {}
-    };
-    const signedNames = signedHeadersString(headers);
-    const canonicalRequest = [
-      opts.method,
-      path,
-      query,
-      canonicalHeaders(headers),
-      signedNames,
-      EMPTY_SHA256
-    ].join(`
+  async function signedFetch(opts, deadline = createS3TransportDeadline(config)) {
+    return guardedS3Transport(opts.signal, (transportSignal) => {
+      const endpoint = new URL(config.endpoint);
+      const { dateStamp, amzDate: requestDate } = amzDate();
+      const path = buildPath(opts.bucket, opts.key);
+      const query = canonicalQuery(opts.query);
+      const url = `${config.endpoint.replace(/\/$/, "")}${path}${query ? `?${query}` : ""}`;
+      const headers = {
+        host: endpoint.host,
+        "x-amz-content-sha256": EMPTY_SHA256,
+        "x-amz-date": requestDate,
+        ...config.sessionToken ? { "x-amz-security-token": config.sessionToken } : {},
+        ...opts.headers || {}
+      };
+      const signedNames = signedHeadersString(headers);
+      const canonicalRequest = [
+        opts.method,
+        path,
+        query,
+        canonicalHeaders(headers),
+        signedNames,
+        EMPTY_SHA256
+      ].join(`
 `);
-    const scope = `${dateStamp}/${config.region}/s3/aws4_request`;
-    const stringToSign = [
-      "AWS4-HMAC-SHA256",
-      requestDate,
-      scope,
-      sha256(canonicalRequest)
-    ].join(`
+      const scope = `${dateStamp}/${config.region}/s3/aws4_request`;
+      const stringToSign = [
+        "AWS4-HMAC-SHA256",
+        requestDate,
+        scope,
+        sha256(canonicalRequest)
+      ].join(`
 `);
-    const signature = createHmac("sha256", signingKey(config.secretAccessKey, dateStamp, config.region)).update(stringToSign, "utf8").digest("hex");
-    const requestHeaders = new Headers;
-    for (const [key, value] of Object.entries(headers)) {
-      if (key !== "host")
-        requestHeaders.set(key, value);
-    }
-    requestHeaders.set("Authorization", `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${scope}, SignedHeaders=${signedNames}, Signature=${signature}`);
-    if (config.dockerContainerName) {
-      if (opts.method === "GET" && opts.key && !opts.headers?.range && !opts.headers?.Range) {
-        throw new S3HttpError(503, "S3 raw streaming requires a published host port or a ranged request");
+      const signature = createHmac("sha256", signingKey(config.secretAccessKey, dateStamp, config.region)).update(stringToSign, "utf8").digest("hex");
+      const requestHeaders = new Headers;
+      for (const [key, value] of Object.entries(headers)) {
+        if (key !== "host")
+          requestHeaders.set(key, value);
       }
-      return dockerCurlFetch({
-        containerName: config.dockerContainerName,
+      requestHeaders.set("Authorization", `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${scope}, SignedHeaders=${signedNames}, Signature=${signature}`);
+      if (config.dockerContainerName) {
+        if (opts.method === "GET" && opts.key && !opts.headers?.range && !opts.headers?.Range) {
+          throw new S3HttpError(503, "S3 raw streaming requires a published host port or a ranged request");
+        }
+        return dockerCurlFetch({
+          containerName: config.dockerContainerName,
+          method: opts.method,
+          url,
+          headers: requestHeaders,
+          signal: transportSignal
+        });
+      }
+      return fetch(url, {
         method: opts.method,
-        url,
         headers: requestHeaders,
-        signal: opts.signal
+        signal: transportSignal
       });
-    }
-    return fetch(url, {
-      method: opts.method,
-      headers: requestHeaders,
-      signal: opts.signal
-    });
+    }, deadline);
   }
-  async function textOrThrow(res) {
-    const text = await res.text();
+  async function textOrThrow(res, signal, deadline) {
+    const text = await readResponseTextWithTimeout(res, signal, deadline);
     if (!res.ok)
       throw sanitizeS3Error(res.status, text);
     return text;
   }
   async function listBuckets(signal) {
-    const xml = await textOrThrow(await signedFetch({ method: "GET", signal }));
+    const deadline = createS3TransportDeadline(config);
+    const xml = await textOrThrow(await signedFetch({ method: "GET", signal }, deadline), signal, deadline);
     return parseBuckets(xml);
   }
   async function listObjects(opts) {
+    const deadline = createS3TransportDeadline(config);
     const xml = await textOrThrow(await signedFetch({
       method: "GET",
       bucket: opts.bucket,
@@ -7901,32 +8666,34 @@ function createS3Adapter(config) {
         ...opts.continuationToken ? { "continuation-token": opts.continuationToken } : {}
       },
       signal: opts.signal
-    }));
+    }, deadline), opts.signal, deadline);
     return parseObjects(xml);
   }
   async function headObject(opts) {
+    const deadline = createS3TransportDeadline(config);
     const res = await signedFetch({
       method: "HEAD",
       bucket: opts.bucket,
       key: opts.key,
       signal: opts.signal
-    });
+    }, deadline);
     if (!res.ok)
-      throw sanitizeS3Error(res.status, await res.text());
+      throw sanitizeS3Error(res.status, await readResponseTextWithTimeout(res, opts.signal, deadline));
     return headFromObjectResponse(opts.bucket, opts.key, res);
   }
   async function getObjectText(opts) {
     const maxBytes = Math.min(1024 * 1024, Math.max(1, opts.maxBytes ?? 512 * 1024));
+    const deadline = createS3TransportDeadline(config);
     const res = await signedFetch({
       method: "GET",
       bucket: opts.bucket,
       key: opts.key,
       headers: { range: `bytes=0-${maxBytes - 1}` },
       signal: opts.signal
-    });
+    }, deadline);
     if (!res.ok && res.status !== 206)
-      throw sanitizeS3Error(res.status, await res.text());
-    const bytes = new Uint8Array(await res.arrayBuffer());
+      throw sanitizeS3Error(res.status, await readResponseTextWithTimeout(res, opts.signal, deadline));
+    const bytes = await readResponseBytesWithTimeout(res, opts.signal, deadline);
     const head = headFromObjectResponse(opts.bucket, opts.key, res);
     const fullSize = head.sizeBytes;
     return {
@@ -7936,17 +8703,18 @@ function createS3Adapter(config) {
     };
   }
   async function getObjectResponse(opts) {
+    const deadline = createS3TransportDeadline(config);
     const res = await signedFetch({
       method: opts.method,
       bucket: opts.bucket,
       key: opts.key,
       headers: opts.range ? { range: opts.range } : undefined,
       signal: opts.signal
-    });
+    }, deadline);
     if (!res.ok && res.status !== 206) {
-      throw sanitizeS3Error(res.status, await res.text());
+      throw sanitizeS3Error(res.status, await readResponseTextWithTimeout(res, opts.signal, deadline));
     }
-    return new Response(opts.method === "HEAD" ? null : res.body, {
+    return new Response(opts.method === "HEAD" ? null : timeoutReadableStream(res.body, opts.signal), {
       status: res.status,
       headers: rawObjectHeaders(opts.key, res)
     });
@@ -7966,6 +8734,9 @@ async function s3ConfigFromDockerInfoAsync(info, signal) {
   const image = info.image?.toLowerCase() || "";
   const minioDefault = image.includes("minio");
   const env = info.env;
+  if (!info.hostPort && minioDefault) {
+    throw new S3HttpError(503, 'MinIO S3 browsing requires a published host port. Add a compose port mapping like "9000:9000" for the MinIO API.');
+  }
   const dockerContainerName = info.hostPort ? undefined : await resolveRunningComposeContainerNameOrThrowAsync(info.serviceName, info.composeDir, signal);
   return {
     endpoint: info.hostPort ? `http://localhost:${info.hostPort}` : `http://127.0.0.1:${info.containerPort}`,
@@ -7982,7 +8753,7 @@ async function openS3ExplorerAsync(info, signal) {
 function isS3HttpError(err) {
   return err instanceof S3HttpError;
 }
-var spawnSyncImpl3, spawnSyncImplIsTestOverride = false, S3HttpError, EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var spawnSyncImpl3, spawnSyncImplIsTestOverride = false, S3HttpError, EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", DEFAULT_S3_REQUEST_TIMEOUT_MS = 5000, DEFAULT_S3_DOCKER_CURL_TIMEOUT_MS = 30000, s3RequestTimeoutMs, s3DockerCurlTimeoutMs;
 var init_s3 = __esm(() => {
   init_raw_file_headers();
   init_docker_utils();
@@ -7995,6 +8766,8 @@ var init_s3 = __esm(() => {
       this.status = status;
     }
   };
+  s3RequestTimeoutMs = DEFAULT_S3_REQUEST_TIMEOUT_MS;
+  s3DockerCurlTimeoutMs = DEFAULT_S3_DOCKER_CURL_TIMEOUT_MS;
 });
 
 // web-src/server/database/handle-s3.ts
@@ -8356,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: [] };
@@ -8381,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);
@@ -8479,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;
@@ -8504,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) {
@@ -8512,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;
@@ -8525,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");
@@ -8772,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,
@@ -8869,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 };
@@ -8943,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();
@@ -8964,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;
@@ -8987,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;
@@ -8996,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",
@@ -9067,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
@@ -9095,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)) {
@@ -10054,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)
@@ -10216,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();
@@ -10274,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++) {
@@ -10433,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" }
   });
 }
@@ -10667,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;
@@ -10678,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;
@@ -10732,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;
@@ -10751,7 +11610,7 @@ function safeWorktreePath(path) {
   return realFull;
 }
 function worktreePath(path) {
-  return join12(cwd, path);
+  return join13(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -10767,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) {
@@ -10834,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;
       }
@@ -10889,6 +11748,13 @@ function handleSettings() {
     }
   });
 }
+function worktreeWatchDirectoryLimitFromEnv() {
+  const raw = process.env.CODE_VIEWER_WORKTREE_WATCH_LIMIT;
+  if (!raw)
+    return DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT;
+}
 function handleFiles2(url) {
   const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
   if (target !== "worktree" && !verifyTreeRef(target, cwd))
@@ -10948,7 +11814,7 @@ function grepWorktreeFallback(query, max, paths, omitDirNames, excludeNames) {
       continue;
     let data;
     try {
-      data = readFileSync5(full);
+      data = readFileSync4(full);
     } catch {
       continue;
     }
@@ -11484,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 });
   }
@@ -11496,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);
       }
@@ -11606,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) };
@@ -11642,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) };
@@ -11800,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);
@@ -11850,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))
@@ -11874,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 });
   }
@@ -11893,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,
@@ -11908,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,
@@ -11922,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,
@@ -11941,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 });
@@ -11953,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 });
   }
@@ -11964,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 });
   }
@@ -12044,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;
@@ -12149,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")
@@ -12237,6 +13109,7 @@ data: ok
     excludeNames: scopeExcludeNames,
     watch,
     initialScanMode: "async",
+    maxWatchedDirectories: worktreeWatchDirectoryLimitFromEnv(),
     onUpdate: triggerUpdate,
     onError: (error) => {
       const message = error instanceof Error ? error.message : String(error);