@genn-inc/cluebase-frontend-sdk 0.0.3 → 0.0.8

package/dist/exporter/batch.js

@@ -1,52 +1,76 @@
-import { CONSENT_DENIED_ABORT_REASON } from "../provider/constants.js";
-import { BrowserOutbox, } from "./browser-outbox.js";
-import { ownEvent } from "./browser-outbox-records.js";
+import { DEFAULT_CONFIG } from "../provider/constants.js";
+import { applyDeliveredPrivacyPolicy, resetPrivacyPolicy, } from "../provider/privacy-policy-store.js";
+import { BrowserOutbox } from "./browser-outbox.js";
+import { ownEvent, sentByteLength } from "./browser-outbox-records.js";
+import { DeliveryPipeline, } from "./delivery-pipeline.js";
 import { DiagnosticStore } from "./diagnostics.js";
+const CLOSE_DEADLINE_MS = 5000;
+const CORE_CONSENT = {
+    unknown: "unknown",
+    granted: "granted",
+    denied: "denied",
+};
 export class BatchTransport {
     constructor(options) {
-        this.activeSendController = null;
-        this.closeDeadlineController = null;
-        this.closeDeadlineTimer = null;
+        this.idleHandle = null;
+        this.flushing = false;
+        this.flushAgainAfterCurrent = false;
         this.closeDeadlineAt = null;
-        this.closePermitOrdinal = null;
-        this.flushDeadlineController = null;
-        this.flushDeadlineTimer = null;
-        this.flushDeadlineAt = null;
+        this.clearedAt = null;
+        this.disposed = false;
+        this.closeDeadlineTimer = null;
         this.lifecycle = "open";
         this.closeHadTerminalDisposition = false;
+        this.restored = false;
+        this.tokenRefusedForGood = false;
         this.activeFlushPromise = null;
         this.enqueueTail = Promise.resolve();
-        this.seenEventIds = new Set();
         this.enabled = options.enabled;
         this.flushIntervalMs = Math.max(100, options.flushIntervalMs);
         this.maxPayloadBytes = Math.max(1024, options.maxPayloadBytes);
         this.flushThresholdBytes = Math.min(this.maxPayloadBytes, Math.max(1024, options.flushThresholdBytes ?? Math.floor(this.maxPayloadBytes * 0.8)));
+        this.maxSize = Math.max(1, options.maxSize ?? DEFAULT_CONFIG.batch.maxSize);
         this.client = options.client;
         this.metrics = options.metrics ?? null;
         this.diagnostics = options.diagnostics ?? new DiagnosticStore();
-        this.onGovernorFeedback = options.onGovernorFeedback ?? null;
         this.outbox = new BrowserOutbox({
             projectKey: options.projectKey ?? "unconfigured",
             initialConsent: options.initialConsent ?? "unknown",
             metrics: this.metrics ?? undefined,
             diagnostics: this.diagnostics,
-            maxEvents: options.queueMaxItems ?? 5000,
-            maxBytes: options.queueMaxBytes ?? 300 * 1024,
             onConsentRevoked: () => this.abortActiveSendForConsent(),
             ...(options.projectKey ? {} : { storage: null }),
         });
-        this.idleHandle = null;
-        this.flushing = false;
-        this.flushAgainAfterCurrent = false;
+        this.pipeline = new DeliveryPipeline({
+            endpoint: options.endpoint,
+            projectKey: options.projectKey ?? "unconfigured",
+            sdkVersion: options.sdkVersion,
+            sourceSchemaVersion: options.sourceSchemaVersion,
+            sdkRequest: options.sdkRequest,
+            queueLimits: {
+                max_payload_bytes: this.maxPayloadBytes,
+                max_buffer_bytes: options.queueMaxBytes ?? 300 * 1024,
+                max_buffer_events: options.queueMaxItems ?? 5000,
+            },
+            ...(options.requestTimeoutMs === undefined
+                ? {}
+                : { requestTimeoutMs: options.requestTimeoutMs }),
+            initialConsent: CORE_CONSENT[options.initialConsent ?? "unknown"],
+            transport: (request) => this.client.perform(request),
+            clock: {
+                nowMs: monotonicNow,
+                sleep: (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)),
+            },
+        });
+        this.adoptStoredRecords();
         this.recordPendingBatchCount();
     }
     getDiagnostics() {
         return this.diagnostics.snapshot();
     }
     start() {
-        if (!this.enabled) {
+        if (!this.enabled)
             return;
-        }
     }
     stop() {
         if (this.idleHandle) {
@@ -55,55 +79,64 @@ export class BatchTransport {
         }
     }
     dispose() {
+        this.disposed = true;
         this.stop();
         this.outbox.close();
+        this.pipeline.dispose();
     }
     currentConsent() {
         return this.outbox.currentConsent();
     }
     capturePermit() {
-        return this.outbox.capturePermit();
+        return this.pipeline.permit();
     }
     setConsent(consent) {
-        if (consent === "denied") {
+        if (consent === "denied")
             this.abortActiveSendForConsent();
-        }
         const transition = this.outbox.setConsent(consent);
+        const report = this.pipeline.declareConsent(CORE_CONSENT[consent]);
+        this.outbox.releaseEvents(report.purged_event_keys);
+        for (const entry of report.diagnostics)
+            this.diagnostics.record(entry);
         void this.queueOutboxMutation(async () => {
             await this.outbox.withDeliveryLock(async () => this.outbox.commitConsentTransition(transition), { restore: false });
             this.recordPendingBatchCount();
         });
     }
     enqueue(event, permit) {
-        if (this.lifecycle !== "open" &&
-            !(this.lifecycle === "closing" &&
-                permit !== undefined &&
-                this.closePermitOrdinal !== null &&
-                permit.captureOrdinal < this.closePermitOrdinal)) {
-            this.metrics?.increment("dropped_count");
-            return;
-        }
-        const collectionPermit = permit ?? this.outbox.capturePermit();
-        const owned = ownEvent(event, collectionPermit);
-        const eventId = event.event_id;
-        if (!owned || typeof eventId !== "string" || eventId.length === 0) {
+        const collectionPermit = permit ?? this.pipeline.permit();
+        const owned = ownEvent(event);
+        if (!owned) {
             this.metrics?.increment("dropped_count");
             return;
         }
+        const snapshot = owned.value();
         void this.queueOutboxMutation(async () => {
-            if (this.seenEventIds.has(eventId)) {
-                return;
-            }
-            const retained = await this.outbox.withDeliveryLock(async () => this.outbox.addDraft(owned.value(), owned.permit));
-            if (!retained) {
+            const draft = await this.outbox.withDeliveryLock(async () => {
+                this.adoptStoredRecords();
+                return this.outbox.holdDraft(snapshot);
+            });
+            if (!draft) {
                 this.metrics?.increment("dropped_count");
                 return;
             }
-            this.seenEventIds.add(eventId);
-            if (this.seenEventIds.size > BatchTransport.DEDUP_CAPACITY) {
-                const oldest = this.seenEventIds.values().next().value;
-                if (oldest !== undefined)
-                    this.seenEventIds.delete(oldest);
+            const report = this.pipeline.admit({
+                eventKey: draft.eventKeyHash,
+                byteLength: sentByteLength(draft.event),
+                diagnosticCanonicalBytes: this.client.diagnosticCanonicalPayload(JSON.stringify(draft.event)),
+            }, collectionPermit);
+            for (const entry of report.diagnostics)
+                this.diagnostics.record(entry);
+            this.outbox.releaseEvents(report.overflowed_event_keys);
+            if (report.overflowed_event_keys.length > 0) {
+                this.metrics?.increment("dropped_count", report.overflowed_event_keys.length);
+            }
+            if (!report.retained) {
+                if (report.overflowed_event_keys.length === 0) {
+                    this.outbox.releaseEvents([draft.eventKeyHash]);
+                    this.metrics?.increment("dropped_count");
+                }
+                return;
             }
             this.recordPendingBatchCount();
             this.scheduleFlushDeadline();
@@ -111,70 +144,33 @@ export class BatchTransport {
                 void this.flush();
                 return;
             }
-            if (this.outbox.estimatedDraftBytes((events, metadata) => this.client.measurePayloadBytes([...events], metadata), this.client.createBatchEnvelopeMetadata()) >= this.flushThresholdBytes) {
+            const depth = this.pipeline.depth(this.envelopeOverheadBytes());
+            if (depth.draft_count >= this.maxSize ||
+                depth.draft_body_bytes >= this.flushThresholdBytes) {
                 void this.flush();
             }
         });
     }
-    scheduleFlushDeadline() {
-        if (!this.enabled) {
-            return;
-        }
-        if (this.idleHandle) {
-            return;
-        }
-        this.idleHandle = setTimeout(() => {
-            this.idleHandle = null;
-            void this.flush();
-        }, this.flushIntervalMs);
-    }
-    beginFlushDeadline() {
-        const active = this.currentDeadline();
-        if (active)
-            return active;
-        const controller = new AbortController();
-        const deadlineAt = monotonicNow() + 5000;
-        this.flushDeadlineController = controller;
-        this.flushDeadlineAt = deadlineAt;
-        this.flushDeadlineTimer = setTimeout(() => {
-            controller.abort("shutdown_deadline");
-            this.activeSendController?.abort("shutdown_deadline");
-        }, 5000);
-        return { signal: controller.signal, deadlineAt };
-    }
-    endFlushDeadline(deadline) {
-        if (!deadline || this.flushDeadlineController?.signal !== deadline.signal)
-            return;
-        if (this.flushDeadlineTimer)
-            clearTimeout(this.flushDeadlineTimer);
-        this.flushDeadlineTimer = null;
-        this.flushDeadlineController = null;
-        this.flushDeadlineAt = null;
-    }
-    async flush(deadline = this.currentDeadline()) {
+    async flush() {
         if (this.lifecycle === "closed")
             return;
+        this.tokenRefusedForGood = false;
         if (this.flushing) {
             this.flushAgainAfterCurrent = true;
-            if (this.activeFlushPromise) {
+            if (this.activeFlushPromise)
                 await this.activeFlushPromise;
-            }
             return;
         }
-        const enqueuesAtStart = this.enqueueTail;
-        await enqueuesAtStart;
+        await this.enqueueTail;
         if (this.flushing) {
             this.flushAgainAfterCurrent = true;
             if (this.activeFlushPromise)
                 await this.activeFlushPromise;
             return;
         }
-        if (this.idleHandle) {
-            clearTimeout(this.idleHandle);
-            this.idleHandle = null;
-        }
+        this.stop();
         this.flushing = true;
-        this.activeFlushPromise = this.runFlushUntilIdle(deadline);
+        this.activeFlushPromise = this.runFlushUntilIdle();
         try {
             await this.activeFlushPromise;
         }
@@ -182,56 +178,46 @@ export class BatchTransport {
             this.activeFlushPromise = null;
             this.flushing = false;
         }
-        this.diagnostics.setFlushOutcome(this.outbox.pendingEventCount() === 0 ? "clean" : "failed");
-        return;
+        this.diagnostics.setFlushOutcome(this.pipeline.pendingCount() === 0 ? "clean" : "failed");
     }
-    async runFlushUntilIdle(deadline) {
+    async runFlushUntilIdle() {
         while (true) {
             const enqueuesAtCycleStart = this.enqueueTail;
             await enqueuesAtCycleStart;
-            await this.outbox.withDeliveryLock(() => this.runFlushCycle(deadline));
-            const enqueuesAfterCycle = this.enqueueTail;
-            if (this.lifecycle !== "open" ||
+            const stop = await this.outbox.withDeliveryLock(() => this.runFlushCycle());
+            if (stop === "retries_exhausted" ||
+                this.lifecycle !== "open" ||
                 (!this.flushAgainAfterCurrent &&
-                    enqueuesAfterCycle === enqueuesAtCycleStart)) {
+                    this.enqueueTail === enqueuesAtCycleStart)) {
                 return;
             }
             this.flushAgainAfterCurrent = false;
         }
     }
     beginClose() {
-        if (this.lifecycle === "closed")
-            return null;
-        if (this.lifecycle === "closing" && this.closeDeadlineController) {
-            return this.closeDeadlineController.signal;
-        }
+        if (this.lifecycle === "closed" || this.lifecycle === "closing")
+            return;
         this.lifecycle = "closing";
         this.closeHadTerminalDisposition = false;
         this.diagnostics.setLifecycle("closing");
         this.stop();
-        const controller = new AbortController();
-        this.closeDeadlineController = controller;
-        this.closeDeadlineAt = monotonicNow() + 5000;
-        this.closePermitOrdinal = this.outbox.capturePermit().captureOrdinal;
+        this.pipeline.beginClose();
+        this.closeDeadlineAt = monotonicNow() + CLOSE_DEADLINE_MS;
         this.closeDeadlineTimer = setTimeout(() => {
-            controller.abort("shutdown_deadline");
-            this.activeSendController?.abort("shutdown_deadline");
-        }, 5000);
-        return controller.signal;
+            this.client.abortAttempt("deadline");
+        }, CLOSE_DEADLINE_MS);
     }
     async close() {
         if (this.lifecycle === "closed")
             return;
-        const signal = this.beginClose();
-        if (!signal)
-            return;
+        this.beginClose();
         try {
             await this.flush();
         }
         finally {
-            this.clearCloseDeadline(signal);
+            this.clearCloseDeadline();
         }
-        if (this.outbox.pendingEventCount() > 0) {
+        if (this.pipeline.pendingCount() > 0) {
             this.lifecycle = "closing_failed";
             this.diagnostics.setLifecycle("closing_failed");
             this.diagnostics.setCloseOutcome("retryable_failure");
@@ -242,217 +228,185 @@ export class BatchTransport {
         this.diagnostics.setLifecycle("closed");
         this.diagnostics.setCloseOutcome(this.closeHadTerminalDisposition ? "terminal_failure" : "clean");
     }
-    async runFlushCycle(deadline) {
-        const fence = this.outbox.prepareFence({
-            maxPayloadBytes: this.maxPayloadBytes,
-            createMetadata: () => this.client.createBatchEnvelopeMetadata(),
-            measure: (events, metadata) => this.client.measurePayloadBytes([...events], metadata),
-        });
-        if (fence.oversized > 0)
-            this.recordPendingBatchCount();
-        while (true) {
-            const batch = this.outbox.headThrough(fence.targetOrdinal);
-            if (!batch) {
-                break;
-            }
-            if (batch.events.length === 0 ||
-                batch.events.some((event) => !this.outbox.permits(event.permit))) {
-                this.outbox.removeHead(batch);
-                this.recordPendingBatchCount();
-                continue;
-            }
-            this.metrics?.increment("batch_flush_count");
-            const result = await this.sendBatchWhilePermitted(batch, deadline);
-            if (!result || this.applyDeliveryResult(batch, result) === "break")
-                break;
-        }
+    flushOnUnload() {
+        if (!this.client.hasUsableBrowserToken())
+            return;
+        this.beginClose();
+        void this.flush();
     }
-    async sendBatchWhilePermitted(batch, deadline) {
-        const sendController = new AbortController();
-        const abortForClose = () => sendController.abort("shutdown_deadline");
-        if (deadline?.signal.aborted)
-            abortForClose();
-        deadline?.signal.addEventListener("abort", abortForClose, { once: true });
-        this.activeSendController = sendController;
-        let result;
-        try {
-            result = await this.client.send(batch.events.map((event) => event.value()), {
-                maxPayloadBytes: this.maxPayloadBytes,
-                metadata: batch.metadata,
-                signal: sendController.signal,
-                deadlineAt: deadline?.deadlineAt,
+    clear() {
+        this.clearedAt = monotonicNow();
+        this.client.abortAttempt("shutdown");
+        this.outbox.clearMemory();
+        if (this.flushing && this.activeFlushPromise) {
+            void this.activeFlushPromise.finally(() => {
+                if (this.disposed)
+                    return;
+                this.pipeline.reset();
+                this.clearedAt = null;
             });
         }
-        finally {
-            deadline?.signal.removeEventListener("abort", abortForClose);
-            if (this.activeSendController === sendController) {
-                this.activeSendController = null;
-            }
-        }
-        if (batch.events.some((event) => !this.outbox.permits(event.permit))) {
-            this.recordPendingBatchCount();
-            return null;
+        else {
+            this.pipeline.reset();
+            this.clearedAt = null;
         }
-        return result;
-    }
-    applyDeliveryResult(batch, result) {
-        if (result.governor)
-            this.onGovernorFeedback?.(result.governor);
-        return result.ok
-            ? this.applySuccessfulDelivery(batch, result)
-            : this.applyFailedDelivery(batch, result);
+        void this.queueOutboxMutation(async () => {
+            await this.outbox.withDeliveryLock(async () => this.outbox.clear());
+        });
+        this.recordPendingBatchCount();
     }
-    applyFailedDelivery(batch, result) {
-        if (result.retryStrategy === "split_batch") {
-            if (this.outbox.splitHead(batch, () => this.client.createBatchEnvelopeMetadata())) {
-                this.recordPendingBatchCount();
-                this.scheduleFlushDeadline();
-                return "continue";
-            }
-            this.metrics?.increment("dropped_count", batch.events.length);
-            this.metrics?.increment("oversized_event_dropped_count");
-            this.outbox.removeHead(batch);
+    async runFlushCycle() {
+        this.adoptStoredRecords();
+        if (!(await this.ensureDeliveryToken()))
+            return null;
+        const fence = this.pipeline.fence(this.envelopeOverheadBytes());
+        for (const entry of fence.diagnostics)
+            this.diagnostics.record(entry);
+        if (fence.oversized_event_keys.length > 0) {
+            this.outbox.releaseEvents(fence.oversized_event_keys);
+            this.metrics?.increment("oversized_event_count", fence.oversized_event_keys.length);
+            this.metrics?.increment("dropped_count", fence.oversized_event_keys.length);
             this.recordPendingBatchCount();
-            return "continue";
         }
-        if (this.shouldRetainFailedBatch(result.retryStrategy)) {
-            this.diagnostics.record({
-                code: "retry_exhausted",
-                strategy: "retry_same_batch",
-                attempt: result.attempts,
-                batch_fingerprint: this.diagnostics.batchFingerprint(batch.diagnosticCanonicalBytes),
-            });
-            this.outbox.retainHead(batch);
+        const summary = await this.pipeline.run({
+            body: (batchId, eventKeys) => this.serializeBatch(batchId, eventKeys),
+            onObservation: (observation) => this.applyObservation(observation),
+            deadlineMs: () => this.closeDeadlineAt ?? this.clearedAt ?? undefined,
+        });
+        if (summary.stop === "retries_exhausted") {
             this.metrics?.increment("transport_requeue_count");
-            this.recordPendingBatchCount();
             if (this.lifecycle === "open")
                 this.scheduleFlushDeadline();
-            return "break";
         }
-        this.diagnostics.record({
-            code: result.retryStrategy === "drop_event"
-                ? "intentional_drop"
-                : "terminal_rejection",
-            strategy: result.retryStrategy ?? undefined,
-            count: batch.events.length,
-            batch_fingerprint: this.diagnostics.batchFingerprint(batch.diagnosticCanonicalBytes),
+        this.recordPendingBatchCount();
+        return summary.stop;
+    }
+    serializeBatch(batchId, eventKeys) {
+        const claim = this.outbox.claimBatch({
+            batchId,
+            eventKeys,
+            createMetadata: () => this.client.createBatchEnvelopeMetadata(),
         });
-        if (this.lifecycle === "closing")
-            this.closeHadTerminalDisposition = true;
-        this.metrics?.increment("dropped_count", batch.events.length);
-        this.metrics?.increment("transport_failed_count");
-        if (!this.outbox.removeHead(batch)) {
-            this.metrics?.increment("transport_requeue_count");
-            this.recordPendingBatchCount();
-            return "break";
+        if (!claim)
+            return null;
+        const metadata = {
+            batch_id: claim.record.batchId,
+            idempotency_key: claim.record.idempotencyKey,
+            sent_at: claim.record.sentAt,
+        };
+        const body = this.client.stringifyPayload(claim.record.events.map((event) => event.event), metadata);
+        if (claim.minted) {
+            this.metrics?.increment("payload_size_bytes", new TextEncoder().encode(body).byteLength);
         }
-        this.recordPendingBatchCount();
-        return "continue";
+        return {
+            body,
+            diagnosticCanonicalBytes: this.client.diagnosticCanonicalPayload(body),
+        };
     }
-    applySuccessfulDelivery(batch, result) {
-        if (!this.outbox.removeHead(batch)) {
-            this.metrics?.increment("transport_requeue_count");
-            this.recordPendingBatchCount();
-            return "break";
+    applyObservation(observation) {
+        for (const entry of observation.diagnostics)
+            this.diagnostics.record(entry);
+        if (observation.privacyPolicy !== undefined) {
+            applyDeliveredPrivacyPolicy(observation.privacyPolicy);
         }
-        if (result.partial) {
-            if (this.lifecycle === "closing")
-                this.closeHadTerminalDisposition = true;
-            this.diagnostics.record({
-                code: "intentional_drop",
-                count: result.droppedEventCount ?? 0,
-                batch_fingerprint: this.diagnostics.batchFingerprint(batch.diagnosticCanonicalBytes),
-            });
+        else if (observation.directiveUnreadable) {
+            resetPrivacyPolicy();
+        }
+        const progress = observation.progress;
+        if (progress.kind !== "retry_scheduled") {
+            this.metrics?.increment("batch_flush_count");
+        }
+        else {
+            this.metrics?.increment("retry_count");
+            this.metrics?.increment("transport_retry_count");
+        }
+        if (progress.kind === "settled") {
+            this.outbox.releaseBatch(progress.batch_id);
+            this.metrics?.increment("sent_count", progress.settled_event_keys.length);
+            if (observation.droppedEventCount > 0) {
+                this.metrics?.increment("ingest_dropped_event_count", observation.droppedEventCount);
+                if (this.lifecycle === "closing") {
+                    this.closeHadTerminalDisposition = true;
+                }
+            }
+            return;
+        }
+        if (progress.kind === "dropped_oversized") {
+            this.outbox.releaseBatch(progress.batch_id);
+            this.metrics?.increment("dropped_count");
+            this.metrics?.increment("oversized_event_dropped_count");
+            return;
+        }
+        if (progress.kind === "split_scheduled") {
+            this.outbox.reopenBatch(progress.batch_id);
+            this.scheduleFlushDeadline();
+            return;
+        }
+        if (progress.kind === "consent_revoked") {
+            this.metrics?.increment("transport_failed_count");
+            return;
+        }
+        if (progress.kind === "retries_exhausted") {
+            this.metrics?.increment("transport_failed_count");
         }
-        this.recordPendingBatchCount();
-        return "continue";
     }
-    flushOnUnload() {
-        if (!this.client.hasUsableBrowserToken()) {
+    adoptStoredRecords() {
+        if (this.restored)
             return;
+        this.restored = true;
+        const restorable = this.outbox.restorable();
+        for (const batch of restorable.batches) {
+            const report = this.pipeline.adoptRestoredBatch(batch.ordinal, batch.events);
+            if (report.adopted && report.batch_id !== undefined) {
+                this.outbox.bindRestoredBatch(batch.storedBatchId, report.batch_id);
+            }
+        }
+        for (const draft of restorable.drafts) {
+            this.pipeline.admit({
+                eventKey: draft.eventKeyHash,
+                byteLength: sentByteLength(draft.event),
+                diagnosticCanonicalBytes: this.client.diagnosticCanonicalPayload(JSON.stringify(draft.event)),
+            }, this.pipeline.permit());
         }
-        this.stop();
-        void this.queueOutboxMutation(async () => {
-            await this.outbox.withDeliveryLock(async () => {
-                const fence = this.outbox.prepareFence({
-                    maxPayloadBytes: this.maxPayloadBytes,
-                    createMetadata: () => this.client.createBatchEnvelopeMetadata(),
-                    measure: (events, metadata) => this.client.measurePayloadBytes([...events], metadata),
-                });
-                this.recordPendingBatchCount();
-                const batch = this.outbox.headThrough(fence.targetOrdinal);
-                if (!batch)
-                    return;
-                const sendController = new AbortController();
-                this.activeSendController = sendController;
-                try {
-                    await this.client.send(batch.events.map((event) => event.value()), {
-                        keepalive: true,
-                        useBeacon: false,
-                        requireCachedBrowserToken: true,
-                        maxPayloadBytes: this.maxPayloadBytes,
-                        metadata: batch.metadata,
-                        signal: sendController.signal,
-                    });
-                }
-                finally {
-                    if (this.activeSendController === sendController) {
-                        this.activeSendController = null;
-                    }
-                }
-            });
-        });
     }
-    clear() {
-        this.activeSendController?.abort();
-        this.activeSendController = null;
-        this.outbox.clearMemory();
-        void this.queueOutboxMutation(async () => {
-            await this.outbox.withDeliveryLock(async () => this.outbox.clear());
-        });
-        this.recordPendingBatchCount();
+    async ensureDeliveryToken() {
+        const result = await this.client.ensureDeliveryToken();
+        if (!result.ok) {
+            this.metrics?.increment("send_failure_count");
+            this.tokenRefusedForGood = result.retryStrategy === "stop_and_report";
+            return false;
+        }
+        this.tokenRefusedForGood = false;
+        this.pipeline.rememberBrowserToken(result.token);
+        return true;
+    }
+    envelopeOverheadBytes() {
+        return this.client.measurePayloadBytes([], this.client.createBatchEnvelopeMetadata());
+    }
+    scheduleFlushDeadline() {
+        if (!this.enabled || this.idleHandle || this.tokenRefusedForGood)
+            return;
+        this.idleHandle = setTimeout(() => {
+            this.idleHandle = null;
+            void this.flush();
+        }, this.flushIntervalMs);
     }
     abortActiveSendForConsent() {
-        this.activeSendController?.abort(CONSENT_DENIED_ABORT_REASON);
-        this.activeSendController = null;
+        this.client.abortAttempt("consent_revoked");
     }
     recordPendingBatchCount() {
-        this.metrics?.set("pending_batch_count", this.outbox.pendingEventCount());
+        this.metrics?.set("pending_batch_count", this.pipeline.pendingCount());
     }
-    clearCloseDeadline(signal) {
-        if (this.closeDeadlineController?.signal !== signal)
-            return;
-        if (this.closeDeadlineTimer) {
+    clearCloseDeadline() {
+        if (this.closeDeadlineTimer)
             clearTimeout(this.closeDeadlineTimer);
-            this.closeDeadlineTimer = null;
-        }
-        this.closeDeadlineController = null;
+        this.closeDeadlineTimer = null;
         this.closeDeadlineAt = null;
-        this.closePermitOrdinal = null;
-    }
-    currentDeadline() {
-        if (this.closeDeadlineController && this.closeDeadlineAt !== null) {
-            return {
-                signal: this.closeDeadlineController.signal,
-                deadlineAt: this.closeDeadlineAt,
-            };
-        }
-        if (this.flushDeadlineController && this.flushDeadlineAt !== null) {
-            return {
-                signal: this.flushDeadlineController.signal,
-                deadlineAt: this.flushDeadlineAt,
-            };
-        }
-        return null;
     }
     queueOutboxMutation(operation) {
         const next = this.enqueueTail.then(operation, operation);
         this.enqueueTail = next.catch(() => undefined);
         return next;
     }
-    shouldRetainFailedBatch(retryStrategy) {
-        return retryStrategy === null || retryStrategy === "retry_same_batch";
-    }
 }
-BatchTransport.DEDUP_CAPACITY = 1024;
 const monotonicNow = () => typeof performance !== "undefined" ? performance.now() : Date.now();