dsh-sessions-manager 3.4.0 → 3.4.2

package/lib/index.js

@@ -1,6 +1,6 @@
 // src/index.js
-import { mkdir as mkdir3, realpath, rename as rename3, stat, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join as join3 } from "node:path";
+import { mkdir as mkdir4, realpath, rename as rename4, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { basename, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
 import { readFileSync as readFileSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 
@@ -405,18 +405,211 @@ function createAutoArchiveStore(options = {}) {
       return store;
     });
   }
-  function isFresh(store, now = Date.now()) {
+  function isFresh2(store, now = Date.now()) {
     return Number.isFinite(store && store.lastRunAt) && now - store.lastRunAt < RUN_INTERVAL_MS;
   }
-  return { read, write, mutate, update, recordRun, isFresh, indexPath, dir };
+  return { read, write, mutate, update, recordRun, isFresh: isFresh2, indexPath, dir };
+}
+
+// src/session-meta-cache.js
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_MAX = 4e3;
+function fingerprintOf(stat2) {
+  if (!stat2 || typeof stat2 !== "object") return null;
+  const mtimeMs = stat2.mtimeMs;
+  const size = stat2.size;
+  if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs <= 0) return null;
+  if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return null;
+  return `${Math.floor(mtimeMs)}:${size}`;
+}
+function isFresh(entry, stat2, now, ttlMs = DEFAULT_TTL_MS) {
+  if (!entry) return false;
+  const fp = fingerprintOf(stat2);
+  if (!fp) return false;
+  if (entry.fingerprint !== fp) return false;
+  if (typeof entry.at !== "number") return false;
+  return now - entry.at <= ttlMs;
+}
+function partitionByCache(ids, statsById, cache, now = Date.now(), ttlMs = DEFAULT_TTL_MS) {
+  const cached = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const id of ids) {
+    const entry = cache && cache.get(String(id));
+    const stat2 = statsById && statsById.get(String(id));
+    if (isFresh(entry, stat2, now, ttlMs) && entry && entry.meta) {
+      cached.set(String(id), entry.meta);
+    } else {
+      missing.push(String(id));
+    }
+  }
+  return { cached, missing };
+}
+function createSessionMetaCache(opts = {}) {
+  const ttlMs = Number.isFinite(opts.ttlMs) ? opts.ttlMs : DEFAULT_TTL_MS;
+  const max = Number.isInteger(opts.max) && opts.max > 0 ? opts.max : DEFAULT_MAX;
+  const map = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  return {
+    // 命中返回 meta，未命中/无法校验返回 null。
+    get(id, stat2) {
+      const key = String(id);
+      const entry = map.get(key);
+      if (isFresh(entry, stat2, Date.now(), ttlMs)) {
+        hits++;
+        map.delete(key);
+        map.set(key, entry);
+        return entry.meta;
+      }
+      misses++;
+      return null;
+    },
+    set(id, stat2, meta) {
+      if (!meta) return null;
+      const fp = fingerprintOf(stat2);
+      if (!fp) return null;
+      const key = String(id);
+      map.delete(key);
+      map.set(key, { fingerprint: fp, at: Date.now(), meta });
+      if (map.size > max) {
+        const oldest = map.keys().next().value;
+        if (oldest !== void 0) map.delete(oldest);
+      }
+      return meta;
+    },
+    // 批量判定：一次算出「命中缓存」与「需要解码」两组，供列表构建做批量投影。
+    partition(ids, statsById) {
+      return partitionByCache(ids, statsById, map, Date.now(), ttlMs);
+    },
+    invalidate(id) {
+      if (id == null) return false;
+      const key = String(id);
+      const had = map.has(key);
+      map.delete(key);
+      return had;
+    },
+    clear() {
+      map.clear();
+    },
+    get size() {
+      return map.size;
+    },
+    stats() {
+      return { size: map.size, hits, misses, ttlMs };
+    }
+  };
+}
+
+// src/title-persist-index.js
+import { mkdir as mkdir3, readFile, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname, join as join3 } from "node:path";
+var TITLE_INDEX_SCHEMA_VERSION = 1;
+var MAX_ENTRIES = 2e4;
+function normalizeEntry(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const title = typeof raw.title === "string" ? raw.title : null;
+  const cwd = typeof raw.cwd === "string" ? raw.cwd : null;
+  const createdAt = typeof raw.createdAt === "number" ? raw.createdAt : null;
+  const fingerprint = typeof raw.fingerprint === "string" && raw.fingerprint ? raw.fingerprint : null;
+  const updatedAt = typeof raw.updatedAt === "number" ? raw.updatedAt : 0;
+  if (!fingerprint || !title && !cwd) return null;
+  return { title, cwd, createdAt, fingerprint, updatedAt };
+}
+function normalizeTitleIndex(raw) {
+  const entries = {};
+  if (raw && typeof raw === "object" && raw.entries && typeof raw.entries === "object") {
+    for (const [id, entry] of Object.entries(raw.entries)) {
+      if (typeof id !== "string" || !id || id.length > 200) continue;
+      const normalized = normalizeEntry(entry);
+      if (normalized) entries[id] = normalized;
+    }
+  }
+  return { schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries };
+}
+function mergeEntries(left, right) {
+  const merged = { ...left };
+  for (const [id, entry] of Object.entries(right)) merged[id] = entry;
+  const ids = Object.keys(merged);
+  if (ids.length > MAX_ENTRIES) {
+    ids.sort((a, b) => (merged[a].updatedAt || 0) - (merged[b].updatedAt || 0));
+    for (const id of ids.slice(0, ids.length - MAX_ENTRIES)) delete merged[id];
+  }
+  return merged;
+}
+function createTitleIndexStore({ dir, file }) {
+  let cache = null;
+  let chain = Promise.resolve();
+  const path = file || join3(dir, "title-index.json");
+  async function readRaw() {
+    try {
+      return normalizeTitleIndex(JSON.parse(await readFile(path, "utf8")));
+    } catch (e) {
+      return normalizeTitleIndex(null);
+    }
+  }
+  function enqueue(mutator) {
+    const operation = chain.then(async () => {
+      const store = cache || (cache = (await readRaw()).entries);
+      await mutator(store);
+      return store;
+    });
+    chain = operation.catch(() => {
+    });
+    return operation;
+  }
+  return {
+    // 只读：内存优先，未加载过才落盘一次。绝不抛错。
+    async entries() {
+      if (cache) return cache;
+      cache = (await readRaw()).entries;
+      return cache;
+    },
+    // 批量合并写入（原子替换）。失败静默：索引只是加速器，坏了下次重解码。
+    async merge(batch) {
+      const right = {};
+      for (const [id, entry] of Object.entries(batch || {})) {
+        const normalized = normalizeEntry(entry);
+        if (normalized) right[String(id)] = normalized;
+      }
+      if (!Object.keys(right).length) return false;
+      await enqueue(async (store) => {
+        const next = mergeEntries(store, right);
+        await mkdir3(dirname(path), { recursive: true });
+        const tmp = join3(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile3(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
+        await rename3(tmp, path);
+        cache = next;
+      });
+      return true;
+    },
+    async remove(ids) {
+      const wanted = new Set((ids || []).map(String));
+      if (!wanted.size) return false;
+      await enqueue(async (store) => {
+        let changed = false;
+        for (const id of wanted) {
+          if (id in store) {
+            delete store[id];
+            changed = true;
+          }
+        }
+        if (!changed) return;
+        await mkdir3(dirname(path), { recursive: true });
+        const tmp = join3(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile3(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
+        await rename3(tmp, path);
+      });
+      return true;
+    }
+  };
 }
 
 // src/index.js
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;
-var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join3(homedir3(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join3(TRASH_DIR, "index.json");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join4(homedir3(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join4(TRASH_DIR, "index.json");
 var TRASH_SCHEMA_VERSION = 2;
 var DEFAULT_TRASH_SETTINGS = Object.freeze({ retentionDays: 0 });
 var FETCH_TOOL_RE = /search|fetch|download|browse/i;
@@ -500,7 +693,58 @@ function apply(ctx) {
   const sq = ctx.sessionQuery;
   const dom = () => ctx.storageDomain.get("workspace");
   const authorityTitleCache = /* @__PURE__ */ new Map();
-  let authorityTitlesLoaded = false;
+  const metaCache = createSessionMetaCache();
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join4(TRASH_DIR, "title-index.json") });
+  async function hydrateFromPersist(ids, statsById) {
+    const hits = /* @__PURE__ */ new Map();
+    if (!ids || !ids.length) return hits;
+    let store;
+    try {
+      store = await titleIndex.entries();
+    } catch (e) {
+      return hits;
+    }
+    for (const id of ids) {
+      const stat2 = statsById.get(id);
+      const entry = store && store[id];
+      if (!stat2 || !entry) continue;
+      const fp = fingerprintOf(stat2);
+      if (fp && entry.fingerprint === fp) {
+        hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt });
+      }
+    }
+    return hits;
+  }
+  function persistDecoded(decoded, statsById) {
+    if (!decoded || !decoded.size) return;
+    const batch = {};
+    const now = Date.now();
+    for (const [id, meta] of decoded) {
+      const fp = fingerprintOf(statsById.get(id));
+      if (!fp) continue;
+      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now };
+    }
+    if (!Object.keys(batch).length) return;
+    titleIndex.merge(batch).catch(() => {
+    });
+  }
+  function metaFromSnapshot(o) {
+    let title = null, createdAt = null, cwd = null;
+    if (o) {
+      if (o.title && o.title.title) title = String(o.title.title);
+      if (o.session) {
+        cwd = o.session.cwd || null;
+        createdAt = o.session.createdAt || null;
+      }
+    }
+    return { title, cwd, createdAt };
+  }
+  function unwrapSnapshot(result) {
+    if (!result) return null;
+    if (result.status === "fulfilled") return result.value || null;
+    if (result.status === "rejected") return null;
+    return result;
+  }
   async function archivedState() {
     const d = dom();
     if (!d) throw new Error("workspace domain is not open");
@@ -534,56 +778,66 @@ function apply(ctx) {
     return operation;
   }
   let wsByPath = {};
-  async function resolveOne(id, usage) {
-    let title = null, createdAt = null, cwd = null;
-    try {
-      const o = await sq.readTitleSnapshot(id);
-      if (o) {
-        if (o.title && o.title.title) title = String(o.title.title);
-        if (o.session) {
-          cwd = o.session.cwd || null;
-          createdAt = o.session.createdAt || null;
-        }
-      }
-    } catch (e) {
-    }
-    if (!title || !cwd) {
-      try {
-        const r = await sp.readFrom(id, 0);
-        if (r.meta) {
-          if (!cwd) cwd = r.meta.cwd || null;
-          if (!createdAt) createdAt = r.meta.createdAt || null;
-        }
-        if (!title && Array.isArray(r.events)) title = foldTitle(r.events);
-      } catch (e2) {
-      }
-    }
+  function buildItem(key, meta, usage, exposeUsage) {
+    const cwd = meta.cwd || null;
     const ws = cwd ? wsByPath[cwd] : void 0;
-    const workspaceGone = !!(cwd && !ws);
+    const title = meta.title || null;
     const display = title ? String(title).length > MAX_TITLE ? String(title).slice(0, MAX_TITLE) + "\u2026" : String(title) : null;
     const base = {
-      sessionId: id,
+      sessionId: key,
       title: display,
-      createdAt: createdAt || null,
-      workspacePath: cwd || null,
+      createdAt: meta.createdAt || null,
+      workspacePath: cwd,
       workspaceTitle: ws && ws.title ? ws.title : null,
-      workspaceGone: workspaceGone ? true : false,
+      workspaceGone: !!(cwd && !ws),
       hasWorkspace: !!cwd
     };
-    if (usage) {
-      if (usage.sizeById && usage.sizeById.has(id)) base.sizeBytes = usage.sizeById.get(id);
-      if (usage.mtimeById && usage.mtimeById.has(id)) base.updatedAt = usage.mtimeById.get(id);
+    if (exposeUsage && usage) {
+      if (usage.sizeById && usage.sizeById.has(key)) base.sizeBytes = usage.sizeById.get(key);
+      if (usage.mtimeById && usage.mtimeById.has(key)) base.updatedAt = usage.mtimeById.get(key);
     }
     return base;
   }
-  async function collectUsage() {
+  async function resolveOne(id, usage, opts = {}) {
+    const key = String(id);
+    const statInfo = usage ? { mtimeMs: usage.mtimeById.get(key), size: usage.sizeById.get(key) } : null;
+    const cached = metaCache.get(key, statInfo);
+    if (cached) return buildItem(key, cached, usage, opts.exposeUsage);
+    let meta = { title: null, cwd: null, createdAt: null };
+    if (opts.preloaded !== void 0) {
+      meta = metaFromSnapshot(unwrapSnapshot(opts.preloaded));
+    } else if (typeof sq.readTitleSnapshot === "function") {
+      try {
+        meta = metaFromSnapshot(await sq.readTitleSnapshot(id));
+      } catch (e) {
+      }
+    }
+    if (!meta.title || !meta.cwd) {
+      try {
+        const r = await sp.readFrom(id, 0);
+        if (r.meta) {
+          if (!meta.cwd) meta.cwd = r.meta.cwd || null;
+          if (!meta.createdAt) meta.createdAt = r.meta.createdAt || null;
+        }
+        if (!meta.title && Array.isArray(r.events)) meta.title = foldTitle(r.events);
+      } catch (e2) {
+      }
+    }
+    metaCache.set(key, statInfo, meta);
+    if (opts.collectDecoded && statInfo) opts.collectDecoded(key, meta);
+    return buildItem(key, meta, usage, opts.exposeUsage);
+  }
+  async function collectUsage(preloadedHeaders) {
     const sizeById = /* @__PURE__ */ new Map();
     const mtimeById = /* @__PURE__ */ new Map();
-    let headers = [];
-    try {
-      headers = await sp.list();
-    } catch (e) {
-      headers = [];
+    let headers = null;
+    if (Array.isArray(preloadedHeaders)) headers = preloadedHeaders;
+    else {
+      try {
+        headers = await sp.list();
+      } catch (e) {
+        headers = [];
+      }
     }
     if (!Array.isArray(headers)) headers = [];
     const CHUNK = 8;
@@ -631,10 +885,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    await mkdir3(TRASH_DIR, { recursive: true });
-    const tmp = join3(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
-    await writeFile3(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename3(tmp, TRASH_INDEX);
+    await mkdir4(TRASH_DIR, { recursive: true });
+    const tmp = join4(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile4(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename4(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -740,7 +994,7 @@ function apply(ctx) {
       } catch (e) {
       }
       if (!target && typeof entry.originalPath === "string") target = entry.originalPath;
-      const targetOwnsSession = target && (basename(dirname(target)) === sid || basename(target).includes(sid));
+      const targetOwnsSession = target && (basename(dirname2(target)) === sid || basename(target).includes(sid));
       if (target && !targetOwnsSession) {
         const error = new Error("\u65E5\u5FD7\u8DEF\u5F84\u4E0E\u4F1A\u8BDD ID \u4E0D\u5339\u914D\uFF0C\u5DF2\u505C\u6B62\u6C38\u4E45\u5220\u9664");
         error.status = 409;
@@ -833,8 +1087,8 @@ function apply(ctx) {
   async function moveTargetWorkspace(rawPath) {
     if (typeof rawPath !== "string" || !rawPath.trim()) throw new Error("\u7F3A\u5C11\u76EE\u6807\u5DE5\u4F5C\u533A\u8DEF\u5F84");
     let p = String(rawPath).trim();
-    if (p.startsWith("~/")) p = join3(homedir3(), p.slice(2));
-    if (!isAbsolute(p)) p = join3(homedir3(), p);
+    if (p.startsWith("~/")) p = join4(homedir3(), p.slice(2));
+    if (!isAbsolute(p)) p = join4(homedir3(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -842,7 +1096,7 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir3(p, { recursive: true });
+      await mkdir4(p, { recursive: true });
       canonical = await realpath(p);
     }
     return { canonical, entity: await w.create(canonical, basename(canonical) || "workspace") };
@@ -880,13 +1134,13 @@ function apply(ctx) {
       if (!oldPath || !newPath || oldPath === newPath) return false;
       const backupPath = `${oldPath}.move-backup-${Date.now()}`;
       try {
-        await mkdir3(dirname(newPath), { recursive: true });
-        await rename3(oldPath, backupPath);
+        await mkdir4(dirname2(newPath), { recursive: true });
+        await rename4(oldPath, backupPath);
         await rewriteFrame0Cwd(backupPath, canonical);
-        await rename3(backupPath, newPath);
+        await rename4(backupPath, newPath);
       } catch (e) {
         try {
-          await rename3(backupPath, oldPath);
+          await rename4(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -932,7 +1186,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename3(oldPath, backupPath);
+            await rename4(oldPath, backupPath);
           } catch (e) {
             if (e && e.code !== "ENOENT") throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u5907\u4EFD\u65E7\u7684\u4F1A\u8BDD\u65E5\u5FD7");
           }
@@ -940,7 +1194,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename3(backupPath, oldPath);
+              await rename4(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -1034,25 +1288,38 @@ function apply(ctx) {
       return { next: null, value: { ok: true, archived: true } };
     });
   }
-  async function allSessionItems(opts = {}) {
-    let materialized = /* @__PURE__ */ new Set();
-    let live = ctx.get("sessions");
-    let headersOk = false;
+  async function projectTitles(ids) {
+    const out = /* @__PURE__ */ new Map();
+    if (!ids || !ids.length) return out;
+    if (typeof sq.readTitleSnapshots !== "function") return out;
     try {
-      const headers = await sp.list();
-      materialized = new Set(headers.map((h) => String(h.id)));
-      headersOk = true;
+      const results = await sq.readTitleSnapshots(ids);
+      if (!Array.isArray(results)) return out;
+      results.forEach((result, index) => {
+        const id = String(ids[index]);
+        out.set(id, unwrapSnapshot(result));
+      });
     } catch (e) {
     }
-    const ids = [];
+    return out;
+  }
+  async function allSessionItems(opts = {}) {
+    let headers = [];
+    let headersOk = false;
     try {
-      for (const header of await sp.list()) ids.push(String(header.id));
+      headers = await sp.list();
+      headersOk = Array.isArray(headers);
+      if (!headersOk) headers = [];
     } catch (e) {
+      headers = [];
     }
+    let live = ctx.get("sessions");
+    const ids = headers.map((h) => String(h.id));
     if (live) {
       try {
         live.list().forEach((s) => {
-          if (!ids.includes(String(s.id))) ids.push(String(s.id));
+          const sid = String(s.id);
+          if (!ids.includes(sid)) ids.push(sid);
         });
       } catch (e) {
       }
@@ -1072,12 +1339,27 @@ function apply(ctx) {
     }
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || []);
     const items = [];
-    const usage = opts && opts.usage ? await collectUsage() : null;
+    const usage = await collectUsage(headers);
+    const statsById = new Map(visibleIds.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]));
+    const { cached, missing } = metaCache.partition(visibleIds, statsById);
+    const persisted = await hydrateFromPersist(missing, statsById);
+    for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta);
+    const stillMissing = missing.filter((id) => !persisted.has(id));
+    const snapshotById = await projectTitles(stillMissing);
+    const decoded = /* @__PURE__ */ new Map();
+    const collectDecoded = (id, meta) => {
+      decoded.set(id, meta);
+    };
     const CHUNK = 6;
     for (let i = 0; i < visibleIds.length; i += CHUNK) {
-      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage)));
+      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage, {
+        exposeUsage: !!(opts && opts.usage),
+        preloaded: snapshotById.has(id) ? snapshotById.get(id) : void 0,
+        collectDecoded
+      })));
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) });
     }
+    persistDecoded(decoded, statsById);
     let starredSet = /* @__PURE__ */ new Set();
     try {
       starredSet = new Set((await stars.read()).starredSessionIds);
@@ -1123,35 +1405,47 @@ function apply(ctx) {
   }
   async function sidebarAuthority() {
     const ids = [];
+    let headers = [];
     try {
-      for (const header of await sp.list()) ids.push(String(header.id));
+      headers = await sp.list();
     } catch (e) {
+      headers = [];
     }
+    if (!Array.isArray(headers)) headers = [];
+    for (const header of headers) ids.push(String(header.id));
     const sessions = ctx.get("sessions");
     try {
       if (sessions) sessions.list().forEach((session) => {
-        if (!ids.includes(String(session.id))) ids.push(String(session.id));
+        const sid = String(session.id);
+        if (!ids.includes(sid)) ids.push(sid);
       });
     } catch (e) {
     }
     const store = await readTrashStore();
-    if (!authorityTitlesLoaded && ids.length && typeof sq.readTitleSnapshots === "function") {
-      const results = await sq.readTitleSnapshots(ids);
-      results.forEach((result, index) => {
-        if (result && result.status === "fulfilled" && result.value && result.value.title && typeof result.value.title.title === "string") {
-          authorityTitleCache.set(ids[index], result.value.title.title);
-        }
-      });
-      authorityTitlesLoaded = true;
-    } else if (!authorityTitlesLoaded) {
-      for (const sid of ids) {
-        try {
-          const snapshot = await sq.readTitleSnapshot(sid);
-          if (snapshot && snapshot.title && typeof snapshot.title.title === "string") authorityTitleCache.set(sid, snapshot.title.title);
-        } catch (e) {
+    if (ids.length) {
+      const usage = await collectUsage(headers);
+      const statsById = new Map(ids.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]));
+      const { cached, missing } = metaCache.partition(ids, statsById);
+      const persisted = await hydrateFromPersist(missing, statsById);
+      for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta);
+      const rest = missing.filter((id) => !persisted.has(id));
+      const snapshotById = await projectTitles(rest);
+      const decoded = /* @__PURE__ */ new Map();
+      const collectDecoded = (id, meta) => {
+        decoded.set(id, meta);
+      };
+      for (const id of ids) {
+        let meta = cached.get(id) || persisted.get(id) || null;
+        if (!meta) {
+          const snapshot = snapshotById.has(id) ? snapshotById.get(id) : typeof sq.readTitleSnapshot === "function" ? await sq.readTitleSnapshot(id).catch(() => null) : null;
+          const next = metaFromSnapshot(snapshot);
+          metaCache.set(id, statsById.get(id), next);
+          if (statsById.get(id)) collectDecoded(id, next);
+          meta = next;
         }
+        if (meta && meta.title) authorityTitleCache.set(id, String(meta.title));
       }
-      authorityTitlesLoaded = true;
+      persistDecoded(decoded, statsById);
     }
     return {
       titles: Object.fromEntries(authorityTitleCache),
@@ -1380,7 +1674,9 @@ function apply(ctx) {
           const body = await readJsonBody(req);
           const sid = body && typeof body.sessionId === "string" ? body.sessionId : null;
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
-          json(res, await deleteOne(sid));
+          const out = await deleteOne(sid);
+          metaCache.invalidate(sid);
+          json(res, out);
         } catch (e) {
           json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
         }
@@ -1398,6 +1694,7 @@ function apply(ctx) {
           for (const sid of ids) {
             try {
               results.push({ sessionId: sid, ok: true, ...await deleteOne(sid) });
+              metaCache.invalidate(sid);
             } catch (e) {
               results.push({ sessionId: sid, ok: false, error: String(e && e.message || e) });
             }
@@ -1461,7 +1758,9 @@ function apply(ctx) {
           const body = await readJsonBody(req);
           const sid = body && typeof body.sessionId === "string" ? body.sessionId : null;
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
-          json(res, await restoreFromTrash(sid));
+          const out = await restoreFromTrash(sid);
+          metaCache.invalidate(sid);
+          json(res, out);
         } catch (e) {
           json(res, { ok: false, error: String(e && e.message || e) }, 500);
         }
@@ -1475,7 +1774,11 @@ function apply(ctx) {
           const body = await readJsonBody(req);
           const sid = body && typeof body.sessionId === "string" ? body.sessionId : null;
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
-          json(res, await purgeFromTrash(sid));
+          const out = await purgeFromTrash(sid);
+          metaCache.invalidate(sid);
+          titleIndex.remove([sid]).catch(() => {
+          });
+          json(res, out);
         } catch (e) {
           json(res, { ok: false, error: String(e && e.message || e) }, 500);
         }
@@ -1493,6 +1796,9 @@ function apply(ctx) {
           for (const sid of ids) {
             try {
               results.push({ sessionId: sid, ok: true, ...await purgeFromTrash(sid) });
+              metaCache.invalidate(sid);
+              titleIndex.remove([sid]).catch(() => {
+              });
             } catch (e) {
               results.push({ sessionId: sid, ok: false, error: String(e && e.message || e) });
             }
@@ -1592,6 +1898,7 @@ function apply(ctx) {
           if (!sid) return json(res, { ok: false, error: "missing sessionId" }, 400);
           if (!target) return json(res, { ok: false, error: "missing targetPath" }, 400);
           const moved = await moveOne(sid, target);
+          metaCache.invalidate(sid);
           try {
             await reindexRegistry();
           } catch (e) {
@@ -1673,8 +1980,16 @@ function apply(ctx) {
           const patch = {};
           if (body && Object.prototype.hasOwnProperty.call(body, "inactiveDays")) patch.inactiveDays = body.inactiveDays;
           if (body && Object.prototype.hasOwnProperty.call(body, "skipStarred")) patch.skipStarred = body.skipStarred;
-          const settings = Object.keys(patch).length ? await autoArchive.update(patch) : (await autoArchive.read()).settings;
-          const sweep = await autoArchiveSweep();
+          const isPatch = Object.keys(patch).length > 0;
+          const settings = isPatch ? await autoArchive.update(patch) : (await autoArchive.read()).settings;
+          let sweep;
+          if (isPatch) {
+            sweep = await autoArchiveSweep();
+          } else {
+            void autoArchiveSweep().catch(() => {
+            });
+            sweep = { triggered: true };
+          }
           const store = await autoArchive.read();
           json(res, {
             ok: true,