@spine-event-engine/server 2.0.0-snapshot.2 → 2.0.0-snapshot.21

package/dist/delivery/delivery.js

@@ -14,13 +14,15 @@
 import { clone, create } from "@bufbuild/protobuf";
 import { AnySchema } from "@bufbuild/protobuf/wkt";
 import { randomUUID } from "node:crypto";
+import { TenantIdSchema } from "@spine-event-engine/proto";
 import { WorkerIdSchema } from "@spine-event-engine/proto/delivery";
 import { AlreadyPickedUp, DeliveryMonitor, FailedPickUp, FailedReception, } from "./delivery-monitor.js";
 import { Inbox, InboxTargets } from "./inbox.js";
-import { InboxStorage } from "./inbox-storage.js";
+import { InboxStorage, InboxStorageClock } from "./inbox-storage.js";
 import { ShardIndex } from "./shard-index.js";
 import { ShardedWorkRegistry } from "./sharded-work-registry.js";
 import { withDeliveryCommitFence } from "../repository/commit-fence.js";
+const deliveryFailureLimit = 100;
 /**
  * Executes direct Inbox delivery for one complete worker identity.
  */
@@ -70,7 +72,7 @@ export class Delivery {
             options.worker.nodeId?.value !== options.node) {
             throw new Error("Delivery worker node must match the configured delivery node.");
         }
-        this.context = Object.freeze({ ...options.context });
+        this.context = Delivery.#contextSnapshot(options.context);
         this.storageFactory = options.storageFactory;
         this.strategy = options.strategy ?? { shardCount: 1, shardFor: () => ShardIndex.single() };
         this.worker =
@@ -137,18 +139,34 @@ export class Delivery {
      * @returns The terminal direct-delivery result.
      */
     async drainMessage(message, input) {
-        const onMessage = typeof input === "function" ? input : input.onMessage;
-        const observeDelivered = typeof input === "function" ? undefined : input.onDelivered;
+        return this.#drainDirect(message, this.#directInput(input));
+    }
+    #directInput(input) {
+        return typeof input === "function" ? { onMessage: input } : input;
+    }
+    static #contextSnapshot(context) {
+        return Object.freeze(context.multitenant
+            ? {
+                name: context.name,
+                multitenant: true,
+                tenantId: clone(TenantIdSchema, context.tenantId),
+            }
+            : { name: context.name, multitenant: false });
+    }
+    async #drainDirect(message, input) {
         let acknowledged = false;
         const run = await this.drain(message.shard, {
-            onMessage,
-            ...(typeof input === "function" || input.acceptMessage === undefined
-                ? {}
-                : { acceptMessage: input.acceptMessage }),
+            onMessage: input.onMessage,
+            ...(input.acceptMessage === undefined ? {} : { acceptMessage: input.acceptMessage }),
             onDelivered: (next) => {
                 acknowledged ||=
                     next.id.value === message.id.value && next.id.shard.key() === message.id.shard.key();
-                observeDelivered?.(next);
+                input.onDelivered?.(next);
+            },
+            onDuplicateRemoved: (next) => {
+                acknowledged ||=
+                    next.id.value === message.id.value && next.id.shard.key() === message.id.shard.key();
+                input.onDuplicateRemoved?.(next);
             },
         });
         return Object.freeze({ run, acknowledged });
@@ -179,162 +197,405 @@ export class Delivery {
             const released = await safelyValue(() => this.shards.release(session), false);
             return result(released ? "STOPPED" : "FAILED");
         }
-        const statistics = counts();
-        const failures = [];
-        const complete = (status, value = statistics, runFailures = failures) => result(status, value, runFailures);
-        let current = session;
-        const ownership = { lost: false };
-        const validate = async () => {
-            const validated = await safelyValue(() => this.shards.validateOwnership(current, options.operation), undefined);
-            if (validated === undefined) {
-                ownership.lost = true;
-                return false;
+        return new DeliveryDrain({
+            inbox: this.inbox,
+            monitor: this.#monitor,
+            options,
+            pageSize: this.pageSize,
+            session,
+            shards: this.shards,
+            shard,
+        }).run();
+    }
+}
+/**
+ * Processes inbox pages while retaining one shard session.
+ */
+class DeliveryDrain {
+    input;
+    #statistics = counts();
+    #failures = [];
+    #deduplication;
+    #blockedTargets = new Set();
+    #removedInPage = new Set();
+    #current;
+    #ownershipLost = false;
+    #failureLimitReached = false;
+    /**
+     * Creates a drain for one acquired shard session.
+     *
+     * @param input Supplies the inbox, callbacks, and shard session.
+     */
+    constructor(input) {
+        this.input = input;
+        this.#current = input.session;
+        this.#deduplication = new DeliveryDeduplication(input.inbox);
+    }
+    /**
+     * Executes delivery and releases the shard session.
+     *
+     * @returns The terminal delivery outcome and counts.
+     */
+    async run() {
+        let run;
+        try {
+            run = (await this.#canStart()) ? await this.#readPages() : this.#complete("STOPPED");
+        }
+        catch (error) {
+            if (!(await this.#release()))
+                return this.#complete("FAILED");
+            throw error;
+        }
+        return (await this.#release()) ? run : this.#complete("FAILED");
+    }
+    /**
+     * Removes the session and reports completion when release succeeds.
+     *
+     * @returns Whether the session was released.
+     */
+    async #release() {
+        const released = await safelyValue(() => this.input.shards.release(this.#current, this.input.options.operation), false);
+        if (released)
+            await safely(() => this.#completeMonitoring());
+        return released;
+    }
+    /**
+     * Checks whether monitoring permits this drain to start.
+     *
+     * @returns Whether page processing may start.
+     */
+    async #canStart() {
+        if (!(await safelyBoolean(() => this.input.monitor.shouldContinueAfter("DELIVERY"))))
+            return false;
+        return safely(() => this.input.monitor.onDeliveryStarted(this.input.shard));
+    }
+    /**
+     * Reads and processes inbox pages until the shard is drained or stopped.
+     *
+     * @returns The terminal delivery outcome.
+     */
+    async #readPages() {
+        let after;
+        let deliveredInScan = false;
+        for (;;) {
+            const messages = await this.#readPage(after);
+            this.#removedInPage.clear();
+            if (messages.length === 0) {
+                if (!deliveredInScan)
+                    return this.#complete("DRAINED");
+                after = undefined;
+                deliveredInScan = false;
+                continue;
             }
-            current = validated;
-            return true;
-        };
-        const cleanupPage = async () => {
-            if (this.inbox.removeDelivered === undefined)
-                return true;
-            if (!(await validate()))
-                return false;
-            let after;
-            for (let page = 0; page < 2; page += 1) {
-                let removedAny = false;
-                const delivered = await this.inbox.read(shard, {
-                    statuses: ["DELIVERED"],
-                    limit: this.pageSize,
-                    ...(after === undefined ? {} : { after }),
-                    ...(options.operation ?? {}),
-                });
-                for (const message of delivered) {
-                    if (options.operation?.signal?.aborted || !(await validate()))
-                        return false;
-                    const removed = await this.inbox.removeDelivered(message, current, options.operation);
-                    if (options.operation?.signal?.aborted || (!removed && !(await validate())))
-                        return false;
-                    removedAny ||= removed;
-                }
-                const last = delivered.at(-1);
-                if (removedAny || last === undefined || delivered.length < this.pageSize)
-                    break;
-                after = {
-                    messageId: last.id.value,
-                    whenReceived: last.whenReceived,
-                    version: last.version,
-                };
+            const deliveredBefore = this.#statistics.delivered;
+            if (!(await this.#processPage(messages)))
+                return this.#complete("STOPPED");
+            if (!(await this.#cleanupPage(messages)))
+                return this.#complete("STOPPED");
+            deliveredInScan ||= this.#statistics.delivered !== deliveredBefore;
+            if (messages.length < this.input.pageSize) {
+                if (!deliveredInScan)
+                    return this.#complete("DRAINED");
+                after = undefined;
+                deliveredInScan = false;
+                continue;
             }
+            const survivor = messages.findLast((message) => !this.#removedInPage.has(message));
+            if (survivor !== undefined)
+                after = this.#continuation([survivor]);
+        }
+    }
+    /**
+     * Reads the next inbox page after an optional continuation.
+     *
+     * @param after Supplies the prior page position, when present.
+     * @returns The ordered inbox messages in the next page.
+     */
+    #readPage(after) {
+        return this.input.inbox.read(this.input.shard, {
+            limit: this.input.pageSize,
+            ...(after === undefined ? {} : { after }),
+            ...(this.input.options.operation ?? {}),
+        });
+    }
+    /**
+     * Processes every message in one page.
+     *
+     * @param messages Supplies the inbox page to process.
+     * @returns Whether page processing may continue.
+     */
+    async #processPage(messages) {
+        const page = this.#deduplication.page(messages, this.#retentionTime());
+        for (const message of messages) {
+            if (!(await this.#processMessage(message, page)))
+                return false;
+            if (this.#failureLimitReached)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Processes one message unless it is skipped or its target is blocked.
+     *
+     * @param message Supplies the inbox message.
+     * @param page Provides duplicate checks for this page.
+     * @returns Whether processing may continue.
+     */
+    async #processMessage(message, page) {
+        if (this.input.options.operation?.signal?.aborted)
+            return false;
+        if (this.#shouldSkip(message))
             return true;
-        };
-        const dispatch = (message) => withDeliveryCommitFence(async () => {
-            if (!(await validate()))
-                throw new Error("Shard ownership was lost.");
-        }, () => Promise.resolve(options.onMessage(message)));
-        const markDelivered = async (message) => {
-            if ((await this.inbox.markDelivered(message, options.operation)) === undefined)
-                throw new Error("Inbox message was not marked delivered.");
-            statistics.delivered += 1;
-            options.onDelivered?.(message);
-        };
+        const target = this.#targetKey(message);
+        if (this.#blockedTargets.has(target))
+            return true;
+        this.#statistics.processed += 1;
+        if (!(await this.#mayProcess()))
+            return false;
+        if (page.isDuplicate(message))
+            return this.#removeDuplicate(message, target);
+        return this.#deliver(message, target);
+    }
+    /**
+     * Determines whether an inbox message is ineligible for endpoint delivery.
+     *
+     * @param message Supplies the message to check.
+     * @returns Whether the message should be skipped.
+     */
+    #shouldSkip(message) {
+        return (message.status !== "TO_DELIVER" ||
+            !isEndpointMessage(message) ||
+            (this.input.options.acceptMessage !== undefined && !this.input.options.acceptMessage(message)));
+    }
+    /**
+     * Builds the key used to block further messages for one target.
+     *
+     * @param message Supplies the inbox message.
+     * @returns The target type and ID key.
+     */
+    #targetKey(message) {
+        return `${message.inboxId.targetTypeUrl}:${InboxTargets.key(message.inboxId.targetId)}`;
+    }
+    /**
+     * Checks monitoring and verifies that the shard session remains current.
+     *
+     * @returns Whether this message may be processed.
+     */
+    async #mayProcess() {
+        return ((await safelyBoolean(() => this.input.monitor.shouldContinueAfter("PAGE"))) &&
+            (await this.#validate()));
+    }
+    /**
+     * Removes a duplicate message and records a failure if removal fails.
+     *
+     * @param message Supplies the duplicate message.
+     * @param target Identifies the target to block after a failure.
+     * @returns Whether processing may continue.
+     */
+    async #removeDuplicate(message, target) {
         try {
-            if (!(await safelyBoolean(() => this.#monitor.shouldContinueAfter("DELIVERY"))))
-                return complete("STOPPED");
-            if (!(await safely(() => this.#monitor.onDeliveryStarted(shard))))
-                return complete("STOPPED");
-            const blockedTargets = new Set();
-            let after;
-            for (;;) {
-                const messages = await this.inbox.read(shard, {
-                    statuses: ["TO_DELIVER"],
-                    limit: this.pageSize,
-                    ...(after === undefined ? {} : { after }),
-                    ...(options.operation ?? {}),
-                });
-                if (messages.length === 0) {
-                    if (!(await cleanupPage()))
-                        return complete("STOPPED");
-                    break;
-                }
-                const deliveredBefore = statistics.delivered;
-                for (const message of messages) {
-                    if (options.operation?.signal?.aborted)
-                        return complete("STOPPED");
-                    if (!isEndpointMessage(message))
-                        continue;
-                    if (options.acceptMessage !== undefined && !options.acceptMessage(message))
-                        continue;
-                    const target = `${message.inboxId.targetTypeUrl}:${InboxTargets.key(message.inboxId.targetId)}`;
-                    if (blockedTargets.has(target))
-                        continue;
-                    statistics.processed += 1;
-                    if (!(await safelyBoolean(() => this.#monitor.shouldContinueAfter("PAGE"))))
-                        return complete("STOPPED");
-                    if (!(await validate()))
-                        return complete("STOPPED");
-                    try {
-                        statistics.accepted += 1;
-                        await dispatch(message);
-                        if (options.operation?.signal?.aborted)
-                            return complete("STOPPED");
-                        if (!(await validate()))
-                            return complete("STOPPED");
-                        await markDelivered(message);
-                    }
-                    catch (error) {
-                        statistics.failed += 1;
-                        failures.push(Object.freeze({ message: snapshot(message), error }));
-                        const reception = new FailedReception(message, error, async () => {
-                            if (!(await validate()))
-                                throw new Error("Shard ownership was lost.");
-                            await markDelivered(message);
-                        }, async () => {
-                            await dispatch(message);
-                            if (!(await validate()))
-                                throw new Error("Shard ownership was lost.");
-                            await markDelivered(message);
-                        });
-                        const action = await safelyValue(() => this.#monitor.onReceptionFailure(reception), reception.markDelivered());
-                        if (!(await safely(() => action.execute())) &&
-                            !(await safely(() => reception.markDelivered().execute()))) {
-                            blockedTargets.add(target);
-                        }
-                        if (ownership.lost)
-                            return complete("STOPPED");
-                    }
-                }
-                if (!(await cleanupPage()))
-                    return complete("STOPPED");
-                const last = messages.at(-1);
-                if (statistics.delivered !== deliveredBefore) {
-                    after = undefined;
-                    continue;
-                }
-                if (last === undefined || messages.length < this.pageSize)
-                    break;
-                after = {
-                    messageId: last.id.value,
-                    whenReceived: last.whenReceived,
-                    version: last.version,
-                };
-                // Reached a full page without progress: continue past it once. A later
-                // independent target may still be actionable; exhaustion ends the run.
-            }
-            return complete("DRAINED");
+            if (!(await this.input.inbox.removeDuplicate(message, this.#current, this.input.options.operation)))
+                throw new Error("Inbox duplicate was not removed.");
+            this.#removedInPage.add(message);
+            this.input.options.onDuplicateRemoved?.(message);
+        }
+        catch (error) {
+            this.#recordFailure(message, error);
+            this.#blockedTargets.add(target);
+        }
+        return true;
+    }
+    /**
+     * Delivers one message and records its outcome.
+     *
+     * @param message Supplies the inbox message.
+     * @param target Identifies the message target.
+     * @returns Whether processing may continue.
+     */
+    async #deliver(message, target) {
+        try {
+            this.#statistics.accepted += 1;
+            await this.#dispatch(message);
+            if (this.input.options.operation?.signal?.aborted || !(await this.#validate()))
+                return false;
+            await this.#markDelivered(message);
         }
-        finally {
-            const released = await safelyValue(() => this.shards.release(current, options.operation), false);
-            if (!released) {
-                // The release result changes the terminal delivery outcome: a shard is
-                // not complete until ownership is confirmed released.
-                // eslint-disable-next-line no-unsafe-finally
-                return complete("FAILED");
+        catch (error) {
+            await this.#handleReceptionFailure(message, target, error);
+            if (this.#ownershipLost)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Records endpoint failure and runs the configured recovery action.
+     *
+     * @param message Supplies the failed inbox message.
+     * @param target Identifies the message target.
+     * @param error Supplies the endpoint or acknowledgement failure.
+     * @returns Completion after the recovery action finishes.
+     */
+    async #handleReceptionFailure(message, target, error) {
+        this.#recordFailure(message, error);
+        const reception = new FailedReception(message, error, () => this.#acknowledge(message), () => this.#repeat(message));
+        const action = await safelyValue(() => this.input.monitor.onReceptionFailure(reception), reception.markDelivered());
+        if (!(await safely(() => action.execute())) &&
+            !(await safely(() => reception.markDelivered().execute())))
+            this.#blockedTargets.add(target);
+    }
+    /**
+     * Marks a message delivered after checking the shard session.
+     *
+     * @param message Supplies the inbox message to acknowledge.
+     * @returns Completion after the message is marked delivered.
+     */
+    async #acknowledge(message) {
+        if (!(await this.#validate()))
+            throw new Error("Shard ownership was lost.");
+        await this.#markDelivered(message);
+    }
+    /**
+     * Dispatches the message again and acknowledges it.
+     *
+     * @param message Supplies the inbox message to repeat.
+     * @returns Completion after dispatch and acknowledgement.
+     */
+    async #repeat(message) {
+        await this.#dispatch(message);
+        await this.#acknowledge(message);
+    }
+    /**
+     * Dispatches a message while validating the shard session before the call.
+     *
+     * @param message Supplies the inbox message for the endpoint.
+     * @returns Completion after endpoint dispatch.
+     */
+    async #dispatch(message) {
+        await withDeliveryCommitFence(async () => {
+            if (!(await this.#validate()))
+                throw new Error("Shard ownership was lost.");
+        }, () => Promise.resolve(this.input.options.onMessage(message)));
+    }
+    /**
+     * Marks a message delivered and updates local counts and callbacks.
+     *
+     * @param message Supplies the inbox message to acknowledge.
+     * @returns Completion after durable acknowledgement.
+     */
+    async #markDelivered(message) {
+        if ((await this.input.inbox.markDelivered(message, this.input.options.operation)) === undefined)
+            throw new Error("Inbox message was not marked delivered.");
+        this.#deduplication.recordDelivered(message);
+        this.#statistics.delivered += 1;
+        this.input.options.onDelivered?.(message);
+    }
+    /**
+     * Removes expired delivered messages from one page when supported.
+     *
+     * @param messages Supplies the inbox page to clean up.
+     * @returns Whether cleanup completed while the session remained valid.
+     */
+    async #cleanupPage(messages) {
+        if (this.input.inbox.removeDelivered === undefined)
+            return true;
+        if (!(await this.#validate()))
+            return false;
+        const now = this.#retentionTime().getTime();
+        for (const message of messages) {
+            if (message.status === "DELIVERED" &&
+                (message.keepUntil === undefined || message.keepUntil.getTime() <= now)) {
+                const removed = await this.#removeDelivered(message);
+                if (removed === undefined)
+                    return false;
+                if (removed)
+                    this.#removedInPage.add(message);
             }
-            await safely(() => this.#monitor.onDeliveryCompleted(Object.freeze({
-                processed: statistics.processed,
-                delivered: statistics.delivered,
-                failed: statistics.failed,
-            })));
         }
+        return true;
+    }
+    /**
+     * Removes one expired delivered message when supported.
+     *
+     * @param message Supplies the delivered message to remove.
+     * @returns Whether the row was removed, or undefined if the session was lost.
+     */
+    async #removeDelivered(message) {
+        if (this.input.inbox.removeDelivered === undefined)
+            return false;
+        if (this.input.options.operation?.signal?.aborted || !(await this.#validate()))
+            return undefined;
+        const removed = await this.input.inbox.removeDelivered(message, this.#current, this.input.options.operation);
+        if (this.input.options.operation?.signal?.aborted || (!removed && !(await this.#validate())))
+            return undefined;
+        return removed;
+    }
+    /**
+     * Creates the continuation following the last message in a page.
+     *
+     * @param messages Supplies the non-empty inbox page.
+     * @returns The continuation identifying its last message.
+     */
+    #continuation(messages) {
+        const last = messages.at(-1);
+        if (last === undefined)
+            throw new Error("Inbox page has no continuation.");
+        return { messageId: last.id.value, whenReceived: last.whenReceived, version: last.version };
+    }
+    /**
+     * Reads the inbox retention clock or the current time.
+     *
+     * @returns The time used to evaluate message retention.
+     */
+    #retentionTime() {
+        return this.input.inbox instanceof Inbox
+            ? InboxStorageClock.read(this.input.inbox.storage)
+            : new Date();
+    }
+    /**
+     * Checks the shard session and records when it is lost.
+     *
+     * @returns Whether the shard session remains valid.
+     */
+    async #validate() {
+        const current = await safelyValue(() => this.input.shards.validateOwnership(this.#current, this.input.options.operation), undefined);
+        if (current === undefined)
+            this.#ownershipLost = true;
+        else
+            this.#current = current;
+        return current !== undefined;
+    }
+    /**
+     * Records an ephemeral delivery failure up to the configured limit.
+     *
+     * @param message Supplies the failed inbox message.
+     * @param error Supplies the observed failure.
+     */
+    #recordFailure(message, error) {
+        this.#statistics.failed += 1;
+        if (this.#failures.length < deliveryFailureLimit)
+            this.#failures.push(Object.freeze({ message: snapshot(message), error }));
+        this.#failureLimitReached = this.#failures.length === deliveryFailureLimit;
+    }
+    /**
+     * Creates a terminal result from the current counters and failures.
+     *
+     * @param status Identifies the terminal delivery outcome.
+     * @returns The immutable delivery result.
+     */
+    #complete(status) {
+        return result(status, this.#statistics, this.#failures);
+    }
+    /**
+     * Sends delivery completion to the monitor.
+     *
+     * @returns Completion after the monitor callback settles.
+     */
+    #completeMonitoring() {
+        return Promise.resolve(this.input.monitor.onDeliveryCompleted(Object.freeze({
+            processed: this.#statistics.processed,
+            delivered: this.#statistics.delivered,
+            failed: this.#statistics.failed,
+        })));
     }
 }
 function workerId(node) {
@@ -384,6 +645,14 @@ async function safelyBoolean(action) {
         return false;
     }
 }
+/**
+ * Returns an action result or a fallback when the action fails.
+ *
+ * @typeParam T Action result type.
+ * @param action Supplies the action to run.
+ * @param fallback Supplies the result to use after failure.
+ * @returns The action result or fallback value.
+ */
 async function safelyValue(action, fallback) {
     try {
         return await action();
@@ -397,4 +666,118 @@ function isEndpointMessage(message) {
         message.label === "UPDATE_SUBSCRIBER" ||
         message.label === "REACT_UPON_EVENT");
 }
+/**
+ * Tracks recently delivered messages for one inbox.
+ */
+class DeliveryDeduplication {
+    #recent;
+    /**
+     * Creates or reuses recent delivery state for the supplied inbox.
+     *
+     * @param inbox Supplies the inbox used as the deduplication key.
+     */
+    constructor(inbox) {
+        const current = recentDeliveries.get(inbox);
+        this.#recent = current ?? new RecentDeliveries();
+        if (current === undefined)
+            recentDeliveries.set(inbox, this.#recent);
+    }
+    /**
+     * Creates duplicate checks for one page and retention time.
+     *
+     * @param messages Supplies the messages in the page.
+     * @param now Supplies the time used to check message retention.
+     * @returns Duplicate checks for the page.
+     */
+    page(messages, now) {
+        return new DeliveryPageDeduplication(messages, this.#recent, now);
+    }
+    /**
+     * Records a message as recently delivered.
+     *
+     * @param message Supplies the delivered message.
+     */
+    recordDelivered(message) {
+        this.#recent.add(message);
+    }
+}
+/**
+ * Checks duplicates within a page and the recent-delivery cache.
+ */
+class DeliveryPageDeduplication {
+    recent;
+    #identities;
+    /**
+     * Creates duplicate checks from retained messages in one page.
+     *
+     * @param messages Supplies the inbox page.
+     * @param recent Provides recently delivered message identities.
+     * @param now Supplies the time used to check message retention.
+     */
+    constructor(messages, recent, now) {
+        this.recent = recent;
+        this.#identities = new Set(messages
+            .filter((message) => message.status === "DELIVERED" &&
+            message.keepUntil !== undefined &&
+            message.keepUntil.getTime() > now.getTime())
+            .map((message) => RecentDeliveries.key(message)));
+    }
+    /**
+     * Checks whether a message appeared earlier in the page or cache.
+     *
+     * @param message Supplies the message to check.
+     * @returns Whether this message is a duplicate.
+     */
+    isDuplicate(message) {
+        const identity = RecentDeliveries.key(message);
+        if (this.#identities.has(identity) || this.recent.has(identity))
+            return true;
+        this.#identities.add(identity);
+        return false;
+    }
+}
+/**
+ * Stores a bounded set of recently delivered message identities.
+ */
+class RecentDeliveries {
+    #identities = new Map();
+    /**
+     * Checks whether an identity is in the recent-delivery set.
+     *
+     * @param identity Supplies the encoded message identity.
+     * @returns Whether that identity is present.
+     */
+    has(identity) {
+        return this.#identities.has(identity);
+    }
+    /**
+     * Adds a message identity and removes the oldest entry when over capacity.
+     *
+     * @param message Supplies the delivered message.
+     */
+    add(message) {
+        const identity = RecentDeliveries.key(message);
+        this.#identities.delete(identity);
+        this.#identities.set(identity, undefined);
+        if (this.#identities.size > 1_000) {
+            const oldest = this.#identities.keys().next().value;
+            if (oldest !== undefined)
+                this.#identities.delete(oldest);
+        }
+    }
+    /**
+     * Creates the identity key used for recent-delivery checks.
+     *
+     * @param message Supplies the message to identify.
+     * @returns The serialized message identity.
+     */
+    static key(message) {
+        return JSON.stringify([
+            message.signalId,
+            message.inboxId.targetTypeUrl,
+            InboxTargets.key(message.inboxId.targetId),
+        ]);
+    }
+}
+const recentDeliveries = new WeakMap();
 //# sourceMappingURL=delivery.js.map