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

package/dist/exporter/client.js

@@ -1,40 +1,14 @@
 import { canonicalize as canonicalJsonStringify } from "json-canonicalize";
 import { CONSENT_DENIED_ABORT_REASON, DEFAULT_FRONTEND_SOURCE_IDENTIFIER, } from "../provider/constants.js";
-import { appliedPrivacyPolicyToken, applyDeliveredPrivacyPolicy, } from "../provider/privacy-policy-store.js";
-import { classifyIngestHttpStatus, evaluateBrowserDeliveryResponse, } from "./delivery-response.js";
-import { generateEventId } from "./event-id.js";
-import { computeRetryDelay, RETRY_CONFIG } from "./retry.js";
-import { isBrowserSourceSignalEvent, SDK_SOURCE_SIGNAL_EVENT_NAME, SDK_SOURCE_SIGNAL_EVENT_TYPE, } from "./source-event.js";
+import { appliedPrivacyPolicyToken } from "../provider/privacy-policy-store.js";
+import { classifyIngestHttpStatus, } from "./delivery-response.js";
+import { generateBatchId } from "./event-id.js";
+import { describeIngestEndpoint, } from "./sdk-core-wasm.js";
+import { withSourceEvidence } from "./source-event.js";
 export const CLUEBASE_SDK_REQUEST_HEADER = "x-cluebase-sdk-request";
 export const CLUEBASE_SDK_VERSION_HEADER = "x-cluebase-sdk-version";
 export const CLUEBASE_SOURCE_SCHEMA_VERSION_HEADER = "x-cluebase-source-schema-version";
 export const CLUEBASE_BROWSER_TOKEN_HEADER = "x-cluebase-browser-token";
-export const CANONICAL_BROWSER_INGEST_PATH = "/api/v1/ingest/browser";
-export const CANONICAL_BROWSER_TOKEN_PATH = "/api/v1/ingest/browser-tokens";
-const CANONICAL_INGEST_PATH_SUFFIX = CANONICAL_BROWSER_INGEST_PATH.replace(/^\/api\/v1/, "");
-export const resolveCanonicalIngestEndpoint = (endpoint) => {
-    if (!endpoint) {
-        return endpoint;
-    }
-    if (endpoint.endsWith(CANONICAL_INGEST_PATH_SUFFIX)) {
-        return endpoint;
-    }
-    const trimmed = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
-    if (trimmed.endsWith("/api/v1")) {
-        return `${trimmed}${CANONICAL_INGEST_PATH_SUFFIX}`;
-    }
-    try {
-        const parsed = new URL(trimmed);
-        if (parsed.pathname === "" || parsed.pathname === "/") {
-            parsed.pathname = CANONICAL_BROWSER_INGEST_PATH;
-            parsed.search = "";
-            parsed.hash = "";
-            return parsed.toString();
-        }
-    }
-    catch { }
-    return endpoint;
-};
 const BROWSER_TOKEN_REFRESH_LEEWAY_MS = 60000;
 class BrowserTokenRequestError extends Error {
     constructor(status) {
@@ -43,163 +17,85 @@ class BrowserTokenRequestError extends Error {
         this.name = "BrowserTokenRequestError";
     }
 }
-export const resolveBrowserTokenEndpoint = (endpoint) => {
-    if (!endpoint) {
-        return CANONICAL_BROWSER_TOKEN_PATH;
-    }
-    try {
-        const parsed = new URL(endpoint);
-        parsed.pathname = CANONICAL_BROWSER_TOKEN_PATH;
-        parsed.search = "";
-        parsed.hash = "";
-        return parsed.toString();
-    }
-    catch {
-        const trimmed = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
-        const apiV1Idx = trimmed.indexOf("/api/v1");
-        if (apiV1Idx >= 0) {
-            return `${trimmed.slice(0, apiV1Idx)}${CANONICAL_BROWSER_TOKEN_PATH}`;
-        }
-        return `${trimmed}${CANONICAL_BROWSER_TOKEN_PATH}`;
-    }
-};
-const NORMAL_ATTEMPT_TIMEOUT_MS = 15000;
 export class IngestClient {
     constructor(options) {
-        this.sourceIdentifier = DEFAULT_FRONTEND_SOURCE_IDENTIFIER;
+        this.describedEndpoint = null;
+        this.describePromise = null;
         this.producerId = DEFAULT_FRONTEND_SOURCE_IDENTIFIER;
         this.cachedToken = null;
         this.pendingTokenRequest = null;
-        this.endpoint = resolveCanonicalIngestEndpoint(options.endpoint);
-        this.browserTokenEndpoint = resolveBrowserTokenEndpoint(options.endpoint);
+        this.inFlight = null;
+        this.configuredEndpoint = options.endpoint;
         this.projectKey = options.projectKey;
         this.sdkType = options.sdkType;
         this.sdkVersion = options.sdkVersion;
         this.schemaVersion = options.schemaVersion;
         this.metrics = options.metrics ?? null;
         this.diagnostics = options.diagnostics ?? null;
+        this.onEndpointsResolved = options.onEndpointsResolved ?? null;
     }
-    async send(events, options = {}) {
-        if (!hasDeadlineRemaining(options.deadlineAt)) {
-            return this.failedSend(null, 0, "retry_same_batch");
-        }
-        const sourceSignalEvents = events.filter(isBrowserSourceSignalEvent);
-        const droppedEventCount = events.length - sourceSignalEvents.length;
-        if (droppedEventCount > 0) {
-            this.metrics?.increment("dropped_count", droppedEventCount);
-        }
-        if (sourceSignalEvents.length === 0) {
+    async endpoints() {
+        this.describePromise ?? (this.describePromise = describeIngestEndpoint(this.configuredEndpoint).then((described) => {
+            this.describedEndpoint = described;
+            this.onEndpointsResolved?.(described);
+            return described;
+        }));
+        return await this.describePromise;
+    }
+    knownEndpoints() {
+        return this.describedEndpoint;
+    }
+    async perform(request) {
+        const active = {
+            controller: new AbortController(),
+            cause: null,
+            timedOut: false,
+        };
+        this.inFlight = active;
+        const timeout = setTimeout(() => {
+            active.timedOut = true;
+            active.controller.abort();
+        }, request.timeout_ms);
+        try {
+            const response = await fetch(request.url, {
+                method: request.method,
+                headers: Object.fromEntries(request.headers.map((header) => [header.name, header.value])),
+                body: request.body,
+                redirect: request.follow_redirects ? "follow" : "error",
+                signal: active.controller.signal,
+                ...(request.omit_credentials ? { credentials: "omit" } : {}),
+                ...(request.keepalive ? { keepalive: true } : {}),
+            });
+            const body = await readBoundedBody(response, request.max_response_body_bytes);
             return {
-                ok: true,
-                status: null,
-                attempts: 0,
-                governor: null,
-                retryStrategy: null,
+                kind: "response",
+                status: response.status,
+                body: body.text,
+                body_over_limit: body.overLimit,
             };
         }
-        const maxPayloadBytes = Math.max(1024, options.maxPayloadBytes ?? Number.MAX_SAFE_INTEGER);
-        const metadata = options.metadata ?? this.createBatchEnvelopeMetadata();
-        const payload = this.stringifyPayload(sourceSignalEvents, metadata);
-        const keepalive = options.keepalive ?? options.useBeacon ?? false;
-        const payloadSize = new TextEncoder().encode(payload).byteLength;
-        this.metrics?.increment("payload_size_bytes", payloadSize);
-        if (payloadSize > maxPayloadBytes) {
-            return this.failedSend(null, 0, "split_batch");
-        }
-        const browserTokenResult = await this.safeEnsureBrowserToken({
-            signal: options.signal,
-            requireCachedToken: options.requireCachedBrowserToken,
-            deadlineAt: options.deadlineAt,
-        });
-        if (!browserTokenResult.ok) {
-            this.metrics?.increment("send_failure_count");
-            this.metrics?.increment("transport_failed_count");
-            return {
-                ok: false,
-                status: null,
-                attempts: 0,
-                governor: null,
-                retryStrategy: browserTokenResult.retryStrategy ??
-                    (options.requireCachedBrowserToken ? "drop_event" : null),
-            };
+        catch {
+            if (active.cause)
+                return { kind: "aborted", cause: active.cause };
+            if (active.timedOut)
+                return { kind: "timeout" };
+            return { kind: "network_error" };
         }
-        let browserToken = browserTokenResult.token;
-        let refreshedToken = false;
-        let lastStatus = null;
-        for (let attempts = 1; attempts <= RETRY_CONFIG.maxAttempts; attempts += 1) {
-            if (options.signal?.aborted ||
-                !hasDeadlineRemaining(options.deadlineAt)) {
-                return this.failedSend(lastStatus, attempts - 1, isConsentAbort(options.signal) ? "drop_event" : "retry_same_batch");
-            }
-            const attempt = await this.postBatch({
-                payload,
-                browserToken,
-                keepalive,
-                signal: options.signal,
-                deadlineAt: options.deadlineAt,
-                localSubmittedCount: sourceSignalEvents.length,
-            });
-            lastStatus = attempt.status;
-            const decision = attempt.decision;
-            this.recordDecision(decision, lastStatus, attempts, payload);
-            if (decision.ok) {
-                if (decision.droppedEventCount > 0) {
-                    this.metrics?.increment("ingest_dropped_event_count", decision.droppedEventCount);
-                }
-                this.metrics?.increment("sent_count", decision.acceptedEventCount);
-                return {
-                    ok: true,
-                    status: lastStatus,
-                    attempts,
-                    governor: decision.governor,
-                    retryStrategy: null,
-                    observationIngestBatchId: decision.observationIngestBatchId,
-                    partial: decision.acceptedPartial,
-                    droppedEventCount: decision.droppedEventCount,
-                    reason: decision.reason,
-                };
-            }
-            if (decision.droppedEventCount > 0) {
-                this.metrics?.increment("ingest_dropped_event_count", decision.droppedEventCount);
-            }
-            if (!options.requireCachedBrowserToken &&
-                !refreshedToken &&
-                (decision.reason === "expired_browser_token" ||
-                    decision.reason === "stale_browser_token")) {
-                this.cachedToken = null;
-                const refreshed = await this.safeEnsureBrowserToken({
-                    signal: options.signal,
-                    deadlineAt: options.deadlineAt,
-                });
-                if (!refreshed.ok) {
-                    return this.failedSend(lastStatus, attempts, refreshed.retryStrategy ?? "retry_same_batch");
-                }
-                browserToken = refreshed.token;
-                refreshedToken = true;
-                continue;
-            }
-            if (decision.retryStrategy !== "retry_same_batch" ||
-                attempts === RETRY_CONFIG.maxAttempts) {
-                return this.failedSend(lastStatus, attempts, decision.retryStrategy, decision.governor);
-            }
-            this.metrics?.increment("retry_count");
-            this.metrics?.increment("transport_retry_count");
-            this.diagnostics?.record({
-                code: "retry_scheduled",
-                strategy: "retry_same_batch",
-                http_status: lastStatus ?? undefined,
-                attempt: attempts,
-                batch_fingerprint: this.diagnostics.batchFingerprint(diagnosticCanonicalPayload(payload)),
-            });
-            if (!(await sleep(computeRetryDelay(attempts, RETRY_CONFIG), options.signal, options.deadlineAt))) {
-                return this.failedSend(lastStatus, attempts, isConsentAbort(options.signal) ? "drop_event" : "retry_same_batch");
-            }
+        finally {
+            clearTimeout(timeout);
+            if (this.inFlight === active)
+                this.inFlight = null;
         }
-        return this.failedSend(lastStatus, RETRY_CONFIG.maxAttempts, "retry_same_batch");
+    }
+    abortAttempt(cause) {
+        if (!this.inFlight)
+            return;
+        this.inFlight.cause = cause;
+        this.inFlight.controller.abort();
     }
     measurePayloadBytes(events, metadata = {
-        batch_id: "batch_00000000-0000-4000-8000-000000000000",
-        idempotency_key: "idem_00000000-0000-4000-8000-000000000000",
+        batch_id: `batch_${"0".repeat(32)}`,
+        idempotency_key: `idem_${"0".repeat(32)}`,
         sent_at: "2026-01-01T00:00:00.000Z",
     }) {
         return new TextEncoder().encode(this.stringifyPayload(events, metadata))
@@ -218,34 +114,28 @@ export class IngestClient {
                 sdk_type: this.sdkType,
                 sdk_version: this.sdkVersion,
             },
-            events: events.map((event) => this.withSourceEvidence(event)),
+            events: events.map((event) => withSourceEvidence(event)),
         });
     }
-    withSourceEvidence(event) {
-        return {
-            ...event,
-            source_event_id: event.source_event_id ?? event.event_id,
-            source_schema_version: String(this.schemaVersion),
-            source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
-            source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
-            event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
-            event_category: "context",
-            producer_id: this.producerId,
-            service_name: event.service_name ?? this.sourceIdentifier,
-            privacy_state: event.privacy_state ?? "masked",
-            privacy_level: event.privacy_level ?? "default_masked",
-            masking_state: event.masking_state ?? "masked",
-            allowed_value_keys: event.allowed_value_keys ?? [],
-        };
-    }
     createBatchEnvelopeMetadata() {
-        const id = this.createId();
+        const id = generateBatchId();
         return {
             batch_id: `batch_${id}`,
             idempotency_key: `idem_${id}`,
             sent_at: new Date().toISOString(),
         };
     }
+    diagnosticCanonicalPayload(payload) {
+        try {
+            return canonicalJsonStringify(JSON.parse(payload));
+        }
+        catch {
+            return "{}";
+        }
+    }
+    async ensureDeliveryToken(options = {}) {
+        return await this.safeEnsureBrowserToken(options);
+    }
     hasUsableBrowserToken(nowMs = Date.now()) {
         return this.getUsableCachedBrowserToken(nowMs) !== null;
     }
@@ -253,78 +143,6 @@ export class IngestClient {
         const result = await this.safeEnsureBrowserToken({ signal });
         return result.ok;
     }
-    failedSend(status, attempts, retryStrategy, governor = null) {
-        this.metrics?.increment("send_failure_count");
-        this.metrics?.increment("transport_failed_count");
-        return { ok: false, status, attempts, governor, retryStrategy };
-    }
-    recordDecision(decision, status, attempt, payload) {
-        const diagnostics = this.diagnostics;
-        if (!diagnostics)
-            return;
-        for (const code of decision.diagnosticCodes) {
-            diagnostics.record({
-                code,
-                count: code === "intentional_drop" ? decision.droppedEventCount : 1,
-                http_status: status ?? undefined,
-                attempt,
-                batch_fingerprint: diagnostics.batchFingerprint(diagnosticCanonicalPayload(payload)),
-            });
-        }
-    }
-    async postBatch(input) {
-        try {
-            const response = await fetchWithDeadline(this.endpoint, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                    "x-cluebase-project-key": this.projectKey,
-                    [CLUEBASE_BROWSER_TOKEN_HEADER]: input.browserToken,
-                    [CLUEBASE_SDK_REQUEST_HEADER]: this.sdkType,
-                    [CLUEBASE_SDK_VERSION_HEADER]: this.sdkVersion,
-                    [CLUEBASE_SOURCE_SCHEMA_VERSION_HEADER]: String(this.schemaVersion),
-                },
-                body: input.payload,
-                keepalive: input.keepalive,
-                credentials: "omit",
-                redirect: "error",
-            }, input.signal, input.deadlineAt);
-            const decision = evaluateBrowserDeliveryResponse({
-                status: response.status,
-                bodyText: await response.text(),
-                localSubmittedCount: input.localSubmittedCount,
-            });
-            if (decision.privacyPolicy !== undefined) {
-                applyDeliveredPrivacyPolicy(decision.privacyPolicy);
-            }
-            return {
-                status: response.status,
-                decision,
-            };
-        }
-        catch {
-            return {
-                status: null,
-                decision: {
-                    ok: false,
-                    retryStrategy: isConsentAbort(input.signal)
-                        ? "drop_event"
-                        : "retry_same_batch",
-                    governor: null,
-                    droppedEventCount: 0,
-                    acceptedEventCount: 0,
-                    acceptedPartial: false,
-                    reason: isConsentAbort(input.signal)
-                        ? "consent_denied"
-                        : "transport_timeout",
-                    diagnosticCodes: [],
-                },
-            };
-        }
-    }
-    createId() {
-        return generateEventId();
-    }
     getUsableCachedBrowserToken(nowMs = Date.now()) {
         if (this.cachedToken &&
             this.cachedToken.expiresAtMs > nowMs + BROWSER_TOKEN_REFRESH_LEEWAY_MS) {
@@ -332,7 +150,7 @@ export class IngestClient {
         }
         return null;
     }
-    async ensureBrowserToken(signal, deadlineAt) {
+    async ensureBrowserToken(signal) {
         const nowMs = Date.now();
         const cachedToken = this.getUsableCachedBrowserToken(nowMs);
         if (cachedToken) {
@@ -342,18 +160,17 @@ export class IngestClient {
             return await awaitWithAbort(this.pendingTokenRequest, signal);
         }
         const request = (async () => {
-            const response = await fetchWithDeadline(this.browserTokenEndpoint, {
+            const response = await fetch((await this.endpoints()).browserTokenUrl, {
                 method: "POST",
                 headers: {
                     "content-type": "application/json",
                     "x-cluebase-project-key": this.projectKey,
                 },
-                body: JSON.stringify({
-                    projectKey: this.projectKey,
-                }),
+                body: JSON.stringify({ projectKey: this.projectKey }),
                 credentials: "omit",
                 redirect: "error",
-            }, signal, deadlineAt);
+                ...(signal ? { signal } : {}),
+            });
             if (!response.ok) {
                 throw new BrowserTokenRequestError(response.status);
             }
@@ -392,7 +209,7 @@ export class IngestClient {
         try {
             return {
                 ok: true,
-                token: await this.ensureBrowserToken(options.signal, options.deadlineAt),
+                token: await this.ensureBrowserToken(options.signal),
             };
         }
         catch (error) {
@@ -411,35 +228,25 @@ export class IngestClient {
         }
     }
 }
-const asObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
-    ? value
-    : null;
-const diagnosticCanonicalPayload = (payload) => {
-    try {
-        return canonicalJsonStringify(JSON.parse(payload));
-    }
-    catch {
-        return "{}";
+const readBoundedBody = async (response, maxBytes) => {
+    if (!response.body)
+        return { text: "", overLimit: false };
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = "";
+    while (true) {
+        const chunk = await reader.read();
+        if (chunk.done)
+            return { text: text + decoder.decode(), overLimit: false };
+        bytes += chunk.value.byteLength;
+        if (bytes > maxBytes) {
+            await reader.cancel();
+            return { text: "", overLimit: true };
+        }
+        text += decoder.decode(chunk.value, { stream: true });
     }
 };
-const isConsentAbort = (signal) => signal?.aborted === true && signal.reason === CONSENT_DENIED_ABORT_REASON;
-const sleep = (milliseconds, signal, deadlineAt) => new Promise((resolve) => {
-    const remaining = remainingDeadlineMs(deadlineAt);
-    if (signal?.aborted || (remaining !== null && remaining <= 0)) {
-        resolve(false);
-        return;
-    }
-    const abort = () => {
-        clearTimeout(timeout);
-        resolve(false);
-    };
-    const timeoutMs = Math.min(milliseconds, remaining ?? milliseconds);
-    const timeout = setTimeout(() => {
-        signal?.removeEventListener("abort", abort);
-        resolve(timeoutMs === milliseconds);
-    }, timeoutMs);
-    signal?.addEventListener("abort", abort, { once: true });
-});
 const awaitWithAbort = async (promise, signal) => {
     if (!signal)
         return await promise;
@@ -457,27 +264,7 @@ const awaitWithAbort = async (promise, signal) => {
         });
     });
 };
-const fetchWithDeadline = async (input, init, externalSignal, deadlineAt) => {
-    const controller = new AbortController();
-    const abort = () => controller.abort();
-    if (externalSignal?.aborted)
-        abort();
-    externalSignal?.addEventListener("abort", abort, { once: true });
-    const remaining = remainingDeadlineMs(deadlineAt);
-    if (remaining !== null && remaining <= 0)
-        abort();
-    const timeout = setTimeout(abort, Math.min(NORMAL_ATTEMPT_TIMEOUT_MS, remaining ?? NORMAL_ATTEMPT_TIMEOUT_MS));
-    try {
-        return await fetch(input, { ...init, signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timeout);
-        externalSignal?.removeEventListener("abort", abort);
-    }
-};
-const monotonicNow = () => typeof performance !== "undefined" ? performance.now() : Date.now();
-const remainingDeadlineMs = (deadlineAt) => deadlineAt === undefined ? null : Math.max(0, deadlineAt - monotonicNow());
-const hasDeadlineRemaining = (deadlineAt) => {
-    const remaining = remainingDeadlineMs(deadlineAt);
-    return remaining === null || remaining > 0;
-};
+const isConsentAbort = (signal) => signal?.aborted === true && signal.reason === CONSENT_DENIED_ABORT_REASON;
+const asObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;

package/dist/exporter/delivery-pipeline.d.ts

@@ -0,0 +1,71 @@
+import type { DiagnosticCode } from "./diagnostics.js";
+import { type CollectionPermit, type ConsentReport, type ConsentState, type DeliveryProgress, type DiagnosticEntry, type EnqueueReport, type FenceReport, type QueueDepthReport, type QueueLimitsInput, type RestoredEvent, type RestoreReport, type TransportOutcome, type TransportRequest } from "./sdk-core-delivery.js";
+export type DeliveryTransport = (request: TransportRequest) => Promise<TransportOutcome>;
+export type DeliveryClock = {
+    nowMs: () => number;
+    sleep: (delayMs: number) => Promise<void>;
+};
+export type DeliveryPipelineOptions = {
+    readonly endpoint: string;
+    readonly projectKey: string;
+    readonly sdkVersion: string;
+    readonly sourceSchemaVersion: string;
+    readonly sdkRequest: string;
+    readonly queueLimits: QueueLimitsInput;
+    readonly requestTimeoutMs?: number;
+    readonly initialConsent: ConsentState;
+    readonly transport: DeliveryTransport;
+    readonly clock: DeliveryClock;
+};
+export type AdmittedEvent = {
+    readonly eventKey: string;
+    readonly byteLength: number;
+    readonly diagnosticCanonicalBytes?: string;
+};
+export type DeliveryObservation = {
+    readonly progress: DeliveryProgress;
+    readonly diagnostics: readonly DiagnosticEntry[];
+    readonly settledEventKeys: readonly string[];
+    readonly droppedEventKeys: readonly string[];
+    readonly droppedEventCount: number;
+    readonly httpStatus: number | null;
+    readonly reason: string | null;
+    readonly privacyPolicy?: unknown;
+    readonly directiveUnreadable: boolean;
+    readonly diagnosticCodes: readonly DiagnosticCode[];
+};
+export type SerializedBatch = {
+    readonly body: string;
+    readonly diagnosticCanonicalBytes?: string;
+};
+export type DeliveryRunStop = "queue_drained" | "awaiting_result" | "consent_revoked" | "deadline_exceeded" | "retries_exhausted" | "retry_not_due" | "batch_unavailable";
+export type DeliveryRunSummary = {
+    readonly observations: readonly DeliveryObservation[];
+    readonly attempts: number;
+    readonly stop: DeliveryRunStop;
+};
+export declare class DeliveryPipeline {
+    private readonly consentHandle;
+    private readonly driverOptions;
+    private handle;
+    private readonly transport;
+    private readonly clock;
+    private released;
+    constructor(options: DeliveryPipelineOptions);
+    reset(): void;
+    permit(): CollectionPermit;
+    admit(event: AdmittedEvent, permit: CollectionPermit): EnqueueReport;
+    adoptRestoredBatch(ordinal: number, events: readonly RestoredEvent[]): RestoreReport;
+    depth(envelopeOverheadBytes: number): QueueDepthReport;
+    pendingCount(): number;
+    fence(envelopeOverheadBytes: number): FenceReport;
+    rememberBrowserToken(token: string | null): void;
+    declareConsent(consent: ConsentState): ConsentReport;
+    beginClose(): void;
+    dispose(): boolean;
+    run(input: {
+        readonly body: (batchId: number, eventKeys: readonly string[]) => SerializedBatch | null;
+        readonly onObservation?: (observation: DeliveryObservation) => void;
+        readonly deadlineMs?: number | (() => number | undefined);
+    }): Promise<DeliveryRunSummary>;
+}