@rei-standard/amsg-sw 2.1.0-next.3 → 2.1.0

package/README.md

@@ -39,13 +39,62 @@ navigator.serviceWorker.addEventListener('message', (e) => {
 });
 ```
 
+### 通知显示策略 (Notification Rendering)
+
+默认情况下：
+- `content` 和老式 payload：自动弹系统通知。
+- `reasoning` / `tool_request` / `error`：不弹通知，只触发 client 事件。
+
+通过 `payload.notification.show`，你可以显式覆盖这个默认行为。此字段由服务端或产生 payload 时指定：
+
+- `"auto"` 或不传：保持默认行为。
+- `"always"`：强制弹系统通知，无视 `messageKind`。
+- `"when-hidden"`：仅当没有 `visibilityState === "visible"` 的客户端时才弹系统通知。如果应用在前台，则静默。
+- `false`：强制不弹通知，即使是 `content`。适合完全交给应用自行接管或自绘弹窗的场景。
+
+当设置了弹通知时，通知文案完全由 `payload.notification` 决定（支持 `title`, `body`, `icon`, `badge`, `tag`, `data` 等字段）。如果缺省，会后备到 payload 根级属性。
+
+#### 场景示例
+
+**1. tool_request 需要用户处理**
+某些 Agent loop 跑到 `tool_request` 时需要用户在界面上确认或执行。由于默认 `tool_request` 不弹通知，用户如果在后台可能会漏掉：
+
+```json
+{
+  "messageKind": "tool_request",
+  "sessionId": "...",
+  "toolCalls": [],
+  "notification": {
+    "show": "when-hidden",
+    "title": "需要继续处理",
+    "body": "点开应用继续完成工具调用"
+  }
+}
+```
+
+**2. Content 消息完全由前端接管**
+应用层想在页面前台做非常定制的 Toast，不想弹系统级别通知：
+
+```json
+{
+  "messageKind": "content",
+  "message": "...",
+  "notification": {
+    "show": false
+  }
+}
+```
+
+> **注意：对于 multipart 传输**
+> 当 payload 通过 `_multipart` 分片时，未收齐前不仅不派发业务事件，也**绝不**弹系统通知。收齐并还原为原始 payload 后，再按原始 payload 的 `notification.show` 策略执行判定。
+
 ### Blob envelope
 
 当 `amsg-instant` 检测到 payload 超过 `maxInlineBytes` 时会改发 blob envelope `{ _blob: true, key, url, messageKind?, type? }`。SW **不会** 自动 fetch blob 内容（那是 client 的职责），但仍然会按 envelope 上的 `messageKind` 分发对应事件，让 client 知道有什么类型的内容即将到达，自己决定要不要拉取。Blob envelope 也只在 `messageKind === 'content'`（或缺失）时才渲染占位通知，与普通 push 行为一致。
 
-### Generic multipart transport（next）
+### Generic multipart transport（2.1.0+）
 
-next 阶段移除了旧 reasoning 专用 `chunkIndex` / `totalChunks` wire format。现在 `_multipart` 是统一 transport kind，任何原始 payload 都可以被包起来：
+2.1.0 移除了旧 reasoning 专用 `chunkIndex` / `totalChunks` wire format。现在 `_multipart` 是统一 transport kind，任何原始 payload 都可以被包起来：
 
 ```json
 {
@@ -79,7 +128,7 @@ installReiSW(self, {
     maxChunks: 128,
     cleanupIntervalMs: 15 * 60_000
   },
-  // （新增于 2.1.0-next.3）离线持久化等业务拦截钩子：
+  // （新增于 2.1.0）离线持久化等业务拦截钩子：
   onBusinessPayload: async (payload) => {
     // 收到完整 payload 时触发，由于内置在 event.waitUntil 中，能够确保离线写库完毕再允许 SW 休眠
     // await db.saveIncomingMessage(payload);
@@ -101,8 +150,8 @@ TTL 到期仍未收齐时，SW 会清理 pending 并广播：
 
 ### 升级注意事项
 
-- 想给 `reasoning` / `tool_request` / `error` 也弹通知的业务：必须自行在 app 内监听上面的 postMessage 事件、调 `Notification` 或 `registration.showNotification`。SW 默认不再为它们弹通知。
-- 应用级 SW 可以删除旧 reasoning `chunkIndex` / `totalChunks` 拼接逻辑；next 版本只会把完整还原后的 reasoning payload 发给 client。
+- 想给 `reasoning` / `tool_request` / `error` 弹通知的业务：SW 默认不再为它们弹通知，但可以通过设置 `payload.notification.show = "always"` 或 `"when-hidden"` 来让 SW 在包层直接弹通知。无需再强求在 app 内自绘。
+- 应用级 SW 可以删除旧 reasoning `chunkIndex` / `totalChunks` 拼接逻辑；2.1.0+ 版本只会把完整还原后的 reasoning payload 发给 client。
 - 客户端代码继续兼容只有 `installReiSW` + `REI_SW_MESSAGE_TYPE`（队列）的 2.0.x 写法——新增导出不破坏既有 API。
 - 想拿到 push 类型相关的 TS 类型：从 `@rei-standard/amsg-shared` 引 `AmsgPush` 等类型（本包通过 JSDoc 引用同一份类型）。
 

package/dist/index.cjs

@@ -25,11 +25,14 @@ __export(src_exports, {
   installReiSW: () => installReiSW
 });
 module.exports = __toCommonJS(src_exports);
+var import_amsg_shared = require("@rei-standard/amsg-shared");
 var REI_SW_DB_NAME = "rei-sw";
 var REI_SW_DB_STORE = "request-outbox";
 var REI_SW_MULTIPART_STORE = "multipart-pending";
 var REI_SW_MULTIPART_DONE_STORE = "multipart-done";
-var REI_SW_DB_VERSION = 2;
+var REI_SW_MULTIPART_CHUNK_STORE = "multipart-chunk";
+var REI_SW_DB_VERSION = 3;
+var cachedDB = null;
 var REI_SW_SYNC_TAG = "rei-sw-flush-request-outbox";
 var MULTIPART_MESSAGE_KIND = "_multipart";
 var MULTIPART_ENCODING = "json-utf8-base64url";
@@ -42,6 +45,7 @@ var DEFAULT_MULTIPART_OPTIONS = Object.freeze({
 });
 var memoryMultipartPending = /* @__PURE__ */ new Map();
 var memoryMultipartDone = /* @__PURE__ */ new Map();
+var memoryMultipartChunks = /* @__PURE__ */ new Map();
 var REI_AMSG_POSTMESSAGE_TYPE = "REI_AMSG_PUSH";
 var REI_SW_EVENT = Object.freeze({
   CONTENT_RECEIVED: "rei-amsg-content-received",
@@ -110,8 +114,27 @@ async function handlePushPayload(sw, payload, ctx) {
 }
 async function dispatchBusinessPayload(sw, payload, defaults) {
   const eventName = resolveEventName(payload);
-  const shouldRenderNotification = isNotificationKind(payload);
-  const work = [dispatchPushToClients(sw, eventName, payload)];
+  let clientList = [];
+  try {
+    clientList = await sw.clients.matchAll({
+      type: "window",
+      includeUncontrolled: true
+    });
+  } catch (_matchError) {
+  }
+  let shouldRenderNotification = false;
+  const showOpt = payload && payload.notification ? payload.notification.show : void 0;
+  if (showOpt === "always") {
+    shouldRenderNotification = true;
+  } else if (showOpt === "when-hidden") {
+    const hasVisibleClient = clientList.some((client) => client.visibilityState === "visible");
+    shouldRenderNotification = !hasVisibleClient;
+  } else if (showOpt === false) {
+    shouldRenderNotification = false;
+  } else {
+    shouldRenderNotification = isNotificationKind(payload);
+  }
+  const work = [dispatchPushToClients(sw, eventName, payload, clientList)];
   if (shouldRenderNotification) {
     const notification = createNotificationFromPayload(payload, defaults);
     if (notification) {
@@ -137,13 +160,13 @@ async function dispatchBusinessPayload(sw, payload, defaults) {
 function resolveEventName(payload) {
   const kind = payload && typeof payload === "object" ? payload.messageKind : void 0;
   switch (kind) {
-    case "content":
+    case import_amsg_shared.MESSAGE_KIND.CONTENT:
       return REI_SW_EVENT.CONTENT_RECEIVED;
-    case "reasoning":
+    case import_amsg_shared.MESSAGE_KIND.REASONING:
       return REI_SW_EVENT.REASONING_RECEIVED;
-    case "tool_request":
+    case import_amsg_shared.MESSAGE_KIND.TOOL_REQUEST:
       return REI_SW_EVENT.TOOL_REQUEST_RECEIVED;
-    case "error":
+    case import_amsg_shared.MESSAGE_KIND.ERROR:
       return REI_SW_EVENT.ERROR_RECEIVED;
     default:
       return REI_SW_EVENT.UNKNOWN_RECEIVED;
@@ -153,11 +176,11 @@ function isNotificationKind(payload) {
   if (!payload || typeof payload !== "object") return false;
   const kind = payload.messageKind;
   if (kind === void 0 || kind === null) return true;
-  return kind === "content";
+  return kind === import_amsg_shared.MESSAGE_KIND.CONTENT;
 }
-async function dispatchPushToClients(sw, eventName, payload) {
+async function dispatchPushToClients(sw, eventName, payload, preFetchedClientList = null) {
   try {
-    const clientList = await sw.clients.matchAll({
+    const clientList = preFetchedClientList || await sw.clients.matchAll({
       type: "window",
       includeUncontrolled: true
     });
@@ -199,9 +222,9 @@ function createNotificationFromPayload(payload, defaults) {
     };
   }
   const pushNotification = payload.notification && typeof payload.notification === "object" ? payload.notification : {};
-  const title = pushNotification.title || payload.title || payload.contactName && `\u6765\u81EA ${payload.contactName}` || "New notification";
+  const title = pushNotification.title || payload.title || payload.contactName || "New notification";
   const body = pushNotification.body || payload.body || payload.message || "";
-  const data = payload.data && typeof payload.data === "object" ? { ...payload.data } : {};
+  const data = pushNotification.data && typeof pushNotification.data === "object" ? { ...pushNotification.data } : payload.data && typeof payload.data === "object" ? { ...payload.data } : {};
   if (data.payload == null) data.payload = payload;
   return {
     title,
@@ -269,34 +292,43 @@ async function acceptMultipartChunk(sw, payload, options) {
     total: normalized.total,
     originalMessageKind: normalized.originalMessageKind,
     encoding: normalized.encoding,
-    chunks: {},
+    receivedCount: 0,
     receivedBytes: 0
   };
   if (base.total !== normalized.total || base.encoding !== normalized.encoding) {
     await deleteMultipartPending(normalized.id);
+    await deleteMultipartChunks(normalized.id, base.total);
     return null;
   }
-  if (base.chunks[String(normalized.index)] !== void 0) {
-    return null;
-  }
-  base.chunks[String(normalized.index)] = normalized.chunk;
+  const chunkId = `${normalized.id}_${normalized.index}`;
+  const chunkExists = await hasMultipartChunk(chunkId);
+  if (chunkExists) return null;
+  base.receivedCount++;
   base.receivedBytes = positiveIntegerOrDefault(base.receivedBytes, 0) + normalized.chunkBytes.byteLength;
   if (base.receivedBytes > options.maxTotalBytes) {
     await deleteMultipartPending(normalized.id);
+    await deleteMultipartChunks(normalized.id, base.total);
     return null;
   }
-  const received = Object.keys(base.chunks).length;
-  if (received < base.total) {
+  await writeMultipartChunk({
+    id_index: chunkId,
+    id: normalized.id,
+    index: normalized.index,
+    chunk: normalized.chunk
+  });
+  if (base.receivedCount < base.total) {
     await writeMultipartPending(base);
     return null;
   }
   await deleteMultipartPending(base.id);
   let restored;
   try {
-    restored = restoreMultipartPayload(base, options);
+    restored = await restoreMultipartPayload(base, options);
   } catch (_error) {
+    await deleteMultipartChunks(base.id, base.total);
     return null;
   }
+  await deleteMultipartChunks(base.id, base.total);
   const doneTtlMs = Math.max(base.ttlMs * 2, base.ttlMs + 1);
   await writeMultipartDone({
     id: base.id,
@@ -314,8 +346,9 @@ function normalizeMultipartChunk(payload, options) {
   if (meta.index <= 0 || meta.index > meta.total) return null;
   let chunkBytes;
   try {
-    chunkBytes = base64UrlToBytes(payload.chunk);
+    chunkBytes = (0, import_amsg_shared.base64UrlToBytes)(payload.chunk);
   } catch (_error) {
+    console.error("RESTORE ERROR", _error);
     return null;
   }
   const now = Date.now();
@@ -338,22 +371,22 @@ function normalizeMultipartChunk(payload, options) {
     chunkBytes
   };
 }
-function restoreMultipartPayload(record, options) {
+async function restoreMultipartPayload(record, options) {
   const chunks = [];
   let totalBytes = 0;
   for (let index = 1; index <= record.total; index++) {
-    const chunk = record.chunks[String(index)];
-    if (typeof chunk !== "string") {
+    const chunkRecord = await readMultipartChunk(record.id, index);
+    if (!chunkRecord || typeof chunkRecord.chunk !== "string") {
       throw new Error("[rei-standard-amsg-sw] multipart missing chunk");
     }
-    const bytes = base64UrlToBytes(chunk);
+    const bytes = (0, import_amsg_shared.base64UrlToBytes)(chunkRecord.chunk);
     totalBytes += bytes.byteLength;
     if (totalBytes > options.maxTotalBytes) {
       throw new Error("[rei-standard-amsg-sw] multipart payload exceeds maxTotalBytes");
     }
     chunks.push(bytes);
   }
-  const json = new TextDecoder("utf-8", { fatal: false }).decode(concatBytes(chunks));
+  const json = new TextDecoder("utf-8", { fatal: false }).decode((0, import_amsg_shared.concatBytes)(...chunks));
   return JSON.parse(json);
 }
 async function maybeCleanupMultipart(sw, ctx) {
@@ -365,50 +398,62 @@ async function maybeCleanupMultipart(sw, ctx) {
   try {
     await cleanupMultipartStores(sw, now);
   } catch (_error) {
+    console.error("RESTORE ERROR", _error);
   }
 }
 async function cleanupMultipartStores(sw, now) {
-  const pending = await listMultipartPending();
-  for (const record of pending) {
-    if (record.expiresAt > now) continue;
-    await deleteMultipartPending(record.id);
+  if (!hasIndexedDB()) {
+    for (const [id, record] of memoryMultipartPending.entries()) {
+      if (record.expiresAt <= now) {
+        memoryMultipartPending.delete(id);
+        await deleteMultipartChunks(id, record.total);
+        await dispatchMultipartExpired(sw, record);
+      }
+    }
+    for (const [id, record] of memoryMultipartDone.entries()) {
+      if (record.expiresAt <= now) {
+        memoryMultipartDone.delete(id);
+      }
+    }
+    return;
+  }
+  const pendingExpired = await withDatabaseStore(REI_SW_MULTIPART_STORE, "readonly", (store, resolve, reject) => {
+    const index = store.index("expiresAt");
+    const range = IDBKeyRange.upperBound(now);
+    const req = index.getAll(range);
+    req.onsuccess = () => resolve(req.result || []);
+    req.onerror = () => reject(req.error);
+  });
+  for (const record of pendingExpired) {
+    await deleteStoreRecord(REI_SW_MULTIPART_STORE, record.id);
+    await deleteMultipartChunks(record.id, record.total);
     await dispatchMultipartExpired(sw, record);
   }
-  const done = await listMultipartDone();
-  for (const record of done) {
-    if (record.expiresAt <= now) {
-      await deleteMultipartDone(record.id);
+  const doneExpiredKeys = await withDatabaseStore(REI_SW_MULTIPART_DONE_STORE, "readonly", (store, resolve, reject) => {
+    const index = store.index("expiresAt");
+    const range = IDBKeyRange.upperBound(now);
+    if (index.getAllKeys) {
+      const req = index.getAllKeys(range);
+      req.onsuccess = () => resolve(req.result || []);
+      req.onerror = () => reject(req.error);
+    } else {
+      const req = index.getAll(range);
+      req.onsuccess = () => resolve((req.result || []).map((r) => r.id));
+      req.onerror = () => reject(req.error);
     }
+  });
+  for (const id of doneExpiredKeys) {
+    await deleteStoreRecord(REI_SW_MULTIPART_DONE_STORE, id);
   }
 }
 async function dispatchMultipartExpired(sw, record) {
   await dispatchPushToClients(sw, REI_SW_EVENT.MULTIPART_EXPIRED, {
     id: record.id,
-    received: record.chunks && typeof record.chunks === "object" ? Object.keys(record.chunks).length : 0,
+    received: typeof record.receivedCount === "number" ? record.receivedCount : 0,
     total: record.total,
     originalMessageKind: record.originalMessageKind
   });
 }
-function base64UrlToBytes(input) {
-  const s = String(input).replace(/-/g, "+").replace(/_/g, "/");
-  const pad = (4 - s.length % 4) % 4;
-  const padded = s + "=".repeat(pad);
-  const bin = typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("binary");
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
-function concatBytes(chunks) {
-  let total = 0;
-  for (const chunk of chunks) total += chunk.byteLength;
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return out;
-}
 async function enqueueAndFlush(sw, event, requestPayload) {
   try {
     const request = normalizeQueuedRequest(requestPayload);
@@ -468,6 +513,7 @@ function normalizeRequestBody(bodyInput) {
   try {
     return JSON.stringify(bodyInput);
   } catch (_error) {
+    console.error("RESTORE ERROR", _error);
     throw new Error("[rei-standard-amsg-sw] request body is not serializable");
   }
 }
@@ -494,6 +540,7 @@ async function trySendQueuedRequest(queuedRequest) {
     }
     return false;
   } catch (_error) {
+    console.error("RESTORE ERROR", _error);
     return false;
   }
 }
@@ -503,6 +550,7 @@ async function registerFlushSync(sw) {
   try {
     await syncManager.register(REI_SW_SYNC_TAG);
   } catch (_error) {
+    console.error("RESTORE ERROR", _error);
   }
 }
 function respondToSender(event, message) {
@@ -525,9 +573,6 @@ function writeMultipartPending(record) {
 function deleteMultipartPending(id) {
   return deleteStoreRecord(REI_SW_MULTIPART_STORE, id);
 }
-function listMultipartPending() {
-  return listStoreRecords(REI_SW_MULTIPART_STORE);
-}
 function readMultipartDone(id) {
   return readStoreRecord(REI_SW_MULTIPART_DONE_STORE, id);
 }
@@ -537,8 +582,54 @@ function writeMultipartDone(record) {
 function deleteMultipartDone(id) {
   return deleteStoreRecord(REI_SW_MULTIPART_DONE_STORE, id);
 }
-function listMultipartDone() {
-  return listStoreRecords(REI_SW_MULTIPART_DONE_STORE);
+async function hasMultipartChunk(id_index) {
+  if (!hasIndexedDB()) return memoryMultipartChunks.has(id_index);
+  return withDatabaseStore(REI_SW_MULTIPART_CHUNK_STORE, "readonly", (store, resolve, reject) => {
+    const request = store.count(id_index);
+    request.onsuccess = () => resolve(request.result > 0);
+    request.onerror = () => reject(request.error);
+  });
+}
+function writeMultipartChunk(record) {
+  if (!hasIndexedDB()) {
+    memoryMultipartChunks.set(record.id_index, cloneRecord(record));
+    return Promise.resolve();
+  }
+  return putStoreRecord(REI_SW_MULTIPART_CHUNK_STORE, record);
+}
+function readMultipartChunk(id, index) {
+  const id_index = `${id}_${index}`;
+  if (!hasIndexedDB()) {
+    return Promise.resolve(cloneRecord(memoryMultipartChunks.get(id_index) || null));
+  }
+  return readStoreRecord(REI_SW_MULTIPART_CHUNK_STORE, id_index);
+}
+async function deleteMultipartChunks(id, total) {
+  if (!hasIndexedDB()) {
+    for (let index = 1; index <= total; index++) {
+      memoryMultipartChunks.delete(`${id}_${index}`);
+    }
+    return;
+  }
+  return withDatabaseStore(REI_SW_MULTIPART_CHUNK_STORE, "readwrite", (store, resolve, reject) => {
+    let pending = total;
+    let failed = false;
+    for (let index = 1; index <= total; index++) {
+      const request = store.delete(`${id}_${index}`);
+      request.onsuccess = () => {
+        if (failed) return;
+        pending--;
+        if (pending === 0) resolve(void 0);
+      };
+      request.onerror = () => {
+        if (!failed) {
+          failed = true;
+          reject(request.error);
+        }
+      };
+    }
+    if (total === 0) resolve(void 0);
+  });
 }
 async function readStoreRecord(storeName, id) {
   if (!hasIndexedDB()) {
@@ -572,28 +663,14 @@ async function deleteStoreRecord(storeName, id) {
     request.onerror = () => reject(request.error || new Error(`Failed to delete ${storeName}`));
   });
 }
-async function listStoreRecords(storeName) {
-  if (!hasIndexedDB()) {
-    return Array.from(memoryStoreFor(storeName).values()).map(cloneRecord);
-  }
-  return withDatabaseStore(storeName, "readonly", (store, resolve, reject) => {
-    const request = store.getAll();
-    request.onsuccess = () => resolve(Array.isArray(request.result) ? request.result : []);
-    request.onerror = () => reject(request.error || new Error(`Failed to list ${storeName}`));
-  });
-}
 async function withDatabaseStore(storeName, mode, handler) {
   const db = await openQueueDatabase();
-  try {
-    return await new Promise((resolve, reject) => {
-      const transaction = db.transaction(storeName, mode);
-      const store = transaction.objectStore(storeName);
-      transaction.onerror = () => reject(transaction.error || new Error("Database transaction failed"));
-      Promise.resolve(handler(store, resolve, reject)).catch(reject);
-    });
-  } finally {
-    db.close();
-  }
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction(storeName, mode);
+    const store = transaction.objectStore(storeName);
+    transaction.onerror = () => reject(transaction.error || new Error("Database transaction failed"));
+    Promise.resolve(handler(store, resolve, reject)).catch(reject);
+  });
 }
 function hasIndexedDB() {
   return typeof indexedDB !== "undefined" && indexedDB && typeof indexedDB.open === "function";
@@ -601,6 +678,7 @@ function hasIndexedDB() {
 function memoryStoreFor(storeName) {
   if (storeName === REI_SW_MULTIPART_DONE_STORE) return memoryMultipartDone;
   if (storeName === REI_SW_MULTIPART_STORE) return memoryMultipartPending;
+  if (storeName === REI_SW_MULTIPART_CHUNK_STORE) return memoryMultipartChunks;
   throw new Error(`[rei-standard-amsg-sw] unknown memory store: ${storeName}`);
 }
 function cloneRecord(record) {
@@ -608,35 +686,47 @@ function cloneRecord(record) {
   return JSON.parse(JSON.stringify(record));
 }
 function openQueueDatabase() {
+  if (cachedDB) return Promise.resolve(cachedDB);
   return new Promise((resolve, reject) => {
     const request = indexedDB.open(REI_SW_DB_NAME, REI_SW_DB_VERSION);
     request.onupgradeneeded = () => {
       const db = request.result;
-      createObjectStoreIfMissing(db, REI_SW_DB_STORE, { keyPath: "id", autoIncrement: true });
-      createObjectStoreIfMissing(db, REI_SW_MULTIPART_STORE, { keyPath: "id" });
-      createObjectStoreIfMissing(db, REI_SW_MULTIPART_DONE_STORE, { keyPath: "id" });
+      const tx = request.transaction;
+      createObjectStoreIfMissing(db, tx, REI_SW_DB_STORE, { keyPath: "id", autoIncrement: true });
+      const mpStore = createObjectStoreIfMissing(db, tx, REI_SW_MULTIPART_STORE, { keyPath: "id" });
+      const mpDoneStore = createObjectStoreIfMissing(db, tx, REI_SW_MULTIPART_DONE_STORE, { keyPath: "id" });
+      createObjectStoreIfMissing(db, tx, REI_SW_MULTIPART_CHUNK_STORE, { keyPath: "id_index" });
+      if (mpStore && !mpStore.indexNames.contains("expiresAt")) {
+        mpStore.createIndex("expiresAt", "expiresAt", { unique: false });
+      }
+      if (mpDoneStore && !mpDoneStore.indexNames.contains("expiresAt")) {
+        mpDoneStore.createIndex("expiresAt", "expiresAt", { unique: false });
+      }
+    };
+    request.onsuccess = () => {
+      cachedDB = request.result;
+      cachedDB.onversionchange = () => {
+        cachedDB.close();
+        cachedDB = null;
+      };
+      resolve(cachedDB);
     };
-    request.onsuccess = () => resolve(request.result);
     request.onerror = () => reject(request.error || new Error("Failed to open queue database"));
   });
 }
-function createObjectStoreIfMissing(db, name, options) {
-  if (db.objectStoreNames.contains(name)) return;
-  db.createObjectStore(name, options);
+function createObjectStoreIfMissing(db, tx, name, options) {
+  if (db.objectStoreNames.contains(name)) return tx.objectStore(name);
+  return db.createObjectStore(name, options);
 }
 async function withQueueStore(mode, handler) {
   const db = await openQueueDatabase();
-  try {
-    return await new Promise((resolve, reject) => {
-      const transaction = db.transaction(REI_SW_DB_STORE, mode);
-      const store = transaction.objectStore(REI_SW_DB_STORE);
-      transaction.oncomplete = () => resolve(void 0);
-      transaction.onerror = () => reject(transaction.error || new Error("Queue transaction failed"));
-      Promise.resolve(handler(store, resolve, reject)).catch(reject);
-    });
-  } finally {
-    db.close();
-  }
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction(REI_SW_DB_STORE, mode);
+    const store = transaction.objectStore(REI_SW_DB_STORE);
+    transaction.oncomplete = () => resolve(void 0);
+    transaction.onerror = () => reject(transaction.error || new Error("Queue transaction failed"));
+    Promise.resolve(handler(store, resolve, reject)).catch(reject);
+  });
 }
 async function addQueuedRequest(request) {
   return withQueueStore("readwrite", (store, resolve, reject) => {