@rei-standard/amsg-sw 2.0.1 → 2.1.0-next.2

package/README.md

@@ -3,9 +3,108 @@
 `@rei-standard/amsg-sw` 是 ReiStandard 主动消息标准的 Service Worker 插件包，目标是让推送展示和离线重试“开箱即用”。
 
 
+## v2.1.0 — 按 kind 分发的客户端事件
+
+2.1.0 跟随 `@rei-standard/amsg-shared` 的三轴 push schema：每条 push 现在通过 `payload.messageKind`（`content` / `reasoning` / `tool_request` / `error`）区分内容类型。SW 在收到 push 后会做两件事：
+
+1. **永远** 通过 `postMessage` 把 payload 广播给所有受控窗口（包括 `includeUncontrolled: true` 的未受控窗口）。
+2. **仅当** `messageKind === 'content'` 或 payload 没有 `messageKind`（2.0.x 老 payload 的回退路径）时，才调用 `showNotification`。`reasoning` / `tool_request` / `error` 三种 kind 一律不弹通知——业务在 app 内通过 postMessage 通道自行渲染。
+
+### 新增导出 `REI_SW_EVENT`
+
+事件名由 SW 在每次广播时打在 `e.data.event` 上：
+
+| 常量 | 字符串值 | 触发条件 |
+|------|---------|---------|
+| `REI_SW_EVENT.CONTENT_RECEIVED`      | `'rei-amsg-content-received'`      | `payload.messageKind === 'content'` |
+| `REI_SW_EVENT.REASONING_RECEIVED`    | `'rei-amsg-reasoning-received'`    | `payload.messageKind === 'reasoning'` |
+| `REI_SW_EVENT.TOOL_REQUEST_RECEIVED` | `'rei-amsg-tool-request-received'` | `payload.messageKind === 'tool_request'` |
+| `REI_SW_EVENT.ERROR_RECEIVED`        | `'rei-amsg-error-received'`        | `payload.messageKind === 'error'` |
+| `REI_SW_EVENT.MULTIPART_EXPIRED`     | `'rei-amsg-multipart-expired'`     | `_multipart` 分片 TTL 到期仍未收齐 |
+| `REI_SW_EVENT.UNKNOWN_RECEIVED`      | `'rei-amsg-unknown-received'`      | 缺 `messageKind`（2.0.x 老 payload / blob envelope） |
+
+### 客户端订阅示例
+
+```js
+navigator.serviceWorker.addEventListener('message', (e) => {
+  if (e.data?.type !== 'REI_AMSG_PUSH') return;
+  switch (e.data.event) {
+    case 'rei-amsg-content-received':      /* 渲染 app 内消息 */ break;
+    case 'rei-amsg-reasoning-received':    /* 渲染思考中 UI */ break;
+    case 'rei-amsg-tool-request-received': /* 弹出工具执行确认 */ break;
+    case 'rei-amsg-error-received':        /* 显示错误 toast */ break;
+    case 'rei-amsg-multipart-expired':     /* 观测 transport 缺片 */ break;
+    case 'rei-amsg-unknown-received':      /* 2.0.x 老 payload 的兼容路径 */ break;
+  }
+});
+```
+
+### 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）
+
+next 阶段移除了旧 reasoning 专用 `chunkIndex` / `totalChunks` wire format。现在 `_multipart` 是统一 transport kind，任何原始 payload 都可以被包起来：
+
+```json
+{
+  "messageKind": "_multipart",
+  "multipart": {
+    "version": 1,
+    "id": "mp_<uuid>",
+    "index": 1,
+    "total": 4,
+    "encoding": "json-utf8-base64url",
+    "originalMessageKind": "reasoning",
+    "createdAt": 1710000000000,
+    "ttlMs": 60000
+  },
+  "chunk": "base64url..."
+}
+```
+
+SW 收到 `_multipart` 后会先写 IndexedDB，支持乱序、重复分片和 SW 重启恢复。未收齐时不 `postMessage`、不 `showNotification`。收齐后按 `index` 拼回原始 JSON payload，删除 pending，写短期 done 标记避免推送服务重投递造成二次业务事件，然后递归走普通 `messageKind` 分发。
+
+配置：
+
+```js
+installReiSW(self, {
+  defaultIcon: '/icon-192x192.png',
+  defaultBadge: '/badge-72x72.png',
+  multipart: {
+    enabled: true,
+    ttlMs: 60_000,
+    maxTotalBytes: 256_000,
+    maxChunks: 128,
+    cleanupIntervalMs: 15 * 60_000
+  }
+});
+```
+
+TTL 到期仍未收齐时，SW 会清理 pending 并广播：
+
+```js
+{
+  type: 'REI_AMSG_PUSH',
+  event: 'rei-amsg-multipart-expired',
+  payload: { id, received, total, originalMessageKind }
+}
+```
+
+业务应用只订阅普通事件即可。`content` multipart 收齐后照常弹通知；`reasoning` / `tool_request` / `error` 仍默认不弹通知。
+
+### 升级注意事项
+
+- 想给 `reasoning` / `tool_request` / `error` 也弹通知的业务：必须自行在 app 内监听上面的 postMessage 事件、调 `Notification` 或 `registration.showNotification`。SW 默认不再为它们弹通知。
+- 应用级 SW 可以删除旧 reasoning `chunkIndex` / `totalChunks` 拼接逻辑；next 版本只会把完整还原后的 reasoning payload 发给 client。
+- 客户端代码继续兼容只有 `installReiSW` + `REI_SW_MESSAGE_TYPE`（队列）的 2.0.x 写法——新增导出不破坏既有 API。
+- 想拿到 push 类型相关的 TS 类型：从 `@rei-standard/amsg-shared` 引 `AmsgPush` 等类型（本包通过 JSDoc 引用同一份类型）。
+
 ## 功能概览
 
-- 处理 `push` 事件：自动解析 payload 并展示通知
+- 处理 `push` 事件：按 `messageKind` 三轴 schema 分发到客户端 + 仅 `content` 走 `showNotification`
+- 透明重组 `_multipart` transport：应用层只收到完整原始 payload
 - 处理 `message` 事件：支持离线请求入队与主动冲刷队列
 - 处理 `sync` 事件：在网络恢复后自动重试队列请求
 - 使用 IndexedDB 存储待发送请求，避免页面关闭后丢失
@@ -25,7 +124,8 @@ import { installReiSW } from '@rei-standard/amsg-sw';
 
 installReiSW(self, {
   defaultIcon: '/icon-192x192.png',
-  defaultBadge: '/badge-72x72.png'
+  defaultBadge: '/badge-72x72.png',
+  multipart: { enabled: true }
 });
 
 // 业务侧自行实现点击跳转
@@ -97,8 +197,19 @@ export async function enqueueRequestToSW(requestPayload) {
 ## 导出 API（Exports）
 
 - `installReiSW`
+- `REI_SW_EVENT` — 2.1.0 新增，按 kind 分发的客户端事件名
+- `REI_AMSG_POSTMESSAGE_TYPE` — 2.1.0 新增，SW → client 广播信封的 `type` 字段（恒为 `'REI_AMSG_PUSH'`）
 - `REI_SW_MESSAGE_TYPE`
 
+`REI_SW_EVENT` 包含（详见上文 v2.1.0 章节）：
+
+- `CONTENT_RECEIVED`
+- `REASONING_RECEIVED`
+- `TOOL_REQUEST_RECEIVED`
+- `ERROR_RECEIVED`
+- `MULTIPART_EXPIRED`
+- `UNKNOWN_RECEIVED`
+
 `REI_SW_MESSAGE_TYPE` 包含：
 
 - `ENQUEUE_REQUEST`

package/dist/index.cjs

@@ -19,14 +19,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
+  REI_AMSG_POSTMESSAGE_TYPE: () => REI_AMSG_POSTMESSAGE_TYPE,
+  REI_SW_EVENT: () => REI_SW_EVENT,
   REI_SW_MESSAGE_TYPE: () => REI_SW_MESSAGE_TYPE,
   installReiSW: () => installReiSW
 });
 module.exports = __toCommonJS(src_exports);
 var REI_SW_DB_NAME = "rei-sw";
 var REI_SW_DB_STORE = "request-outbox";
-var REI_SW_DB_VERSION = 1;
+var REI_SW_MULTIPART_STORE = "multipart-pending";
+var REI_SW_MULTIPART_DONE_STORE = "multipart-done";
+var REI_SW_DB_VERSION = 2;
 var REI_SW_SYNC_TAG = "rei-sw-flush-request-outbox";
+var MULTIPART_MESSAGE_KIND = "_multipart";
+var MULTIPART_ENCODING = "json-utf8-base64url";
+var DEFAULT_MULTIPART_OPTIONS = Object.freeze({
+  enabled: true,
+  ttlMs: 6e4,
+  maxTotalBytes: 256e3,
+  maxChunks: 128,
+  cleanupIntervalMs: 15 * 6e4
+});
+var memoryMultipartPending = /* @__PURE__ */ new Map();
+var memoryMultipartDone = /* @__PURE__ */ new Map();
+var REI_AMSG_POSTMESSAGE_TYPE = "REI_AMSG_PUSH";
+var REI_SW_EVENT = Object.freeze({
+  CONTENT_RECEIVED: "rei-amsg-content-received",
+  REASONING_RECEIVED: "rei-amsg-reasoning-received",
+  TOOL_REQUEST_RECEIVED: "rei-amsg-tool-request-received",
+  ERROR_RECEIVED: "rei-amsg-error-received",
+  MULTIPART_EXPIRED: "rei-amsg-multipart-expired",
+  UNKNOWN_RECEIVED: "rei-amsg-unknown-received"
+});
 var REI_SW_MESSAGE_TYPE = Object.freeze({
   ENQUEUE_REQUEST: "REI_ENQUEUE_REQUEST",
   FLUSH_QUEUE: "REI_FLUSH_QUEUE",
@@ -35,17 +59,20 @@ var REI_SW_MESSAGE_TYPE = Object.freeze({
 function installReiSW(sw, opts = {}) {
   const defaultIcon = opts.defaultIcon || "/icon-192x192.png";
   const defaultBadge = opts.defaultBadge || "/badge-72x72.png";
+  const multipart = normalizeMultipartOptions(opts.multipart);
+  let lastMultipartCleanupAt = 0;
   sw.addEventListener("push", (event) => {
     const payload = readPushPayload(event);
     if (!payload) return;
-    const notification = createNotificationFromPayload(payload, {
+    event.waitUntil(handlePushPayload(sw, payload, {
+      defaultBadge,
       defaultIcon,
-      defaultBadge
-    });
-    if (!notification) return;
-    event.waitUntil(
-      sw.registration.showNotification(notification.title, notification.options)
-    );
+      multipart,
+      getLastMultipartCleanupAt: () => lastMultipartCleanupAt,
+      setLastMultipartCleanupAt: (value) => {
+        lastMultipartCleanupAt = value;
+      }
+    }));
   });
   sw.addEventListener("message", (event) => {
     const message = event.data;
@@ -65,6 +92,75 @@ function installReiSW(sw, opts = {}) {
     event.waitUntil(flushQueuedRequests(sw));
   });
 }
+async function handlePushPayload(sw, payload, ctx) {
+  await maybeCleanupMultipart(sw, ctx);
+  if (isMultipartPush(payload)) {
+    if (!ctx.multipart.enabled) return;
+    const restoredPayload = await acceptMultipartChunk(sw, payload, ctx.multipart);
+    if (!restoredPayload) return;
+    await handlePushPayload(sw, restoredPayload, ctx);
+    return;
+  }
+  await dispatchBusinessPayload(sw, payload, {
+    defaultIcon: ctx.defaultIcon,
+    defaultBadge: ctx.defaultBadge
+  });
+}
+async function dispatchBusinessPayload(sw, payload, defaults) {
+  const eventName = resolveEventName(payload);
+  const shouldRenderNotification = isNotificationKind(payload);
+  const work = [dispatchPushToClients(sw, eventName, payload)];
+  if (shouldRenderNotification) {
+    const notification = createNotificationFromPayload(payload, defaults);
+    if (notification) {
+      work.push(
+        sw.registration.showNotification(notification.title, notification.options)
+      );
+    }
+  }
+  await Promise.all(work);
+}
+function resolveEventName(payload) {
+  const kind = payload && typeof payload === "object" ? payload.messageKind : void 0;
+  switch (kind) {
+    case "content":
+      return REI_SW_EVENT.CONTENT_RECEIVED;
+    case "reasoning":
+      return REI_SW_EVENT.REASONING_RECEIVED;
+    case "tool_request":
+      return REI_SW_EVENT.TOOL_REQUEST_RECEIVED;
+    case "error":
+      return REI_SW_EVENT.ERROR_RECEIVED;
+    default:
+      return REI_SW_EVENT.UNKNOWN_RECEIVED;
+  }
+}
+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";
+}
+async function dispatchPushToClients(sw, eventName, payload) {
+  try {
+    const clientList = await sw.clients.matchAll({
+      type: "window",
+      includeUncontrolled: true
+    });
+    const envelope = {
+      type: REI_AMSG_POSTMESSAGE_TYPE,
+      event: eventName,
+      payload
+    };
+    for (const client of clientList) {
+      try {
+        client.postMessage(envelope);
+      } catch (_postError) {
+      }
+    }
+  } catch (_matchError) {
+  }
+}
 function readPushPayload(event) {
   if (!event.data) return null;
   try {
@@ -89,7 +185,7 @@ function createNotificationFromPayload(payload, defaults) {
     };
   }
   const pushNotification = payload.notification && typeof payload.notification === "object" ? payload.notification : {};
-  const title = pushNotification.title || payload.title || "New notification";
+  const title = pushNotification.title || payload.title || payload.contactName && `\u6765\u81EA ${payload.contactName}` || "New notification";
   const body = pushNotification.body || payload.body || payload.message || "";
   const data = payload.data && typeof payload.data === "object" ? { ...payload.data } : {};
   if (data.payload == null) data.payload = payload;
@@ -108,6 +204,197 @@ function createNotificationFromPayload(payload, defaults) {
     }
   };
 }
+function normalizeMultipartOptions(input) {
+  const source = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  return {
+    enabled: source.enabled !== false,
+    ttlMs: positiveIntegerOrDefault(source.ttlMs, DEFAULT_MULTIPART_OPTIONS.ttlMs),
+    maxTotalBytes: positiveIntegerOrDefault(
+      source.maxTotalBytes,
+      DEFAULT_MULTIPART_OPTIONS.maxTotalBytes
+    ),
+    maxChunks: positiveIntegerOrDefault(source.maxChunks, DEFAULT_MULTIPART_OPTIONS.maxChunks),
+    cleanupIntervalMs: source.cleanupIntervalMs === 0 ? 0 : positiveIntegerOrDefault(
+      source.cleanupIntervalMs,
+      DEFAULT_MULTIPART_OPTIONS.cleanupIntervalMs
+    )
+  };
+}
+function positiveIntegerOrDefault(value, fallback) {
+  return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function isMultipartPush(payload) {
+  return !!payload && typeof payload === "object" && payload.messageKind === MULTIPART_MESSAGE_KIND && payload.multipart && typeof payload.multipart === "object" && typeof payload.chunk === "string";
+}
+async function acceptMultipartChunk(sw, payload, options) {
+  const normalized = normalizeMultipartChunk(payload, options);
+  if (!normalized) return null;
+  if (normalized.expiresAt <= Date.now()) {
+    await dispatchMultipartExpired(sw, {
+      id: normalized.id,
+      chunks: {},
+      total: normalized.total,
+      originalMessageKind: normalized.originalMessageKind
+    });
+    return null;
+  }
+  const done = await readMultipartDone(normalized.id);
+  if (done && done.expiresAt > Date.now()) return null;
+  if (done) await deleteMultipartDone(normalized.id);
+  const now = Date.now();
+  const existing = await readMultipartPending(normalized.id);
+  if (existing && existing.expiresAt <= now) {
+    await deleteMultipartPending(existing.id);
+    await dispatchMultipartExpired(sw, existing);
+  }
+  const base = existing && existing.expiresAt > now ? existing : {
+    id: normalized.id,
+    createdAt: normalized.createdAt,
+    expiresAt: normalized.expiresAt,
+    ttlMs: normalized.ttlMs,
+    total: normalized.total,
+    originalMessageKind: normalized.originalMessageKind,
+    encoding: normalized.encoding,
+    chunks: {},
+    receivedBytes: 0
+  };
+  if (base.total !== normalized.total || base.encoding !== normalized.encoding) {
+    await deleteMultipartPending(normalized.id);
+    return null;
+  }
+  if (base.chunks[String(normalized.index)] !== void 0) {
+    return null;
+  }
+  base.chunks[String(normalized.index)] = normalized.chunk;
+  base.receivedBytes = positiveIntegerOrDefault(base.receivedBytes, 0) + normalized.chunkBytes.byteLength;
+  if (base.receivedBytes > options.maxTotalBytes) {
+    await deleteMultipartPending(normalized.id);
+    return null;
+  }
+  const received = Object.keys(base.chunks).length;
+  if (received < base.total) {
+    await writeMultipartPending(base);
+    return null;
+  }
+  await deleteMultipartPending(base.id);
+  let restored;
+  try {
+    restored = restoreMultipartPayload(base, options);
+  } catch (_error) {
+    return null;
+  }
+  const doneTtlMs = Math.max(base.ttlMs * 2, base.ttlMs + 1);
+  await writeMultipartDone({
+    id: base.id,
+    expiresAt: Date.now() + doneTtlMs
+  });
+  return restored;
+}
+function normalizeMultipartChunk(payload, options) {
+  const meta = payload.multipart;
+  if (!meta || typeof meta !== "object") return null;
+  if (meta.version !== 1 || meta.encoding !== MULTIPART_ENCODING) return null;
+  if (typeof meta.id !== "string" || !meta.id) return null;
+  if (!Number.isInteger(meta.index) || !Number.isInteger(meta.total)) return null;
+  if (meta.total <= 0 || meta.total > options.maxChunks) return null;
+  if (meta.index <= 0 || meta.index > meta.total) return null;
+  let chunkBytes;
+  try {
+    chunkBytes = base64UrlToBytes(payload.chunk);
+  } catch (_error) {
+    return null;
+  }
+  const now = Date.now();
+  const ttlMs = Math.min(
+    positiveIntegerOrDefault(meta.ttlMs, options.ttlMs),
+    options.ttlMs
+  );
+  const createdAt = Number.isFinite(meta.createdAt) ? Number(meta.createdAt) : now;
+  const expiresAt = createdAt + ttlMs;
+  return {
+    id: meta.id,
+    createdAt,
+    expiresAt,
+    ttlMs,
+    total: meta.total,
+    index: meta.index,
+    originalMessageKind: typeof meta.originalMessageKind === "string" ? meta.originalMessageKind : null,
+    encoding: meta.encoding,
+    chunk: payload.chunk,
+    chunkBytes
+  };
+}
+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") {
+      throw new Error("[rei-standard-amsg-sw] multipart missing chunk");
+    }
+    const bytes = base64UrlToBytes(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));
+  return JSON.parse(json);
+}
+async function maybeCleanupMultipart(sw, ctx) {
+  if (!ctx.multipart.enabled) return;
+  const now = Date.now();
+  const last = ctx.getLastMultipartCleanupAt();
+  if (last && now - last < ctx.multipart.cleanupIntervalMs) return;
+  ctx.setLastMultipartCleanupAt(now);
+  try {
+    await cleanupMultipartStores(sw, now);
+  } catch (_error) {
+  }
+}
+async function cleanupMultipartStores(sw, now) {
+  const pending = await listMultipartPending();
+  for (const record of pending) {
+    if (record.expiresAt > now) continue;
+    await deleteMultipartPending(record.id);
+    await dispatchMultipartExpired(sw, record);
+  }
+  const done = await listMultipartDone();
+  for (const record of done) {
+    if (record.expiresAt <= now) {
+      await deleteMultipartDone(record.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,
+    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);
@@ -215,18 +502,114 @@ function respondToSender(event, message) {
     source.postMessage(message);
   }
 }
+function readMultipartPending(id) {
+  return readStoreRecord(REI_SW_MULTIPART_STORE, id);
+}
+function writeMultipartPending(record) {
+  return putStoreRecord(REI_SW_MULTIPART_STORE, 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);
+}
+function writeMultipartDone(record) {
+  return putStoreRecord(REI_SW_MULTIPART_DONE_STORE, record);
+}
+function deleteMultipartDone(id) {
+  return deleteStoreRecord(REI_SW_MULTIPART_DONE_STORE, id);
+}
+function listMultipartDone() {
+  return listStoreRecords(REI_SW_MULTIPART_DONE_STORE);
+}
+async function readStoreRecord(storeName, id) {
+  if (!hasIndexedDB()) {
+    return cloneRecord(memoryStoreFor(storeName).get(id));
+  }
+  return withDatabaseStore(storeName, "readonly", (store, resolve, reject) => {
+    const request = store.get(id);
+    request.onsuccess = () => resolve(request.result || null);
+    request.onerror = () => reject(request.error || new Error(`Failed to read ${storeName}`));
+  });
+}
+async function putStoreRecord(storeName, record) {
+  if (!hasIndexedDB()) {
+    memoryStoreFor(storeName).set(record.id, cloneRecord(record));
+    return;
+  }
+  return withDatabaseStore(storeName, "readwrite", (store, resolve, reject) => {
+    const request = store.put(record);
+    request.onsuccess = () => resolve(void 0);
+    request.onerror = () => reject(request.error || new Error(`Failed to write ${storeName}`));
+  });
+}
+async function deleteStoreRecord(storeName, id) {
+  if (!hasIndexedDB()) {
+    memoryStoreFor(storeName).delete(id);
+    return;
+  }
+  return withDatabaseStore(storeName, "readwrite", (store, resolve, reject) => {
+    const request = store.delete(id);
+    request.onsuccess = () => resolve(void 0);
+    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();
+  }
+}
+function hasIndexedDB() {
+  return typeof indexedDB !== "undefined" && indexedDB && typeof indexedDB.open === "function";
+}
+function memoryStoreFor(storeName) {
+  if (storeName === REI_SW_MULTIPART_DONE_STORE) return memoryMultipartDone;
+  if (storeName === REI_SW_MULTIPART_STORE) return memoryMultipartPending;
+  throw new Error(`[rei-standard-amsg-sw] unknown memory store: ${storeName}`);
+}
+function cloneRecord(record) {
+  if (record == null) return null;
+  return JSON.parse(JSON.stringify(record));
+}
 function openQueueDatabase() {
   return new Promise((resolve, reject) => {
     const request = indexedDB.open(REI_SW_DB_NAME, REI_SW_DB_VERSION);
     request.onupgradeneeded = () => {
       const db = request.result;
-      if (db.objectStoreNames.contains(REI_SW_DB_STORE)) return;
-      db.createObjectStore(REI_SW_DB_STORE, { keyPath: "id", autoIncrement: true });
+      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" });
     };
     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);
+}
 async function withQueueStore(mode, handler) {
   const db = await openQueueDatabase();
   try {