@laserdata/laser-sdk 0.5.3 → 0.6.0

package/dist/iggy/apache-iggy.js

@@ -1,21 +1,34 @@
+import { JOIN_GROUP } from "apache-iggy/dist/wire/consumer-group/join-group.command.js";
+import { SYNC_GROUP } from "apache-iggy/dist/wire/consumer-group/sync-group.command.js";
 import { connectOptions } from "../client/connect-options.js";
 import { publishOptions, publishWithin } from "../client/publish-options.js";
-import { Consumer, DeserializeError, HeaderKeyFactory, HeaderValue as IggyHeaderValueFactory, Partitioning, PollingStrategy as IggyPollingStrategy, ResponseError, SimpleClient, getRawClient } from "apache-iggy";
+import { Consumer, DeserializeError, HeaderKeyFactory, HeaderValue as IggyHeaderValueFactory, Partitioning, PollingStrategy as IggyPollingStrategy, SimpleClient, getRawClient } from "apache-iggy";
 import { readFileSync } from "node:fs";
 import { isIP } from "node:net";
-import { AmbiguousMutationError, ConfigError, ProtocolError, TimeoutError, TransportError, UnsupportedError } from "../client/errors.js";
+import { AmbiguousMutationError, ConfigError, InvalidError, ProtocolError, PublishFailedError, TimeoutError, TransportError, UnsupportedError } from "../client/errors.js";
 import { LASERDATA_ROOT_CA } from "../client/laserdata-ca.js";
 import { Mutex } from "../runtime/mutex.js";
 import { mintUlidValue } from "../runtime/ulid.js";
 import { encodeNamed } from "../wire/cbor.js";
 import { isIdempotentManagedRequest } from "../wire/codes.js";
 import { MANAGED_REQUEST_VERSION, encodeManagedRequestEnvelope } from "../wire/mutation.js";
+/** The `maxTopicSize` value that lifts the topic size limit (u64 max). */
+export const UNLIMITED_TOPIC_SIZE = 18446744073709551615n;
+/** The message expiry that keeps records until retention removes them (u64 max). */
+export const NEVER_EXPIRE = 18446744073709551615n;
+const TOPIC_NAME_ALREADY_EXISTS = 2013;
+const UNAUTHENTICATED = 40;
+const POLL_MESSAGES_CODE = 100;
+const PUBLISH_BATCH_LENGTH = 1_000;
+const NUMERIC_IDENTIFIER = 1;
+const STRING_IDENTIFIER = 2;
+// Server replies a later attempt can clear: a write the cluster did not
+// commit or admit, and a partition the node could not read or find yet.
+const TRANSIENT_PUBLISH_CODES = new Set([57, 58, 3004, 3007, 10002]);
 const DEFAULT_RECONNECT_INTERVAL_MS = 1_000;
 const ACCEPT_STAGE = "Iggy server to accept the connection";
 const LOGIN_STAGE = "Iggy login reply";
 const VSR_HEARTBEAT_INTERVAL_MS = 5_000;
-const TRANSIENT_NOT_COMMITTED = 57;
-const TRANSIENT_NOT_ACCEPTED = 58;
 const POLLED_HEAD_BYTES = 16;
 const BATCH_HEADER_BYTES = 256;
 const FRAME_HEADER_BYTES = 48;
@@ -25,7 +38,18 @@ const STRICT_UTF8 = new TextDecoder("utf-8", { fatal: true });
 export function toNodeBuffer(bytes) {
     return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 }
+/** The records with an id each: a record without one gets a fresh id. */
+export function withMessageIds(records) {
+    return records.map((record) => record.id === undefined || record.id === 0n ? { ...record, id: mintUlidValue() } : record);
+}
 const SYNC_CONSUMER_GROUP_CODE = 606;
+const GROUP_MEMBER_NOT_FOUND = 5006;
+const GROUP_PARTITION_NOT_OWNED = 5009;
+const RESYNC_REQUIRED_PARTITION = 0xffff_ffff;
+const GROUP_ASSIGNMENT_REFRESH_MS = 5_000;
+const GROUP_POLL_MAX_ATTEMPTS = 2;
+const TRANSIENT_NOT_COMMITTED = 57;
+const GROUP_POLL_STATES = new WeakMap();
 function toIggyConsumer(target) {
     return target.kind === "single"
         ? target.name === undefined
@@ -33,6 +57,52 @@ function toIggyConsumer(target) {
             : { kind: 1, id: target.name }
         : Consumer.Group(target.name);
 }
+// The poll command body: consumer, stream, topic, partition, strategy,
+// count, and the auto-commit flag, laid out as the Apache Iggy client lays it.
+function encodePollRequest(streamId, topicId, target, partitionId, strategy, count, autoCommit) {
+    const consumer = target.kind === "group" ? encodeIdentifier(target.name) : encodeIdentifier(target.name ?? 0);
+    const parts = [
+        Uint8Array.of(target.kind === "group" ? 2 : 1),
+        consumer,
+        encodeIdentifier(streamId),
+        encodeIdentifier(topicId)
+    ];
+    const tail = new Uint8Array(19);
+    const view = new DataView(tail.buffer);
+    view.setUint8(0, 1);
+    view.setUint32(1, partitionId, true);
+    const polling = toIggyPollingStrategy(strategy);
+    view.setUint8(5, polling.kind);
+    view.setBigUint64(6, polling.value, true);
+    view.setUint32(14, count, true);
+    view.setUint8(18, autoCommit ? 1 : 0);
+    parts.push(tail);
+    const request = new Uint8Array(parts.reduce((size, part) => size + part.byteLength, 0));
+    let offset = 0;
+    for (const part of parts) {
+        request.set(part, offset);
+        offset += part.byteLength;
+    }
+    return request;
+}
+function encodeIdentifier(value) {
+    if (typeof value === "number") {
+        const numeric = new Uint8Array(6);
+        const view = new DataView(numeric.buffer);
+        view.setUint8(0, NUMERIC_IDENTIFIER);
+        view.setUint8(1, 4);
+        view.setUint32(2, value, true);
+        return numeric;
+    }
+    const name = new TextEncoder().encode(value);
+    if (name.byteLength === 0 || name.byteLength > 255)
+        throw new ConfigError("an Iggy identifier must contain 1 to 255 UTF-8 bytes");
+    const encoded = new Uint8Array(2 + name.byteLength);
+    encoded[0] = STRING_IDENTIFIER;
+    encoded[1] = name.byteLength;
+    encoded.set(name, 2);
+    return encoded;
+}
 function toIggyOffsetConsumer(target) {
     return target.kind === "group"
         ? Consumer.Group(target.name)
@@ -100,7 +170,7 @@ function toIggyPollingStrategy(strategy) {
             return IggyPollingStrategy.Next;
         case "offset":
             return IggyPollingStrategy.Offset(strategy.value);
-        case "timestamp":
+        case "timestampMicros":
             return IggyPollingStrategy.Timestamp(strategy.value);
     }
 }
@@ -138,70 +208,16 @@ function toIggyHeaderValue(value) {
             return IggyHeaderValueFactory.Double(value.value);
     }
 }
-const HEADER_KIND_BY_NUMBER = {
-    1: "raw",
-    2: "string",
-    3: "bool",
-    4: "int8",
-    5: "int16",
-    6: "int32",
-    7: "int64",
-    8: "int128",
-    9: "uint8",
-    10: "uint16",
-    11: "uint32",
-    12: "uint64",
-    13: "uint128",
-    14: "float",
-    15: "double"
-};
-function fromParsedHeaderValue(kind, value) {
-    const tag = HEADER_KIND_BY_NUMBER[kind];
-    if (tag === undefined)
-        return undefined;
-    switch (tag) {
-        case "raw":
-        case "int128":
-        case "uint128": {
-            if (!(value instanceof Buffer))
-                return undefined;
-            return { kind: tag, value: new Uint8Array(value) };
-        }
-        case "string":
-            return typeof value === "string" ? { kind: tag, value } : undefined;
-        case "bool":
-            return typeof value === "boolean" ? { kind: tag, value } : undefined;
-        case "int64":
-        case "uint64":
-            return typeof value === "bigint" ? { kind: tag, value } : undefined;
-        case "int8":
-        case "int16":
-        case "int32":
-        case "uint8":
-        case "uint16":
-        case "uint32":
-        case "float":
-        case "double":
-            return typeof value === "number" ? { kind: tag, value } : undefined;
-    }
-}
-function parsedHeadersToMap(entries) {
-    const map = new Map();
-    for (const entry of entries) {
-        if (typeof entry.key.value !== "string")
-            continue;
-        const value = fromParsedHeaderValue(entry.value.kind, entry.value.value);
-        if (value !== undefined)
-            map.set(entry.key.value, value);
-    }
-    return map;
-}
 /** The Iggy error code a server reply carried, through any transport wrapping. */
 export function serverErrorCode(error) {
-    for (let current = error; current !== undefined;) {
-        if (current instanceof ResponseError)
-            return current.errorCode;
-        current = current instanceof Error ? current.cause : undefined;
+    let current = error;
+    for (let depth = 0; depth < 8; depth += 1) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        const code = current.errorCode;
+        if (typeof code === "number")
+            return code;
+        current = "cause" in current ? current.cause : undefined;
     }
     return undefined;
 }
@@ -216,6 +232,7 @@ export function decodePolledBody(body) {
         throw malformed("head");
     const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
     const partitionId = view.getUint32(0, true);
+    const currentOffset = view.getBigUint64(4, true);
     const messages = [];
     let position = POLLED_HEAD_BYTES;
     while (position < body.byteLength) {
@@ -223,6 +240,7 @@ export function decodePolledBody(body) {
             throw malformed("batch header");
         const baseOffset = view.getBigUint64(position + 8, true);
         const baseTimestamp = view.getBigUint64(position + 16, true);
+        const originTimestamp = view.getBigUint64(position + 24, true);
         const batchLength = view.getBigUint64(position + 32, true);
         if (batchLength < BigInt(BATCH_HEADER_BYTES) ||
             batchLength > BigInt(body.byteLength - position))
@@ -248,6 +266,11 @@ export function decodePolledBody(body) {
                 partitionId,
                 offset: baseOffset + BigInt(offsetDelta),
                 timestampMicros: baseTimestamp,
+                messageId: view.getBigUint64(position + 8, true) | (view.getBigUint64(position + 16, true) << 64n),
+                checksum: view.getBigUint64(position, true),
+                originTimestampMicros: originTimestamp + BigInt(view.getUint32(position + 28, true)),
+                currentOffset,
+                ...(block.byteLength > 0 ? { userHeaders: block } : {}),
                 ...(typeof headers === "string"
                     ? {
                         headers: typeof contentType === "string" ? new Map() : contentType,
@@ -557,7 +580,7 @@ function pinnedClient(raw, loginDeadline) {
     const data = raw;
     const queue = data._queueCommand;
     if (typeof queue !== "function")
-        throw new UnsupportedError("this Apache Iggy SDK does not expose the partition data request queue required by filtered Primary reads");
+        throw new UnsupportedError("this Apache Iggy SDK does not expose the partition data request queue required by filtered Primary reads", { surface: "filters" });
     const facade = {
         sendCommand(code, payload, options) {
             return queue.call(data, code, payload, options?.handleResponse ?? true, options?.last ?? true, false, options?.deadline ??
@@ -805,7 +828,10 @@ export class ApacheIggyTransport {
                 payload
             }))
             : payload;
-        const buffer = toNodeBuffer(request);
+        return this.sendManagedPreframed(code, request, options);
+    }
+    async sendManagedPreframed(code, payload, options) {
+        const buffer = toNodeBuffer(payload);
         const reply = await this.execute((client) => client.sendBinaryRequest(code, buffer), `managed command ${String(code)} failed`, options?.retryAfterReconnect ?? true);
         return new Uint8Array(reply.buffer, reply.byteOffset, reply.byteLength);
     }
@@ -836,23 +862,45 @@ export class ApacheIggyTransport {
     async ensureConsumerGroup(streamId, topicId, name) {
         await this.execute((client) => client.group.ensure(streamId, topicId, name), `failed to ensure consumer group \`${name}\``);
     }
+    /** Creates the topic when it is absent, keeping records until retention
+     * removes them like Rust `ensure_topic`. An existing topic is left as it is. */
     async ensureTopic(streamId, topicId, partitions) {
-        const topic = await this.execute((client) => client.topic.ensure(streamId, topicId, partitions), `failed to ensure topic \`${topicId}\` on stream \`${streamId}\``);
-        this.partitionCounts.set(this.topicKey(streamId, topicId), topic.partitionsCount);
+        await this.createTopicIfAbsent(streamId, topicId, partitions, {
+            messageExpiryMicros: NEVER_EXPIRE
+        });
     }
+    /** `ensureTopic` with a message expiry for a topic it creates. An existing
+     * topic keeps its own expiry. */
     async ensureTopicWithExpiry(streamId, topicId, partitions, messageExpiryMicros) {
+        await this.createTopicIfAbsent(streamId, topicId, partitions, { messageExpiryMicros });
+    }
+    async createTopicIfAbsent(streamId, topicId, partitions, settings) {
         const partitionCount = await this.execute(async (client) => {
-            const topic = await client.topic.ensure(streamId, topicId, partitions);
-            if (topic.messageExpiry === messageExpiryMicros)
-                return topic.partitionsCount;
-            await client.topic.update({
-                streamId,
-                topicId,
-                name: topic.name,
-                messageExpiry: messageExpiryMicros
-            });
-            return topic.partitionsCount;
-        }, `failed to ensure topic \`${topicId}\` on stream \`${streamId}\` with message expiry`);
+            const existing = await client.topic.get({ streamId, topicId });
+            if (existing !== null)
+                return existing.partitionsCount;
+            try {
+                const created = await client.topic.create({
+                    streamId,
+                    name: topicId,
+                    partitionCount: partitions,
+                    compressionAlgorithm: 1,
+                    ...(settings.messageExpiryMicros === undefined
+                        ? {}
+                        : { messageExpiry: settings.messageExpiryMicros }),
+                    ...(settings.maxTopicSize === undefined ? {} : { maxTopicSize: settings.maxTopicSize })
+                });
+                return created.partitionsCount;
+            }
+            catch (error) {
+                if (serverErrorCode(error) !== TOPIC_NAME_ALREADY_EXISTS)
+                    throw error;
+                const raced = await client.topic.get({ streamId, topicId });
+                if (raced === null)
+                    throw error;
+                return raced.partitionsCount;
+            }
+        }, `failed to create topic \`${topicId}\` on stream \`${streamId}\``);
         this.partitionCounts.set(this.topicKey(streamId, topicId), partitionCount);
     }
     async findTopicPartitionCount(streamId, topicId) {
@@ -915,9 +963,13 @@ export class ApacheIggyTransport {
             }
             catch (cause) {
                 const response = serverResponseError(cause);
-                const code = response !== undefined && "errorCode" in response ? response.errorCode : undefined;
-                const transient = code === TRANSIENT_NOT_COMMITTED || code === TRANSIENT_NOT_ACCEPTED;
+                const code = serverErrorCode(cause);
+                const transient = code !== undefined && TRANSIENT_PUBLISH_CODES.has(code);
+                // An expired session on a connection that logged in once means the
+                // socket was re-dialed underneath it. A reconnect logs in again.
+                const reauthenticate = code === UNAUTHENTICATED && this.connection !== undefined;
                 const retryable = transient ||
+                    reauthenticate ||
                     (response === undefined &&
                         !(cause instanceof DeserializeError) &&
                         !(cause instanceof ConfigError) &&
@@ -926,7 +978,7 @@ export class ApacheIggyTransport {
                 // the current one. A concurrent publish may already have replaced it,
                 // and destroying that fresh connection would starve every publisher for
                 // as long as failures keep arriving.
-                if (response === undefined && retryable && this.client === used) {
+                if ((response === undefined || reauthenticate) && retryable && this.client === used) {
                     this.disconnected.add(used);
                     // Destroy before retry so a timed-out queued write cannot run on the old socket.
                     await used.destroy().catch(() => undefined);
@@ -944,28 +996,12 @@ export class ApacheIggyTransport {
         throw new TransportError("publish attempts exhausted", true);
     }
     async sendMessages(streamId, topicId, payloads, routing) {
-        let partitionId;
-        const messages = payloads.map((payload) => ({
-            id: mintUlidValue(),
-            payload: toNodeBuffer(payload)
-        }));
-        return this.publish(async (client) => {
-            partitionId ??= await this.resolvePartition(streamId, topicId, routing, client);
-            if (this.disconnected.has(client))
-                throw new TransportError("publish connection was retired", true);
-            return client.message.send({
-                streamId,
-                topicId,
-                messages,
-                partition: Partitioning.PartitionId(partitionId)
-            });
-        });
+        return this.sendRecords(streamId, topicId, payloads.map((payload) => ({ payload, headers: new Map() })), routing);
     }
     async sendMessageWithHeaders(streamId, topicId, payload, headers, partitionKey, partitionId) {
         return this.sendMessagesWithHeaders(streamId, topicId, [{ payload, headers }], partitionKey, partitionId);
     }
     async sendMessagesWithHeaders(streamId, topicId, messages, partitionKey, partitionId, options) {
-        let resolvedPartition;
         const routing = partitionId !== undefined
             ? { kind: "partition", partition: partitionId }
             : partitionKey !== undefined
@@ -976,43 +1012,84 @@ export class ApacheIggyTransport {
                         : partitionKey
                 }
                 : { kind: "balanced" };
-        const prepared = messages.map(({ payload, headers }) => ({
-            id: mintUlidValue(),
-            payload: toNodeBuffer(payload),
-            headers: [...headers].map(([key, value]) => ({
-                key: HeaderKeyFactory.String(key),
-                value: toIggyHeaderValue(value)
-            }))
-        }));
-        return this.publish(async (client) => {
-            resolvedPartition ??= await this.resolvePartition(streamId, topicId, routing, client);
-            if (this.disconnected.has(client))
-                throw new TransportError("publish connection was retired", true);
-            return client.message.send({
-                streamId,
-                topicId,
-                messages: prepared,
-                partition: Partitioning.PartitionId(resolvedPartition)
-            });
-        }, options);
+        return this.sendRecords(streamId, topicId, messages, routing, options);
+    }
+    // Sends the records in consecutive requests of at most `batchLength`, each
+    // with bounded retries, like the Rust `send_batch_on`. A failure reports the
+    // confirmed requests and every record from the failed request on, with the
+    // ids its attempts used. An empty batch sends nothing.
+    async sendRecords(streamId, topicId, messages, routing, options) {
+        if (messages.length === 0)
+            return { confirmations: [] };
+        if (routing.kind === "key" && (routing.key.byteLength === 0 || routing.key.byteLength > 255))
+            throw new InvalidError("a partition key must hold 1 to 255 bytes");
+        const records = withMessageIds(messages);
+        const batchLength = options?.batchLength ?? PUBLISH_BATCH_LENGTH;
+        const confirmations = [];
+        let resolvedPartition;
+        for (let start = 0; start < records.length; start += batchLength) {
+            const prepared = records.slice(start, start + batchLength).map((record) => ({
+                id: record.id ?? mintUlidValue(),
+                payload: toNodeBuffer(record.payload),
+                headers: [...record.headers].map(([key, value]) => ({
+                    key: HeaderKeyFactory.String(key),
+                    value: toIggyHeaderValue(value)
+                }))
+            }));
+            try {
+                const response = await this.publish(async (client) => {
+                    resolvedPartition ??= await this.resolvePartition(streamId, topicId, routing, client);
+                    if (this.disconnected.has(client))
+                        throw new TransportError("publish connection was retired", true);
+                    return client.message.send({
+                        streamId,
+                        topicId,
+                        messages: prepared,
+                        partition: Partitioning.PartitionId(resolvedPartition)
+                    });
+                }, options);
+                confirmations.push(...response.confirmations);
+            }
+            catch (cause) {
+                throw new PublishFailedError(streamId, topicId, confirmations, records.slice(start), cause);
+            }
+        }
+        return { confirmations };
     }
     async pollMessages(streamId, topicId, target, strategy, count, autoCommit) {
-        const reply = await this.execute((client) => client.message.poll({
-            streamId,
-            topicId,
-            partitionId: target.partitionId ?? null,
-            consumer: toIggyConsumer(target),
-            pollingStrategy: toIggyPollingStrategy(strategy),
-            count,
-            autocommit: autoCommit
-        }), `failed to poll topic \`${topicId}\``);
-        return reply.messages.map((message) => ({
-            payload: new Uint8Array(message.payload.buffer, message.payload.byteOffset, message.payload.byteLength),
-            partitionId: reply.partitionId,
-            offset: message.headers.offset,
-            timestampMicros: BigInt(message.headers.timestamp.getTime()) * 1000n,
-            headers: parsedHeadersToMap(message.userHeaders)
-        }));
+        const partitionId = target.partitionId;
+        if (partitionId === undefined) {
+            if (target.kind !== "group")
+                throw new InvalidError("a single consumer needs a partition");
+            return this.execute(async (client) => {
+                const raw = await client.clientProvider();
+                const release = raw.hold?.();
+                try {
+                    const state = groupPollState(raw);
+                    for (;;) {
+                        const generation = state.sessionGeneration;
+                        try {
+                            return await pollGroupRecords(raw, state, streamId, topicId, target, strategy, count, autoCommit);
+                        }
+                        catch (error) {
+                            if (state.sessionGeneration === generation ||
+                                serverErrorCode(error) === TRANSIENT_NOT_COMMITTED)
+                                throw error;
+                        }
+                    }
+                }
+                finally {
+                    release?.();
+                }
+            }, `failed to poll topic \`${topicId}\``);
+        }
+        const request = toNodeBuffer(encodePollRequest(streamId, topicId, target, partitionId, strategy, count, autoCommit));
+        const body = await this.execute((client) => client.sendBinaryRequest(POLL_MESSAGES_CODE, request), `failed to poll topic \`${topicId}\``);
+        // The stored records exactly: microsecond times, message ids, and a
+        // header block that does not decode marked rather than failing the poll.
+        return body.byteLength === 0
+            ? []
+            : decodePolledBody(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
     }
     async storeOffset(streamId, topicId, target, partitionId, offset) {
         await this.execute((client) => client.offset.store({
@@ -1023,6 +1100,14 @@ export class ApacheIggyTransport {
             offset
         }), `failed to store offset for topic \`${topicId}\``);
     }
+    async deleteOffset(streamId, topicId, target, partitionId) {
+        await this.execute((client) => client.offset.delete({
+            streamId,
+            topicId,
+            consumer: toIggyConsumer(target),
+            partitionId
+        }), `failed to delete offset for topic \`${topicId}\``);
+    }
     async getConsumerOffset(streamId, topicId, target, partitionId) {
         const offset = await this.execute((client) => client.offset.get({
             streamId,
@@ -1172,4 +1257,82 @@ export class ApacheIggyTransport {
         return cursor % partitionCount;
     }
 }
+function groupPollState(client) {
+    const current = GROUP_POLL_STATES.get(client);
+    if (current !== undefined)
+        return current;
+    const state = { cursors: new Map(), sessionGeneration: 0 };
+    GROUP_POLL_STATES.set(client, state);
+    client.on("sessionReset", () => {
+        state.cursors.clear();
+        state.sessionGeneration += 1;
+    });
+    client.on("heartbeat", () => {
+        for (const cursor of state.cursors.values())
+            cursor.synchronizedAt = 0;
+    });
+    return state;
+}
+async function pollGroupRecords(client, state, streamId, topicId, target, strategy, count, autoCommit) {
+    const key = `${streamId}\0${topicId}\0${target.name}`;
+    for (let attempt = 0; attempt < GROUP_POLL_MAX_ATTEMPTS; attempt += 1) {
+        let cursor = state.cursors.get(key);
+        const age = cursor === undefined ? -1 : Date.now() - cursor.synchronizedAt;
+        if (cursor === undefined || age < 0 || age >= GROUP_ASSIGNMENT_REFRESH_MS) {
+            const group = { streamId, topicId, groupId: target.name };
+            let assignment;
+            try {
+                assignment = SYNC_GROUP.deserialize(await client.sendCommand(SYNC_GROUP.code, SYNC_GROUP.serialize(group)));
+            }
+            catch (error) {
+                if (serverErrorCode(error) !== GROUP_MEMBER_NOT_FOUND)
+                    throw error;
+                assignment = null;
+            }
+            if (assignment === null) {
+                await client.sendCommand(JOIN_GROUP.code, JOIN_GROUP.serialize(group));
+                assignment = SYNC_GROUP.deserialize(await client.sendCommand(SYNC_GROUP.code, SYNC_GROUP.serialize(group)));
+            }
+            if (assignment === null)
+                throw new ProtocolError("the consumer group assignment is absent");
+            cursor = {
+                generation: assignment.generation,
+                partitions: assignment.partitions,
+                position: cursor?.generation === assignment.generation &&
+                    cursor.position < assignment.partitions.length
+                    ? cursor.position
+                    : 0,
+                synchronizedAt: Date.now()
+            };
+            state.cursors.set(key, cursor);
+        }
+        const partition = cursor.partitions[cursor.position];
+        if (partition === undefined)
+            return [];
+        cursor.position = (cursor.position + 1) % cursor.partitions.length;
+        let body;
+        try {
+            const response = await client.sendCommand(POLL_MESSAGES_CODE, toNodeBuffer(encodePollRequest(streamId, topicId, target, partition, strategy, count, autoCommit)));
+            body = new Uint8Array(response.data.buffer, response.data.byteOffset, response.data.byteLength);
+        }
+        catch (error) {
+            const code = serverErrorCode(error);
+            if (code !== GROUP_MEMBER_NOT_FOUND && code !== GROUP_PARTITION_NOT_OWNED)
+                throw error;
+            state.cursors.delete(key);
+            continue;
+        }
+        if (body.byteLength === 0)
+            return [];
+        const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+        if (body.byteLength >= POLLED_HEAD_BYTES &&
+            view.getUint32(0, true) === RESYNC_REQUIRED_PARTITION &&
+            view.getUint32(12, true) === 0) {
+            state.cursors.delete(key);
+            continue;
+        }
+        return decodePolledBody(body);
+    }
+    return [];
+}
 //# sourceMappingURL=apache-iggy.js.map