@rei-standard/amsg-sw 2.1.0 → 2.2.0

package/dist/index.mjs

@@ -7,6 +7,10 @@ var REI_SW_MULTIPART_DONE_STORE = "multipart-done";
 var REI_SW_MULTIPART_CHUNK_STORE = "multipart-chunk";
 var REI_SW_DB_VERSION = 3;
 var cachedDB = null;
+var REI_AMSG_DEDUPE_DB_NAME = "rei_amsg_sw_dedupe_v1";
+var REI_AMSG_DEDUPE_STORE = "delivery-dedupe";
+var DEFAULT_DEDUPE_TTL_MS = 10 * 6e4;
+var DEFAULT_DEDUPE_CLEANUP_INTERVAL_MS = 6e4;
 var REI_SW_SYNC_TAG = "rei-sw-flush-request-outbox";
 var MULTIPART_MESSAGE_KIND = "_multipart";
 var MULTIPART_ENCODING = "json-utf8-base64url";
@@ -20,6 +24,8 @@ var DEFAULT_MULTIPART_OPTIONS = Object.freeze({
 var memoryMultipartPending = /* @__PURE__ */ new Map();
 var memoryMultipartDone = /* @__PURE__ */ new Map();
 var memoryMultipartChunks = /* @__PURE__ */ new Map();
+var multipartLocks = /* @__PURE__ */ new Map();
+var dedupeDbCache = /* @__PURE__ */ new Map();
 var REI_AMSG_POSTMESSAGE_TYPE = "REI_AMSG_PUSH";
 var REI_SW_EVENT = Object.freeze({
   CONTENT_RECEIVED: "rei-amsg-content-received",
@@ -31,27 +37,39 @@ var REI_SW_EVENT = Object.freeze({
 });
 var REI_SW_MESSAGE_TYPE = Object.freeze({
   ENQUEUE_REQUEST: "REI_ENQUEUE_REQUEST",
+  DELIVER: "REI_AMSG_DELIVER",
   FLUSH_QUEUE: "REI_FLUSH_QUEUE",
   QUEUE_RESULT: "REI_QUEUE_RESULT"
 });
+var REI_AMSG_DELIVER_MESSAGE_TYPE = REI_SW_MESSAGE_TYPE.DELIVER;
 function installReiSW(sw, opts = {}) {
   const defaultIcon = opts.defaultIcon || "/icon-192x192.png";
   const defaultBadge = opts.defaultBadge || "/badge-72x72.png";
   const multipart = normalizeMultipartOptions(opts.multipart);
+  const dedupe = normalizeDedupeOptions(opts.dedupe);
   let lastMultipartCleanupAt = 0;
+  let lastDedupeCleanupAt = 0;
+  const makeDeliveryContext = (source) => ({
+    defaultBadge,
+    defaultIcon,
+    dedupe,
+    multipart,
+    onDuplicate: opts.onDuplicate,
+    onBusinessPayload: opts.onBusinessPayload,
+    source,
+    getLastDedupeCleanupAt: () => lastDedupeCleanupAt,
+    setLastDedupeCleanupAt: (value) => {
+      lastDedupeCleanupAt = value;
+    },
+    getLastMultipartCleanupAt: () => lastMultipartCleanupAt,
+    setLastMultipartCleanupAt: (value) => {
+      lastMultipartCleanupAt = value;
+    }
+  });
   sw.addEventListener("push", (event) => {
     const payload = readPushPayload(event);
     if (!payload) return;
-    event.waitUntil(handlePushPayload(sw, payload, {
-      defaultBadge,
-      defaultIcon,
-      multipart,
-      onBusinessPayload: opts.onBusinessPayload,
-      getLastMultipartCleanupAt: () => lastMultipartCleanupAt,
-      setLastMultipartCleanupAt: (value) => {
-        lastMultipartCleanupAt = value;
-      }
-    }));
+    event.waitUntil(handlePushPayload(sw, payload, makeDeliveryContext("webpush")));
   });
   sw.addEventListener("message", (event) => {
     const message = event.data;
@@ -62,6 +80,10 @@ function installReiSW(sw, opts = {}) {
       );
       return;
     }
+    if (message.type === REI_SW_MESSAGE_TYPE.DELIVER) {
+      event.waitUntil(handleDeliverMessage(sw, event, message, makeDeliveryContext()));
+      return;
+    }
     if (message.type === REI_SW_MESSAGE_TYPE.FLUSH_QUEUE) {
       event.waitUntil(flushQueuedRequests(sw));
     }
@@ -77,16 +99,48 @@ async function handlePushPayload(sw, payload, ctx) {
     if (!ctx.multipart.enabled) return;
     const restoredPayload = await acceptMultipartChunk(sw, payload, ctx.multipart);
     if (!restoredPayload) return;
-    await handlePushPayload(sw, restoredPayload, ctx);
-    return;
+    return handlePushPayload(sw, restoredPayload, ctx);
+  }
+  const claim = await claimDedupe(payload, ctx);
+  if (claim.duplicate) {
+    const duplicateNotification = await maybeShowDuplicateNotification(sw, payload, claim, ctx);
+    claim.duplicateNotification = duplicateNotification;
+    await notifyDuplicate(payload, claim, ctx);
+    return { ...claim, duplicateNotification };
   }
   await dispatchBusinessPayload(sw, payload, {
     defaultIcon: ctx.defaultIcon,
     defaultBadge: ctx.defaultBadge,
     onBusinessPayload: ctx.onBusinessPayload
+  }, async (intermediateResult) => {
+    await updateDedupeNotificationState(claim, ctx, intermediateResult);
   });
+  return claim;
+}
+async function handleDeliverMessage(sw, event, message, ctx) {
+  let result = {};
+  try {
+    if (!Object.prototype.hasOwnProperty.call(message, "payload")) {
+      throw new Error("[rei-standard-amsg-sw] REI_AMSG_DELIVER requires payload");
+    }
+    const source = typeof message.source === "string" && message.source ? message.source : "message";
+    result = await handlePushPayload(sw, message.payload, { ...ctx, source }) || {};
+    respondToSender(event, {
+      ok: true,
+      duplicate: Boolean(result.duplicate),
+      key: result.key,
+      requestId: message.requestId
+    });
+  } catch (error) {
+    respondToSender(event, {
+      ok: false,
+      error: error instanceof Error ? error.message : "Failed to deliver payload",
+      key: result && result.key,
+      requestId: message.requestId
+    });
+  }
 }
-async function dispatchBusinessPayload(sw, payload, defaults) {
+async function dispatchBusinessPayload(sw, payload, defaults, onNotificationSettled) {
   const eventName = resolveEventName(payload);
   let clientList = [];
   try {
@@ -96,40 +150,41 @@ async function dispatchBusinessPayload(sw, payload, defaults) {
     });
   } 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 notificationState = {
+    shouldRender: shouldRenderNotification(payload, clientList),
+    shown: false
+  };
+  const notificationWork = [dispatchPushToClients(sw, eventName, payload, clientList)];
+  if (notificationState.shouldRender) {
     const notification = createNotificationFromPayload(payload, defaults);
     if (notification) {
-      work.push(
-        sw.registration.showNotification(notification.title, notification.options)
+      notificationWork.push(
+        sw.registration.showNotification(notification.title, notification.options).then(() => {
+          notificationState.shown = true;
+        })
       );
     }
   }
+  let businessWork = null;
   if (typeof defaults.onBusinessPayload === "function") {
     try {
       const result = defaults.onBusinessPayload(payload);
-      if (result instanceof Promise) {
-        work.push(result.catch((error) => {
+      if (result && typeof result.then === "function") {
+        businessWork = Promise.resolve(result).catch((error) => {
           console.error("[rei-standard-amsg-sw] onBusinessPayload promise rejected:", error);
-        }));
+        });
       }
     } catch (error) {
       console.error("[rei-standard-amsg-sw] onBusinessPayload error:", error);
     }
   }
-  await Promise.all(work);
+  await Promise.all(notificationWork);
+  const settledResult = { eventName, notification: notificationState };
+  if (typeof onNotificationSettled === "function") {
+    await onNotificationSettled(settledResult);
+  }
+  if (businessWork) await businessWork;
+  return settledResult;
 }
 function resolveEventName(payload) {
   const kind = payload && typeof payload === "object" ? payload.messageKind : void 0;
@@ -152,6 +207,19 @@ function isNotificationKind(payload) {
   if (kind === void 0 || kind === null) return true;
   return kind === MESSAGE_KIND.CONTENT;
 }
+function shouldRenderNotification(payload, clientList) {
+  const showOpt = payload && payload.notification ? payload.notification.show : void 0;
+  if (showOpt === "always") {
+    return true;
+  }
+  if (showOpt === "when-hidden") {
+    return !clientList.some((client) => client.visibilityState === "visible");
+  }
+  if (showOpt === false) {
+    return false;
+  }
+  return isNotificationKind(payload);
+}
 async function dispatchPushToClients(sw, eventName, payload, preFetchedClientList = null) {
   try {
     const clientList = preFetchedClientList || await sw.clients.matchAll({
@@ -196,7 +264,7 @@ function createNotificationFromPayload(payload, defaults) {
     };
   }
   const pushNotification = payload.notification && typeof payload.notification === "object" ? payload.notification : {};
-  const title = pushNotification.title || payload.title || payload.contactName || "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 = pushNotification.data && typeof pushNotification.data === "object" ? { ...pushNotification.data } : payload.data && typeof payload.data === "object" ? { ...payload.data } : {};
   if (data.payload == null) data.payload = payload;
@@ -211,7 +279,8 @@ function createNotificationFromPayload(payload, defaults) {
       renotify: Boolean(pushNotification.renotify ?? payload.renotify ?? false),
       requireInteraction: Boolean(
         pushNotification.requireInteraction ?? payload.requireInteraction ?? false
-      )
+      ),
+      silent: Boolean(pushNotification.silent ?? payload.silent ?? false)
     }
   };
 }
@@ -231,15 +300,218 @@ function normalizeMultipartOptions(input) {
     )
   };
 }
+function normalizeDedupeOptions(input) {
+  const source = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  if (Object.prototype.hasOwnProperty.call(source, "storeName")) {
+    throw new Error(
+      "[rei-standard-amsg-sw] dedupe.storeName \u4E0D\u518D\u53EF\u914D\u7F6E\u3002\u6539 storeName \u4F1A\u89E6\u53D1 IndexedDB \u7248\u672C\u5347\u7EA7\uFF0C\u672C\u5305\u4E0D\u7EF4\u62A4 migration \u903B\u8F91\u3002\u9700\u8981\u9694\u79BB\u53BB\u91CD\u6570\u636E\u8BF7\u6539\u7528 dedupe.dbName\uFF08\u6BCF\u4E2A dbName \u662F\u72EC\u7ACB IDB \u5B9E\u4F8B\uFF09\u3002"
+    );
+  }
+  return {
+    enabled: source.enabled !== false,
+    ttlMs: positiveIntegerOrDefault(source.ttlMs, DEFAULT_DEDUPE_TTL_MS),
+    cleanupIntervalMs: source.cleanupIntervalMs === 0 ? 0 : positiveIntegerOrDefault(
+      source.cleanupIntervalMs,
+      DEFAULT_DEDUPE_CLEANUP_INTERVAL_MS
+    ),
+    key: typeof source.key === "function" ? source.key : null,
+    dbName: typeof source.dbName === "string" && source.dbName.trim() ? source.dbName.trim() : REI_AMSG_DEDUPE_DB_NAME,
+    storeName: REI_AMSG_DEDUPE_STORE,
+    _memoryStore: /* @__PURE__ */ new Map()
+  };
+}
 function positiveIntegerOrDefault(value, fallback) {
   return Number.isInteger(value) && value > 0 ? value : fallback;
 }
+async function claimDedupe(payload, ctx) {
+  if (!ctx.dedupe || ctx.dedupe.enabled === false) {
+    return { duplicate: false, key: void 0 };
+  }
+  const key = resolveDedupeKey(payload, ctx.dedupe);
+  if (!key) return { duplicate: false, key: void 0 };
+  await maybeCleanupDedupe(ctx);
+  const now = Date.now();
+  const record = {
+    key,
+    firstSeenAt: now,
+    expiresAt: now + ctx.dedupe.ttlMs,
+    source: ctx.source || "unknown",
+    messageKind: getPayloadMessageKind(payload),
+    notificationShown: false,
+    notificationStatePending: true
+  };
+  if (await addDedupeRecord(ctx.dedupe, record)) {
+    return { duplicate: false, key, record };
+  }
+  const existing = await readDedupeRecord(ctx.dedupe, key);
+  if (existing && existing.expiresAt <= now) {
+    await deleteDedupeRecord(ctx.dedupe, key);
+    if (await addDedupeRecord(ctx.dedupe, record)) {
+      return { duplicate: false, key, record };
+    }
+  }
+  return {
+    duplicate: true,
+    key,
+    record,
+    existing: existing || null
+  };
+}
+async function updateDedupeNotificationState(claim, ctx, dispatchResult) {
+  if (!claim || claim.duplicate || !claim.key || !ctx.dedupe || ctx.dedupe.enabled === false) return;
+  if (!dispatchResult || !dispatchResult.notification) return;
+  const notification = dispatchResult.notification;
+  const next = {
+    ...claim.record,
+    notificationShown: notification.shown === true,
+    notificationStatePending: false
+  };
+  try {
+    await putDedupeRecord(ctx.dedupe, next);
+    claim.record = next;
+  } catch (error) {
+    console.error("[rei-standard-amsg-sw] dedupe notification state update failed:", error);
+  }
+}
+async function maybeShowDuplicateNotification(sw, payload, claim, ctx) {
+  const existing = claim && claim.existing ? claim.existing : null;
+  if (!existing || existing.notificationShown === true) {
+    return { shown: false, reason: existing ? "already-shown" : "no-existing-record" };
+  }
+  if (existing.notificationStatePending === true) {
+    return { shown: false, reason: "first-delivery-pending" };
+  }
+  let clientList = [];
+  try {
+    clientList = await sw.clients.matchAll({
+      type: "window",
+      includeUncontrolled: true
+    });
+  } catch (_matchError) {
+  }
+  if (!shouldRenderNotification(payload, clientList)) {
+    return { shown: false, reason: "policy-suppressed" };
+  }
+  const notification = createNotificationFromPayload(payload, {
+    defaultIcon: ctx.defaultIcon,
+    defaultBadge: ctx.defaultBadge
+  });
+  if (!notification) {
+    return { shown: false, reason: "no-notification" };
+  }
+  await sw.registration.showNotification(notification.title, notification.options);
+  const next = {
+    ...existing,
+    notificationShown: true,
+    notificationStatePending: false
+  };
+  await putDedupeRecord(ctx.dedupe, next);
+  return { shown: true, reason: "shown-from-duplicate" };
+}
+function resolveDedupeKey(payload, dedupe) {
+  if (typeof dedupe.key === "function") {
+    try {
+      const custom = dedupe.key(payload);
+      return typeof custom === "string" && custom.trim() ? custom.trim() : void 0;
+    } catch (error) {
+      console.error("[rei-standard-amsg-sw] dedupe.key error:", error);
+      return void 0;
+    }
+  }
+  if (!payload || typeof payload !== "object") return void 0;
+  for (const field of ["messageId", "id", "dedupeKey"]) {
+    const value = payload[field];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function getPayloadMessageKind(payload) {
+  return payload && typeof payload === "object" && typeof payload.messageKind === "string" ? payload.messageKind : void 0;
+}
+async function notifyDuplicate(payload, claim, ctx) {
+  if (typeof ctx.onDuplicate !== "function") return;
+  const existing = claim.existing || {};
+  const info = {
+    key: claim.key,
+    source: ctx.source || "unknown",
+    messageKind: getPayloadMessageKind(payload),
+    firstSeenAt: existing.firstSeenAt,
+    existingSource: existing.source,
+    existingMessageKind: existing.messageKind,
+    existingNotificationShown: existing.notificationShown === true,
+    duplicateNotificationShown: claim.duplicateNotification && claim.duplicateNotification.shown === true
+  };
+  try {
+    await ctx.onDuplicate(info);
+  } catch (error) {
+    console.error("[rei-standard-amsg-sw] onDuplicate error:", error);
+  }
+}
+async function maybeCleanupDedupe(ctx) {
+  if (!ctx.dedupe || ctx.dedupe.enabled === false || ctx.dedupe.cleanupIntervalMs === 0) return;
+  const now = Date.now();
+  const last = ctx.getLastDedupeCleanupAt ? ctx.getLastDedupeCleanupAt() : 0;
+  if (last && now - last < ctx.dedupe.cleanupIntervalMs) return;
+  if (ctx.setLastDedupeCleanupAt) ctx.setLastDedupeCleanupAt(now);
+  try {
+    await cleanupDedupeStore(ctx.dedupe, now);
+  } catch (error) {
+    console.error("[rei-standard-amsg-sw] dedupe cleanup failed:", error);
+  }
+}
+async function cleanupDedupeStore(dedupe, now) {
+  if (!hasIndexedDB()) {
+    const store = memoryDedupeStoreFor(dedupe);
+    for (const [key, record] of store.entries()) {
+      if (record.expiresAt <= now) store.delete(key);
+    }
+    return;
+  }
+  await withDedupeStore(dedupe, "readwrite", (store, resolve, reject) => {
+    const index = store.index("expiresAt");
+    const range = IDBKeyRange.upperBound(now);
+    let failed = false;
+    const request = index.openCursor(range);
+    request.onsuccess = () => {
+      if (failed) return;
+      const cursor = request.result;
+      if (!cursor) {
+        resolve(void 0);
+        return;
+      }
+      const deleteRequest = cursor.delete();
+      deleteRequest.onsuccess = () => {
+        if (failed) return;
+        cursor.continue();
+      };
+      deleteRequest.onerror = () => {
+        if (!failed) {
+          failed = true;
+          reject(deleteRequest.error || new Error("Failed to delete expired dedupe record"));
+        }
+      };
+    };
+    request.onerror = () => reject(request.error || new Error("Failed to scan expired dedupe records"));
+  });
+}
 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;
+  const previous = multipartLocks.get(normalized.id) || Promise.resolve();
+  const current = previous.catch(() => void 0).then(() => acceptMultipartChunkInternal(sw, normalized, options));
+  multipartLocks.set(normalized.id, current);
+  try {
+    return await current;
+  } finally {
+    if (multipartLocks.get(normalized.id) === current) {
+      multipartLocks.delete(normalized.id);
+    }
+  }
+}
+async function acceptMultipartChunkInternal(sw, normalized, options) {
   if (normalized.expiresAt <= Date.now()) {
     await dispatchMultipartExpired(sw, {
       id: normalized.id,
@@ -538,6 +810,69 @@ function respondToSender(event, message) {
     source.postMessage(message);
   }
 }
+async function addDedupeRecord(dedupe, record) {
+  if (!hasIndexedDB()) {
+    const store = memoryDedupeStoreFor(dedupe);
+    if (store.has(record.key)) return false;
+    store.set(record.key, cloneRecord(record));
+    return true;
+  }
+  return withDedupeStore(dedupe, "readwrite", (store, resolve, reject) => {
+    let settled = false;
+    const request = store.add(record);
+    request.onsuccess = () => {
+      settled = true;
+      resolve(true);
+    };
+    request.onerror = (event) => {
+      settled = true;
+      if (request.error && request.error.name === "ConstraintError") {
+        if (event && typeof event.preventDefault === "function") event.preventDefault();
+        resolve(false);
+        return;
+      }
+      reject(request.error || new Error("Failed to add dedupe record"));
+    };
+    store.transaction.onerror = () => {
+      if (!settled) reject(store.transaction.error || new Error("Dedupe transaction failed"));
+    };
+  });
+}
+function readDedupeRecord(dedupe, key) {
+  if (!hasIndexedDB()) {
+    return Promise.resolve(cloneRecord(memoryDedupeStoreFor(dedupe).get(key) || null));
+  }
+  return withDedupeStore(dedupe, "readonly", (store, resolve, reject) => {
+    const request = store.get(key);
+    request.onsuccess = () => resolve(request.result || null);
+    request.onerror = () => reject(request.error || new Error("Failed to read dedupe record"));
+  });
+}
+function putDedupeRecord(dedupe, record) {
+  if (!record || typeof record.key !== "string" || !record.key) {
+    return Promise.resolve();
+  }
+  if (!hasIndexedDB()) {
+    memoryDedupeStoreFor(dedupe).set(record.key, cloneRecord(record));
+    return Promise.resolve();
+  }
+  return withDedupeStore(dedupe, "readwrite", (store, resolve, reject) => {
+    const request = store.put(record);
+    request.onsuccess = () => resolve(void 0);
+    request.onerror = () => reject(request.error || new Error("Failed to put dedupe record"));
+  });
+}
+function deleteDedupeRecord(dedupe, key) {
+  if (!hasIndexedDB()) {
+    memoryDedupeStoreFor(dedupe).delete(key);
+    return Promise.resolve();
+  }
+  return withDedupeStore(dedupe, "readwrite", (store, resolve, reject) => {
+    const request = store.delete(key);
+    request.onsuccess = () => resolve(void 0);
+    request.onerror = () => reject(request.error || new Error("Failed to delete dedupe record"));
+  });
+}
 function readMultipartPending(id) {
   return readStoreRecord(REI_SW_MULTIPART_STORE, id);
 }
@@ -646,9 +981,22 @@ async function withDatabaseStore(storeName, mode, handler) {
     Promise.resolve(handler(store, resolve, reject)).catch(reject);
   });
 }
+async function withDedupeStore(dedupe, mode, handler) {
+  const db = await openDedupeDatabase(dedupe);
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction(dedupe.storeName, mode);
+    const store = transaction.objectStore(dedupe.storeName);
+    transaction.onerror = () => reject(transaction.error || new Error("Dedupe transaction failed"));
+    Promise.resolve(handler(store, resolve, reject)).catch(reject);
+  });
+}
 function hasIndexedDB() {
   return typeof indexedDB !== "undefined" && indexedDB && typeof indexedDB.open === "function";
 }
+function memoryDedupeStoreFor(dedupe) {
+  if (!dedupe._memoryStore) dedupe._memoryStore = /* @__PURE__ */ new Map();
+  return dedupe._memoryStore;
+}
 function memoryStoreFor(storeName) {
   if (storeName === REI_SW_MULTIPART_DONE_STORE) return memoryMultipartDone;
   if (storeName === REI_SW_MULTIPART_STORE) return memoryMultipartPending;
@@ -659,6 +1007,31 @@ function cloneRecord(record) {
   if (record == null) return null;
   return JSON.parse(JSON.stringify(record));
 }
+function openDedupeDatabase(dedupe) {
+  const cacheKey = `${dedupe.dbName}:${dedupe.storeName}`;
+  const cached = dedupeDbCache.get(cacheKey);
+  if (cached) return Promise.resolve(cached);
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dedupe.dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      const store = db.objectStoreNames.contains(dedupe.storeName) ? request.transaction.objectStore(dedupe.storeName) : db.createObjectStore(dedupe.storeName, { keyPath: "key" });
+      if (store && !store.indexNames.contains("expiresAt")) {
+        store.createIndex("expiresAt", "expiresAt", { unique: false });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      dedupeDbCache.set(cacheKey, db);
+      db.onversionchange = () => {
+        db.close();
+        dedupeDbCache.delete(cacheKey);
+      };
+      resolve(db);
+    };
+    request.onerror = () => reject(request.error || new Error("Failed to open dedupe database"));
+  });
+}
 function openQueueDatabase() {
   if (cachedDB) return Promise.resolve(cachedDB);
   return new Promise((resolve, reject) => {
@@ -728,6 +1101,7 @@ async function removeQueuedRequest(id) {
   });
 }
 export {
+  REI_AMSG_DELIVER_MESSAGE_TYPE,
   REI_AMSG_POSTMESSAGE_TYPE,
   REI_SW_EVENT,
   REI_SW_MESSAGE_TYPE,

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@rei-standard/amsg-sw",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "ReiStandard Active Messaging service worker SDK — three-axis push schema (content / reasoning / tool_request / error) with per-kind client postMessage events",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Tosd0/ReiStandard",
+    "url": "git+https://github.com/Tosd0/ReiStandard.git",
     "directory": "packages/rei-standard-amsg/sw"
   },
   "license": "MIT",
@@ -33,7 +33,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@rei-standard/amsg-shared": "0.1.0"
+    "@rei-standard/amsg-shared": "0.2.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",