@rei-standard/amsg-sw 2.1.0 → 2.2.0

package/README.md

@@ -52,7 +52,10 @@ navigator.serviceWorker.addEventListener('message', (e) => {
 - `"when-hidden"`：仅当没有 `visibilityState === "visible"` 的客户端时才弹系统通知。如果应用在前台，则静默。
 - `false`：强制不弹通知，即使是 `content`。适合完全交给应用自行接管或自绘弹窗的场景。
 
-当设置了弹通知时，通知文案完全由 `payload.notification` 决定（支持 `title`, `body`, `icon`, `badge`, `tag`, `data` 等字段）。如果缺省，会后备到 payload 根级属性。
+当设置了弹通知时，通知文案完全由 `payload.notification` 决定（支持 `title`, `body`, `icon`, `badge`, `tag`, `renotify`, `requireInteraction`, `silent`, `data` 等字段）。如果缺省，会后备到 payload 根级属性。
+
+> **APNs / iOS Web Push 提醒**
+> 如果业务大量发送后台 push 却长期不展示可见通知，iOS Web Push 的送达可能被系统策略影响。生产环境建议对后台消息使用 `notification.show = "always"` 或 `"when-hidden"`，再配合 `tag` 折叠与 `silent: true` 降低打扰。
 
 #### 场景示例
 
@@ -88,9 +91,92 @@ navigator.serviceWorker.addEventListener('message', (e) => {
 > **注意：对于 multipart 传输**
 > 当 payload 通过 `_multipart` 分片时，未收齐前不仅不派发业务事件，也**绝不**弹系统通知。收齐并还原为原始 payload 后，再按原始 payload 的 `notification.show` 策略执行判定。
 
+### Delivery dedupe（通知前去重）
+
+`installReiSW()` 默认启用包级 dedupe。所有业务 payload 不管来自 Web Push、multipart 还原、blob envelope，还是页面通过 `postMessage` 桥接进 SW，都会先经过同一个 gate：
+
+```
+dedupe -> notification.show 策略 -> showNotification / postMessage / onBusinessPayload
+```
+
+第一次到达的 payload 会正常走 `notification.show` 策略、窗口广播和 `onBusinessPayload`。重复 payload **不会**再次广播，也**不会**再次调用 `onBusinessPayload`；如果第一次到达时因为前台可见等原因没有展示系统通知，而后到的 Web Push backup 已经满足 `notification.show` 条件，SW 会只补一次系统通知，然后把结果放进 `onDuplicate(info)`。这层去重发生在业务落地前面，不依赖业务层 inbox 自己兜底。
+
+默认 key 按顺序读取：
+
+1. `payload.messageId`
+2. `payload.id`
+3. `payload.dedupeKey`
+
+没有 key 时不去重，保持旧 payload 兼容。multipart 会先还原成原始 payload 再取 key；blob envelope 如果携带 `messageId` / `id` / `dedupeKey`，也会被同一套 gate 覆盖。
+
+```js
+installReiSW(self, {
+  dedupe: {
+    enabled: true,              // 默认 true
+    ttlMs: 10 * 60_000,         // 默认 10 分钟
+    dbName: 'rei_amsg_sw_dedupe_v1', // 想隔离另一套去重数据就改这个；每个 dbName 是独立 IDB instance
+    key: (payload) => payload.messageId,
+  },
+  onDuplicate: async (info) => {
+    // { key, source, messageKind, firstSeenAt, existingSource,
+    //   existingMessageKind, existingNotificationShown, duplicateNotificationShown }
+  },
+});
+```
+
+实现使用 IndexedDB 的 `add()` + keyPath 做原子 claim：第一次 add 成功才放行；几乎同时到达的同 key payload，后到者会命中 `ConstraintError` 并作为 duplicate 返回。TTL 清理是懒清理，不需要 KV / D1 / Durable Object。
+
+### 页面 -> SW 业务投递
+
+SSE 默认先进页面主线程。若要让 SSE payload 和 Web Push backup 共用 SW 的 dedupe / notification / `onBusinessPayload` 管线，页面可以把 payload 转交给 SW：
+
+```js
+const registration = await navigator.serviceWorker.ready;
+const channel = new MessageChannel();
+
+channel.port1.onmessage = (event) => {
+  // 成功：{ ok: true, duplicate?: boolean, key?: string, requestId?: string }
+  // 失败：{ ok: false, error: string, key?: string, requestId?: string }
+};
+
+registration.active?.postMessage({
+  type: 'REI_AMSG_DELIVER',
+  source: 'sse',
+  requestId: crypto.randomUUID(),
+  payload,
+}, [channel.port2]);
+```
+
+Web Push `push` event 和 `REI_AMSG_DELIVER` 最终都会进入同一个内部 pipeline。SSE 先到时，后来的 Web Push backup 会被 dedupe；Web Push 先到时，后来的 SSE bridge 也会被 dedupe。若首包已经落过业务但没弹通知，重复包只负责按当前 `notification.show` 策略补通知，不会重复触发业务回调。
+
+### 生产推荐链路：SSE + Web Push backup + SW dedupe
+
+0.9.0 / 2.2.0 起，正式环境推荐把“双路投递、包层去重”当作默认责任边界。`amsg-instant` 固定 `backupPush:'on'`，所以 Worker 不需要等断线才发 backup；client 收到 SSE 后应立刻桥接给 SW；SW 负责统一去重、补通知和业务落地。
+
+| 环节 | 包配置 / 调用 | 推荐值 | 责任 |
+|------|---------------|--------|------|
+| Worker 侧 SSE | `createInstantHandler({ sse })` | 可省略；等价于 `backupPush:'on'`, `keepaliveMs:1_000`, `immediateKeepalive:true` | SSE 正常流式返回，同时每条 payload 都发 Web Push backup |
+| Client 侧 SSE → SW | `consumeInstantStream(..., { onPayload })` 内立刻 `postMessage({ type:'REI_AMSG_DELIVER', payload, source:'sse', requestId })` | 强烈推荐 | 让 SSE 与 Web Push 进入同一条 SW delivery / dedupe 管线 |
+| SW 侧 dedupe | `installReiSW(self, { dedupe })` | 可省略；默认启用，key 为 `messageId` → `id` → `dedupeKey`，TTL 10 分钟 | 先到者触发业务，后到者不重复入库；必要时只补系统通知 |
+| 通知策略 | `payload.notification.show` | 普通内容推荐 `'when-hidden'`；低打扰更新可加 `silent:true` + `tag` | 前台交给 UI，隐藏/关闭后由 Web Push backup 补通知 |
+
+一个最小形态：
+
+```js
+installReiSW(self, {
+  defaultIcon: './icons/icon-192.png',
+  defaultBadge: './icons/icon-192.png',
+  multipart: { enabled: true },
+  onBusinessPayload: async (payload) => persistIncomingPayload(payload),
+  onDuplicate: async (info) => traceDuplicate(info),
+});
+```
+
+这样当前台页面还活着时，SSE bridge 先进入 SW，`notification.show:'when-hidden'` 不弹系统通知但会触发业务落地；如果页面随后隐藏或已关闭，Web Push backup 到达 SW 后会命中同一个 key，只补通知，不重复调用 `onBusinessPayload`。
+
 ### 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 行为一致。
+当 `amsg-instant` 检测到 payload 超过 `maxInlineBytes` 时会改发 blob envelope `{ _blob: true, key, url, messageKind?, type?, messageId?, id?, dedupeKey? }`。SW **不会** 自动 fetch blob 内容（那是 client 的职责），但仍然会按 envelope 上的 `messageKind` 分发对应事件，让 client 知道有什么类型的内容即将到达，自己决定要不要拉取。Blob envelope 也只在 `messageKind === 'content'`（或缺失）时才渲染占位通知，与普通 push 行为一致。
 
 ### Generic multipart transport（2.1.0+）
 

package/dist/index.cjs

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
+  REI_AMSG_DELIVER_MESSAGE_TYPE: () => REI_AMSG_DELIVER_MESSAGE_TYPE,
   REI_AMSG_POSTMESSAGE_TYPE: () => REI_AMSG_POSTMESSAGE_TYPE,
   REI_SW_EVENT: () => REI_SW_EVENT,
   REI_SW_MESSAGE_TYPE: () => REI_SW_MESSAGE_TYPE,
@@ -33,6 +34,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";
@@ -46,6 +51,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",
@@ -57,27 +64,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;
@@ -88,6 +107,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));
     }
@@ -103,16 +126,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 {
@@ -122,40 +177,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;
@@ -178,6 +234,19 @@ function isNotificationKind(payload) {
   if (kind === void 0 || kind === null) return true;
   return kind === import_amsg_shared.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({
@@ -222,7 +291,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;
@@ -237,7 +306,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)
     }
   };
 }
@@ -257,15 +327,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,
@@ -564,6 +837,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);
 }
@@ -672,9 +1008,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;
@@ -685,6 +1034,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) => {