opencode-sesh 2.1.3 → 2.1.5

package/AGENTS.md

@@ -31,6 +31,7 @@ bun run test           # build + fixture-DB regression suite — must stay green
 bun run test:changelog # release-tooling regressions (scripts/changelog.sh)
 bun run test:picker    # PTY picker suite
 bun run test:tui-home  # real OpenTUI home layout regressions (also in bun run test)
+bun run test:tui-worker # real blob Worker + bun:sqlite regressions (also in bun run test)
 bun run typecheck      # tsc over tui-plugins/ and plugins/
 bun run lint:sh        # bash -n on every script
 HOME=/tmp/fakehome bash install.sh   # installer smoke test (never touches ~/.config)
@@ -181,7 +182,11 @@ when opencode exits, the picker reopens with the query preserved.
   scrolling inside; the picker remains the place for transcript search.
   Sessions waiting on the user (unanswered questions, stuck runs) pin a
   **Needs input** group above the directories, with the count in the heading —
-  same `NEEDS_INPUT_SQL` heuristic as `bin/sesh-waiting.sh`.
+  same `NEEDS_INPUT_SQL` heuristic as `bin/sesh-waiting.sh`. The query runs in
+  a blob Worker (`createDbClient`; failure means "local store unavailable"),
+  off the TUI thread but still costing worker CPU every poll, so the shared
+  poll runs it only while the sidebar is subscribed
+  (`poll(listener, { waiting: true })`); the home list never triggers it.
 - **Picker:** a custom dialog (not `DialogSelect`) grouped by
   project/directory, recency-ordered, resume via
   `api.route.navigate("session", …)`. `option+o` and the command palette open it;
@@ -266,6 +271,9 @@ when opencode exits, the picker reopens with the query preserved.
   and Python 3).
 - `bun run test:tui-home` — real OpenTUI render regressions for the home list
   (also run by `bun run test`).
+- `bun run test:tui-worker` — starts the real blob Worker against a bun:sqlite
+  fixture; asserts results round-trip and the main thread keeps ticking during
+  a slow query (also run by `bun run test`).
 - `bun run typecheck` — `tsc` over `tui-plugins/` and `plugins/`.
 - `bun run lint:sh` — `bash -n` on every script.
 - `HOME=/tmp/fakehome bash install.sh` — installer smoke test.

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.5] - 2026-11-02
+
+### Fixed
+
+- **tui:** Run needs-input SQLite reads in a worker (#34)
+
+## [2.1.4] - 2026-11-02
+
+### Fixed
+
+- **tui:** Skip the needs-input query when no sidebar consumes it (#33)
+
 ## [2.1.3] - 2026-11-02
 
 ### Fixed
@@ -530,6 +542,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixture-database regression suite, TypeScript typechecking, and ShellCheck in
   CI.
 
+[2.1.5]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.4...v2.1.5
+[2.1.4]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.3...v2.1.4
 [2.1.3]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.2...v2.1.3
 [2.1.2]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.1...v2.1.2
 [2.1.1]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.0...v2.1.1

package/dist/tui.js

@@ -636,8 +636,107 @@ async function openTranscriptDb() {
     return undefined;
   }
 }
+
+// Runs in a blob Worker so slow queries never block the TUI thread. The
+// connection opens on the first request and stays open; `loadSqlite` is
+// injected only by tests.
+const DB_WORKER_SOURCE = `
+let opening
+const load = typeof loadSqlite === "function" ? loadSqlite : () => import("bun:sqlite")
+const open = (path) => opening ??= load().then((sqlite) => new sqlite.Database(path, { readonly: true }), (error) => { opening = undefined; throw error })
+self.onmessage = async (event) => {
+  const { id, path, sql, params } = event.data
+  try {
+    const db = await open(path)
+    self.postMessage({ id, rows: db.query(sql).all(...(params ?? [])) })
+  } catch (error) {
+    self.postMessage({ id, error: String(error?.message ?? error) })
+  }
+}`;
+const DB_QUERY_TIMEOUT_MS = 30000;
+function createDbWorker() {
+  return new globalThis.Worker(URL.createObjectURL(new Blob([DB_WORKER_SOURCE], {
+    type: "text/javascript"
+  })));
+}
+
+// Read-only queries against the local store, served by one lazily started
+// worker. Any failure (no worker, no bun:sqlite, query error, timeout) rejects;
+// a timeout or worker error discards the worker so the next call starts afresh.
+function createDbClient(createWorker = createDbWorker, timeoutMs = DB_QUERY_TIMEOUT_MS) {
+  let worker;
+  let nextId = 0;
+  const pending = new Map();
+  const reset = error => {
+    const dead = worker;
+    worker = undefined;
+    try {
+      dead?.terminate();
+    } catch {}
+    const requests = [...pending.values()];
+    pending.clear();
+    for (const request of requests) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+  };
+  const start = () => {
+    const created = createWorker();
+    created.onmessage = event => {
+      const {
+        id,
+        rows,
+        error
+      } = event?.data ?? {};
+      const request = pending.get(id);
+      if (!request) return;
+      pending.delete(id);
+      clearTimeout(request.timer);
+      if (typeof error === "string") request.reject(new Error(error));else request.resolve(Array.isArray(rows) ? rows : []);
+    };
+    created.onerror = event => {
+      event?.preventDefault?.();
+      if (worker === created) reset(new Error(String(event?.message ?? "local store worker failed")));
+    };
+    created.unref?.();
+    return created;
+  };
+  const run = (sql, params = []) => new Promise((resolve, reject) => {
+    try {
+      worker ??= start();
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const id = ++nextId;
+    const timer = setTimeout(() => reset(new Error("local store query timed out")), timeoutMs);
+    timer.unref?.();
+    pending.set(id, {
+      resolve,
+      reject,
+      timer
+    });
+    try {
+      worker.postMessage({
+        id,
+        path: resolveDbPath(),
+        sql,
+        params
+      });
+    } catch (error) {
+      reset(error);
+    }
+  });
+  return {
+    run,
+    close: () => reset(new Error("local store closed"))
+  };
+}
+const dbClient = createDbClient();
 function createSessionPoll(api, refreshPins) {
-  const listeners = new Set();
+  // Listener -> whether it reads `snapshot.waiting`. The needs-input query
+  // costs worker CPU on every poll, so it only runs while such a listener exists.
+  const listeners = new Map();
   let snapshot = {
     entries: [],
     waiting: new Map(),
@@ -645,7 +744,11 @@ function createSessionPoll(api, refreshPins) {
   };
   let clock;
   let inFlight;
+  // Whether `snapshot.waiting` came from a poll that ran the query; a poll
+  // without waiting listeners clears it so a later subscriber never sees a stale set.
+  let waitingLoaded = false;
   const active = () => listeners.size > 0;
+  const wantsWaiting = () => [...listeners.values()].some(Boolean);
   const load = () => {
     if (inFlight || !active()) return;
     inFlight = (async () => {
@@ -671,30 +774,40 @@ function createSessionPoll(api, refreshPins) {
         };
       }
       if (!active()) return;
-      const db = await openTranscriptDb();
-      if (db) {
+      if (wantsWaiting()) {
         try {
-          if (active()) snapshot = {
-            ...snapshot,
-            waiting: await queryWaitingIds(db)
-          };
+          const waiting = await queryWaitingIds(dbClient.run);
+          if (wantsWaiting()) {
+            snapshot = {
+              ...snapshot,
+              waiting
+            };
+            waitingLoaded = true;
+          }
         } catch {
           // Keep the previous waiting set when the local store is unavailable.
-        } finally {
-          db.close();
         }
+      } else if (!wantsWaiting()) {
+        snapshot = {
+          ...snapshot,
+          waiting: new Map()
+        };
+        waitingLoaded = false;
       }
-      for (const listener of listeners) listener(snapshot);
+      for (const listener of [...listeners.keys()]) listener(snapshot);
     })().finally(() => {
       inFlight = undefined;
     });
   };
-  return listener => {
-    listeners.add(listener);
+  return (listener, options = {}) => {
+    const needsWaiting = options.waiting === true;
+    listeners.set(listener, needsWaiting);
     listener(snapshot);
     if (!clock) {
       load();
       clock = setInterval(load, POLL_MS);
+    } else if (needsWaiting && !waitingLoaded) {
+      load();
     }
     return () => {
       listeners.delete(listener);
@@ -770,8 +883,8 @@ WHERE COALESCE(s.time_archived, 0) = 0
       WHERE live.session_id = s.id AND live.status = 'running' AND live.created < ${stuckBefore})
       AND ${NO_RECENT_ACTIVITY("s.id", stuckBefore)}))
 ORDER BY s.time_updated DESC`;
-async function queryWaitingIds(db) {
-  const rows = db.query(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS)).all() ?? [];
+async function queryWaitingIds(run) {
+  const rows = await run(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS));
   const out = new Map();
   for (const row of rows) {
     if (typeof row?.id === "string" && SESSION_ID_PATTERN.test(row.id) && (row.reason === "question" || row.reason === "stuck")) {
@@ -783,8 +896,8 @@ async function queryWaitingIds(db) {
 // The shared needs-input query decides *which* sessions are waiting. Read the
 // oldest still-unanswered question or stuck tool for each result so triage can
 // show how long it has waited, rather than its last (unrelated) update time.
-async function queryWaitingDetails(db) {
-  const reasons = await queryWaitingIds(db);
+async function queryWaitingDetails(run) {
+  const reasons = await queryWaitingIds(run);
   const details = new Map([...reasons].map(([id, reason]) => [id, {
     reason: reason
   }]));
@@ -792,12 +905,12 @@ async function queryWaitingDetails(db) {
   const cutoff = Date.now() - STUCK_AFTER_MS;
   for (let i = 0; i < ids.length; i += 200) {
     const batch = ids.slice(i, i + 200);
-    const rows = db.query(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
+    const rows = await run(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
 SELECT live.session_id AS id,
   MIN(CASE WHEN ${QUESTION_OPEN} THEN live.created END) AS question_since,
   MIN(CASE WHEN live.status = 'running' AND live.created < ${cutoff} THEN live.created END) AS stuck_since
 FROM live
-GROUP BY live.session_id`).all(...batch) ?? [];
+GROUP BY live.session_id`, batch);
     for (const row of rows) {
       const detail = details.get(row.id);
       if (!detail) continue;
@@ -1212,6 +1325,8 @@ function SidebarSessions(props) {
     setEntries(snapshot.entries);
     setLoadFailed(snapshot.failed);
     setWaiting(snapshot.waiting);
+  }, {
+    waiting: true
   })));
   const filteredEntries = createMemo(() => {
     const q = query().trim().toLowerCase();
@@ -2729,21 +2844,14 @@ const tui = async api => {
     const [waitingCoverage, setWaitingCoverage] = createSignal("loading");
     let alive = true;
     void (async () => {
-      const db = await openTranscriptDb();
-      if (!db) {
-        if (alive) setWaitingCoverage("unavailable");
-        return;
-      }
       try {
-        const ids = await queryWaitingIds(db);
+        const ids = await queryWaitingIds(dbClient.run);
         if (alive) {
           setWaitingIds(new Set(ids.keys()));
           setWaitingCoverage("ready");
         }
       } catch {
         if (alive) setWaitingCoverage("unavailable");
-      } finally {
-        db.close();
       }
     })();
     const [pendingDelete, setPendingDelete] = createSignal();
@@ -3904,20 +4012,16 @@ const tui = async api => {
       const {
         entries
       } = await fetchEntries(api);
-      const db = await openTranscriptDb();
-      if (!db) {
+      let waiting;
+      try {
+        waiting = await queryWaitingDetails(dbClient.run);
+      } catch {
         api.ui.toast({
           message: "Needs-input data unavailable",
           variant: "error"
         });
         return;
       }
-      let waiting;
-      try {
-        waiting = await queryWaitingDetails(db);
-      } finally {
-        db.close();
-      }
       items = entries.filter(entry => waiting.has(entry.id)).map(entry => ({
         entry,
         reason: waiting.get(entry.id)?.reason === "question" ? "awaiting answer" : "run stuck",
@@ -4471,6 +4575,7 @@ export default Plugin.define({
       if (api.ui.dialog.open) api.ui.dialog.clear();
       disposeSlot();
       removeRootMouse?.();
+      dbClient.close();
     };
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sesh",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "OpenCode session browser: search, preview, and resume every session across every project from the terminal or TUI.",
   "type": "module",
   "license": "MIT",
@@ -57,8 +57,9 @@
     "build": "node scripts/build-tui.mjs",
     "prepack": "node scripts/build-tui.mjs",
     "test": "bun run test:unit && bash tests/changelog.sh",
-    "test:unit": "node scripts/build-tui.mjs && bun run test:tui-home && bash tests/sesh.sh && bash tests/install.sh",
+    "test:unit": "node scripts/build-tui.mjs && bun run test:tui-home && bun run test:tui-worker && bash tests/sesh.sh && bash tests/install.sh",
     "test:tui-home": "bun --conditions=browser tests/tui-home.mjs",
+    "test:tui-worker": "bun tests/tui-worker.mjs",
     "test:changelog": "bash tests/changelog.sh",
     "test:picker": "python3 tests/picker.py",
     "typecheck": "tsc --noEmit",

package/tui-plugins/sesh-panel/tui.tsx

@@ -537,14 +537,105 @@ async function openTranscriptDb(): Promise<any | undefined> {
   }
 }
 
+// Runs in a blob Worker so slow queries never block the TUI thread. The
+// connection opens on the first request and stays open; `loadSqlite` is
+// injected only by tests.
+const DB_WORKER_SOURCE = `
+let opening
+const load = typeof loadSqlite === "function" ? loadSqlite : () => import("bun:sqlite")
+const open = (path) => opening ??= load().then((sqlite) => new sqlite.Database(path, { readonly: true }), (error) => { opening = undefined; throw error })
+self.onmessage = async (event) => {
+  const { id, path, sql, params } = event.data
+  try {
+    const db = await open(path)
+    self.postMessage({ id, rows: db.query(sql).all(...(params ?? [])) })
+  } catch (error) {
+    self.postMessage({ id, error: String(error?.message ?? error) })
+  }
+}`
+
+const DB_QUERY_TIMEOUT_MS = 30000
+
+type DbRun = (sql: string, params?: unknown[]) => Promise<unknown[]>
+
+function createDbWorker(): any {
+  return new (globalThis as any).Worker(URL.createObjectURL(new Blob([DB_WORKER_SOURCE], { type: "text/javascript" })))
+}
+
+// Read-only queries against the local store, served by one lazily started
+// worker. Any failure (no worker, no bun:sqlite, query error, timeout) rejects;
+// a timeout or worker error discards the worker so the next call starts afresh.
+function createDbClient(createWorker: () => any = createDbWorker, timeoutMs = DB_QUERY_TIMEOUT_MS) {
+  type Pending = { resolve: (rows: unknown[]) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> }
+  let worker: any
+  let nextId = 0
+  const pending = new Map<number, Pending>()
+  const reset = (error: Error) => {
+    const dead = worker
+    worker = undefined
+    try { dead?.terminate() } catch {}
+    const requests = [...pending.values()]
+    pending.clear()
+    for (const request of requests) {
+      clearTimeout(request.timer)
+      request.reject(error)
+    }
+  }
+  const start = () => {
+    const created = createWorker()
+    created.onmessage = (event: any) => {
+      const { id, rows, error } = event?.data ?? {}
+      const request = pending.get(id)
+      if (!request) return
+      pending.delete(id)
+      clearTimeout(request.timer)
+      if (typeof error === "string") request.reject(new Error(error))
+      else request.resolve(Array.isArray(rows) ? rows : [])
+    }
+    created.onerror = (event: any) => {
+      event?.preventDefault?.()
+      if (worker === created) reset(new Error(String(event?.message ?? "local store worker failed")))
+    }
+    created.unref?.()
+    return created
+  }
+  const run: DbRun = (sql, params = []) =>
+    new Promise((resolve, reject) => {
+      try {
+        worker ??= start()
+      } catch (error) {
+        reject(error)
+        return
+      }
+      const id = ++nextId
+      const timer = setTimeout(() => reset(new Error("local store query timed out")), timeoutMs)
+      ;(timer as any).unref?.()
+      pending.set(id, { resolve, reject, timer })
+      try {
+        worker.postMessage({ id, path: resolveDbPath(), sql, params })
+      } catch (error) {
+        reset(error as Error)
+      }
+    })
+  return { run, close: () => reset(new Error("local store closed")) }
+}
+
+const dbClient = createDbClient()
+
 type SessionSnapshot = { entries: Entry[]; waiting: Map<string, string>; failed: boolean }
 
 function createSessionPoll(api: TuiPluginApi, refreshPins: () => void) {
-  const listeners = new Set<(snapshot: SessionSnapshot) => void>()
+  // Listener -> whether it reads `snapshot.waiting`. The needs-input query
+  // costs worker CPU on every poll, so it only runs while such a listener exists.
+  const listeners = new Map<(snapshot: SessionSnapshot) => void, boolean>()
   let snapshot: SessionSnapshot = { entries: [], waiting: new Map(), failed: false }
   let clock: ReturnType<typeof setInterval> | undefined
   let inFlight: Promise<void> | undefined
+  // Whether `snapshot.waiting` came from a poll that ran the query; a poll
+  // without waiting listeners clears it so a later subscriber never sees a stale set.
+  let waitingLoaded = false
   const active = () => listeners.size > 0
+  const wantsWaiting = () => [...listeners.values()].some(Boolean)
   const load = () => {
     if (inFlight || !active()) return
     inFlight = (async () => {
@@ -563,25 +654,32 @@ function createSessionPoll(api: TuiPluginApi, refreshPins: () => void) {
         snapshot = { ...snapshot, failed: true }
       }
       if (!active()) return
-      const db = await openTranscriptDb()
-      if (db) {
+      if (wantsWaiting()) {
         try {
-          if (active()) snapshot = { ...snapshot, waiting: await queryWaitingIds(db) }
+          const waiting = await queryWaitingIds(dbClient.run)
+          if (wantsWaiting()) {
+            snapshot = { ...snapshot, waiting }
+            waitingLoaded = true
+          }
         } catch {
           // Keep the previous waiting set when the local store is unavailable.
-        } finally {
-          db.close()
         }
+      } else if (!wantsWaiting()) {
+        snapshot = { ...snapshot, waiting: new Map() }
+        waitingLoaded = false
       }
-      for (const listener of listeners) listener(snapshot)
+      for (const listener of [...listeners.keys()]) listener(snapshot)
     })().finally(() => { inFlight = undefined })
   }
-  return (listener: (snapshot: SessionSnapshot) => void) => {
-    listeners.add(listener)
+  return (listener: (snapshot: SessionSnapshot) => void, options: { waiting?: boolean } = {}) => {
+    const needsWaiting = options.waiting === true
+    listeners.set(listener, needsWaiting)
     listener(snapshot)
     if (!clock) {
       load()
       clock = setInterval(load, POLL_MS)
+    } else if (needsWaiting && !waitingLoaded) {
+      load()
     }
     return () => {
       listeners.delete(listener)
@@ -659,8 +757,8 @@ WHERE COALESCE(s.time_archived, 0) = 0
       AND ${NO_RECENT_ACTIVITY("s.id", stuckBefore)}))
 ORDER BY s.time_updated DESC`
 
-async function queryWaitingIds(db: any): Promise<Map<string, string>> {
-  const rows = (db.query(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS)).all() ?? []) as {
+async function queryWaitingIds(run: DbRun): Promise<Map<string, string>> {
+  const rows = (await run(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS))) as {
     id: unknown
     reason: unknown
   }[]
@@ -682,8 +780,8 @@ type WaitingDetail = { reason: "question" | "stuck"; since?: number }
 // The shared needs-input query decides *which* sessions are waiting. Read the
 // oldest still-unanswered question or stuck tool for each result so triage can
 // show how long it has waited, rather than its last (unrelated) update time.
-async function queryWaitingDetails(db: any): Promise<Map<string, WaitingDetail>> {
-  const reasons = await queryWaitingIds(db)
+async function queryWaitingDetails(run: DbRun): Promise<Map<string, WaitingDetail>> {
+  const reasons = await queryWaitingIds(run)
   const details = new Map<string, WaitingDetail>(
     [...reasons].map(([id, reason]) => [id, { reason: reason as WaitingDetail["reason"] }]),
   )
@@ -691,12 +789,12 @@ async function queryWaitingDetails(db: any): Promise<Map<string, WaitingDetail>>
   const cutoff = Date.now() - STUCK_AFTER_MS
   for (let i = 0; i < ids.length; i += 200) {
     const batch = ids.slice(i, i + 200)
-    const rows = (db.query(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
+    const rows = (await run(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
 SELECT live.session_id AS id,
   MIN(CASE WHEN ${QUESTION_OPEN} THEN live.created END) AS question_since,
   MIN(CASE WHEN live.status = 'running' AND live.created < ${cutoff} THEN live.created END) AS stuck_since
 FROM live
-GROUP BY live.session_id`).all(...batch) ?? []) as { id: string; question_since: number | null; stuck_since: number | null }[]
+GROUP BY live.session_id`, batch)) as { id: string; question_since: number | null; stuck_since: number | null }[]
     for (const row of rows) {
       const detail = details.get(row.id)
       if (!detail) continue
@@ -1098,7 +1196,7 @@ function SidebarSessions(props: { api: TuiPluginApi } & PinProps) {
     setEntries(snapshot.entries)
     setLoadFailed(snapshot.failed)
     setWaiting(snapshot.waiting)
-  })))
+  }, { waiting: true })))
 
   const filteredEntries = createMemo(() => {
     const q = query().trim().toLowerCase()
@@ -2212,21 +2310,14 @@ const tui: TuiPlugin = async (api) => {
     const [waitingCoverage, setWaitingCoverage] = createSignal<"loading" | "ready" | "unavailable">("loading")
     let alive = true
     void (async () => {
-      const db = await openTranscriptDb()
-      if (!db) {
-        if (alive) setWaitingCoverage("unavailable")
-        return
-      }
       try {
-        const ids = await queryWaitingIds(db)
+        const ids = await queryWaitingIds(dbClient.run)
         if (alive) {
           setWaitingIds(new Set(ids.keys()))
           setWaitingCoverage("ready")
         }
       } catch {
         if (alive) setWaitingCoverage("unavailable")
-      } finally {
-        db.close()
       }
     })()
     const [pendingDelete, setPendingDelete] = createSignal<Entry>()
@@ -3044,16 +3135,12 @@ const tui: TuiPlugin = async (api) => {
     let items: { entry: Entry; reason: string; since?: number }[] = []
     try {
       const { entries } = await fetchEntries(api)
-      const db = await openTranscriptDb()
-      if (!db) {
-        api.ui.toast({ message: "Needs-input data unavailable", variant: "error" })
-        return
-      }
       let waiting: Map<string, WaitingDetail>
       try {
-        waiting = await queryWaitingDetails(db)
-      } finally {
-        db.close()
+        waiting = await queryWaitingDetails(dbClient.run)
+      } catch {
+        api.ui.toast({ message: "Needs-input data unavailable", variant: "error" })
+        return
       }
       items = entries
         .filter((entry) => waiting.has(entry.id))
@@ -3506,6 +3593,7 @@ export default Plugin.define({
       if (api.ui.dialog.open) api.ui.dialog.clear()
       disposeSlot()
       removeRootMouse?.()
+      dbClient.close()
     }
   },
 })