cross-tab-worker-databus 0.8.0 → 0.11.0

package/dist/cjs/index.cjs

@@ -339,6 +339,13 @@ function writeJson(storage, key, value) {
   } catch {
   }
 }
+function publicationMetadata(messageId, timestamp) {
+  if (messageId === void 0 && timestamp === void 0) return void 0;
+  return {
+    ...messageId === void 0 ? {} : { messageId },
+    ...timestamp === void 0 ? {} : { timestamp }
+  };
+}
 function listKeys(storage, prefix) {
   try {
     return Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter(
@@ -568,26 +575,21 @@ var WorkerClusterRuntime = class {
       this.sendRouteReleased(owner.workerId, topic, topicKey, generation);
     }
   }
-  /**
-   * Publish a message to `topic`, routing through the owning Worker (or self if
-   * no owner is found). Returns false when the control message could not be
-   * posted to a remote owner, so the caller can surface the failure instead of
-   * silently dropping the publication.
-   */
-  publish(topic, data, messageId) {
+  publish(topic, data, metadataOrMessageId) {
+    const metadata = typeof metadataOrMessageId === "string" ? { messageId: metadataOrMessageId } : metadataOrMessageId;
     const topicKey = this.rememberTopic(topic);
     if (this.assignedTopics.has(topicKey)) {
-      return this.sendControl(this.workerId, "PUBLISH", topic, topicKey, data, messageId);
+      return this.sendControl(this.workerId, "PUBLISH", topic, topicKey, data, metadata);
     }
     for (const pattern of this.assignedTopics.values()) {
       if (pattern !== topic && topicMatchesPattern(pattern, topic)) {
-        return this.sendControl(this.workerId, "PUBLISH", topic, topicKey, data, messageId);
+        return this.sendControl(this.workerId, "PUBLISH", topic, topicKey, data, metadata);
       }
     }
     const workers = this.readWorkers();
     const route = this.readRoute(topicKey);
     const target = this.routeOwnerIsLive(route, workers) ? route?.workerId ?? this.workerId : this.workerId;
-    return this.sendControl(target, "PUBLISH", topic, topicKey, data, messageId);
+    return this.sendControl(target, "PUBLISH", topic, topicKey, data, metadata);
   }
   /** True when `route` exists and its owner worker is among `workers`.
    * Shared by subscribe (skip re-assignment) and publish (route to owner).
@@ -709,11 +711,15 @@ var WorkerClusterRuntime = class {
       default:
         break;
     }
-    if (message.messageId === void 0) {
-      this.handlers.onControl(message.action, message.topic, message.data);
-    } else {
-      this.handlers.onControl(message.action, message.topic, message.data, message.messageId);
-    }
+    const metadata = publicationMetadata(message.messageId, message.timestamp);
+    if (metadata) this.handlers.onControl(
+      message.action,
+      message.topic,
+      message.data,
+      metadata.messageId,
+      metadata.timestamp
+    );
+    else this.handlers.onControl(message.action, message.topic, message.data);
     if (message.action !== "PUBLISH") this.updateLoad();
   }
   /**
@@ -830,7 +836,7 @@ var WorkerClusterRuntime = class {
    * Local execution updates the assignment map and route synchronously, bypassing
    * the BroadcastChannel latency.
    */
-  sendControl(targetWorkerId, action, topic, topicKey, data, messageId) {
+  sendControl(targetWorkerId, action, topic, topicKey, data, metadata) {
     if (targetWorkerId === this.workerId) {
       switch (action) {
         case "SUBSCRIBE":
@@ -844,8 +850,14 @@ var WorkerClusterRuntime = class {
         default:
           break;
       }
-      if (messageId === void 0) this.handlers.onControl(action, topic, data);
-      else this.handlers.onControl(action, topic, data, messageId);
+      if (metadata) this.handlers.onControl(
+        action,
+        topic,
+        data,
+        metadata.messageId,
+        metadata.timestamp
+      );
+      else this.handlers.onControl(action, topic, data);
       if (action !== "PUBLISH") this.updateLoad();
       return true;
     }
@@ -857,7 +869,8 @@ var WorkerClusterRuntime = class {
       topic,
       topicKey,
       ...data === void 0 ? {} : { data },
-      ...messageId === void 0 ? {} : { messageId }
+      ...metadata?.messageId === void 0 ? {} : { messageId: metadata.messageId },
+      ...metadata?.timestamp === void 0 ? {} : { timestamp: metadata.timestamp }
     });
   }
   /** Post a message on the BroadcastChannel. Returns false on postMessage failure. */
@@ -1078,6 +1091,8 @@ var DataBusTraceReporter = class {
   // Bucketed histogram: bucket index = floor(delayMs / 50), capped at 19.
   latencyBuckets = new Array(LATENCY_BUCKET_COUNT).fill(0);
   latencySumMs = 0;
+  dedupAccepted = 0;
+  dedupSuppressed = 0;
   constructor(options, now = Date.now) {
     this.enabled = options?.enabled ?? false;
     this.mode = options?.mode ?? "all";
@@ -1153,6 +1168,13 @@ var DataBusTraceReporter = class {
     this.latencyBuckets[bucketIndex] = (this.latencyBuckets[bucketIndex] ?? 0) + 1;
     this.latencySumMs += delayMs;
   }
+  /** Record deduplication outcomes for the next metrics window. */
+  recordDedupAccepted() {
+    if (this.metricsActive) this.dedupAccepted += 1;
+  }
+  recordDedupSuppressed() {
+    if (this.metricsActive) this.dedupSuppressed += 1;
+  }
   /** True when metrics recording is active: enabled and mode includes metrics.
    * Extracted so the four record / flush methods share one guard expression
    * instead of repeating `!this.enabled || this.mode === 'events'` at each. */
@@ -1166,7 +1188,7 @@ var DataBusTraceReporter = class {
   }
   flushNow() {
     const timestamp = this.now();
-    if (this.received > 0 || this.dispatched > 0) {
+    if (this.received > 0 || this.dispatched > 0 || this.dedupAccepted > 0 || this.dedupSuppressed > 0) {
       const samples = this.latencySamples;
       this.emit({
         type: "message_metrics",
@@ -1180,6 +1202,8 @@ var DataBusTraceReporter = class {
         dispatchP50Ms: roundMs(percentileMs(this.latencyBuckets, samples, 0.5)),
         dispatchP95Ms: roundMs(percentileMs(this.latencyBuckets, samples, 0.95)),
         dispatchMaxMs: roundMs(percentileMs(this.latencyBuckets, samples, 1)),
+        dedupAccepted: this.dedupAccepted,
+        dedupSuppressed: this.dedupSuppressed,
         timestamp
       });
       this.resetMetrics();
@@ -1194,6 +1218,8 @@ var DataBusTraceReporter = class {
     this.receivedAt.clear();
     this.latencyBuckets.fill(0);
     this.latencySumMs = 0;
+    this.dedupAccepted = 0;
+    this.dedupSuppressed = 0;
   }
   emit(event) {
     try {
@@ -1244,6 +1270,7 @@ var CrossTabDataBus = class _CrossTabDataBus {
   replayBuffers;
   replayMaxPerTopic;
   replayPersistence;
+  replayRetentionMs;
   replayHydration;
   initialConfig;
   hasInitialConfig;
@@ -1252,6 +1279,8 @@ var CrossTabDataBus = class _CrossTabDataBus {
   dedupTtlMs;
   dedupEnabled;
   seenMessageIds = /* @__PURE__ */ new Map();
+  dedupSuppressed = 0;
+  dedupAccepted = 0;
   activeConfig;
   status = "disconnected";
   started = false;
@@ -1289,6 +1318,10 @@ var CrossTabDataBus = class _CrossTabDataBus {
     this.replayMaxPerTopic = replay?.maxPerTopic ?? DEFAULT_REPLAY_MAX_PER_TOPIC;
     this.replayBuffers = replay ? /* @__PURE__ */ new Map() : null;
     this.replayPersistence = replay?.persistence ?? null;
+    this.replayRetentionMs = replay?.retentionMs;
+    if (this.replayRetentionMs !== void 0 && (!Number.isFinite(this.replayRetentionMs) || this.replayRetentionMs <= 0)) {
+      throw new TypeError("replay.retentionMs must be a positive finite number.");
+    }
     this.replayHydration = this.hydrateReplay();
     const { autoStart, initialConfig, trace, transport, dedup, ...clusterOptions } = options;
     this.transport = transport;
@@ -1309,7 +1342,7 @@ var CrossTabDataBus = class _CrossTabDataBus {
       handlers: {
         // The cluster calls `onControl` when it receives a SUBSCRIBE/UNSUBSCRIBE/PUBLISH
         // control message — meaning the owning Worker has delegated the action to us.
-        onControl: (action, topic, data, messageId) => {
+        onControl: (action, topic, data, messageId, timestamp) => {
           switch (action) {
             case "SUBSCRIBE":
               if (this.subscribeTransport(topic)) this.traceSubscription("subscribe", topic);
@@ -1318,7 +1351,14 @@ var CrossTabDataBus = class _CrossTabDataBus {
               if (this.unsubscribeTransport(topic)) this.traceSubscription("unsubscribe", topic);
               break;
             case "PUBLISH":
-              this.runTransport(() => this.transport.publish(topic, data, messageId ? { messageId } : void 0));
+              this.runTransport(() => this.transport.publish(
+                topic,
+                data,
+                messageId === void 0 && timestamp === void 0 ? void 0 : {
+                  ...messageId === void 0 ? {} : { messageId },
+                  ...timestamp === void 0 ? {} : { timestamp }
+                }
+              ));
               break;
             default:
               break;
@@ -1509,10 +1549,49 @@ var CrossTabDataBus = class _CrossTabDataBus {
       }
     }
   }
+  /** Clear replay history for one exact topic, including durable storage. */
+  async clearReplayTopic(topic) {
+    this.replayBuffers?.delete(topic);
+    if (this.replayPersistence?.clearTopic) {
+      try {
+        await this.replayPersistence.clearTopic(topic);
+      } catch (error) {
+        this.reportError(error);
+        throw error;
+      }
+    }
+  }
+  /** Remove replay entries older than an epoch-millisecond cutoff. */
+  async clearReplayBefore(timestamp) {
+    if (!Number.isFinite(timestamp)) throw new TypeError("timestamp must be finite.");
+    if (this.replayBuffers) {
+      for (const [topic, messages] of this.replayBuffers) {
+        const kept = messages.filter((message) => (message.timestamp ?? 0) >= timestamp);
+        if (kept.length) this.replayBuffers.set(topic, kept);
+        else this.replayBuffers.delete(topic);
+      }
+    }
+    if (this.replayPersistence?.clearBefore) await this.replayPersistence.clearBefore(timestamp);
+  }
+  /** Return bounded deduplication counters for diagnostics and health checks. */
+  getDedupStats() {
+    return {
+      enabled: this.dedupEnabled,
+      tracked: this.seenMessageIds.size,
+      suppressed: this.dedupSuppressed,
+      accepted: this.dedupAccepted
+    };
+  }
+  /** Drop all remembered IDs and reset dedup counters. */
+  resetDedup() {
+    this.seenMessageIds.clear();
+    this.dedupSuppressed = 0;
+    this.dedupAccepted = 0;
+  }
   /** Publish a message to `topic`. The owning Worker delivers it to the transport. */
   publish(topic, data, options) {
     this.ensureStarted();
-    if (!this.cluster.publish(topic, data, options?.messageId)) {
+    if (!this.cluster.publish(topic, data, options)) {
       this.reportError(
         new Error("Failed to send the publish control message to the owning worker.")
       );
@@ -1601,9 +1680,13 @@ var CrossTabDataBus = class _CrossTabDataBus {
     }
     if (this.seenMessageIds.has(message.messageId)) {
       this.trace.event({ type: "reliability", operation: "dedup_suppressed", topic: message.topic });
+      this.dedupSuppressed += 1;
+      this.trace.recordDedupSuppressed();
       return true;
     }
     this.seenMessageIds.set(message.messageId, now);
+    this.dedupAccepted += 1;
+    this.trace.recordDedupAccepted();
     while (this.seenMessageIds.size > this.dedupMaxEntries) {
       const oldest = this.seenMessageIds.keys().next().value;
       if (oldest === void 0) break;
@@ -1633,10 +1716,14 @@ var CrossTabDataBus = class _CrossTabDataBus {
       buffer = [];
       this.replayBuffers.set(message.topic, buffer);
     }
-    buffer.push(message);
+    const storedMessage = message;
+    buffer.push(storedMessage);
     if (buffer.length > this.replayMaxPerTopic) buffer.shift();
     if (this.replayPersistence) {
-      void this.replayPersistence.append(message).catch((error) => this.reportError(error));
+      void this.replayPersistence.append(storedMessage).catch((error) => this.reportError(error));
+      if (this.replayRetentionMs !== void 0 && this.replayPersistence.clearBefore) {
+        void this.replayPersistence.clearBefore(Date.now() - this.replayRetentionMs).catch((error) => this.reportError(error));
+      }
     }
   }
   async hydrateReplay() {
@@ -1644,6 +1731,9 @@ var CrossTabDataBus = class _CrossTabDataBus {
       return;
     }
     try {
+      if (this.replayRetentionMs !== void 0 && this.replayPersistence.clearBefore) {
+        await this.replayPersistence.clearBefore(Date.now() - this.replayRetentionMs);
+      }
       for (const message of await this.replayPersistence.load()) {
         let buffer = this.replayBuffers.get(message.topic);
         if (!buffer) {
@@ -1913,10 +2003,48 @@ function createIndexedDbReplayPersistence(options) {
         transaction.oncomplete = () => resolve();
         transaction.onerror = () => reject(transaction.error ?? new Error("Failed to clear topic replay history."));
       });
+    },
+    async clearBefore(timestamp) {
+      const db = await open();
+      await new Promise((resolve, reject) => {
+        const transaction = db.transaction(storeName, "readwrite");
+        const store = transaction.objectStore(storeName);
+        const request = store.getAll();
+        request.onsuccess = () => {
+          for (const record of request.result) {
+            const messages = record.messages.filter((message) => (message.timestamp ?? 0) >= timestamp);
+            if (messages.length === 0) store.delete(record.topic);
+            else if (messages.length !== record.messages.length) store.put({ topic: record.topic, messages });
+          }
+        };
+        request.onerror = () => reject(request.error ?? new Error("Failed to read replay history."));
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error ?? new Error("Failed to prune replay history."));
+      });
     }
   };
 }
 
+// src/core/publication.ts
+function parseDataBusPublication(value, fallbackTopic) {
+  if (!value || typeof value !== "object") {
+    return fallbackTopic ? { topic: fallbackTopic, data: value } : null;
+  }
+  const frame = value;
+  const nested = frame.publication && typeof frame.publication === "object" ? frame.publication : null;
+  const publication = nested ?? frame;
+  const topic = typeof publication.topic === "string" ? publication.topic : fallbackTopic;
+  if (!topic) return null;
+  const hasMetadataEnvelope = fallbackTopic !== void 0 && Object.prototype.hasOwnProperty.call(publication, "data") && (typeof publication.messageId === "string" || typeof publication.timestamp === "number");
+  const data = nested || fallbackTopic === void 0 || hasMetadataEnvelope ? publication.data : value;
+  return {
+    topic,
+    data,
+    ...typeof publication.messageId === "string" ? { messageId: publication.messageId } : {},
+    ...typeof publication.timestamp === "number" ? { timestamp: publication.timestamp } : {}
+  };
+}
+
 // src/websocket.ts
 var WS_OPEN = 1;
 var WebSocketTransport = class {
@@ -1966,10 +2094,16 @@ var WebSocketTransport = class {
   /** Publish `data` to `topic` as a JSON frame. Requires an open socket. */
   publish(topic, data, options) {
     if (data instanceof ArrayBuffer) {
-      this.sendBinaryFrame(topic, data, options?.messageId);
+      this.sendBinaryFrame(topic, data, options?.messageId, options?.timestamp);
       return;
     }
-    this.sendFrame({ op: "publish", topic, data, ...options?.messageId ? { messageId: options.messageId } : {} });
+    this.sendFrame({
+      op: "publish",
+      topic,
+      data,
+      ...options?.messageId === void 0 ? {} : { messageId: options.messageId },
+      ...options?.timestamp === void 0 ? {} : { timestamp: options.timestamp }
+    });
   }
   /** Close the socket and drop all state. Safe to call multiple times. */
   stop() {
@@ -1989,9 +2123,15 @@ var WebSocketTransport = class {
     }
     this.socket.send(JSON.stringify(payload));
   }
-  sendBinaryFrame(topic, data, messageId) {
-    if (messageId) {
-      this.sendFrame({ op: "publish", topic, data: Array.from(new Uint8Array(data)), messageId });
+  sendBinaryFrame(topic, data, messageId, timestamp) {
+    if (messageId !== void 0 || timestamp !== void 0) {
+      this.sendFrame({
+        op: "publish",
+        topic,
+        data: Array.from(new Uint8Array(data)),
+        ...messageId === void 0 ? {} : { messageId },
+        ...timestamp === void 0 ? {} : { timestamp }
+      });
       return;
     }
     if (this.socket?.readyState !== WS_OPEN) {
@@ -2033,14 +2173,8 @@ var WebSocketTransport = class {
       return;
     }
     if (!parsed || typeof parsed !== "object") return;
-    const frame = parsed;
-    if (typeof frame.topic !== "string") return;
-    const message = {
-      topic: frame.topic,
-      data: frame.data,
-      ...typeof frame.messageId === "string" ? { messageId: frame.messageId } : {}
-    };
-    this.handlers?.onMessage(message);
+    const publication = parseDataBusPublication(parsed);
+    if (publication) this.handlers?.onMessage(publication);
   }
 };
 function defaultWebSocketFactory(url, protocols) {