cross-tab-worker-databus 0.20.59 → 0.20.61

package/CHANGELOG.md

@@ -1,4 +1,25 @@
 # Changelog
+
+## [0.20.61] - 2026-09-05
+
+### Added
+- `originTabId?: string` on every `DataBusMessage` (and on the cluster `EVENT` wire frame) so cross-tab replay history is attributed to the tab that produced it.
+- `WorkerClusterRuntime.broadcastEvent()` now defaults `originTabId` to the producing runtime's `tabId` so existing callers (and tests) get source-tab attribution without threading the value manually.
+- `CrossTabDataBus.handleTransportMessage` stamps `originTabId = cluster.tabId` before broadcasting, so neighbors and IndexedDB-replayed late subscribers see the same attribution.
+- Four unit tests under `CrossTabDataBus cross-tab replay consistency contract` cover the producing-tab stamp, local-handler parity, post-write late join with replay, and local-origin replay path.
+- One e2e replay-persistence test now uses `toMatchObject` to tolerate the additional `originTabId` field on persisted entries.
+
+### Changed
+- `WorkerClusterRuntime.onEvent` handler signature now includes a fourth `originTabId?: string` argument; existing call sites use `toMatchObject` so the extra argument does not break strict equality.
+
+# [0.20.60] - 2026-09-04
+
+### Added
+- `publishBatch(topic, items)` on both `CrossTabDataBus` and `WorkerClusterRuntime` packs multiple items into a single BroadcastChannel postMessage so the receiving owner can dispatch them in one tick instead of one channel post per item.
+- Per-item `messageId` / `timestamp` is preserved across the batched wire frame, so dedup / replay / ordering still apply per item in the original order.
+- Empty batch is a no-op; single-item batch delegates to `publish()` so callers do not have to special-case the boundary.
+- Added a `data bus hot paths` bench case (`publishBatch / 1000 messages / 10 per call`) to give an upper-bound reference for the burst path.
+
 ## [0.20.59] - 2026-09-04
 
 ### Added

package/dist/centrifuge.js

@@ -2,7 +2,7 @@ import {
   CrossTabDataBus,
   parseDataBusPublication,
   selectWorkerBackend
-} from "./chunk-RAUX7RZC.js";
+} from "./chunk-VB4P6DS6.js";
 
 // src/centrifuge-session.ts
 import { Centrifuge } from "centrifuge";

package/dist/{chunk-RAUX7RZC.js → chunk-VB4P6DS6.js}

@@ -572,6 +572,67 @@ var WorkerClusterRuntime = class {
       }
       this.wildcardPublishCache.set(topic, null);
     }
+    return this.sendControl(this.resolvePublishTarget(topic, topicKey), "PUBLISH", topic, topicKey, data, metadata);
+  }
+  /**
+   * Burst-friendly variant of `publish()`: packs up to N items into a single
+   * BroadcastChannel postMessage so the receiving owner dispatches them all in
+   * one tick. Per-item dedup / replay / dispatch ordering is preserved; items
+   * may carry their own messageId/timestamp. Empty batch is a no-op,
+   * single-item batch delegates to `publish()`.
+   */
+  publishBatch(topic, items) {
+    if (items.length === 0) return true;
+    if (items.length === 1) {
+      const single = items[0];
+      const metadata = single.messageId !== void 0 || single.timestamp !== void 0 ? {
+        ...single.messageId !== void 0 ? { messageId: single.messageId } : {},
+        ...single.timestamp !== void 0 ? { timestamp: single.timestamp } : {}
+      } : void 0;
+      return this.publish(topic, single.data, metadata);
+    }
+    const topicKey = this.rememberTopic(topic);
+    if (this.assignedTopics.has(topicKey)) {
+      for (const item of items) this.dispatchLocalPublish(topic, topicKey, item.data, item.messageId, item.timestamp);
+      return true;
+    }
+    const cachedPattern = this.wildcardPublishCache.get(topic);
+    if (cachedPattern !== void 0 && cachedPattern !== null && this.assignedTopics.has(cachedPattern)) {
+      for (const item of items) this.dispatchLocalPublish(topic, topicKey, item.data, item.messageId, item.timestamp);
+      return true;
+    }
+    if (cachedPattern === void 0) {
+      for (const pattern of this.assignedTopics.values()) {
+        if (pattern !== topic && topicMatchesPattern(pattern, topic)) {
+          this.wildcardPublishCache.set(topic, pattern);
+          for (const item of items) this.dispatchLocalPublish(topic, topicKey, item.data, item.messageId, item.timestamp);
+          return true;
+        }
+      }
+      this.wildcardPublishCache.set(topic, null);
+    }
+    const target = this.resolvePublishTarget(topic, topicKey);
+    if (target === this.workerId) {
+      for (const item of items) this.dispatchLocalPublish(topic, topicKey, item.data, item.messageId, item.timestamp);
+      return true;
+    }
+    return this.send({
+      type: "CONTROL",
+      sourceWorkerId: this.workerId,
+      targetWorkerId: target,
+      action: "PUBLISH",
+      topic,
+      topicKey,
+      items: items.map((item) => ({
+        data: item.data,
+        ...item.messageId !== void 0 ? { messageId: item.messageId } : {},
+        ...item.timestamp !== void 0 ? { timestamp: item.timestamp } : {}
+      }))
+    });
+  }
+  /** Resolve which worker should receive a PUBLISH for `topic`. Centralises the
+   * route-owner cache lookup so `publish()` and `publishBatch()` share one path. */
+  resolvePublishTarget(topic, topicKey) {
     const workers = this.readWorkers();
     const route = this.readRoute(topicKey);
     const cached = this.routeOwnerCache.get(topicKey);
@@ -579,9 +640,19 @@ var WorkerClusterRuntime = class {
     if (cachedLive) this.routeOwnerCacheHits += 1;
     else this.routeOwnerCacheMisses += 1;
     const target = cachedLive ? cached.workerId : this.routeOwnerIsLive(route, workers) ? route?.workerId ?? this.workerId : this.workerId;
-    if (route && target === route.workerId) this.touchRouteOwnerCache(topicKey, { workerId: route.workerId, generation: route.generation });
-    else this.routeOwnerCache.delete(topicKey);
-    return this.sendControl(target, "PUBLISH", topic, topicKey, data, metadata);
+    if (route && target === route.workerId) {
+      this.touchRouteOwnerCache(topicKey, { workerId: route.workerId, generation: route.generation });
+    } else {
+      this.routeOwnerCache.delete(topicKey);
+    }
+    return target;
+  }
+  /** Fan out a single batched item to the local onControl path. */
+  dispatchLocalPublish(topic, topicKey, data, messageId, timestamp) {
+    void topicKey;
+    const meta = publicationMetadata(messageId, timestamp);
+    if (meta) this.handlers.onControl("PUBLISH", topic, data, meta.messageId, meta.timestamp);
+    else this.handlers.onControl("PUBLISH", topic, data);
   }
   /** True when `route` exists and its owner worker is among `workers`.
    * Shared by subscribe (skip re-assignment) and publish (route to owner).
@@ -590,9 +661,12 @@ var WorkerClusterRuntime = class {
   routeOwnerIsLive(route, workers) {
     return Boolean(route && workers.some((worker) => worker.workerId === route.workerId));
   }
-  /** Broadcast an event to every tab — used to fan out transport publications. */
-  broadcastEvent(eventType, payload) {
-    this.send({ type: "EVENT", sourceWorkerId: this.workerId, eventType, payload });
+  /** Broadcast an event to every tab — used to fan out transport publications.
+   * `originTabId` (when set) is propagated across the BroadcastChannel hop so
+   * listeners can attribute the event to its source tab even after fan-out. */
+  broadcastEvent(eventType, payload, originTabId) {
+    const effectiveOriginTabId = originTabId ?? this.tabId;
+    this.send({ type: "EVENT", sourceWorkerId: this.workerId, eventType, payload, originTabId: effectiveOriginTabId });
   }
   isAssigned(topic) {
     const topicKey = createOpaqueKey(topic);
@@ -680,7 +754,7 @@ var WorkerClusterRuntime = class {
       case "ROUTE_RELEASED":
         return this.handleRouteReleasedMessage(message);
       case "EVENT":
-        this.handlers.onEvent(message.eventType, message.payload, message.sourceWorkerId);
+        this.handlers.onEvent(message.eventType, message.payload, message.sourceWorkerId, message.originTabId);
         return;
       case "REGISTRY":
       default:
@@ -701,6 +775,15 @@ var WorkerClusterRuntime = class {
         if (this.releaseHandoffOnUnsubscribe(message)) return;
         break;
       case "PUBLISH":
+        if (message.items && message.items.length > 0) {
+          for (const item of message.items) {
+            const itemMeta = publicationMetadata(item.messageId, item.timestamp);
+            if (itemMeta) this.handlers.onControl("PUBLISH", message.topic, item.data, itemMeta.messageId, itemMeta.timestamp);
+            else this.handlers.onControl("PUBLISH", message.topic, item.data);
+          }
+          return;
+        }
+        break;
       default:
         break;
     }
@@ -1423,9 +1506,10 @@ var CrossTabDataBus = class {
         // typed `unknown` at the cluster boundary (the cluster is transport-
         // agnostic); here we narrow it to DataBusMessage — the sender is our
         // own broadcastEvent call, which always posts a DataBusMessage.
-        onEvent: (eventType, payload) => {
+        onEvent: (eventType, payload, _sourceWorkerId, originTabId) => {
           if (eventType !== PUBLICATION_EVENT) return;
-          const message = payload;
+          const incoming = payload;
+          const message = incoming.originTabId !== void 0 ? incoming : originTabId !== void 0 ? { ...incoming, originTabId } : incoming;
           if (this.cluster.hasLocalSubscriber(message.topic)) this.dispatch(message);
         },
         onSuspend: () => {
@@ -1670,6 +1754,32 @@ var CrossTabDataBus = class {
       );
     }
   }
+  /**
+   * Burst-friendly variant of `publish()`: delivers `items` in a single
+   * BroadcastChannel postMessage so the receiving owner can dispatch them all
+   * in one tick. Per-item dedup / replay / ordering is preserved; each item
+   * may carry its own `messageId` / `timestamp` via `options`. Empty array is
+   * a no-op; single-item array delegates to `publish()`.
+   */
+  publishBatch(topic, items) {
+    this.ensureStarted();
+    if (items.length === 0) return;
+    if (items.length === 1) {
+      const first = items[0];
+      this.publish(topic, first.data, first.options);
+      return;
+    }
+    const mapped = items.map((item) => ({
+      data: item.data,
+      ...item.options?.messageId !== void 0 ? { messageId: item.options.messageId } : {},
+      ...item.options?.timestamp !== void 0 ? { timestamp: item.options.timestamp } : {}
+    }));
+    if (!this.cluster.publishBatch(topic, mapped)) {
+      this.reportError(
+        new Error("Failed to send the batched publish control message to the owning worker.")
+      );
+    }
+  }
   /** Register a handler that fires on every transport status change. Immediately invoked with the current status. */
   onStatus(handler) {
     this.statusHandlers.add(handler);
@@ -1762,9 +1872,10 @@ var CrossTabDataBus = class {
       this.trace.recordDiscarded(message.topic);
       return;
     }
-    this.cluster.broadcastEvent(PUBLICATION_EVENT, message);
+    const stamped = message.originTabId === void 0 ? { ...message, originTabId: this.cluster.tabId } : message;
+    this.cluster.broadcastEvent(PUBLICATION_EVENT, stamped, stamped.originTabId);
     if (this.cluster.hasLocalSubscriber(message.topic)) {
-      this.dispatch(message);
+      this.dispatch(stamped);
       return;
     }
     this.trace.recordDiscarded(message.topic);
@@ -2182,4 +2293,4 @@ export {
   parseDataBusPublication,
   selectWorkerBackend
 };
-//# sourceMappingURL=chunk-RAUX7RZC.js.map
+//# sourceMappingURL=chunk-VB4P6DS6.js.map