n8n-nodes-base 2.34.2 → 2.35.0

package/dist/nodes/Kafka/v2/TriggerSettings.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettings = getSettings;
+exports.manualRunGroupId = manualRunGroupId;
+exports.explainManualRunGroupDenial = explainManualRunGroupDenial;
+exports.toConsumerOptions = toConsumerOptions;
+exports.toEmitterOptions = toEmitterOptions;
+const node_crypto_1 = require("node:crypto");
+const n8n_workflow_1 = require("n8n-workflow");
+const consumer_1 = require("./consumer");
+/** v1's defaults for the consumer settings, from `createConsumerConfig`. v2 is
+ * always >= 1.3, so the heartbeat default is 1.3's 10s rather than 3s. */
+const DEFAULT_SESSION_TIMEOUT_MS = 30_000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 10_000;
+/**
+ * The most we may ask for. librdkafka accepts 1..86400000 for
+ * `max.poll.interval.ms`, and the library doubles whatever it is given, so half
+ * of that ceiling is the limit here.
+ *
+ * Going over does not fail cleanly: the doubled value overflows the 32-bit int
+ * librdkafka stores it in, and the consumer refuses to connect complaining
+ * about a negative number nobody chose. Measured against a real broker with a
+ * 30 day workflow timeout: `value -1702967296 is outside allowed range
+ * 1..86400000`.
+ */
+const MAX_REBALANCE_TIMEOUT_MS = 43_200_000;
+/** librdkafka's range for `auto.commit.interval.ms`. 0 turns interval commits off. */
+const MAX_AUTO_COMMIT_INTERVAL_MS = 86_400_000;
+/**
+ * Kafka's own guidance, and the ratio both defaults already sit at: a heartbeat
+ * every 10s against a 30s session. Three beats fit inside one session, so two
+ * can be lost before the broker gives up on the consumer.
+ */
+const HEARTBEATS_PER_SESSION = 3;
+/**
+ * Keeps the heartbeat frequent enough for the session timeout it is paired with.
+ *
+ * The two options are independent in the UI but not in Kafka, and getting them
+ * wrong fails silently rather than loudly. Lower Session Timeout to 10s and
+ * leave the 10s heartbeat default alone, and the first beat lands exactly on the
+ * deadline: the broker fences the consumer, the uncommitted offset is lost, and
+ * the same message is redelivered forever with no error anywhere. Measured
+ * against a real broker: a workflow that takes 5s re-ran the same message every
+ * ~10s indefinitely.
+ *
+ * v1 has the same trap. Clamping is a deliberate improvement over it, and the
+ * safe direction is unambiguous, so it is applied rather than only warned about.
+ * @param heartbeatInterval - Resolved Heartbeat Interval, in milliseconds
+ * @param sessionTimeout - Resolved Session Timeout, in milliseconds
+ * @param logger - Warns when the supplied heartbeat had to be lowered
+ */
+function heartbeatWithinSession(heartbeatInterval, sessionTimeout, logger) {
+    // An unusable session timeout is left to librdkafka to reject by name.
+    if (!Number.isFinite(sessionTimeout) || sessionTimeout <= 0)
+        return heartbeatInterval;
+    const largest = Math.floor(sessionTimeout / HEARTBEATS_PER_SESSION);
+    if (Number.isFinite(heartbeatInterval) && heartbeatInterval <= largest) {
+        return heartbeatInterval;
+    }
+    logger?.warn('Kafka Heartbeat Interval lowered to stay under a third of the Session Timeout, so the consumer is not dropped from its group', { supplied: heartbeatInterval, applied: largest, sessionTimeout });
+    return largest;
+}
+/**
+ * A user-supplied millisecond value, or `undefined` to leave the library's own
+ * default in place. Options can come from an expression, so a value that
+ * librdkafka would reject is dropped with a warning rather than passed on: it
+ * fails the whole connection, and the error names a number nobody typed.
+ * @param value - The raw option
+ * @param max - Largest value librdkafka accepts
+ * @param label - Option name, for the warning
+ * @param logger - Warns when a supplied value could not be used
+ */
+function millisecondsInRange(value, max, label, logger) {
+    if (value === undefined)
+        return undefined;
+    const usable = Number.isFinite(value) && value >= 0 && value <= max;
+    if (!usable) {
+        logger?.warn(`Kafka ${label} ignored, outside the range the library accepts`, {
+            supplied: value,
+            allowed: `0..${max}`,
+        });
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Reads and resolves every node parameter up front, so the trigger below never
+ * touches one directly. The single cast is contained here: a `collection`
+ * parameter is untyped at the boundary, and this is the one place that knows
+ * its shape.
+ */
+function getSettings() {
+    const options = this.getNodeParameter('options', {});
+    const { executionTimeout } = this.getWorkflowSettings();
+    // A manual test run always resolves immediately, as in v1: the editor discards
+    // the run once it has its sample, so waiting on an execution that nothing will
+    // finish would hold the batch open until close.
+    const isManualRun = this.getMode() === 'manual';
+    const resolveOffsetMode = isManualRun
+        ? 'immediately'
+        : // Falls back to the field's own default rather than v1's 'immediately', so
+            // an absent value keeps the at-least-once behaviour.
+            this.getNodeParameter('resolveOffset', 'onCompletion');
+    const configuredGroupId = this.getNodeParameter('groupId');
+    return {
+        topic: this.getNodeParameter('topic'),
+        isManualRun,
+        configuredGroupId,
+        consumer: toConsumerOptions(
+        // Read Messages From Beginning defaults to on, and a manual run's group is
+        // brand new, so honouring it would replay the whole topic into the editor.
+        // On an activated workflow the setting is moot anyway, since the group
+        // already has a committed offset to resume from.
+        isManualRun ? { ...options, fromBeginning: false } : options, manualRunGroupId(configuredGroupId, isManualRun), executionTimeout, this.logger),
+        emitter: toEmitterOptions(options, resolveOffsetMode, this.getNodeParameter('allowedStatuses', []), executionTimeout),
+        parser: options,
+        batchSize: options.batchSize,
+        // 0 means "all partitions sequentially", which the loop expresses by
+        // leaving the key off and taking its own default of 1.
+        partitionsConsumedConcurrently: options.partitionsConsumedConcurrently || undefined,
+        errorRetryDelay: options.errorRetryDelay,
+    };
+}
+/**
+ * The consumer group a run joins. A manual run gets a throwaway one.
+ *
+ * Sharing the configured group with an activated workflow means Kafka splits the
+ * partitions between the two, and a test run resolves offsets immediately, so
+ * pressing "Listen for test event" would mark messages read that the activated
+ * workflow never saw. A group of its own leaves production untouched. v1 has
+ * this defect and needs its own fix.
+ *
+ * The throwaway group is left behind on the broker; Kafka expires an empty group
+ * on its own once its retention window passes.
+ * @param configured - The node's Group ID parameter
+ * @param isManualRun - Whether this is an editor test run
+ */
+function manualRunGroupId(configured, isManualRun) {
+    return isManualRun ? `${MANUAL_RUN_PREFIX(configured)}${(0, node_crypto_1.randomUUID)()}` : configured;
+}
+/** The part of a manual run's group id that is stable, and so grantable in an ACL. */
+const MANUAL_RUN_PREFIX = (configured) => `${configured}-n8n-manual-`;
+/** Broker rejections that mean the group itself was refused, not the credential. */
+const GROUP_AUTHORIZATION_FAILED = /group authorization failed/i;
+/**
+ * Explains a group authorization failure on a manual run, where the group the
+ * broker refused is one the user never chose and cannot see.
+ *
+ * On a cluster with an authorizer, group ACLs are usually granted `LITERAL` on
+ * the exact Group ID. The throwaway group is a different resource name, so the
+ * join is denied while the activated workflow keeps working: "Listen for test
+ * event" fails on its own, and the raw broker message names neither the group
+ * nor the fix. A `PREFIXED` ACL on the stable part covers every future test run.
+ *
+ * Only manual runs are rewritten. On an activated workflow the group is exactly
+ * what the user typed, so the broker's own message is already actionable.
+ * @param error - The error raised from the library's log stream
+ * @param configuredGroupId - The node's Group ID parameter, before the suffix
+ * @param isManualRun - Whether this is an editor test run
+ */
+function explainManualRunGroupDenial(error, configuredGroupId, isManualRun) {
+    if (!isManualRun || !GROUP_AUTHORIZATION_FAILED.test(error.message))
+        return error;
+    return new n8n_workflow_1.UserError('Kafka refused the consumer group used for a test run', {
+        description: `A test run uses a throwaway consumer group so it cannot mark messages read for the activated workflow, and this cluster has not authorized it. Grant a prefixed group ACL for "${MANUAL_RUN_PREFIX(configuredGroupId)}", or run the workflow activated instead of testing it.`,
+        cause: error,
+    });
+}
+/**
+ * Maps the node's options onto the consumer factory.
+ *
+ * `rebalanceTimeout` is the one value not passed straight through. In this
+ * library it also becomes `max.poll.interval.ms`, the deadline to finish one
+ * batch before the consumer is dropped from its group, and the library doubles
+ * whatever it is given (`_consumer.js:711`). So the workflow's own execution
+ * timeout is the deadline we actually want, and it is halved here to survive
+ * that doubling, then capped at {@link MAX_REBALANCE_TIMEOUT_MS}. An unbounded
+ * workflow timeout (<= 0), or one that is not a usable number, has no deadline
+ * to derive from, so the Rebalance Timeout option stands in.
+ * @param options - The node's `options` collection
+ * @param groupId - The node's consumer group id
+ * @param executionTimeoutSeconds - `getWorkflowSettings().executionTimeout`, raw
+ * @param logger - Warns when a supplied value could not be used as given
+ */
+function toConsumerOptions(options, groupId, executionTimeoutSeconds, logger) {
+    // A workflow timeout arrives as a number, but Rebalance Timeout can come from
+    // an expression, so neither is trusted to be a usable one.
+    const fromWorkflow = typeof executionTimeoutSeconds === 'number' &&
+        Number.isFinite(executionTimeoutSeconds) &&
+        executionTimeoutSeconds > 0;
+    const configured = options.rebalanceTimeout;
+    const usableOption = typeof configured === 'number' && Number.isFinite(configured) && configured > 0;
+    // Three sources, most specific first.
+    //
+    // The last one used to be the Rebalance Timeout default, which handed the broker
+    // a 10 minute deadline while the emitter was still prepared to wait an hour for
+    // the same execution. Anything in between was fenced and redelivered while n8n
+    // believed the run still owned it: two of our own defaults disagreeing about one
+    // deadline, so they are now the same value by construction.
+    let deadlineMs;
+    if (fromWorkflow) {
+        deadlineMs = executionTimeoutSeconds * 1000;
+    }
+    else if (usableOption) {
+        // No usable workflow timeout, but the user set this deliberately.
+        deadlineMs = configured;
+    }
+    else {
+        // Nothing set anywhere, so match how long the emitter will actually wait.
+        deadlineMs = consumer_1.DEFAULT_EXECUTION_TIMEOUT_SECONDS * 1000;
+    }
+    const sessionTimeout = options.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT_MS;
+    // librdkafka refuses a `max.poll.interval.ms` below `session.timeout.ms`
+    // (`rdkafka_conf.c:4257`, on the classic group protocol we use), and the
+    // deadline becomes exactly that. A range check cannot catch it because both
+    // values are individually legal. Left alone, a workflow timeout under the 30s
+    // session default made the consumer refuse to connect, complaining about two
+    // numbers where the user only chose one.
+    // An unusable session timeout is left for librdkafka to reject by name, as the
+    // heartbeat clamp does. Flooring against it would turn the deadline into NaN
+    // and hide the value actually at fault behind a second complaint.
+    const sessionUsable = Number.isFinite(sessionTimeout) && sessionTimeout > 0;
+    const floored = sessionUsable ? Math.max(deadlineMs, sessionTimeout) : deadlineMs;
+    if (floored !== deadlineMs) {
+        logger?.warn('Kafka processing deadline raised to the Session Timeout, the shortest the library allows', { requestedMs: deadlineMs, appliedMs: floored, sessionTimeout });
+    }
+    const wanted = Math.ceil(floored / 2);
+    // Capped last: the ceiling exists to stop the doubled value overflowing a
+    // 32-bit int, which outranks the floor above. They cannot both bite, since a
+    // session timeout large enough to collide is one librdkafka already rejects.
+    const rebalanceTimeout = Math.min(wanted, MAX_REBALANCE_TIMEOUT_MS);
+    if (rebalanceTimeout !== wanted) {
+        logger?.warn('Kafka processing deadline capped at the largest the library accepts, 24 hours', {
+            requestedMs: deadlineMs,
+            appliedMs: rebalanceTimeout * 2,
+        });
+    }
+    return {
+        groupId,
+        sessionTimeout,
+        heartbeatInterval: heartbeatWithinSession(options.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL_MS, sessionTimeout, logger),
+        rebalanceTimeout,
+        maxBytesPerPartition: options.fetchMaxBytes,
+        minBytes: options.fetchMinBytes,
+        // v1 turns 0 into `null` to mean "no limit". The library has no such
+        // sentinel, so leave the key off and let its own default stand.
+        maxInFlightRequests: options.maxInFlightRequests || undefined,
+        fromBeginning: options.fromBeginning,
+        // 0 is a real setting here, not "unset", so it must not go through the
+        // falsy-to-undefined treatment maxInFlightRequests gets.
+        autoCommitInterval: millisecondsInRange(options.autoCommitInterval, MAX_AUTO_COMMIT_INTERVAL_MS, 'Auto Commit Interval', logger),
+    };
+}
+/**
+ * Maps the node's options and offset settings onto the emitter.
+ *
+ * `executionTimeoutSeconds` is passed through raw: n8n treats <= 0 as
+ * explicitly unbounded, and the emitter handles that. Coercing it to a default
+ * here would reintroduce a deadline the user switched off.
+ * @param options - The node's `options` collection
+ * @param resolveOffsetMode - Already resolved, including the manual-mode override
+ * @param allowedStatuses - Only meaningful when the mode is `onStatus`
+ * @param executionTimeoutSeconds - `getWorkflowSettings().executionTimeout`, raw
+ */
+function toEmitterOptions(options, resolveOffsetMode, allowedStatuses, executionTimeoutSeconds) {
+    return {
+        resolveOffsetMode,
+        allowedStatuses,
+        executionTimeoutSeconds,
+        errorRetryDelay: options.errorRetryDelay,
+    };
+}
+//# sourceMappingURL=TriggerSettings.js.map

package/dist/nodes/Kafka/v2/TriggerSettings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerSettings.js","sourceRoot":"","sources":["../../../../nodes/Kafka/v2/TriggerSettings.ts"],"names":[],"mappings":"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"}

package/dist/nodes/Kafka/v2/consumer/ConsumeTopic.d.ts

@@ -0,0 +1,51 @@
+import type { KafkaJS } from '@confluentinc/kafka-javascript';
+import type { Logger } from 'n8n-workflow';
+import type { DataEmitter } from './DataEmitter';
+import type { KafkaMessageParser } from './MessageParser';
+export interface ConsumeTopicOptions {
+    topic: string;
+    parseMessage: KafkaMessageParser;
+    /** Starts an execution and reports whether its offsets may advance. */
+    emit: DataEmitter;
+    logger: Logger;
+    /** Messages per execution. Defaults to {@link DEFAULT_BATCH_SIZE}. */
+    batchSize?: number;
+    /** Defaults to {@link DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY}. */
+    partitionsConsumedConcurrently?: number;
+    /**
+     * How long to wait before letting a failed chunk be re-delivered. The node
+     * maps v1's existing "Retry Delay on Error" option onto this; v1 applies it
+     * only to failed offset resolution, so the parse path was unpaced.
+     */
+    errorRetryDelay?: number;
+}
+export interface KafkaConsumerHandle {
+    /** Disconnects the consumer. ENT-226 verifies this against a real broker. */
+    close: () => Promise<void>;
+}
+/**
+ * Messages handed to one execution. v1's Batch Size default, and the reason the
+ * library's batch is chunked rather than emitted whole: at 1 each message starts
+ * its own execution.
+ */
+export declare const DEFAULT_BATCH_SIZE = 1;
+/**
+ * Partitions processed in parallel.
+ *
+ * The library defaults this to 1 when the key is absent, but it checks with
+ * `Object.hasOwn`, so passing the key with an explicit `undefined` skips that
+ * default and later fails in `Math.min(undefined, …)`. Never forward a
+ * possibly-undefined user value straight through; resolve it to a number first.
+ */
+export declare const DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = 1;
+/**
+ * Connects, subscribes, and runs the consume loop.
+ *
+ * Automatic progress-saving is off, matching v1: the loop resolves offsets chunk
+ * by chunk, and anything it does not resolve is re-delivered. So a failure part
+ * way through a batch leaves the earlier chunks done rather than replaying them.
+ * @param consumer - An unconnected consumer from `transport/consumer`
+ * @param options - Topic, parser, emitter, and the chunking settings
+ */
+export declare function consumeTopic(consumer: KafkaJS.Consumer, options: ConsumeTopicOptions): Promise<KafkaConsumerHandle>;
+//# sourceMappingURL=ConsumeTopic.d.ts.map

package/dist/nodes/Kafka/v2/consumer/ConsumeTopic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsumeTopic.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/ConsumeTopic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAO1D,MAAM,WAAW,mBAAmB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,kBAAkB,CAAC;IACjC,uEAAuE;IACvE,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IACnC,6EAA6E;IAC7E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAgCD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;;GAOG;AACH,eAAO,MAAM,wCAAwC,IAAI,CAAC;AAM1D;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CACjC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAC1B,OAAO,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAoE9B"}

package/dist/nodes/Kafka/v2/consumer/ConsumeTopic.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = exports.DEFAULT_BATCH_SIZE = void 0;
+exports.consumeTopic = consumeTopic;
+const sleep_1 = require("@n8n/utils/sleep");
+const utils_1 = require("../../utils");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Bounds teardown so a hung broker request cannot block deactivation, as in v1. */
+const CLOSE_TIMEOUT_MS = 30_000;
+/**
+ * Messages handed to one execution. v1's Batch Size default, and the reason the
+ * library's batch is chunked rather than emitted whole: at 1 each message starts
+ * its own execution.
+ */
+exports.DEFAULT_BATCH_SIZE = 1;
+/**
+ * Partitions processed in parallel.
+ *
+ * The library defaults this to 1 when the key is absent, but it checks with
+ * `Object.hasOwn`, so passing the key with an explicit `undefined` skips that
+ * default and later fails in `Math.min(undefined, …)`. Never forward a
+ * possibly-undefined user value straight through; resolve it to a number first.
+ */
+exports.DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = 1;
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/**
+ * Connects, subscribes, and runs the consume loop.
+ *
+ * Automatic progress-saving is off, matching v1: the loop resolves offsets chunk
+ * by chunk, and anything it does not resolve is re-delivered. So a failure part
+ * way through a batch leaves the earlier chunks done rather than replaying them.
+ * @param consumer - An unconnected consumer from `transport/consumer`
+ * @param options - Topic, parser, emitter, and the chunking settings
+ */
+async function consumeTopic(consumer, options) {
+    const { topic, parseMessage, emit, logger } = options;
+    const settings = resolveSettings(options);
+    const closeController = new AbortController();
+    const { signal } = closeController;
+    // Turns "we are closing" into something a wait can race against, since you can
+    // race a promise but not a signal. It only ever resolves: the loser of a race
+    // is abandoned, and an abandoned rejection gets reported as unhandled.
+    const closed = new Promise((resolve) => {
+        // The abort event fires once. If it already fired, no listener would run.
+        if (signal.aborted)
+            return resolve();
+        signal.addEventListener('abort', () => resolve(), { once: true });
+    });
+    /** Paces a re-delivery, unless teardown is already waiting. */
+    const pauseBeforeRetry = async () => {
+        if (signal.aborted)
+            return;
+        await Promise.race([(0, sleep_1.sleep)(settings.errorRetryDelay), closed]);
+    };
+    const context = {
+        ...settings,
+        parseMessage,
+        emit,
+        logger,
+        signal,
+        pauseBeforeRetry,
+    };
+    try {
+        await consumer.connect();
+        await consumer.subscribe({ topics: [topic] });
+        await consumer.run({
+            partitionsConsumedConcurrently: settings.partitionsConsumedConcurrently,
+            // Off, as in v1: processBatch decides what counts as read. Leaving it on
+            // would mark a whole batch done the moment the callback returns, including
+            // messages no execution ever saw.
+            eachBatchAutoResolve: false,
+            eachBatch: async (payload) => await processBatch(payload, context),
+        });
+    }
+    catch (error) {
+        // Nothing else holds this consumer yet, so a failed start must not leave the
+        // broker connection open. `connect()` is inside the try for symmetry rather
+        // than because it leaks: the library marks a failed connect as disconnected
+        // before rejecting, so disconnect() is a no-op on that path today.
+        try {
+            await consumer.disconnect();
+        }
+        catch {
+            // The start failure is the useful one; a failing disconnect must not mask it.
+        }
+        throw error;
+    }
+    return {
+        close: async () => {
+            closeController.abort();
+            // The library's `stop()` is not implemented, so disconnect is the only lever.
+            // Bounded, so a hung broker cannot keep a superseded consumer in the group.
+            await (0, utils_1.withTimeout)(consumer.disconnect(), CLOSE_TIMEOUT_MS, 'Kafka consumer did not disconnect in time');
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// The batch loop
+// ---------------------------------------------------------------------------
+/**
+ * Walks one library batch in chunks, handing each to a workflow and advancing
+ * the read position only once that workflow permits it.
+ *
+ * Stopping early is always safe: whatever is left unresolved is re-delivered.
+ * That is how a close, a rebalance and a failure all end up doing the right
+ * thing without any of them needing to undo work.
+ */
+async function processBatch({ batch, resolveOffset, commitOffsetsIfNecessary, isRunning, isStale }, context) {
+    const { batchSize, parseMessage, emit, logger, signal, pauseBeforeRetry } = context;
+    const { messages } = batch;
+    for (let i = 0; i < messages.length; i += batchSize) {
+        // Stop if the trigger is closing, the consumer stopped, or the partition
+        // was revoked. Unresolved offsets are re-delivered, so stopping here
+        // loses nothing.
+        if (signal.aborted || !isRunning() || isStale()) {
+            logger.debug('Kafka batch interrupted by close, rebalance or consumer stop');
+            return;
+        }
+        const chunk = messages.slice(i, Math.min(i + batchSize, messages.length));
+        let items;
+        try {
+            items = await Promise.all(chunk.map(async (message) => await parseMessage(message, batch.topic)));
+        }
+        catch (error) {
+            // Coordinates included: this message is now re-read indefinitely, and
+            // the log is the only way to find which one it is.
+            logger.error('Kafka chunk could not be parsed, leaving it unresolved', {
+                error,
+                topic: batch.topic,
+                partition: batch.partition,
+                offset: chunk[0]?.offset,
+            });
+            await pauseBeforeRetry();
+            return;
+        }
+        if (!(await emit(items)).mayAdvance) {
+            logger.warn('Kafka chunk was not processed, leaving it unresolved');
+            return;
+        }
+        const lastMessage = chunk[chunk.length - 1];
+        if (lastMessage) {
+            resolveOffset(lastMessage.offset);
+            await commitOffsetsIfNecessary();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Fills in every optional, so the loop only ever sees usable values. */
+function resolveSettings(options) {
+    const { logger } = options;
+    return {
+        batchSize: positiveCount(options.batchSize, exports.DEFAULT_BATCH_SIZE, 'Batch Size', logger),
+        partitionsConsumedConcurrently: positiveCount(options.partitionsConsumedConcurrently, exports.DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY, 'Parallel Processing', logger),
+        errorRetryDelay: (0, utils_1.resolveRetryDelay)(options.errorRetryDelay, logger),
+    };
+}
+/**
+ * A whole number of at least one, or the fallback when the value cannot be used
+ * as a count. Anything unusable takes the same path: not a number, not finite,
+ * or below one.
+ *
+ * Both callers feed either a loop increment or a library config key, where `NaN`
+ * does more damage than a merely wrong number. It slips past `??` because it is
+ * not `undefined`, and past `Math.max` because every comparison with `NaN` is
+ * false, and then quietly produces empty chunks or a broken worker count. A node
+ * option can arrive as `NaN` from an expression that did not evaluate to a
+ * number.
+ * @param name - The option's user-facing name, for the warning
+ * @param logger - Warns when a supplied value had to be replaced. A missing
+ * value is not a misconfiguration, so it falls back quietly. A fractional one
+ * is truncated rather than replaced, which needs no warning either.
+ */
+function positiveCount(value, fallback, name, logger) {
+    if (value === undefined)
+        return fallback;
+    const whole = typeof value === 'number' ? Math.trunc(value) : Number.NaN;
+    if (!Number.isFinite(whole) || whole < 1) {
+        logger.warn(`Kafka "${name}" of ${String(value)} cannot be used, falling back to ${fallback}`);
+        return fallback;
+    }
+    return whole;
+}
+//# sourceMappingURL=ConsumeTopic.js.map

package/dist/nodes/Kafka/v2/consumer/ConsumeTopic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsumeTopic.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/ConsumeTopic.ts"],"names":[],"mappings":"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"}

package/dist/nodes/Kafka/v2/consumer/DataEmitter.d.ts

@@ -0,0 +1,45 @@
+import type { INodeExecutionData, ITriggerFunctions } from 'n8n-workflow';
+/** When a message's read position is recorded as done. Mirrors v1.3's option. */
+export type ResolveOffsetMode = 'immediately' | 'onCompletion' | 'onSuccess' | 'onStatus';
+/** Whether the caller may advance past the chunk it just handed over. */
+export interface OffsetVerdict {
+    readonly mayAdvance: boolean;
+}
+export type DataEmitter = (items: INodeExecutionData[]) => Promise<OffsetVerdict>;
+/**
+ * The slice of the trigger context the emitter needs, so it can be exercised
+ * without a node.
+ */
+export type DataEmitterContext = Pick<ITriggerFunctions, 'emit' | 'logger' | 'getNode'> & {
+    helpers: Pick<ITriggerFunctions['helpers'], 'createDeferredPromise'>;
+};
+export interface DataEmitterOptions {
+    resolveOffsetMode: ResolveOffsetMode;
+    /** Required when the mode is `onStatus`. */
+    allowedStatuses?: string[];
+    /** Seconds an execution may run before the wait is abandoned. */
+    executionTimeoutSeconds?: number;
+    errorRetryDelay?: number;
+}
+/**
+ * The wait an absent workflow execution timeout falls back to. Exported because
+ * the consumer's processing deadline has to agree with it: if the emitter waits
+ * an hour for an execution the broker fenced ten minutes in, the message is
+ * redelivered while n8n still thinks the run owns it.
+ */
+export declare const DEFAULT_EXECUTION_TIMEOUT_SECONDS = 3600;
+/**
+ * Builds the function that starts an execution for a chunk of items and decides
+ * whether its offsets may advance. `mayAdvance: false` means the caller must not
+ * record the chunk as done, so Kafka delivers it again.
+ *
+ * `immediately` never waits, which is at-most-once. The other three wait for the
+ * execution and are at-least-once. This mirrors v1's `configureDataEmitter`,
+ * with the mode and its inputs resolved by the caller rather than read from node
+ * parameters here.
+ * @param ctx - Trigger context used to emit and log
+ * @param options - Resolved offset mode and its inputs
+ * @param closeSignal - Aborted on teardown, so a wait never outlives the trigger
+ */
+export declare function createDataEmitter(ctx: DataEmitterContext, options: DataEmitterOptions, closeSignal: AbortSignal): DataEmitter;
+//# sourceMappingURL=DataEmitter.d.ts.map

package/dist/nodes/Kafka/v2/consumer/DataEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataEmitter.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/DataEmitter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAQ,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAShF,iFAAiF;AACjF,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,cAAc,GAAG,WAAW,GAAG,UAAU,CAAC;AAE1F,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAElF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC,GAAG;IACzF,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,uBAAuB,CAAC,CAAC;CACrE,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,4CAA4C;IAC5C,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iEAAiE;IACjE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,OAAO,CAAC;AAatD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,kBAAkB,EACvB,OAAO,EAAE,kBAAkB,EAC3B,WAAW,EAAE,WAAW,GACtB,WAAW,CAIb"}