youeduc-sdk-messaging 0.0.0 → 0.5.0

package/dist/consumer.js

@@ -0,0 +1,1228 @@
+/**
+ * Kafka consumer with retry through the group's retry topics, DLQ, deduplication and manual
+ * commits (spec §5). Mirrors Python's `consumer.py` step by step.
+ *
+ * Topology (per consumer group):
+ *
+ *     {domain}.events.{version}                       main topic (shared)
+ *     {main}.{group}.retry.{30s,5m,1h,12h}            group retry topics (read back by the group)
+ *     {main}.{group}.dlq                              group DLQ
+ *
+ * With `resourcePrefix` (spec §2.7) the main topic becomes `{prefix}.{domain}.events.{version}` and
+ * the group id `{prefix}.{group}`; retry and DLQ derive from the prefixed main topic and the bare
+ * group. Telemetry, logs and the getters (`group`, `mainTopic`...) show the full names.
+ *
+ * The group subscribes by regex (`naming.retryTopicPattern`) to the main topic and to **every**
+ * retry topic of the group, including delays that left the `RetryPolicy`. A retry is processed
+ * straight from its retry topic when due (`x-retry-due-at`); it is never republished to the main
+ * topic. The next attempt always follows the CURRENT policy, by `x-retry-count`.
+ *
+ * Kafka client: the callback (librdkafka) API of `@confluentinc/kafka-javascript`, wrapped by
+ * `ConfluentConsumerClient` (`consumer-client.ts`, which documents why `KafkaJS.Consumer.run()`
+ * cannot implement §5 and how rebalances are serialized with `consume()`). Mapping to the spec:
+ *
+ * - §5.1 config: `enable.auto.commit=false`, `enable.auto.offset.store=false`,
+ *   `auto.offset.reset=earliest` (always; the user's `latest` is applied on assignment, §5.7),
+ *   `max.poll.interval.ms` (also librdkafka's rebalance timeout), eager `roundrobin` assignor.
+ * - Poll loop = Python's `getmany` loop: `client.poll({maxRecords, timeoutMs})` → batch grouped
+ *   by partition → processed under the batch lock: partitions concurrently
+ *   (`Promise.allSettled`), records of a partition sequentially by offset (§5.4).
+ * - Each record ends in ADVANCE (final outcome, or retry/DLQ send acknowledged) or HOLD. HOLD =
+ *   `pause` + `seek(offset)` + resume timer (§5.4); the rest of the partition's batch is skipped.
+ *   A seek that fails while the partition is still ours is retried before resuming, so a
+ *   partition never resumes from an unknown position.
+ * - End of batch: commit `last contiguous ADVANCE + 1` per partition, only for partitions still
+ *   assigned (`offset_commit_skipped_unassigned`); failure → `offset_commit_failed` (§5.4).
+ * - Not-due retry (§5.5): HOLD for `min(due − now, topic delay)` (10 ms floor), nothing recorded.
+ * - Routing failure (§5.6): retriable → pending route cache (target + headers) + HOLD for
+ *   `routingFailureBackoffMs`, resent without re-running the handler; non-retriable retry send →
+ *   DLQ `routing_failed` with the handler's error; non-retriable DLQ send → one shrunk attempt
+ *   (`x-last-error` ≤ 256 code points, no trace context, nothing injected) → then fatal.
+ * - Dedup (§8): checked before the payload is decoded, marked only after handler success.
+ * - Processing timeout (§7): the handler's `AbortSignal` is aborted at `processingTimeoutMs`,
+ *   then it gets the same time again; still running → `message_handler_abandoned`, detached.
+ * - Lifecycle (§5.7): `stop()` drains at the record boundary, commits and closes; after
+ *   `drainTimeoutMs` the loop is cancelled (every await of the pipeline is raced against the
+ *   cancellation; handlers are aborted) and the unfinished offset is not committed. Revoke asks
+ *   the partitions to stop at the next record boundary and waits for the batch lock (the batch
+ *   commits what it finished), then drops timers/pending routes of the revoked partitions.
+ *   `latest`: main-topic partitions without a committed offset move to the end when assigned (the
+ *   confluent client turns it into the assign start offset); records fetched before that reset
+ *   are dropped. The reset serial is read right after each poll returns (as in Python, after
+ *   `getmany`), so a record fetched after the reset is never dropped (§5.7).
+ *   Fatal poll errors (codes 29, 30, 31, 35, 58, authentication, fatal/stopped client, or any
+ *   non-Kafka error) stop the consumer and `wait()` rethrows; others log `consumer_poll_failed`
+ *   and wait `routingFailureBackoffMs`.
+ *
+ * A handler may run more than once for the same message (crash before commit, failed commit,
+ * rebalance): handlers must be idempotent or use a `DuplicateChecker`. A record may take up to
+ * `2 × processingTimeoutMs`.
+ */
+import { performance } from 'node:perf_hooks';
+import { createConfluentConsumer, partitionKey, } from './consumer-client.js';
+import { HandlerCancelledError, InvalidHandlerError, InvalidPayloadError, NotStartedError, PermanentProcessingError, PublishError, SchemaNotFoundError, SchemaValidationError, } from './errors.js';
+import * as hdr from './headers.js';
+import { defaultLogger } from './logger.js';
+import * as naming from './naming.js';
+import { decodePayload } from './payload.js';
+import { RetryPolicy } from './retry.js';
+import { NoopTelemetry } from './telemetry.js';
+import { isKafkaClientError } from './transport.js';
+import { createMessageInfo, } from './types.js';
+import { errorFields, errorMessage, errorTypeName, formatSeconds, isPositiveFinite, pyRepr, truncateChars, } from './util.js';
+const ADVANCE = 'advance';
+const HOLD = 'hold';
+const FATAL = 'fatal';
+const DEFAULT_RETRY_POLICY = new RetryPolicy();
+const AUTO_OFFSET_RESET = ['earliest', 'latest'];
+/**
+ * Group `session.timeout.ms`, the same as the Python SDK (aiokafka's default). `maxPollIntervalMs`
+ * must be >= it (§5.1; librdkafka refuses the opposite).
+ */
+const SESSION_TIMEOUT_MS = 10_000;
+/** Floor of the resume timer: avoids a hot loop when a retry is due in a few ms. */
+const MIN_RESUME_DELAY_MS = 10;
+/** Second DLQ attempt after a non-retriable error: reduced headers. */
+const SHRUNK_ERROR_LENGTH = 256;
+const TRACE_HEADERS = ['traceparent', 'tracestate'];
+/**
+ * Poll errors that repeating does not fix (spec §5.7): topic/group/cluster authorization (29, 30,
+ * 31), unsupported version (35), SASL authentication (58), local authentication (-169), client
+ * stopped/not connected (-172, librdkafka `ERR__STATE`) and librdkafka fatal errors (-150).
+ */
+const FATAL_POLL_CODES = new Set([29, 30, 31, 35, 58, -169, -172, -150]);
+/** Whether a poll error stops the consumer: any non-Kafka error, a fatal code or `isFatal`. */
+export function isFatalPollError(error) {
+    if (!isKafkaClientError(error))
+        return true;
+    if (error.isFatal === true)
+        return true;
+    return FATAL_POLL_CODES.has(error.code);
+}
+const keyDecoder = new TextDecoder('utf-8', { fatal: false, ignoreBOM: true });
+function isAsyncFunction(value) {
+    return typeof value === 'function' && Object.prototype.toString.call(value) === '[object AsyncFunction]';
+}
+function isPromiseLike(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        typeof value.then === 'function');
+}
+function isAbortError(error) {
+    return typeof error === 'object' && error !== null && error.name === 'AbortError';
+}
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function elapsedMs(started) {
+    return Math.max(performance.now() - started, 0);
+}
+function errorInfo(error) {
+    return errorFields(error, hdr.MAX_ERROR_LENGTH);
+}
+/** Cancellable sleep (no timer left behind). */
+function sleep(ms) {
+    let timer;
+    const promise = new Promise((resolve) => {
+        timer = setTimeout(resolve, ms);
+    });
+    return { promise, cancel: () => clearTimeout(timer) };
+}
+const TIMED_OUT = Symbol('timed out');
+async function withTimeout(promise, ms) {
+    const timer = sleep(ms);
+    try {
+        return await Promise.race([promise, timer.promise.then(() => TIMED_OUT)]);
+    }
+    finally {
+        timer.cancel();
+    }
+}
+function settle(promise) {
+    return promise.then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+}
+/** Raised at every pipeline await once `stop()`'s drain timeout cancelled the loop. */
+class LoopCancelledError extends Error {
+    constructor() {
+        super('consumer loop cancelled');
+        this.name = 'CancelledError';
+    }
+}
+/** FIFO async mutex (asyncio.Lock semantics). */
+class Mutex {
+    #tail = Promise.resolve();
+    run(fn) {
+        const result = this.#tail.then(fn);
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+const INTERNALS = new WeakMap();
+/** @internal */
+export function consumerInternals(consumer) {
+    const internals = INTERNALS.get(consumer);
+    if (internals === undefined)
+        throw new TypeError('not a Consumer');
+    return internals;
+}
+/**
+ * Consumes the domain's main topic and the group's retry topics.
+ *
+ * Handler contract: resolving = success; rejecting with `PermanentProcessingError` = DLQ; any
+ * other rejection (including the processing timeout) = retry, until `retryPolicy` is exhausted.
+ */
+export class Consumer {
+    /** Effective group id (prefixed): Kafka, telemetry and logs. */
+    #group;
+    /** Logical group (no prefix): builds the retry/DLQ topics and the subscription. */
+    #logicalGroup;
+    #resourcePrefix;
+    #mainTopic;
+    #retryTopics;
+    #dlqTopic;
+    #pattern;
+    #config;
+    #domain;
+    #handlers;
+    #validator;
+    #sender;
+    #retryPolicy;
+    #duplicateChecker;
+    #telemetry;
+    #processingTimeoutMs;
+    #maxPollRecords;
+    #pollTimeoutMs;
+    #maxPollIntervalMs;
+    #routingFailureBackoffMs;
+    #autoOffsetReset;
+    #consumerFactory;
+    #clock;
+    #logger;
+    #client = null;
+    #task = null;
+    #taskDone = false;
+    #closing = null;
+    #started = false;
+    #stopping = false;
+    #revoking = 0;
+    #stoppedLogged = false;
+    #fatal = null;
+    #signalStop = () => undefined;
+    #stopped;
+    #cancelled = false;
+    #rejectCancel = () => undefined;
+    #cancellation;
+    #batchLock = new Mutex();
+    #resumeTimers = new Map();
+    /** Routing decision whose send failed (retriable), per partition. */
+    #pendingRoutes = new Map();
+    /** HOLD seeks that failed while the partition was still ours: re-seek before resuming. */
+    #pendingSeeks = new Map();
+    /** `latest`: partitions moved to the end, and the number of that reset. */
+    #resetSerial = 0;
+    #resetAt = new Map();
+    /**
+     * Partitions handed back by `onPartitionsRevoked` and not assigned again since. The listener
+     * returns before the client actually unassigns them, so `client.assignment()` still lists them
+     * for a moment: a batch fetched before the revoke (consume() in flight when the rebalance was
+     * served) and processed in that window is dropped here instead of being handled against a
+     * partition that already belongs to the new owner.
+     */
+    #revoked = new Set();
+    /** Handlers in flight (aborted on cancellation) and handlers that ignored the abort. */
+    #active = new Set();
+    #detached = new Set();
+    constructor(config, options) {
+        const retryPolicy = options.retryPolicy ?? DEFAULT_RETRY_POLICY;
+        this.#logicalGroup = naming.consumerGroup(options.group);
+        this.#resourcePrefix = naming.resourcePrefix(options.resourcePrefix);
+        this.#group = naming.consumerGroup(options.group, { resourcePrefix: this.#resourcePrefix });
+        this.#mainTopic = naming.topic(options.domain, options.version, { resourcePrefix: this.#resourcePrefix });
+        this.#retryTopics = Object.freeze(retryPolicy.retryTopics(this.#mainTopic, options.group));
+        this.#dlqTopic = naming.dlqTopic(this.#mainTopic, options.group);
+        this.#pattern = naming.retryTopicPattern(this.#mainTopic, options.group);
+        const entries = options.handlers instanceof Map
+            ? [...options.handlers.entries()]
+            : Object.entries((options.handlers ?? {}));
+        if (entries.length === 0)
+            throw new TypeError("'handlers' must not be empty");
+        for (const [eventType, handler] of entries) {
+            if (typeof eventType !== 'string') {
+                throw new TypeError(`handler key must be a string; got ${String(eventType)}`);
+            }
+            naming.splitEventType(eventType);
+            if (!isAsyncFunction(handler)) {
+                throw new TypeError(`handler for ${pyRepr(eventType)} must be an async function`);
+            }
+        }
+        const maxPollRecords = options.maxPollRecords ?? 100;
+        const pollTimeoutMs = options.pollTimeoutMs ?? 1000;
+        const maxPollIntervalMs = options.maxPollIntervalMs ?? 300_000;
+        for (const [name, value] of [
+            ['maxPollRecords', maxPollRecords],
+            ['pollTimeoutMs', pollTimeoutMs],
+            ['maxPollIntervalMs', maxPollIntervalMs],
+        ]) {
+            if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+                throw new RangeError(`'${name}' must be an integer >= 1; got ${String(value)}`);
+            }
+        }
+        if (maxPollIntervalMs < SESSION_TIMEOUT_MS) {
+            throw new RangeError(`'maxPollIntervalMs' must be >= the session timeout (${SESSION_TIMEOUT_MS} ms); got ${maxPollIntervalMs}`);
+        }
+        const processingTimeoutMs = options.processingTimeoutMs ?? null;
+        if (processingTimeoutMs !== null) {
+            if (!isPositiveFinite(processingTimeoutMs)) {
+                throw new RangeError(`'processingTimeoutMs' must be a finite number > 0; got ${String(processingTimeoutMs)}`);
+            }
+            if (2 * processingTimeoutMs >= maxPollIntervalMs) {
+                throw new RangeError("'processingTimeoutMs' must be less than half of 'maxPollIntervalMs' (a record may take up" +
+                    ` to 2x the timeout); got ${processingTimeoutMs}ms vs ${maxPollIntervalMs}ms`);
+            }
+        }
+        const routingFailureBackoffMs = options.routingFailureBackoffMs ?? 5000;
+        if (!isPositiveFinite(routingFailureBackoffMs)) {
+            throw new RangeError(`'routingFailureBackoffMs' must be a finite number > 0; got ${String(routingFailureBackoffMs)}`);
+        }
+        const autoOffsetReset = options.autoOffsetReset ?? 'earliest';
+        if (!AUTO_OFFSET_RESET.includes(autoOffsetReset)) {
+            throw new TypeError(`'autoOffsetReset' must be one of ('earliest', 'latest'); got ${pyRepr(String(autoOffsetReset))}`);
+        }
+        const clock = options.clock ?? Date.now;
+        if (typeof clock !== 'function')
+            throw new TypeError("'clock' must be a function");
+        this.#config = config;
+        this.#domain = options.domain;
+        this.#handlers = new Map(entries);
+        this.#validator = options.validator;
+        this.#sender = options.sender;
+        this.#retryPolicy = retryPolicy;
+        this.#duplicateChecker = options.duplicateChecker ?? null;
+        this.#telemetry = options.telemetry ?? new NoopTelemetry();
+        this.#processingTimeoutMs = processingTimeoutMs;
+        this.#maxPollRecords = maxPollRecords;
+        this.#pollTimeoutMs = pollTimeoutMs;
+        this.#maxPollIntervalMs = maxPollIntervalMs;
+        this.#routingFailureBackoffMs = routingFailureBackoffMs;
+        this.#autoOffsetReset = autoOffsetReset;
+        this.#consumerFactory = options.consumerFactory ?? createConfluentConsumer;
+        this.#clock = clock;
+        this.#logger = options.logger;
+        this.#stopped = new Promise((resolve) => {
+            this.#signalStop = resolve;
+        });
+        this.#cancellation = new Promise((_resolve, reject) => {
+            this.#rejectCancel = reject;
+        });
+        this.#cancellation.catch(() => undefined);
+        INTERNALS.set(this, {
+            resumeTimers: () => new Map(this.#resumeTimers),
+            pendingRoutes: () => new Map(this.#pendingRoutes),
+            resumePartition: (tp) => this.#resumePartition(tp),
+            setHandler: (eventType, handler) => {
+                this.#handlers.set(eventType, handler);
+            },
+        });
+    }
+    // ---------------------------------------------------------------------------- properties
+    get mainTopic() {
+        return this.#mainTopic;
+    }
+    /** Retry topics of the current policy (targets of new retries). */
+    get retryTopics() {
+        return [...this.#retryTopics];
+    }
+    /** Subscribed regex (source): main topic + every retry topic of the group. */
+    get subscriptionPattern() {
+        return this.#pattern;
+    }
+    get dlqTopic() {
+        return this.#dlqTopic;
+    }
+    /** Effective Kafka group id (with the resource prefix, if any). */
+    get group() {
+        return this.#group;
+    }
+    get resourcePrefix() {
+        return this.#resourcePrefix;
+    }
+    get running() {
+        return this.#task !== null && !this.#taskDone && !this.#stopping;
+    }
+    get #log() {
+        return this.#logger ?? defaultLogger();
+    }
+    /** Final librdkafka configuration handed to the client factory. */
+    consumerConfig() {
+        return {
+            ...this.#config.clientConfig(),
+            'group.id': this.#group,
+            'enable.auto.commit': false,
+            'enable.auto.offset.store': false,
+            // Always "earliest": an uncommitted retry is never skipped. The user's "latest" is applied
+            // to the main topic only, on assignment.
+            'auto.offset.reset': 'earliest',
+            'max.poll.interval.ms': this.#maxPollIntervalMs,
+            'session.timeout.ms': SESSION_TIMEOUT_MS,
+            // Eager protocol: a revoke always covers the whole assignment (see consumer-client.ts).
+            'partition.assignment.strategy': 'roundrobin',
+        };
+    }
+    // ---------------------------------------------------------------------------- lifecycle
+    async start() {
+        if (this.#started)
+            throw new Error('Consumer has already been started');
+        this.#started = true;
+        let client = null;
+        try {
+            client = await this.#consumerFactory(this.consumerConfig(), {
+                onCommitFailed: (error) => this.#log.warn('offset_commit_failed', {
+                    messaging: { group: this.#group },
+                    error: errorInfo(error),
+                }),
+            });
+            await client.connect();
+            client.subscribe(this.#pattern, this.#listener(client));
+        }
+        catch (error) {
+            if (client !== null) {
+                try {
+                    await client.disconnect(); // release what a failed start may have allocated
+                }
+                catch {
+                    // the original error matters
+                }
+            }
+            this.#started = false;
+            throw error;
+        }
+        this.#client = client;
+        if (this.#stopping) {
+            // stop() called during start(): do not start the loop.
+            await this.#closeClient();
+            return;
+        }
+        const task = this.#run(client);
+        this.#task = task;
+        void task.finally(() => {
+            this.#taskDone = true;
+        });
+        this.#log.info('consumer_started', {
+            messaging: {
+                group: this.#group,
+                subscription_pattern: this.#pattern,
+                retry_topics: [...this.#retryTopics],
+                dlq_topic: this.#dlqTopic,
+            },
+        });
+    }
+    /**
+     * Graceful shutdown: the in-flight record of each partition finishes and the progress is
+     * committed. After `drainTimeoutMs` the loop is cancelled (the in-flight handler is aborted)
+     * and the unfinished offset is not committed: it will be redelivered. Idempotent.
+     */
+    async stop(options = {}) {
+        const drainTimeoutMs = options.drainTimeoutMs ?? 30_000;
+        if (!this.#started)
+            return;
+        this.#stopping = true;
+        this.#signalStop();
+        this.#cancelTimers();
+        const task = this.#task;
+        if (task !== null && !this.#taskDone) {
+            const finished = await withTimeout(task, Math.max(drainTimeoutMs, 0));
+            if (finished === TIMED_OUT) {
+                this.#log.warn('consumer_drain_timeout', {
+                    messaging: { group: this.#group, drain_timeout_s: drainTimeoutMs / 1000 },
+                });
+                this.#cancel();
+                await task;
+            }
+        }
+        this.#cancelTimers();
+        this.#pendingRoutes.clear();
+        this.#pendingSeeks.clear();
+        await this.#closeClient();
+        if (!this.#stoppedLogged) {
+            this.#stoppedLogged = true;
+            this.#log.info('consumer_stopped', { messaging: { group: this.#group } });
+        }
+    }
+    /** Waits for the loop to end; rethrows the fatal error that stopped it, if any. */
+    async wait() {
+        const task = this.#task;
+        if (task === null)
+            throw new NotStartedError('Consumer is not running');
+        await task;
+        if (this.#fatal !== null)
+            throw this.#fatal.error;
+    }
+    /** Closes the Kafka client exactly once (leaves the group). */
+    async #closeClient() {
+        const client = this.#client;
+        if (client === null)
+            return;
+        this.#closing ??= (async () => {
+            try {
+                await client.disconnect();
+            }
+            catch (error) {
+                this.#log.warn('consumer_close_failed', {
+                    messaging: { group: this.#group },
+                    error: errorInfo(error),
+                });
+            }
+        })();
+        await this.#closing;
+    }
+    /** Fatal error: ends the loop (`wait()` rethrows). The record is not committed. */
+    #fail(error) {
+        if (this.#fatal === null) {
+            this.#log.error('consumer_crashed', { messaging: { group: this.#group }, error: errorInfo(error) });
+            this.#fatal = { error };
+        }
+        this.#stopping = true;
+        this.#signalStop();
+    }
+    #cancel() {
+        if (this.#cancelled)
+            return;
+        this.#cancelled = true;
+        const error = new LoopCancelledError();
+        this.#rejectCancel(error);
+        for (const controller of this.#active)
+            controller.abort(error);
+    }
+    /** Races `promise` against the loop cancellation (the Python task cancellation points). */
+    #abortable(promise) {
+        promise.catch(() => undefined); // the loser of the race must not be an unhandled rejection
+        if (this.#cancelled)
+            return Promise.reject(new LoopCancelledError());
+        return Promise.race([promise, this.#cancellation]);
+    }
+    // ---------------------------------------------------------------------------- poll loop
+    async #run(client) {
+        try {
+            while (!this.#stopping) {
+                let records;
+                try {
+                    records = await this.#abortable(client.poll({ maxRecords: this.#maxPollRecords, timeoutMs: this.#pollTimeoutMs }));
+                }
+                catch (error) {
+                    if (error instanceof LoopCancelledError)
+                        throw error;
+                    if (isFatalPollError(error)) {
+                        this.#fail(error);
+                        break;
+                    }
+                    this.#log.error('consumer_poll_failed', {
+                        messaging: { group: this.#group },
+                        error: errorInfo(error),
+                    });
+                    await this.#sleepUnlessStopping(this.#routingFailureBackoffMs);
+                    continue;
+                }
+                // Serial read AFTER the poll: only a reset completed after the poll returned proves the
+                // records were fetched before it (they are below the new end position: dropping them IS
+                // "latest"). A reset completed during the poll (always the case with the confluent client,
+                // which applies rebalances before consume()) may have post-reset records: kept, never lost.
+                const serial = this.#resetSerial;
+                if (records.length === 0)
+                    continue;
+                if (this.#stopping) {
+                    // Not committed: redelivered to whoever takes the partitions.
+                    this.#log.debug('consumer_batch_discarded_on_stop', { messaging: { group: this.#group } });
+                    break;
+                }
+                await this.#batchLock.run(() => this.#processBatch(client, records, serial));
+            }
+        }
+        catch (error) {
+            if (!(error instanceof LoopCancelledError))
+                this.#fail(error);
+        }
+        finally {
+            this.#stopping = true;
+            this.#signalStop();
+            this.#cancelTimers();
+            this.#pendingRoutes.clear();
+            this.#pendingSeeks.clear();
+            await this.#closeClient();
+        }
+    }
+    async #sleepUnlessStopping(ms) {
+        const timer = sleep(ms);
+        try {
+            await this.#abortable(Promise.race([timer.promise, this.#stopped]));
+        }
+        finally {
+            timer.cancel();
+        }
+    }
+    #draining() {
+        return this.#stopping || this.#revoking > 0;
+    }
+    async #processBatch(client, records, serial) {
+        const assigned = new Set(client.assignment().map(partitionKey));
+        const batch = new Map();
+        for (const record of records) {
+            const key = partitionKey(record);
+            let entry = batch.get(key);
+            if (entry === undefined) {
+                entry = { tp: { topic: record.topic, partition: record.partition }, records: [] };
+                batch.set(key, entry);
+            }
+            entry.records.push(record);
+        }
+        // Records fetched before a "latest" reset of the partition are dropped (its position already
+        // moved to the end); records of partitions no longer ours (revoked meanwhile, even if the
+        // client has not unassigned them yet) too: the new owner reads them from the committed offset.
+        // Eager protocol: between a revoke and the next assignment no record of the partition can be
+        // fetched, so a revoked partition's records in a batch are always from before the revoke.
+        const work = [...batch.entries()].filter(([key]) => (this.#resetAt.get(key) ?? 0) <= serial && assigned.has(key) && !this.#revoked.has(key));
+        if (work.length === 0)
+            return;
+        const results = await Promise.allSettled(work.map(([, entry]) => this.#processPartition(client, entry.tp, entry.records)));
+        const offsets = new Map();
+        for (const result of results) {
+            if (result.status === 'rejected')
+                throw result.reason;
+            const { tp, next } = result.value;
+            if (next !== null)
+                offsets.set(partitionKey(tp), { tp, offset: next });
+        }
+        if (offsets.size === 0)
+            return;
+        // A partition that stopped being ours (rebalance) is left out: committing it would be
+        // rejected and take the other partitions' commit down with it.
+        const nowAssigned = new Set(client.assignment().map(partitionKey));
+        const committable = [...offsets.entries()].filter(([key]) => nowAssigned.has(key));
+        if (committable.length !== offsets.size) {
+            this.#log.warn('offset_commit_skipped_unassigned', {
+                messaging: {
+                    group: this.#group,
+                    partitions: [...offsets.keys()].filter((key) => !nowAssigned.has(key)).sort(),
+                },
+            });
+        }
+        if (committable.length === 0)
+            return;
+        try {
+            await this.#abortable(client.commit(committable.map(([, { tp, offset }]) => ({ topic: tp.topic, partition: tp.partition, offset }))));
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError || !isKafkaClientError(error))
+                throw error;
+            // Without the commit the message is redelivered; at-least-once + dedup cover it.
+            this.#log.warn('offset_commit_failed', { messaging: { group: this.#group }, error: errorInfo(error) });
+        }
+    }
+    /** Records in offset order; returns the next committable offset. */
+    async #processPartition(client, tp, records) {
+        let next = null;
+        for (const record of [...records].sort((a, b) => a.offset - b.offset)) {
+            // stop/revoke: finish the in-flight record, start no other. The rest is redone from the
+            // committed offset.
+            if (this.#draining())
+                break;
+            const step = await this.#processRecord(client, tp, record);
+            if (step !== ADVANCE)
+                break;
+            next = record.offset + 1;
+        }
+        return { tp, next };
+    }
+    // ---------------------------------------------------------------------------- rebalance / timers
+    #listener(client) {
+        return {
+            onPartitionsRevoked: (partitions) => this.#onPartitionsRevoked(partitions),
+            onPartitionsAssigned: (partitions) => this.#onPartitionsAssigned(client, partitions),
+        };
+    }
+    async #onPartitionsRevoked(revoked) {
+        // Ask the partitions to stop at the next record boundary (the rebalance does not wait for
+        // the whole batch) and wait for the commit of what was finished.
+        this.#revoking += 1;
+        try {
+            await this.#batchLock.run(async () => {
+                for (const tp of revoked) {
+                    const key = partitionKey(tp);
+                    this.#cancelTimer(key);
+                    this.#pendingRoutes.delete(key);
+                    this.#pendingSeeks.delete(key);
+                    this.#resetAt.delete(key);
+                    this.#revoked.add(key);
+                }
+            });
+        }
+        finally {
+            this.#revoking -= 1;
+        }
+        this.#log.info('consumer_partitions_revoked', {
+            messaging: { group: this.#group, partitions: revoked.length },
+        });
+    }
+    async #onPartitionsAssigned(client, assigned) {
+        // Partitions come back resumed at the committed offset; due dates are re-evaluated. Called
+        // before the client assigns them: records fetched from now on belong to this assignment.
+        for (const tp of assigned)
+            this.#revoked.delete(partitionKey(tp));
+        this.#log.info('consumer_partitions_assigned', {
+            messaging: { group: this.#group, partitions: assigned.length },
+        });
+        if (this.#autoOffsetReset !== 'latest')
+            return;
+        const mainTps = assigned.filter((tp) => tp.topic === this.#mainTopic);
+        if (mainTps.length === 0)
+            return;
+        // Lock before any await: a batch already fetched from the start waits here and is dropped
+        // afterwards (serial) instead of being processed.
+        await this.#batchLock.run(async () => {
+            const toReset = [];
+            for (const tp of mainTps) {
+                let committed;
+                try {
+                    committed = await client.committed(tp);
+                }
+                catch (error) {
+                    // When in doubt stay at "earliest": reprocess, never lose.
+                    this.#log.warn('consumer_committed_offset_failed', {
+                        messaging: { topic: tp.topic, partition: tp.partition },
+                        error: errorInfo(error),
+                    });
+                    continue;
+                }
+                if (committed === null)
+                    toReset.push(tp);
+            }
+            if (toReset.length === 0)
+                return;
+            try {
+                await client.seekToEnd(toReset);
+            }
+            catch (error) {
+                // No guarantee the reset happened: drop nothing.
+                this.#log.warn('consumer_seek_to_end_failed', {
+                    messaging: { group: this.#group },
+                    error: errorInfo(error),
+                });
+                return;
+            }
+            this.#resetSerial += 1;
+            for (const tp of toReset)
+                this.#resetAt.set(partitionKey(tp), this.#resetSerial);
+            this.#log.info('consumer_partitions_reset_to_latest', {
+                messaging: { group: this.#group, partitions: toReset.length },
+            });
+        });
+    }
+    #isAssigned(client, tp) {
+        const key = partitionKey(tp);
+        return client.assignment().some((assigned) => partitionKey(assigned) === key);
+    }
+    #skipUnassigned(tp) {
+        // Not ours anymore: whoever takes it starts from the committed offset.
+        this.#log.debug('partition_hold_skipped_unassigned', {
+            messaging: { topic: tp.topic, partition: tp.partition },
+        });
+        this.#pendingRoutes.delete(partitionKey(tp));
+    }
+    /** Moves the partition back to `offset`, pauses it and schedules the resume. */
+    async #hold(client, tp, offset, delayMs) {
+        const key = partitionKey(tp);
+        if (!this.#isAssigned(client, tp)) {
+            this.#skipUnassigned(tp);
+            return;
+        }
+        try {
+            client.pause([tp]);
+            await this.#abortable(client.seek(tp, offset));
+            this.#pendingSeeks.delete(key);
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError)
+                throw error;
+            if (!this.#isAssigned(client, tp)) {
+                this.#skipUnassigned(tp);
+                return;
+            }
+            // Still ours but the position is unknown: never resume before the seek succeeds.
+            this.#pendingSeeks.set(key, offset);
+        }
+        this.#scheduleResume(tp, delayMs);
+    }
+    #scheduleResume(tp, delayMs) {
+        const key = partitionKey(tp);
+        this.#cancelTimer(key);
+        if (this.#stopping)
+            return;
+        const delay = Math.max(delayMs, MIN_RESUME_DELAY_MS);
+        const entry = {
+            tp,
+            delayMs: delay,
+            cancelled: false,
+            timer: setTimeout(() => {
+                if (this.#resumeTimers.get(key) === entry)
+                    void this.#resumePartition(tp);
+            }, delay),
+        };
+        this.#resumeTimers.set(key, entry);
+    }
+    async #resumePartition(tp) {
+        const key = partitionKey(tp);
+        this.#cancelTimer(key);
+        const client = this.#client;
+        if (this.#stopping || client === null)
+            return;
+        try {
+            if (!this.#isAssigned(client, tp))
+                return;
+            const offset = this.#pendingSeeks.get(key);
+            if (offset !== undefined) {
+                await client.seek(tp, offset);
+                this.#pendingSeeks.delete(key);
+            }
+            if (this.#stopping)
+                return;
+            client.resume([tp]);
+        }
+        catch (error) {
+            this.#log.warn('partition_resume_failed', {
+                messaging: { topic: tp.topic, partition: tp.partition },
+                error: errorInfo(error),
+            });
+            // Try again later: a partition left paused would silently stop consuming.
+            if (this.#client !== null && this.#isAssigned(this.#client, tp)) {
+                this.#scheduleResume(tp, this.#routingFailureBackoffMs);
+            }
+        }
+    }
+    #cancelTimer(key) {
+        const entry = this.#resumeTimers.get(key);
+        if (entry === undefined)
+            return;
+        entry.cancelled = true;
+        clearTimeout(entry.timer);
+        this.#resumeTimers.delete(key);
+    }
+    #cancelTimers() {
+        for (const key of [...this.#resumeTimers.keys()])
+            this.#cancelTimer(key);
+    }
+    // ---------------------------------------------------------------------------- per record
+    /** Never throws (except the loop cancellation). */
+    async #processRecord(client, tp, record) {
+        try {
+            return await this.#handleRecord(client, tp, record);
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError)
+                throw error;
+            // Unexpected internal error: never risk losing the message.
+            this.#log.error('message_processing_failed', {
+                messaging: {
+                    topic: record.topic,
+                    partition: record.partition,
+                    offset: record.offset,
+                    group: this.#group,
+                },
+                error: errorInfo(error),
+            });
+            await this.#hold(client, tp, record.offset, this.#routingFailureBackoffMs);
+            return HOLD;
+        }
+    }
+    async #handleRecord(client, tp, record) {
+        const started = performance.now();
+        const hdrs = hdr.decode(record.headers);
+        const key = partitionKey(tp);
+        const pending = this.#pendingRoutes.get(key);
+        this.#pendingRoutes.delete(key);
+        if (pending !== undefined && pending.offset === record.offset) {
+            // Resend of a decision already taken: the handler does NOT run again.
+            return this.#telemetry.consumeSpan(pending.info, hdrs, (span) => this.#deliver({
+                client,
+                tp,
+                record,
+                hdrs,
+                info: pending.info,
+                fields: pending.fields,
+                span,
+                started,
+                dedupKey: pending.dedupKey,
+            }, pending));
+        }
+        const retryDelayMs = naming.retryDelayOf(record.topic, this.#mainTopic, this.#logicalGroup);
+        if (retryDelayMs !== null) {
+            const dueMs = hdr.retryDueAtMs(hdrs);
+            const nowMs = this.#clock();
+            if (dueMs > nowMs) {
+                // Each retry topic has a fixed delay: due dates are monotonic in the partition, so
+                // blocking it at the first not-due record is correct. Capped by the topic delay against
+                // an absurd header.
+                const waitMs = Math.min(dueMs - nowMs, retryDelayMs);
+                this.#log.debug('message_retry_not_due', {
+                    messaging: {
+                        topic: record.topic,
+                        partition: record.partition,
+                        offset: record.offset,
+                        wait_s: round3(waitMs / 1000),
+                    },
+                });
+                await this.#hold(client, tp, record.offset, waitMs);
+                return HOLD;
+            }
+        }
+        const eventType = hdrs[hdr.EVENT_TYPE] ?? '';
+        const info = createMessageInfo({
+            topic: record.topic,
+            eventType,
+            messageId: hdrs[hdr.MESSAGE_ID] ?? '',
+            schemaVersion: hdrs[hdr.SCHEMA_VERSION] ?? '',
+            key: record.key === null ? null : keyDecoder.decode(record.key),
+            correlationId: hdrs[hdr.CORRELATION_ID] ?? null,
+            // Empty = no tenant, like ConsumedMessage (spec §4.1).
+            tenantId: hdrs[hdr.TENANT_ID] || null,
+            partition: record.partition,
+            offset: record.offset,
+            group: this.#group,
+            retryCount: hdr.retryCount(hdrs),
+        });
+        const fields = this.#logFields(info);
+        const handler = this.#handlers.get(eventType);
+        if (handler === undefined) {
+            this.#telemetry.recordConsume(info, { outcome: 'skipped', durationMs: elapsedMs(started) });
+            this.#log.debug('message_skipped', { messaging: fields });
+            return ADVANCE;
+        }
+        // idempotency_key first; without any key there is no dedup.
+        const dedupKey = hdr.dedupKey(hdrs) ?? '';
+        if (this.#duplicateChecker !== null && dedupKey !== '' && (await this.#isProcessed(dedupKey, fields))) {
+            this.#telemetry.recordConsume(info, { outcome: 'deduplicated', durationMs: elapsedMs(started) });
+            this.#log.info('message_deduplicated', { messaging: fields });
+            return ADVANCE;
+        }
+        return this.#telemetry.consumeSpan(info, hdrs, (span) => this.#processInSpan({ client, tp, record, hdrs, info, fields, span, started, dedupKey }, handler));
+    }
+    async #processInSpan(ctx, handler) {
+        const { record, hdrs, info } = ctx;
+        let payload;
+        try {
+            payload = decodePayload(record.value);
+        }
+        catch (error) {
+            if (!(error instanceof InvalidPayloadError))
+                throw error;
+            return this.#deliver(ctx, this.#dlqRoute(ctx, error, 'invalid_payload'));
+        }
+        try {
+            this.#validator.validate({
+                domain: this.#domain,
+                eventType: info.eventType,
+                version: info.schemaVersion,
+                payload,
+            });
+        }
+        catch (error) {
+            if (error instanceof SchemaNotFoundError || error instanceof SchemaValidationError) {
+                this.#telemetry.recordSchemaError(info);
+                this.#log.warn('message_schema_error', { messaging: ctx.fields, error: errorInfo(error) });
+                return this.#deliver(ctx, this.#dlqRoute(ctx, error, 'schema_error'));
+            }
+            // Validator failure (e.g. registry unavailable), not the payload's.
+            this.#log.warn('message_schema_check_failed', { messaging: ctx.fields, error: errorInfo(error) });
+            return this.#onFailure(ctx, error);
+        }
+        const headers = Object.freeze(Object.assign(Object.create(null), hdrs));
+        const message = Object.freeze({
+            messageId: info.messageId,
+            eventType: info.eventType,
+            schemaVersion: info.schemaVersion,
+            payload,
+            key: info.key,
+            correlationId: hdrs[hdr.CORRELATION_ID] ?? '',
+            idempotencyKey: hdrs[hdr.IDEMPOTENCY_KEY] || null,
+            tenantId: hdrs[hdr.TENANT_ID] || null,
+            producer: hdrs[hdr.PRODUCER] ?? '',
+            publishedAt: hdrs[hdr.PUBLISHED_AT] ?? '',
+            retryCount: info.retryCount,
+            topic: record.topic,
+            partition: record.partition,
+            offset: record.offset,
+            headers,
+        });
+        const outcome = await this.#runHandler(handler, message, ctx.fields);
+        if (outcome.ok) {
+            const durationMs = elapsedMs(ctx.started);
+            this.#finish(ctx, 'success');
+            this.#log.info('message_consumed', {
+                messaging: ctx.fields,
+                processing_duration_ms: round3(durationMs),
+            });
+            // Only after success (retries never mark: they must not become duplicates).
+            await this.#markProcessed(ctx);
+            return ADVANCE;
+        }
+        return this.#onFailure(ctx, outcome.error);
+    }
+    #onFailure(ctx, error) {
+        if (error instanceof PermanentProcessingError) {
+            return this.#deliver(ctx, this.#dlqRoute(ctx, error, 'permanent_error'));
+        }
+        const delayMs = this.#retryPolicy.delayFor(ctx.info.retryCount);
+        if (delayMs === null)
+            return this.#deliver(ctx, this.#dlqRoute(ctx, error, 'max_retries'));
+        return this.#deliver(ctx, this.#retryRoute(ctx, error, delayMs));
+    }
+    /** Runs the handler; resolves with its outcome (transient or not), never rejects (but cancellation). */
+    async #runHandler(handler, message, fields) {
+        const controller = new AbortController();
+        let running;
+        try {
+            const result = handler(message, controller.signal);
+            if (!isPromiseLike(result))
+                throw new TypeError('handler did not return a Promise');
+            running = Promise.resolve(result);
+        }
+        catch (error) {
+            // Could not be called or did not return a promise: configuration error, repeating does not help.
+            return {
+                ok: false,
+                error: new InvalidHandlerError(`handler could not be started: ${errorTypeName(error)}: ${errorMessage(error)}`),
+            };
+        }
+        this.#active.add(controller);
+        const settled = settle(running);
+        try {
+            const timeoutMs = this.#processingTimeoutMs;
+            const outcome = timeoutMs === null
+                ? await this.#abortable(settled)
+                : await this.#abortable(withTimeout(settled, timeoutMs));
+            if (outcome === TIMED_OUT) {
+                const limit = timeoutMs ?? 0;
+                const error = new Error(`handler did not finish within processing timeout of ${formatSeconds(limit)}s`);
+                error.name = 'TimeoutError';
+                controller.abort(error);
+                if ((await this.#abortable(withTimeout(settled, limit))) === TIMED_OUT) {
+                    // Ignored the abort: keeps running detached (side effects may run in parallel with the retry).
+                    this.#log.error('message_handler_abandoned', {
+                        messaging: fields,
+                        processing_timeout_s: limit / 1000,
+                    });
+                    this.#detach(running);
+                }
+                this.#log.warn('message_handler_timeout', { messaging: fields, error: errorInfo(error) });
+                return { ok: false, error };
+            }
+            if (!outcome.ok && isAbortError(outcome.error) && !controller.signal.aborted) {
+                // The handler ended aborted without the consumer asking for it.
+                return {
+                    ok: false,
+                    error: new HandlerCancelledError('handler task was cancelled', { cause: outcome.error }),
+                };
+            }
+            return outcome;
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError) {
+                // The loop itself was cancelled (stop timeout): abort the handler.
+                controller.abort(error);
+                this.#detach(running);
+            }
+            throw error;
+        }
+        finally {
+            this.#active.delete(controller);
+        }
+    }
+    #detach(running) {
+        const tracked = running.then(() => undefined, () => undefined);
+        this.#detached.add(tracked);
+        void tracked.then(() => this.#detached.delete(tracked));
+    }
+    // ---------------------------------------------------------------------------- routing
+    #retryRoute(ctx, error, delayMs) {
+        const { record } = ctx;
+        const nowMs = this.#clock();
+        return {
+            offset: record.offset,
+            kind: 'retry',
+            target: naming.retryTopic(this.#mainTopic, this.#logicalGroup, delayMs),
+            headers: hdr.buildRetryHeaders(ctx.hdrs, error, {
+                dueAtMs: nowMs + delayMs,
+                topic: record.topic,
+                partition: record.partition,
+                offset: record.offset,
+                clock: () => nowMs,
+            }),
+            error,
+            reason: null,
+            attempt: ctx.info.retryCount + 1,
+            info: ctx.info,
+            fields: ctx.fields,
+            dedupKey: ctx.dedupKey,
+            shrunk: false,
+        };
+    }
+    #dlqRoute(ctx, error, reason) {
+        const { record } = ctx;
+        // Same clock as x-retry-due-at (injectable in tests).
+        const nowMs = this.#clock();
+        return {
+            offset: record.offset,
+            kind: 'dlq',
+            target: this.#dlqTopic,
+            headers: hdr.buildDlqHeaders(ctx.hdrs, error, {
+                reason,
+                topic: record.topic,
+                partition: record.partition,
+                offset: record.offset,
+                clock: () => nowMs,
+            }),
+            error,
+            reason,
+            attempt: ctx.info.retryCount,
+            info: ctx.info,
+            fields: ctx.fields,
+            dedupKey: ctx.dedupKey,
+            shrunk: false,
+        };
+    }
+    /** Sends the routing decision; on failure decides between HOLD, fallback and fatal. */
+    async #deliver(ctx, route) {
+        try {
+            await this.#send(ctx, route);
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError)
+                throw error;
+            return this.#onRouteFailure(ctx, route, error);
+        }
+        const { info } = ctx;
+        if (route.kind === 'retry') {
+            this.#telemetry.recordRetry(info, { attempt: route.attempt, retryTopic: route.target });
+            this.#log.warn('message_retry_scheduled', {
+                messaging: { ...ctx.fields, retry_topic: route.target, retry_attempt: route.attempt },
+                error: errorInfo(route.error),
+            });
+            ctx.span.recordError(route.error);
+            this.#finish(ctx, 'retry');
+            // No dedup mark: the retry must be processed when it comes back.
+            return ADVANCE;
+        }
+        const reason = route.reason ?? 'permanent_error';
+        this.#telemetry.recordDlq(info, { reason, dlqTopic: route.target });
+        this.#log.error('message_sent_to_dlq', {
+            messaging: { ...ctx.fields, dlq_topic: route.target },
+            error: { ...errorInfo(route.error), dlq_reason: reason },
+        });
+        ctx.span.recordError(route.error);
+        this.#finish(ctx, 'dlq');
+        // No dedup mark: the message must be reprocessable from the DLQ (replay). A redelivery
+        // before the commit may duplicate it in the DLQ.
+        return ADVANCE;
+    }
+    /** Sends the original value bytes and key to `route.target`. */
+    async #send(ctx, route) {
+        const { record } = ctx;
+        const value = record.value ?? Buffer.alloc(0);
+        const headers = { ...route.headers };
+        if (route.shrunk) {
+            // No trace context: minimal headers to fit the broker limit.
+            await this.#abortable(this.#sender.send(route.target, value, { key: record.key, headers: hdr.encode(headers) }));
+            return;
+        }
+        const { info } = route;
+        const publishInfo = createMessageInfo({
+            topic: route.target,
+            eventType: info.eventType,
+            messageId: info.messageId,
+            schemaVersion: info.schemaVersion,
+            key: info.key,
+            correlationId: info.correlationId,
+            tenantId: info.tenantId,
+            group: this.#group,
+            retryCount: route.attempt,
+        });
+        // publishSpan injects the W3C context into `headers` before they are encoded.
+        await this.#telemetry.publishSpan(publishInfo, headers, () => this.#abortable(this.#sender.send(route.target, value, { key: record.key, headers: hdr.encode(headers) })));
+    }
+    async #onRouteFailure(ctx, route, error) {
+        const nonRetriable = error instanceof PublishError && !error.retriable;
+        this.#log.error('message_routing_failed', {
+            messaging: { ...ctx.fields, target_topic: route.target, retriable: !nonRetriable },
+            error: errorInfo(error),
+        });
+        ctx.span.recordError(error);
+        if (nonRetriable) {
+            if (route.kind === 'retry') {
+                // The retry will never be accepted: straight to the DLQ.
+                return this.#deliver(ctx, this.#dlqRoute(ctx, route.error, 'routing_failed'));
+            }
+            if (!route.shrunk)
+                return this.#deliver(ctx, shrink(route));
+            // Not even the DLQ accepts it: stopping is the only option that does not lose the message.
+            this.#fail(error);
+            return FATAL;
+        }
+        // Retriable: keep the decision and resend after the backoff, without running the handler.
+        this.#pendingRoutes.set(partitionKey(ctx.tp), route);
+        await this.#hold(ctx.client, ctx.tp, ctx.record.offset, this.#routingFailureBackoffMs);
+        return HOLD;
+    }
+    #finish(ctx, outcome) {
+        ctx.span.setOutcome(outcome);
+        this.#telemetry.recordConsume(ctx.info, { outcome, durationMs: elapsedMs(ctx.started) });
+    }
+    async #isProcessed(key, fields) {
+        const checker = this.#duplicateChecker;
+        if (checker === null)
+            return false;
+        try {
+            return await this.#abortable(checker.isProcessed(key));
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError)
+                throw error;
+            this.#log.warn('dedup_check_failed', { messaging: fields, error: errorInfo(error) });
+            return false;
+        }
+    }
+    async #markProcessed(ctx) {
+        const checker = this.#duplicateChecker;
+        if (checker === null || ctx.dedupKey === '')
+            return;
+        try {
+            await this.#abortable(checker.markProcessed(ctx.dedupKey));
+        }
+        catch (error) {
+            if (error instanceof LoopCancelledError)
+                throw error;
+            this.#log.warn('dedup_mark_failed', { messaging: ctx.fields, error: errorInfo(error) });
+        }
+    }
+    #logFields(info) {
+        // Never the payload nor the key (may contain PII).
+        return {
+            topic: info.topic,
+            partition: info.partition,
+            offset: info.offset,
+            group: this.#group,
+            event_type: info.eventType,
+            message_id: info.messageId,
+            schema_version: info.schemaVersion,
+            correlation_id: info.correlationId,
+            retry_count: info.retryCount,
+        };
+    }
+}
+function shrink(route) {
+    const headers = { ...route.headers };
+    const lastError = headers[hdr.LAST_ERROR];
+    if (lastError !== undefined)
+        headers[hdr.LAST_ERROR] = truncateChars(lastError, SHRUNK_ERROR_LENGTH);
+    for (const name of TRACE_HEADERS)
+        delete headers[name];
+    return { ...route, headers, shrunk: true };
+}
+//# sourceMappingURL=consumer.js.map