@youtyan/code-viewer 0.2.7 → 0.2.9

package/dist/code-viewer.js

@@ -3726,286 +3726,10 @@ var init_search = __esm(() => {
   DEFAULT_EXCLUDE_NAMES = [".DS_Store"];
 });
 
-// web-src/server/worktree-watcher.ts
-import {
-  lstatSync as lstatSync3,
-  readdirSync as nodeReaddirSync,
-  watch as nodeWatch
-} from "node:fs";
-import { join as join7, relative } from "node:path";
-function normalizeRelativePath(path) {
-  return path.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-function isInsideRoot(root, path) {
-  const rel = relative(root, path).replace(/\\/g, "/");
-  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
-}
-function startWorktreeUpdateWatch(options) {
-  const watch = options.watch || nodeWatch;
-  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
-  const isDirectory = options.isDirectory || ((path) => {
-    try {
-      return lstatSync3(path).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  const directorySignature = options.directorySignature || ((path) => {
-    try {
-      const stats = lstatSync3(path);
-      if (!stats.isDirectory())
-        return null;
-      return `${stats.dev}:${stats.ino}`;
-    } catch {
-      return null;
-    }
-  });
-  const setTimer = options.setTimeoutFn || setTimeout;
-  const clearTimer = options.clearTimeoutFn || clearTimeout;
-  const debounceMs = options.debounceMs ?? 250;
-  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
-  const watchers = new Map;
-  const signatures = new Map;
-  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
-  const initialScanQueue = [];
-  let initialScanTimer = null;
-  const pendingPathInspections = new Map;
-  let pathInspectionTimer = null;
-  let timer = null;
-  const pendingChangedPaths = new Set;
-  let watchLimitReported = false;
-  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
-  const directoryRelativePath = (dir) => normalizeRelativePath(relative(options.root, dir));
-  const ignoredDirectory = (dir) => {
-    const rel = directoryRelativePath(dir);
-    return Boolean(rel && ignored(rel));
-  };
-  const scheduleUpdate = (changedPath) => {
-    if (changedPath)
-      pendingChangedPaths.add(changedPath);
-    if (timer)
-      clearTimer(timer);
-    timer = setTimer(() => {
-      timer = null;
-      const paths = pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
-      pendingChangedPaths.clear();
-      options.onUpdate(paths);
-    }, debounceMs);
-  };
-  const reportWatchLimit = () => {
-    if (watchLimitReported)
-      return;
-    watchLimitReported = true;
-    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
-  };
-  const closeSubtree = (dir) => {
-    for (const [watchedDir, watcher] of [...watchers]) {
-      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
-        continue;
-      try {
-        watcher.close?.();
-      } catch {}
-      watchers.delete(watchedDir);
-      signatures.delete(watchedDir);
-    }
-  };
-  const closeAll = () => {
-    if (initialScanTimer) {
-      clearTimer(initialScanTimer);
-      initialScanTimer = null;
-    }
-    if (pathInspectionTimer) {
-      clearTimer(pathInspectionTimer);
-      pathInspectionTimer = null;
-    }
-    initialScanQueue.length = 0;
-    pendingPathInspections.clear();
-    for (const watcher of [...watchers.values()]) {
-      try {
-        watcher.close?.();
-      } catch {}
-    }
-    watchers.clear();
-    signatures.clear();
-  };
-  const readChildDirectories = (dir) => {
-    let entries;
-    try {
-      entries = readDirs(dir);
-    } catch (error) {
-      options.onError?.(error);
-      return [];
-    }
-    const children = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const child = join7(dir, entry.name);
-      if (ignoredDirectory(child))
-        continue;
-      children.push(child);
-    }
-    return children;
-  };
-  const processInitialScanQueue = () => {
-    initialScanTimer = null;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-      return;
-    }
-    const next = initialScanQueue.shift();
-    if (next)
-      watchDirectory(next, true);
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      initialScanQueue.length = 0;
-    }
-    if (initialScanQueue.length)
-      initialScanTimer = setTimer(processInitialScanQueue, 50);
-  };
-  const queueInitialChildren = (dir) => {
-    const remaining = maxWatchedDirectories - watchers.size;
-    if (remaining <= 0) {
-      reportWatchLimit();
-      return;
-    }
-    const children = readChildDirectories(dir);
-    if (children.length > remaining)
-      reportWatchLimit();
-    initialScanQueue.push(...children.slice(0, remaining));
-    if (!initialScanTimer)
-      initialScanTimer = setTimer(processInitialScanQueue, 5000);
-  };
-  const processChangedPath = (changed, fullChangedPath) => {
-    const known = watchers.has(fullChangedPath);
-    if (isDirectory(fullChangedPath)) {
-      if (known) {
-        const signature = directorySignature(fullChangedPath);
-        if (signature && signature !== signatures.get(fullChangedPath)) {
-          closeSubtree(fullChangedPath);
-          watchDirectory(fullChangedPath, initialScanAsync);
-        }
-        scheduleUpdate(changed);
-        return;
-      }
-      watchDirectory(fullChangedPath, initialScanAsync);
-    } else if (known) {
-      closeSubtree(fullChangedPath);
-    }
-    scheduleUpdate(changed);
-  };
-  const processPathInspections = () => {
-    pathInspectionTimer = null;
-    const entries = [...pendingPathInspections];
-    pendingPathInspections.clear();
-    for (const [changed, fullChangedPath] of entries) {
-      processChangedPath(changed, fullChangedPath);
-    }
-  };
-  const queuePathInspection = (changed, fullChangedPath) => {
-    pendingPathInspections.set(changed, fullChangedPath);
-    if (!pathInspectionTimer)
-      pathInspectionTimer = setTimer(processPathInspections, 25);
-  };
-  const watchDirectory = (dir, initialScan = false) => {
-    if (watchers.has(dir))
-      return;
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
-    }
-    const rel = directoryRelativePath(dir);
-    if (rel && ignored(rel))
-      return;
-    try {
-      const watcher = watch(dir, { persistent: false }, (_event, filename) => {
-        if (!filename) {
-          scheduleUpdate();
-          return;
-        }
-        const changed = normalizeRelativePath(join7(rel, filename.toString()));
-        if (ignored(changed))
-          return;
-        const fullChangedPath = join7(options.root, changed);
-        if (!isInsideRoot(options.root, fullChangedPath))
-          return;
-        if (initialScanAsync) {
-          queuePathInspection(changed, fullChangedPath);
-          return;
-        }
-        processChangedPath(changed, fullChangedPath);
-      }) || {};
-      watchers.set(dir, watcher);
-      const signature = directorySignature(dir);
-      if (signature)
-        signatures.set(dir, signature);
-      watcher.on?.("error", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
-      });
-      watcher.on?.("close", () => {
-        if (watchers.get(dir) === watcher) {
-          watchers.delete(dir);
-          signatures.delete(dir);
-        }
-      });
-    } catch (error) {
-      options.onError?.(error);
-      return;
-    }
-    if (initialScanAsync && initialScan) {
-      queueInitialChildren(dir);
-      return;
-    }
-    if (watchers.size >= maxWatchedDirectories) {
-      reportWatchLimit();
-      return;
-    }
-    for (const child of readChildDirectories(dir))
-      watchDirectory(child);
-  };
-  watchDirectory(options.root, true);
-  return { started: watchers.size > 0, close: closeAll };
-}
-var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 256;
-var init_worktree_watcher = __esm(() => {
-  init_search();
-});
-
-// web-src/core/control-chars.ts
-function hasControlCharacter(value) {
-  for (const ch of value) {
-    const code = ch.charCodeAt(0);
-    if (code < 32 || code === 127)
-      return true;
-  }
-  return false;
-}
-
-// web-src/core/id.ts
-function bytesToHex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function makeId(prefix) {
-  const cryptoApi = globalThis.crypto;
-  if (typeof cryptoApi?.randomUUID === "function") {
-    return `${prefix}-${cryptoApi.randomUUID().replace(/-/g, "").slice(0, 16)}`;
-  }
-  if (typeof cryptoApi?.getRandomValues === "function") {
-    const bytes = new Uint8Array(8);
-    cryptoApi.getRandomValues(bytes);
-    return `${prefix}-${bytesToHex(bytes)}`;
-  }
-  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";
+import { join as join7 } from "node:path";
 function codeViewerPath(root, fileName) {
-  return join8(root, CODE_VIEWER_DIR2, fileName);
+  return join7(root, CODE_VIEWER_DIR2, fileName);
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -4065,7 +3789,12 @@ function emptySettings() {
   return { version: 1 };
 }
 function emptyViewState() {
-  return { version: 1, collapsedDirs: [], viewedFiles: [] };
+  return {
+    version: 1,
+    collapsedDirs: [],
+    lazyExpandedDirs: [],
+    viewedFiles: []
+  };
 }
 function emptyDbUiState() {
   return { version: 1, columnWidths: {} };
@@ -4138,6 +3867,9 @@ function sanitizeSettings(raw) {
   });
   if (scopeExcludeNames)
     out.scopeExcludeNames = scopeExcludeNames;
+  const uploadEnabled = optionalBoolean(raw.uploadEnabled);
+  if (uploadEnabled !== undefined)
+    out.uploadEnabled = uploadEnabled;
   if (isRecord(raw.range)) {
     const from = optionalString(raw.range.from, MAX_REF_LEN);
     const to = optionalString(raw.range.to, MAX_REF_LEN);
@@ -4171,6 +3903,12 @@ function sanitizeViewState(raw) {
       keepLast: true,
       sort: false
     }) ?? [],
+    lazyExpandedDirs: normalizeStringList(raw.lazyExpandedDirs, {
+      maxItems: MAX_VIEW_ITEMS,
+      maxLen: MAX_KEY_LEN,
+      keepLast: true,
+      sort: false
+    }) ?? [],
     viewedFiles: normalizeStringList(raw.viewedFiles, {
       maxItems: MAX_VIEW_ITEMS,
       maxLen: MAX_KEY_LEN,
@@ -4184,6 +3922,7 @@ function mergeViewState(current, patch) {
     return current;
   const base = sanitizeViewState({ ...current, version: 1 });
   const collapsedDirs = new Set(base.collapsedDirs);
+  const lazyExpandedDirs = new Set(base.lazyExpandedDirs);
   const viewedFiles = new Set(base.viewedFiles);
   const addedCollapsedDirs = normalizeStringList(patch.addedCollapsedDirs, {
     maxItems: MAX_VIEW_ITEMS,
@@ -4191,8 +3930,10 @@ function mergeViewState(current, patch) {
     keepLast: true,
     sort: false
   });
-  for (const path of addedCollapsedDirs || [])
+  for (const path of addedCollapsedDirs || []) {
     collapsedDirs.add(path);
+    lazyExpandedDirs.delete(path);
+  }
   const removedCollapsedDirs = normalizeStringList(patch.removedCollapsedDirs, {
     maxItems: MAX_VIEW_ITEMS,
     maxLen: MAX_KEY_LEN,
@@ -4200,167 +3941,506 @@ function mergeViewState(current, patch) {
   });
   for (const path of removedCollapsedDirs || [])
     collapsedDirs.delete(path);
+  const addedLazyExpandedDirs = normalizeStringList(patch.addedLazyExpandedDirs, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    keepLast: true,
+    sort: false
+  });
+  for (const path of addedLazyExpandedDirs || []) {
+    if (!collapsedDirs.has(path))
+      lazyExpandedDirs.add(path);
+  }
+  const removedLazyExpandedDirs = normalizeStringList(patch.removedLazyExpandedDirs, {
+    maxItems: MAX_VIEW_ITEMS,
+    maxLen: MAX_KEY_LEN,
+    sort: false
+  });
+  for (const path of removedLazyExpandedDirs || [])
+    lazyExpandedDirs.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 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],
+    lazyExpandedDirs: [...lazyExpandedDirs],
+    viewedFiles: [...viewedFiles]
+  });
+}
+function safeObjectKey(value) {
+  if (!value || value.length > MAX_KEY_LEN || value.includes("\x00"))
+    return null;
+  return value;
+}
+function sanitizeDbUiPrefs(raw) {
+  if (!isRecord(raw))
+    return;
+  const out = {};
+  for (const key of DB_UI_BOOL_PREF_KEYS) {
+    const v = raw[key];
+    if (v === true || v === false)
+      out[key] = v;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function sanitizeDbUiState(raw) {
+  if (!isRecord(raw))
+    return emptyDbUiState();
+  const prefs = sanitizeDbUiPrefs(raw.prefs);
+  if (!isRecord(raw.columnWidths)) {
+    return prefs ? { ...emptyDbUiState(), prefs } : 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++;
+  }
+  const out = { version: 1, columnWidths };
+  if (prefs)
+    out.prefs = prefs;
+  return out;
+}
+function mergeDbUiPrefs(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  const next = { ...current ?? {} };
+  for (const key of DB_UI_BOOL_PREF_KEYS) {
+    const v = patch[key];
+    if (v === null)
+      delete next[key];
+    else if (v === true || v === false)
+      next[key] = v;
+  }
+  return Object.keys(next).length > 0 ? next : undefined;
+}
+function mergeDbUiState(current, patch) {
+  if (!isRecord(patch))
+    return current;
+  const mergedPrefs = "prefs" in patch ? mergeDbUiPrefs(current.prefs, patch.prefs) : current.prefs;
+  if (!isRecord(patch.columnWidths)) {
+    const merged = { ...current, version: 1 };
+    if (mergedPrefs)
+      merged.prefs = mergedPrefs;
+    else
+      delete merged.prefs;
+    return sanitizeDbUiState(merged);
+  }
+  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,
+    prefs: mergedPrefs,
+    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, DB_UI_BOOL_PREF_KEYS, settingsStore, viewStateStore, dbUiStore;
+var init_state_store = __esm(() => {
+  init_json_store();
+  DB_UI_BOOL_PREF_KEYS = ["s3TooltipEnabled", "inferFkRails"];
+  settingsStore = createJsonFileStore({
+    filePath: (root) => codeViewerPath(root, SETTINGS_FILE_NAME),
+    empty: emptySettings,
+    sanitize: sanitizeSettings,
+    maxBytes: MAX_SETTINGS_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "settings state too large"
   });
-  for (const path of removedViewedFiles || [])
-    viewedFiles.delete(path);
-  return sanitizeViewState({
-    version: 1,
-    collapsedDirs: [...collapsedDirs],
-    viewedFiles: [...viewedFiles]
+  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/worktree-watcher.ts
+import {
+  lstatSync as lstatSync3,
+  readdirSync as nodeReaddirSync,
+  watch as nodeWatch
+} from "node:fs";
+import { join as join8, relative } from "node:path";
+function normalizeRelativePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
 }
-function safeObjectKey(value) {
-  if (!value || value.length > MAX_KEY_LEN || value.includes("\x00"))
-    return null;
-  return value;
+function isInsideRoot(root, path) {
+  const rel = relative(root, path).replace(/\\/g, "/");
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
 }
-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))
+function startWorktreeUpdateWatch(options) {
+  const watch = options.watch || nodeWatch;
+  const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
+  const isDirectory = options.isDirectory || ((path) => {
+    try {
+      return lstatSync3(path).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const directorySignature = options.directorySignature || ((path) => {
+    try {
+      const stats = lstatSync3(path);
+      if (!stats.isDirectory())
+        return null;
+      return `${stats.dev}:${stats.ino}`;
+    } catch {
+      return null;
+    }
+  });
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 250;
+  const maxWatchedDirectories = Math.max(1, Math.floor(options.maxWatchedDirectories ?? DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT));
+  const watchers = new Map;
+  const signatures = new Map;
+  const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
+  const initialScanQueue = [];
+  let initialScanTimer = null;
+  const pendingPathInspections = new Map;
+  let pathInspectionTimer = null;
+  let timer = null;
+  const pendingChangedPaths = new Set;
+  let watchLimitReported = false;
+  const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative(options.root, dir));
+  const ignoredDirectory = (dir) => {
+    const rel = directoryRelativePath(dir);
+    return Boolean(rel && ignored(rel));
+  };
+  const scheduleUpdate = (changedPath) => {
+    if (changedPath)
+      pendingChangedPaths.add(changedPath);
+    if (timer)
+      clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      const paths = pendingChangedPaths.size ? [...pendingChangedPaths] : undefined;
+      pendingChangedPaths.clear();
+      options.onUpdate(paths);
+    }, debounceMs);
+  };
+  const reportWatchLimit = () => {
+    if (watchLimitReported)
+      return;
+    watchLimitReported = true;
+    options.onWatchLimit?.(maxWatchedDirectories);
+    options.onError?.(new Error(`worktree watcher cap reached (${maxWatchedDirectories}); subsequent changes may be missed`));
+  };
+  const closeSubtree = (dir) => {
+    for (const [watchedDir, watcher] of [...watchers]) {
+      if (watchedDir !== dir && !watchedDir.startsWith(`${dir}/`))
         continue;
-      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)
+      try {
+        watcher.close?.();
+      } catch {}
+      watchers.delete(watchedDir);
+      signatures.delete(watchedDir);
+    }
+  };
+  const closeAll = () => {
+    if (initialScanTimer) {
+      clearTimer(initialScanTimer);
+      initialScanTimer = null;
+    }
+    if (pathInspectionTimer) {
+      clearTimer(pathInspectionTimer);
+      pathInspectionTimer = null;
+    }
+    initialScanQueue.length = 0;
+    pendingPathInspections.clear();
+    for (const watcher of [...watchers.values()]) {
+      try {
+        watcher.close?.();
+      } catch {}
+    }
+    watchers.clear();
+    signatures.clear();
+  };
+  const readChildDirectories = (dir) => {
+    let entries;
+    try {
+      entries = readDirs(dir);
+    } catch (error) {
+      options.onError?.(error);
+      return [];
+    }
+    const children = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory())
         continue;
-      tables[table] = columns;
-      tableCount++;
+      const child = join8(dir, entry.name);
+      if (ignoredDirectory(child))
+        continue;
+      children.push(child);
+    }
+    return children;
+  };
+  const processInitialScanQueue = () => {
+    initialScanTimer = null;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+      return;
+    }
+    const next = initialScanQueue.shift();
+    if (next)
+      watchDirectory(next, true);
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      initialScanQueue.length = 0;
+    }
+    if (initialScanQueue.length)
+      initialScanTimer = setTimer(processInitialScanQueue, 50);
+  };
+  const queueInitialChildren = (dir) => {
+    const remaining = maxWatchedDirectories - watchers.size;
+    if (remaining <= 0) {
+      reportWatchLimit();
+      return;
+    }
+    const children = readChildDirectories(dir);
+    if (children.length > remaining)
+      reportWatchLimit();
+    initialScanQueue.push(...children.slice(0, remaining));
+    if (!initialScanTimer)
+      initialScanTimer = setTimer(processInitialScanQueue, 5000);
+  };
+  const processChangedPath = (changed, fullChangedPath) => {
+    const known = watchers.has(fullChangedPath);
+    if (isDirectory(fullChangedPath)) {
+      if (known) {
+        const signature = directorySignature(fullChangedPath);
+        if (signature && signature !== signatures.get(fullChangedPath)) {
+          closeSubtree(fullChangedPath);
+          watchDirectory(fullChangedPath, initialScanAsync);
+        }
+        scheduleUpdate(changed);
+        return;
+      }
+      watchDirectory(fullChangedPath, initialScanAsync);
+    } else if (known) {
+      closeSubtree(fullChangedPath);
+    }
+    scheduleUpdate(changed);
+  };
+  const processPathInspections = () => {
+    pathInspectionTimer = null;
+    const entries = [...pendingPathInspections];
+    pendingPathInspections.clear();
+    for (const [changed, fullChangedPath] of entries) {
+      processChangedPath(changed, fullChangedPath);
     }
-    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;
+  const queuePathInspection = (changed, fullChangedPath) => {
+    pendingPathInspections.set(changed, fullChangedPath);
+    if (!pathInspectionTimer)
+      pathInspectionTimer = setTimer(processPathInspections, 25);
+  };
+  const watchDirectory = (dir, initialScan = false) => {
+    if (watchers.has(dir))
+      return;
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
     }
-    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;
+    const rel = directoryRelativePath(dir);
+    if (rel && ignored(rel))
+      return;
+    try {
+      const watcher = watch(dir, { persistent: false }, (_event, filename) => {
+        if (!filename) {
+          scheduleUpdate();
+          return;
+        }
+        const changed = normalizeRelativePath(join8(rel, filename.toString()));
+        if (ignored(changed))
+          return;
+        const fullChangedPath = join8(options.root, changed);
+        if (!isInsideRoot(options.root, fullChangedPath))
+          return;
+        if (initialScanAsync) {
+          queuePathInspection(changed, fullChangedPath);
+          return;
+        }
+        processChangedPath(changed, fullChangedPath);
+      }) || {};
+      watchers.set(dir, watcher);
+      const signature = directorySignature(dir);
+      if (signature)
+        signatures.set(dir, signature);
+      watcher.on?.("error", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+      watcher.on?.("close", () => {
+        if (watchers.get(dir) === watcher) {
+          watchers.delete(dir);
+          signatures.delete(dir);
+        }
+      });
+    } catch (error) {
+      options.onError?.(error);
+      return;
     }
-    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);
+    if (initialScanAsync && initialScan) {
+      queueInitialChildren(dir);
+      return;
+    }
+    if (watchers.size >= maxWatchedDirectories) {
+      reportWatchLimit();
+      return;
+    }
+    for (const child of readChildDirectories(dir))
+      watchDirectory(child);
+  };
+  watchDirectory(options.root, true);
+  return { started: watchers.size > 0, close: closeAll };
 }
-async function patchViewState(root, patch) {
-  return viewStateStore.update(root, (state) => {
-    const next = mergeViewState(state, patch);
-    return { state: next, result: next };
-  });
+var DEFAULT_WORKTREE_WATCH_DIRECTORY_LIMIT = 256;
+var init_worktree_watcher = __esm(() => {
+  init_search();
+});
+
+// web-src/core/control-chars.ts
+function hasControlCharacter(value) {
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (code < 32 || code === 127)
+      return true;
+  }
+  return false;
 }
-async function loadDbUiState(root) {
-  return dbUiStore.load(root);
+
+// web-src/core/id.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function patchDbUiState(root, patch) {
-  return dbUiStore.update(root, (state) => {
-    const next = mergeDbUiState(state, patch);
-    return { state: next, result: next };
-  });
+function makeId(prefix) {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === "function") {
+    return `${prefix}-${cryptoApi.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  }
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    const bytes = new Uint8Array(8);
+    cryptoApi.getRandomValues(bytes);
+    return `${prefix}-${bytesToHex(bytes)}`;
+  }
+  return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
 }
-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") {
@@ -4528,25 +4608,23 @@ function sanitizeIdentifier(name, kind = "sqlite") {
     return `\`${name.replace(/`/g, "``")}\``;
   return `"${name.replace(/"/g, '""')}"`;
 }
-function escapeSqlString(value) {
-  return `'${value.replace(/'/g, "''")}'`;
+function escapeSqlString(value, kind) {
+  const escaped = kind === "mysql" ? value.replace(/\\/g, "\\\\").replace(/'/g, "''") : value.replace(/'/g, "''");
+  return `'${escaped}'`;
 }
-function buildFilterWhere(grouped, kind) {
+function buildFilterWhere(grouped, kind, exact) {
   const whereParts = [];
   const params = [];
   const useParams = kind === "sqlite";
+  const castOf = (column) => kind === "mysql" ? `CAST(${sanitizeIdentifier(column, kind)} AS CHAR)` : `CAST(${sanitizeIdentifier(column, kind)} AS TEXT)`;
   for (const [value, cols] of grouped) {
-    const likeVal = useParams ? "?" : escapeSqlString(`%${value}%`);
+    const likeVal = useParams ? "?" : escapeSqlString(`%${value}%`, kind);
     if (cols.length === 1) {
-      const cast = kind === "mysql" ? `CAST(${sanitizeIdentifier(cols[0], kind)} AS CHAR)` : `CAST(${sanitizeIdentifier(cols[0], kind)} AS TEXT)`;
-      whereParts.push(`${cast} LIKE ${likeVal}`);
+      whereParts.push(`${castOf(cols[0])} LIKE ${likeVal}`);
       if (useParams)
         params.push(`%${value}%`);
     } else {
-      const orParts = cols.map((column) => {
-        const cast = kind === "mysql" ? `CAST(${sanitizeIdentifier(column, kind)} AS CHAR)` : `CAST(${sanitizeIdentifier(column, kind)} AS TEXT)`;
-        return `${cast} LIKE ${likeVal}`;
-      });
+      const orParts = cols.map((column) => `${castOf(column)} LIKE ${likeVal}`);
       whereParts.push(`(${orParts.join(" OR ")})`);
       if (useParams) {
         for (let i = 0;i < cols.length; i++)
@@ -4554,6 +4632,12 @@ function buildFilterWhere(grouped, kind) {
       }
     }
   }
+  for (const cond of exact ?? []) {
+    const rhs = useParams ? "?" : escapeSqlString(cond.value, kind);
+    whereParts.push(`${castOf(cond.column)} = ${rhs}`);
+    if (useParams)
+      params.push(cond.value);
+  }
   return { where: whereParts.join(" AND "), params, useParams };
 }
 function filterGroupedColumns(grouped, columnNames) {
@@ -4566,6 +4650,12 @@ function filterGroupedColumns(grouped, columnNames) {
   }
   return filtered;
 }
+function filterExactColumns(exact, columnNames) {
+  if (!exact || exact.length === 0)
+    return [];
+  const validColumns = new Set(columnNames);
+  return exact.filter((cond) => validColumns.has(cond.column));
+}
 function filterOrderByColumns(orderBy, columnNames) {
   if (!orderBy)
     return;
@@ -4869,6 +4959,8 @@ function buildExecArgs(config, sql) {
       "-A",
       "-F",
       "\t",
+      "-R",
+      PG_RECORD_SEPARATOR,
       "-v",
       "ON_ERROR_STOP=1",
       "-c",
@@ -5044,11 +5136,14 @@ function splitTsvLine(line, decodeFields) {
   const fields = line.split("\t");
   return decodeFields ? fields.map(decodeMysqlBatchField) : fields;
 }
-function parseTsvOutput(stdout, hasHeader) {
-  const text = stripFinalLineBreak(stdout);
+function stripFinalRecordSeparator(text, recordSeparator) {
+  return text.endsWith(recordSeparator) ? text.slice(0, -recordSeparator.length) : text;
+}
+function parseTsvOutput(stdout, hasHeader, recordSeparator) {
+  const text = recordSeparator ? stripFinalRecordSeparator(stdout, recordSeparator) : stripFinalLineBreak(stdout);
   if (text.length === 0)
     return { columns: [], rows: [] };
-  const lines = text.split(/\r?\n/);
+  const lines = recordSeparator ? text.split(recordSeparator) : text.split(/\r?\n/);
   if (lines.length === 0)
     return { columns: [], rows: [] };
   if (hasHeader) {
@@ -5115,13 +5210,17 @@ function createTableMetaCache(now = () => Date.now()) {
     }
   };
 }
+function observeBackgroundRejection(promise) {
+  promise.catch(() => {});
+  return promise;
+}
 function createDockerAdapter(config) {
   async function execAsync(sql, signal) {
     const result = await execInContainerAsync(config, sql, 1e4, signal);
     if (result.code !== 0) {
       throw new Error(result.stderr.trim() || "query failed");
     }
-    return parseTsvOutput(result.stdout, config.kind === "mysql");
+    return parseTsvOutput(result.stdout, config.kind === "mysql", config.kind === "postgresql" ? PG_RECORD_SEPARATOR : undefined);
   }
   function toDbValue(val) {
     if (val === "NULL" || val === "\\N")
@@ -5214,25 +5313,18 @@ function createDockerAdapter(config) {
     },
     async getIndexesAsync(signal) {
       let sql;
+      const INDEX_COL_SEP = "\x1F";
       if (config.kind === "postgresql") {
-        sql = `SELECT indexname, tablename FROM pg_indexes WHERE schemaname = ${postgresSchemaLiteral()} AND indexname NOT LIKE 'pg_%' ORDER BY indexname`;
+        sql = `SELECT i.relname, t.relname, CASE WHEN ix.indisunique THEN '1' ELSE '0' END, COALESCE(string_agg(a.attname, E'\\x1f' ORDER BY k.ord), '') FROM pg_index ix JOIN pg_class i ON i.oid = ix.indexrelid JOIN pg_class t ON t.oid = ix.indrelid JOIN pg_namespace n ON n.oid = t.relnamespace LEFT JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum WHERE n.nspname = ${postgresSchemaLiteral()} AND i.relname NOT LIKE 'pg_%' GROUP BY i.relname, t.relname, ix.indisunique ORDER BY t.relname, i.relname`;
       } else {
-        sql = `SELECT DISTINCT index_name, table_name, non_unique FROM information_schema.statistics WHERE table_schema = DATABASE() ORDER BY index_name`;
+        sql = `SELECT index_name, table_name, IF(MAX(non_unique) = 0, '1', '0'), GROUP_CONCAT(column_name ORDER BY seq_in_index SEPARATOR '\x1F') FROM information_schema.statistics WHERE table_schema = DATABASE() GROUP BY index_name, table_name ORDER BY table_name, index_name`;
       }
       const result = await execAsync(sql, signal);
-      if (config.kind === "postgresql") {
-        return result.rows.map((row) => ({
-          name: row[0],
-          table: row[1],
-          columns: [],
-          unique: false
-        }));
-      }
       return result.rows.map((row) => ({
         name: row[0],
         table: row[1],
-        columns: [],
-        unique: row[2] === "0"
+        unique: row[2] === "1",
+        columns: row[3] ? row[3].split(INDEX_COL_SEP).filter((s) => s.length > 0) : []
       }));
     },
     async getForeignKeysAsync(signal) {
@@ -5386,7 +5478,7 @@ function createDockerAdapter(config) {
       const id = tableIdentifier(table);
       const countSql = `SELECT COUNT(*) AS cnt FROM ${id}`;
       const columnsPromise = tableMetaCache.getColumns(table, () => fetchColumnsAsyncUncached(table, signal));
-      const totalRowsPromise = tableMetaCache.getRowCount(table, async () => rowCountFromResult(await execAsync(countSql, signal)));
+      const totalRowsPromise = observeBackgroundRejection(tableMetaCache.getRowCount(table, async () => rowCountFromResult(await execAsync(countSql, signal))));
       let columns;
       try {
         columns = await columnsPromise;
@@ -5422,7 +5514,7 @@ function createDockerAdapter(config) {
       }
       const columnNames = columns.map((column) => column.name);
       const order = buildOrderClause(filterOrderByColumns(options.orderBy, columnNames), config.kind);
-      const where = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), config.kind).where;
+      const where = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), config.kind, filterExactColumns(options.exact, columnNames)).where;
       const whereClause = where ? ` WHERE ${where}` : "";
       const countSql = `SELECT COUNT(*) AS cnt FROM ${id}${whereClause}`;
       const countResultPromise = execAsync(countSql, signal);
@@ -5602,7 +5694,7 @@ async function listDockerDatabasesAsync(serviceName, kind, env, cwd, signal) {
         return fallback;
       return setDockerDatabasesCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
     }
-    const parsed = parseTsvOutput(result.stdout, kind === "mysql");
+    const parsed = parseTsvOutput(result.stdout, kind === "mysql", kind === "postgresql" ? PG_RECORD_SEPARATOR : undefined);
     const dbs = parsed.rows.map((r) => r[0]).filter(Boolean);
     const value = dbs.length > 0 ? dbs : fallbackDockerDatabases(defaultDb);
     return setDockerDatabasesCache(cacheKey, value, value.length > 0 ? DOCKER_DATABASES_POSITIVE_TTL_MS : DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
@@ -5643,7 +5735,7 @@ async function listDockerSchemasAsync(serviceName, kind, env, cwd, overrideDatab
     if (result.code !== 0) {
       return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
     }
-    const parsed = parseTsvOutput(result.stdout, false);
+    const parsed = parseTsvOutput(result.stdout, false, PG_RECORD_SEPARATOR);
     const schemas = parsed.rows.map((r) => r[0]).filter(Boolean);
     const value = schemas.length > 0 ? schemas : ["public"];
     return setDockerSchemasCache(cacheKey, value, DOCKER_DATABASES_POSITIVE_TTL_MS, now);
@@ -5667,7 +5759,7 @@ async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatab
     ...kind === "postgresql" && schema ? { schema } : {}
   });
 }
-var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, MYSQL_SPATIAL_TYPES;
+var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES;
 var init_docker = __esm(() => {
   init_sql_snapshot();
   init_docker_utils();
@@ -5866,7 +5958,7 @@ function createSqliteAdapter(db) {
     async getFilteredTablePageWithMeta(table, options) {
       const columns = queryColumns(db, table);
       const columnNames = columns.map((column) => column.name);
-      const filter = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), "sqlite");
+      const filter = buildFilterWhere(filterGroupedColumns(options.grouped, columnNames), "sqlite", filterExactColumns(options.exact, columnNames));
       const order = buildOrderClause2(filterOrderByColumns(options.orderBy, columnNames));
       const tableId = sanitizeIdentifier(table);
       const whereClause = filter.where ? ` WHERE ${filter.where}` : "";
@@ -5877,7 +5969,7 @@ function createSqliteAdapter(db) {
         columns,
         rows: result.rows,
         rowCount: result.rowCount,
-        totalRows: countRow?.cnt ?? 0
+        totalRows: Number(countRow?.cnt ?? 0)
       };
     },
     executeReadonlyQuery(sql, params, maxRows = 1000) {
@@ -8566,9 +8658,16 @@ function parseBuckets(xml) {
     };
   }).filter((bucket) => bucket.name).sort((a, b) => a.name.localeCompare(b.name));
 }
+function decodeS3UrlEncoded(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
 function parseObjects(xml) {
   const objects = xmlBlocks(xml, "Contents").map((block) => {
-    const key = xmlText(block, "Key") || "";
+    const key = decodeS3UrlEncoded(xmlText(block, "Key") || "");
     const updatedAt = toIsoDate(xmlText(block, "LastModified"));
     return {
       key,
@@ -8578,8 +8677,10 @@ function parseObjects(xml) {
       ...xmlText(block, "StorageClass") ? { storageClass: xmlText(block, "StorageClass") } : {}
     };
   }).filter((object) => object.key);
+  const commonPrefixes = xmlBlocks(xml, "CommonPrefixes").map((block) => decodeS3UrlEncoded(xmlText(block, "Prefix") || "")).filter(Boolean);
   return {
     objects,
+    commonPrefixes,
     nextToken: xmlText(xml, "NextContinuationToken"),
     truncated: xmlText(xml, "IsTruncated") === "true"
   };
@@ -8661,8 +8762,10 @@ function createS3Adapter(config) {
       bucket: opts.bucket,
       query: {
         "list-type": "2",
+        "encoding-type": "url",
         "max-keys": String(Math.min(1000, Math.max(1, opts.maxKeys ?? 200))),
         ...opts.prefix ? { prefix: opts.prefix } : {},
+        ...opts.delimiter ? { delimiter: opts.delimiter } : {},
         ...opts.continuationToken ? { "continuation-token": opts.continuationToken } : {}
       },
       signal: opts.signal
@@ -9020,6 +9123,42 @@ ${s3ObjectName(object.key)}`.toLowerCase();
     return s3ErrorResponse(err, "list s3 objects");
   }
 }
+async function handleFolder(cwd, req, url, omitDirNames) {
+  const r = await resolveS3(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
+  if (r instanceof Response)
+    return r;
+  const bucket = validateBucket(url.searchParams.get("bucket"));
+  if (bucket instanceof Response)
+    return bucket;
+  const prefix = validateOptionalText(url.searchParams.get("prefix"), "prefix", 2048);
+  if (prefix instanceof Response)
+    return prefix;
+  const token = validateOptionalText(url.searchParams.get("token"), "token", 4096);
+  if (token instanceof Response)
+    return token;
+  try {
+    const page = await r.explorer.listObjects({
+      bucket,
+      prefix,
+      delimiter: "/",
+      continuationToken: token || undefined,
+      maxKeys: MAX_OBJECT_LIMIT,
+      signal: req.signal
+    });
+    const objects = page.objects.filter((object) => object.key !== prefix);
+    const body = {
+      dbId: r.dbId,
+      bucket,
+      prefix,
+      folders: page.commonPrefixes ?? [],
+      objects,
+      ...page.nextToken ? { nextToken: page.nextToken } : {}
+    };
+    return json(body);
+  } catch (err) {
+    return s3ErrorResponse(err, "list s3 folder");
+  }
+}
 async function handleHead(cwd, req, url, omitDirNames) {
   const r = await resolveS3(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
   if (r instanceof Response)
@@ -9105,6 +9244,10 @@ async function handleS3Route(req, url, cwd, sideEffectAllowed, omitDirNames) {
       methods: ["GET"],
       handler: () => handleObjects(cwd, req, url, omitDirNames)
     },
+    "/_db/s3/folder": {
+      methods: ["GET"],
+      handler: () => handleFolder(cwd, req, url, omitDirNames)
+    },
     "/_db/s3/head": {
       methods: ["GET"],
       handler: () => handleHead(cwd, req, url, omitDirNames)
@@ -9799,6 +9942,9 @@ function sanitize(input) {
     const sidebarWidth = sanitizeCssSize(tab.sidebarWidth);
     if (sidebarWidth !== undefined)
       out.sidebarWidth = sidebarWidth;
+    const relatedPanelHeight = sanitizeCssSize(tab.relatedPanelHeight);
+    if (relatedPanelHeight !== undefined)
+      out.relatedPanelHeight = relatedPanelHeight;
     const redis = sanitizeRedis(tab.redis);
     if (redis !== undefined)
       out.redis = redis;
@@ -10039,19 +10185,25 @@ async function handleSchema(cwd, url, omitDirNames, signal) {
     linkedAbort.cleanup();
   }
 }
-function parseFilters(url) {
-  const raw = url.searchParams.get("filters");
+function parseColumnValuePairs(url, param) {
+  const raw = url.searchParams.get(param);
   if (!raw)
     return [];
   try {
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed))
       return [];
-    return parsed.filter((f) => !!f && typeof f === "object" && typeof f.column === "string" && typeof f.value === "string");
+    return parsed.filter((f) => !!f && typeof f === "object" && typeof f.column === "string" && typeof f.value === "string").filter((f) => f.column.length <= MAX_FILTER_COLUMN_LEN && f.value.length <= MAX_FILTER_VALUE_LEN).slice(0, MAX_COLUMN_VALUE_PAIRS);
   } catch {
     return [];
   }
 }
+function parseFilters(url) {
+  return parseColumnValuePairs(url, "filters");
+}
+function parseExactConditions(url) {
+  return parseColumnValuePairs(url, "eq");
+}
 function groupFiltersByValue(filters) {
   const grouped = new Map;
   for (const filter of filters) {
@@ -10082,14 +10234,16 @@ async function handleTable(cwd, url, omitDirNames, signal) {
     ];
   }
   const filters = parseFilters(url);
+  const exact = parseExactConditions(url);
   try {
     const adapter = await getAdapter(r, cwd, signal);
-    if (filters.length > 0) {
+    if (filters.length > 0 || exact.length > 0) {
       const meta2 = await adapter.getFilteredTablePageWithMeta(table, {
         offset,
         limit,
         orderBy,
-        grouped: groupFiltersByValue(filters)
+        grouped: groupFiltersByValue(filters),
+        ...exact.length > 0 ? { exact } : {}
       }, signal);
       const colNames2 = new Set(meta2.columns.map((c) => c.name));
       if (sortCol && !colNames2.has(sortCol)) {
@@ -10363,6 +10517,7 @@ async function handleExport(cwd, url, omitDirNames, signal) {
     ];
   }
   const filters = parseFilters(url);
+  const exact = parseExactConditions(url);
   try {
     const adapter = await getAdapter(r, cwd, signal);
     const db = asAsync(adapter);
@@ -10373,12 +10528,13 @@ async function handleExport(cwd, url, omitDirNames, signal) {
       return textError(`invalid sort column: ${sortCol}`, 400);
     }
     let rawRows;
-    if (filters.length > 0) {
+    if (filters.length > 0 || exact.length > 0) {
       const meta = await adapter.getFilteredTablePageWithMeta(table, {
         offset: 0,
         limit: EXPORT_MAX_ROWS,
         orderBy,
-        grouped: groupFiltersByValue(filters)
+        grouped: groupFiltersByValue(filters),
+        ...exact.length > 0 ? { exact } : {}
       }, signal);
       rawRows = meta.rows;
     } else {
@@ -11015,7 +11171,7 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
     }
   }, sideEffectAllowed, wrapResponse, (err) => handleError("database", "handle database request", err));
 }
-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 initialized = false, dockerAdapterCache, MAX_SCHEMA_NAME_LEN2 = 1024, MAX_COLUMN_VALUE_PAIRS = 64, MAX_FILTER_COLUMN_LEN = 128, MAX_FILTER_VALUE_LEN = 4096, 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();
@@ -11082,12 +11238,20 @@ async function parseJsonBody(req) {
 async function handleSettingsGet(cwd) {
   return jsonLoadResponse(() => loadAppSettingsState(cwd), "state", "failed to load settings state");
 }
-async function handleSettingsPatch(cwd, req) {
+async function handleSettingsPatch(cwd, req, onChange) {
   const body = await parseJsonBody(req);
   if (body instanceof Response)
     return body;
   try {
-    return json(await patchAppSettingsState(cwd, body));
+    const next = await patchAppSettingsState(cwd, body);
+    if (onChange) {
+      try {
+        onChange(next);
+      } catch (notifyErr) {
+        console.warn("[code-viewer] settings change notify failed:", notifyErr);
+      }
+    }
+    return json(next);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     if (message === "settings state too large")
@@ -11113,12 +11277,12 @@ async function handleViewPatch(cwd, req) {
     return textError("failed to save view state", 500);
   }
 }
-async function handleStateRoute(req, url, cwd, sideEffectAllowed) {
+async function handleStateRoute(req, url, cwd, sideEffectAllowed, options = {}) {
   return dispatchRoutes(req, url, {
     "/_state/settings": {
       methods: ["GET", "PATCH"],
       sideEffect: (method) => method !== "GET",
-      handler: () => req.method === "GET" ? handleSettingsGet(cwd) : handleSettingsPatch(cwd, req)
+      handler: () => req.method === "GET" ? handleSettingsGet(cwd) : handleSettingsPatch(cwd, req, options.onSettingsChange)
     },
     "/_state/view": {
       methods: ["GET", "PATCH"],
@@ -11214,16 +11378,30 @@ Examples:
   }
   if (rest.length)
     cliArgs = rest;
-  const configScopeOmitDirs = loadProjectConfigScopeOmitDirs();
-  const configScopeExcludeNames = loadProjectConfigScopeExcludeNames();
-  uploadDisabledByConfig = loadProjectConfigUploadDisabled();
+  warnIfLegacyConfigPresent();
   if (scopeOmitDirCliOverride) {
     scopeOmitDirNames = scopeOmitDirCliOverride;
-  } else if (configScopeOmitDirs) {
-    scopeOmitDirNames = configScopeOmitDirs;
   }
-  if (configScopeExcludeNames)
-    scopeExcludeNames = configScopeExcludeNames;
+}
+function warnIfLegacyConfigPresent() {
+  try {
+    if (existsSync6(join13(cwd, ".code-viewer.json"))) {
+      console.warn("[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed.");
+    }
+  } catch {}
+}
+function applyPersistedSettings(state) {
+  if (!scopeOmitDirCliOverride && Array.isArray(state.scopeOmitDirs) && state.scopeOmitDirs.length > 0) {
+    scopeOmitDirNames = state.scopeOmitDirs;
+  } else if (!scopeOmitDirCliOverride) {
+    scopeOmitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES;
+  }
+  if (Array.isArray(state.scopeExcludeNames) && state.scopeExcludeNames.length > 0) {
+    scopeExcludeNames = state.scopeExcludeNames;
+  } else {
+    scopeExcludeNames = DEFAULT_EXCLUDE_NAMES;
+  }
+  uploadEnabled = state.uploadEnabled !== false;
 }
 function json2(data, init = {}) {
   return new Response(JSON.stringify(data), {
@@ -11525,45 +11703,6 @@ function parseScopeExcludeNamesQuery(value) {
   }
   return normalizeScopeExcludeNames(names);
 }
-function loadProjectConfig() {
-  const full = join13(cwd, ".code-viewer.json");
-  if (!existsSync6(full))
-    return null;
-  let realCwd;
-  let realConfig;
-  try {
-    realCwd = realpathSync4(cwd);
-    realConfig = realpathSync4(full);
-  } catch {
-    return null;
-  }
-  if (dirname3(realConfig) !== realCwd || basename3(realConfig) !== ".code-viewer.json")
-    return null;
-  try {
-    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;
-  } catch {
-    return null;
-  }
-}
-function loadProjectConfigUploadDisabled() {
-  const config = loadProjectConfig();
-  return config?.upload?.enabled === false;
-}
-function loadProjectConfigScopeOmitDirs() {
-  const config = loadProjectConfig();
-  if (!config?.scope || !Array.isArray(config.scope.omitDirs))
-    return null;
-  return normalizeScopeOmitDirNames(config.scope.omitDirs);
-}
-function loadProjectConfigScopeExcludeNames() {
-  const config = loadProjectConfig();
-  if (!config?.scope || !Array.isArray(config.scope.excludeNames))
-    return null;
-  return normalizeScopeExcludeNames(config.scope.excludeNames);
-}
 function scopeOmitDirNamesFromQuery(url) {
   if (!url.searchParams.has("omit_dirs"))
     return scopeOmitDirNames;
@@ -11731,7 +11870,7 @@ function handleTree(url) {
     branch: currentBranch(cwd) || undefined,
     entries: recursive ? entries : entries.map((entry) => attachTreeEntryMetadata(target, entry)),
     readme: readReadme(target, path),
-    upload_enabled: !uploadDisabledByConfig && (target === "worktree" || target === "")
+    upload_enabled: uploadEnabled && (target === "worktree" || target === "")
   });
 }
 function handleSettings() {
@@ -12293,8 +12432,8 @@ function uploadOpenFlags() {
   return constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0);
 }
 async function handleUploadFiles(req) {
-  if (uploadDisabledByConfig)
-    return text("upload disabled by project config", 403);
+  if (!uploadEnabled)
+    return text("upload disabled by viewer settings", 403);
   if (req.method !== "POST")
     return text("method not allowed", 405);
   if (!sideEffectRequestAllowed(req))
@@ -12847,9 +12986,6 @@ async function handleAnnotations(req) {
   }
   return text("invalid action", 400);
 }
-function isCodeViewerInternalPath(path) {
-  return path.split(/[\\/]+/).some((part) => part.toLowerCase() === ".code-viewer");
-}
 function sendSse(event, data = "tick") {
   const payload = enc.encode(`event: ${event}
 data: ${data}
@@ -12897,7 +13033,7 @@ async function shutdown(exitCode = 0) {
   }
   process.exit(exitCode);
 }
-var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, uploadDisabledByConfig = false, rgAvailableCache = null, enc, sseClients, sseKeepalives, fileCache, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, server, worktreeWatch = null, shuttingDown = false;
+var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, uploadEnabled = true, rgAvailableCache = null, enc, sseClients, sseKeepalives, fileCache, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, isCodeViewerInternalPath, watchLimitReached = null, server, worktreeWatch = null, shuttingDown = false;
 var init_preview = __esm(async () => {
   init_routes();
   init_annotations();
@@ -12909,6 +13045,7 @@ var init_preview = __esm(async () => {
   init_runtime();
   init_search();
   init_server_registry();
+  init_state_store();
   init_worktree_watcher();
   WEB_ROOT = join13(ROOT, "web");
   VERSION = JSON.parse(readFileSync4(join13(ROOT, "package.json"), "utf8")).version;
@@ -12968,7 +13105,9 @@ var init_preview = __esm(async () => {
   lineIndexCache = new Map;
   blobLineIndexCache = new Map;
   blobBytesCache = new Map;
+  isCodeViewerInternalPath = isToolInternalPath;
   parseCli();
+  applyPersistedSettings(await loadAppSettingsState(cwd));
   server = await startServer({
     hostname: "127.0.0.1",
     port: listenPort,
@@ -13017,7 +13156,7 @@ var init_preview = __esm(async () => {
       }
       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);
+        const stateResponse = await handleStateRoute2(req, url, cwd, sideEffectRequestAllowed, { onSettingsChange: applyPersistedSettings });
         if (stateResponse)
           return stateResponse;
       }
@@ -13042,6 +13181,12 @@ var init_preview = __esm(async () => {
 data: ok
 
 `));
+            if (watchLimitReached !== null) {
+              controller.enqueue(enc.encode(`event: watch-limit
+data: ${watchLimitReached}
+
+`));
+            }
             keepalive = setInterval(() => {
               try {
                 controller.enqueue(enc.encode(`: ping
@@ -13111,6 +13256,10 @@ data: ok
     initialScanMode: "async",
     maxWatchedDirectories: worktreeWatchDirectoryLimitFromEnv(),
     onUpdate: triggerUpdate,
+    onWatchLimit: (limit) => {
+      watchLimitReached = limit;
+      sendSse("watch-limit", String(limit));
+    },
     onError: (error) => {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`code-viewer worktree watch skipped: ${message}`);