apache-iggy 0.10.0 → 0.10.1-edge.2

package/dist/wire/message/poll-messages.command.test.js

@@ -18,11 +18,14 @@ import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import { Readable } from 'node:stream';
 import { describe, it } from 'node:test';
+import { EMPTY_PARTITION_CONTEXT } from '../vsr/header.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { ResponseError } from '../error.utils.js';
+import { LaneBlockedError, OPERATION_TIMEOUT_MS, OperationUncertainError } from '../../client/client.operation.js';
 import { Consumer } from '../offset/offset.utils.js';
 import { PollingStrategy } from './poll.utils.js';
 import { NO_ASSIGNED_PARTITION, pollMessages } from './poll-messages.command.js';
+const UNAUTHENTICATED = 40;
 const response = (data) => ({
     status: 0,
     length: data.length,
@@ -38,7 +41,7 @@ const assignment = (generation, partitions) => {
     return response(data);
 };
 const pollResponse = (partitionId, count = 0) => {
-    const data = Buffer.alloc(16);
+    const data = Buffer.alloc(40);
     data.writeUInt32LE(partitionId, 0);
     data.writeBigUInt64LE(0n, 4);
     data.writeUInt32LE(count, 12);
@@ -59,8 +62,8 @@ const stubClient = (responses, onCommand) => {
     const client = {
         protocol: 'vsr',
         isAuthenticated: true,
-        sendCommand: async (command, payload) => {
-            commands.push({ command, payload });
+        sendCommand: async (command, payload, options) => {
+            commands.push({ command, payload, options });
             onCommand?.(command, emitter);
             const next = responses.shift();
             if (!next)
@@ -129,12 +132,28 @@ describe('VSR consumer-group polling', () => {
         const { client, commands } = stubClient([assignment(1n, [])]);
         assert.deepEqual(await pollMessages(async () => client)(groupRequest), {
             partitionId: NO_ASSIGNED_PARTITION,
+            context: EMPTY_PARTITION_CONTEXT,
             currentOffset: 0n,
             count: 0,
             messages: []
         });
         assert.deepEqual(commands.map(({ command }) => command), [COMMAND_CODE.SyncGroup]);
     });
+    it('resynchronizes an empty assignment on the next poll', async () => {
+        const { client, commands } = stubClient([
+            assignment(1n, []),
+            assignment(4n, [7]),
+            pollResponse(7)
+        ]);
+        const poll = pollMessages(async () => client);
+        assert.equal((await poll(groupRequest)).partitionId, NO_ASSIGNED_PARTITION);
+        assert.equal((await poll(groupRequest)).partitionId, 7);
+        assert.deepEqual(commands.map(({ command }) => command), [
+            COMMAND_CODE.SyncGroup,
+            COMMAND_CODE.SyncGroup,
+            COMMAND_CODE.PollMessages
+        ]);
+    });
     it('caches a cursor and refreshes it after a heartbeat', async () => {
         const responses = [
             assignment(1n, [4, 5]),
@@ -184,7 +203,7 @@ describe('VSR consumer-group polling', () => {
         ], (command, emitter) => {
             if (command === COMMAND_CODE.PollMessages && resetPending) {
                 resetPending = false;
-                emitter.emit('sessionReset');
+                emitter.emit('sessionReset', true);
             }
         });
         assert.equal((await pollMessages(async () => client)(groupRequest)).partitionId, 7);
@@ -197,13 +216,70 @@ describe('VSR consumer-group polling', () => {
             COMMAND_CODE.PollMessages
         ]);
     });
+    it('returns the refused sign-in of a poll that starts signed out', async () => {
+        let resetPending = true;
+        const refusal = new ResponseError(COMMAND_CODE.SyncGroup, UNAUTHENTICATED);
+        const { client, commands } = stubClient([refusal], (_command, emitter) => {
+            // The sign-in that the first command waits for resets a session that was not signed in.
+            if (resetPending) {
+                resetPending = false;
+                emitter.emit('sessionReset', false);
+            }
+        });
+        client.isAuthenticated = false;
+        await assert.rejects(pollMessages(async () => client)(groupRequest), (error) => error === refusal);
+        assert.deepEqual(commands.map(({ command }) => command), [COMMAND_CODE.SyncGroup]);
+    });
+    it('retries a poll that starts signed out when the session it signed in to ends', async () => {
+        let sessionEnded = false;
+        const { client, commands } = stubClient([
+            assignment(1n, [4]),
+            new Error('connection closed while waiting for response'),
+            response(Buffer.alloc(0)),
+            response(Buffer.alloc(0)),
+            assignment(2n, [7]),
+            pollResponse(7)
+        ], (command, emitter) => {
+            if (!client.isAuthenticated) {
+                // The sign-in that the first command waits for resets a session that was not signed in.
+                emitter.emit('sessionReset', false);
+                client.isAuthenticated = true;
+            }
+            else if (command === COMMAND_CODE.PollMessages && !sessionEnded) {
+                sessionEnded = true;
+                emitter.emit('sessionReset', true);
+            }
+        });
+        client.isAuthenticated = false;
+        assert.equal((await pollMessages(async () => client)(groupRequest)).partitionId, 7);
+        assert.deepEqual(commands.map(({ command }) => command), [
+            COMMAND_CODE.SyncGroup, COMMAND_CODE.PollMessages, COMMAND_CODE.SyncGroup,
+            COMMAND_CODE.JoinGroup, COMMAND_CODE.SyncGroup, COMMAND_CODE.PollMessages
+        ]);
+    });
+    it('bounds the retries after session ends by one deadline for the whole call', async (context) => {
+        // Each attempt takes a third of the deadline, so the third one ends at it.
+        const attempts = 3;
+        const sessionEnds = attempts + 1;
+        context.mock.timers.enable({ apis: ['Date'] });
+        const deadline = Date.now() + OPERATION_TIMEOUT_MS;
+        const refusal = () => new ResponseError(COMMAND_CODE.SyncGroup, UNAUTHENTICATED);
+        const { client, commands } = stubClient(Array.from({ length: sessionEnds }, refusal), (_command, emitter) => {
+            if (commands.length <= sessionEnds)
+                emitter.emit('sessionReset', true);
+            context.mock.timers.tick(OPERATION_TIMEOUT_MS / attempts);
+        });
+        await assert.rejects(pollMessages(async () => client)(groupRequest), (error) => error instanceof ResponseError && error.errorCode === UNAUTHENTICATED);
+        assert.equal(commands.length, attempts);
+        assert.ok(commands.every(({ options }) => options?.deadline === deadline));
+    });
     it('does not replay an ambiguous auto-commit poll when its coordinator also resets', async () => {
         const { client, commands } = stubClient([
             assignment(1n, [4]),
             new ResponseError(COMMAND_CODE.PollMessages, 57)
         ], (command, emitter) => {
             if (command === COMMAND_CODE.PollMessages)
-                emitter.emit('sessionReset');
+                emitter.emit('sessionReset', true);
         });
         await assert.rejects(pollMessages(async () => client)({ ...groupRequest, autocommit: true }), (error) => error instanceof ResponseError && error.errorCode === 57);
         assert.deepEqual(commands.map(({ command }) => command), [COMMAND_CODE.SyncGroup, COMMAND_CODE.PollMessages]);
@@ -218,6 +294,7 @@ describe('VSR consumer-group polling', () => {
         ]);
         assert.deepEqual(await pollMessages(async () => client)(groupRequest), {
             partitionId: NO_ASSIGNED_PARTITION,
+            context: EMPTY_PARTITION_CONTEXT,
             currentOffset: 0n,
             count: 0,
             messages: []
@@ -226,6 +303,37 @@ describe('VSR consumer-group polling', () => {
             .filter(({ command }) => command === COMMAND_CODE.PollMessages)
             .map(({ payload }) => payload.readUInt32LE(20)), [1, 2]);
     });
+    it('resolves its uncertain join before synchronizing the group again', async () => {
+        const operationId = 17n;
+        const { client, commands } = stubClient([
+            response(Buffer.alloc(0)),
+            new OperationUncertainError(operationId, new Error('lost join reply')),
+            assignment(2n, [7]),
+            pollResponse(7)
+        ]);
+        const resolutions = [];
+        client.resolveOperation = async (id) => {
+            resolutions.push(id);
+            if (resolutions.length === 1)
+                throw new OperationUncertainError(id, new Error('lost resolve reply'));
+        };
+        const poll = pollMessages(async () => client);
+        await assert.rejects(poll(groupRequest), OperationUncertainError);
+        await assert.rejects(poll(groupRequest), OperationUncertainError);
+        assert.equal((await poll(groupRequest)).partitionId, 7);
+        assert.deepEqual(resolutions, [operationId, operationId]);
+        assert.deepEqual(commands.map(({ command }) => command), [
+            COMMAND_CODE.SyncGroup, COMMAND_CODE.JoinGroup,
+            COMMAND_CODE.SyncGroup, COMMAND_CODE.PollMessages
+        ]);
+    });
+    it('leaves a join blocked by an unrelated operation for the caller to resolve', async () => {
+        const { client } = stubClient([
+            response(Buffer.alloc(0)), new LaneBlockedError(18n)
+        ]);
+        client.resolveOperation = async () => { assert.fail('must not resolve an unrelated operation'); };
+        await assert.rejects(pollMessages(async () => client)(groupRequest), LaneBlockedError);
+    });
     it('rejoins when a cached poll reports a missing member', async () => {
         const { client, commands } = stubClient([
             assignment(1n, [4]),
@@ -308,4 +416,34 @@ describe('VSR consumer-group polling', () => {
         assert.equal(held, false);
     });
 });
+describe('VSR poll context', () => {
+    const context = { incarnation: 7n, ownerGeneration: 8n, metadataOp: 9n };
+    it('passes the caller context with an explicit partition poll', async () => {
+        const { client, commands } = stubClient([pollResponse(4)]);
+        await pollMessages(async () => client)({ ...groupRequest, partitionId: 4, context });
+        assert.deepEqual(commands.map(({ options }) => options?.context), [context]);
+    });
+    it('passes the caller context with the partition a group poll selects', async () => {
+        const { client, commands } = stubClient([assignment(1n, [4]), pollResponse(4)]);
+        await pollMessages(async () => client)({ ...groupRequest, context });
+        assert.deepEqual(commands.map(({ options }) => options?.context), [undefined, context]);
+    });
+    it('surfaces stale ownership under a caller context and resynchronizes next time', async () => {
+        const { client, commands } = stubClient([
+            assignment(1n, [4]),
+            new ResponseError(COMMAND_CODE.PollMessages, 5009),
+            assignment(2n, [7]),
+            pollResponse(7)
+        ]);
+        const poll = pollMessages(async () => client);
+        await assert.rejects(poll({ ...groupRequest, context }), (error) => error instanceof ResponseError && error.errorCode === 5009);
+        assert.equal((await poll(groupRequest)).partitionId, 7);
+        assert.deepEqual(commands.map(({ command }) => command), [
+            COMMAND_CODE.SyncGroup,
+            COMMAND_CODE.PollMessages,
+            COMMAND_CODE.SyncGroup,
+            COMMAND_CODE.PollMessages
+        ]);
+    });
+});
 //# sourceMappingURL=poll-messages.command.test.js.map

package/dist/wire/message/poll.utils.d.ts

@@ -1,3 +1,4 @@
+import { type PartitionContext } from "../vsr/header.js";
 import { type Id } from "../identifier.utils.js";
 import { type ValueOf } from "../../type.utils.js";
 import { type Consumer } from "../offset/offset.utils.js";
@@ -118,6 +119,8 @@ export type Message = {
  * Response from a poll messages command.
  */
 export type PollMessagesResponse = {
+    /** Partition incarnation, owner generation and metadata op the reply carries */
+    context: PartitionContext;
     /** Partition the messages came from */
     partitionId: number;
     /** Current offset in the partition */
@@ -176,6 +179,7 @@ export declare const deserializeMessages: (b: Buffer, pos?: number) => Message[]
  */
 export declare const deserializePollMessages: (r: Buffer, pos?: number) => {
     partitionId: number;
+    context: PartitionContext;
     currentOffset: bigint;
     count: number;
     messages: Message[];

package/dist/wire/message/poll.utils.js

@@ -14,6 +14,7 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
+import { deserializePartitionContext, PARTITION_CONTEXT_SIZE } from "../vsr/header.js";
 import { reverseRecord } from "../../type.utils.js";
 import { toDate } from "../serialize.utils.js";
 import { serializeGetOffset } from "../offset/offset.utils.js";
@@ -211,9 +212,13 @@ export const deserializePollMessages = (r, pos = 0) => {
     const partitionId = r.readUInt32LE(pos);
     const currentOffset = r.readBigUInt64LE(pos + 4);
     const count = r.readUInt32LE(pos + 12);
-    const messages = deserializeMessages(r, pos + 16);
+    const context = deserializePartitionContext(r, pos + 16);
+    const messages = deserializeMessages(r, pos + 16 + PARTITION_CONTEXT_SIZE);
+    if (messages.length !== count)
+        throw new Error("poll response count does not match its messages");
     return {
         partitionId,
+        context,
         currentOffset,
         count,
         messages,

package/dist/wire/message/send-messages.command.d.ts

@@ -1,7 +1,7 @@
 import { type Id } from '../identifier.utils.js';
 import { type CreateMessage } from './message.utils.js';
-import type { Partitioning } from './partitioning.utils.js';
-import type { CommandResponse } from '../../client/client.type.js';
+import { Partitioning } from './partitioning.utils.js';
+import type { ClientProvider, CommandResponse } from '../../client/client.type.js';
 /**
  * Parameters for the send messages command.
  */
@@ -54,5 +54,5 @@ export declare const SEND_MESSAGES: {
  * Executable send messages command function. Resolves to the commit
  * confirmations of the written partitions, empty against the legacy server.
  */
-export declare const sendMessages: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: SendMessages) => Promise<SendMessagesResponse>;
+export declare const sendMessages: (getClient: ClientProvider) => (request: SendMessages) => Promise<SendMessagesResponse>;
 //# sourceMappingURL=send-messages.command.d.ts.map

package/dist/wire/message/send-messages.command.js

@@ -14,10 +14,14 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
+import { setTimeout as delay } from 'node:timers/promises';
+import { xxh32 } from '@node-rs/xxhash';
+import { serializeIdentifier } from '../identifier.utils.js';
 import { serializeSendMessages } from './message.utils.js';
-import { DeserializeError } from '../error.utils.js';
-import { wrapCommand } from '../command.utils.js';
+import { Partitioning, PartitionKind, serializeMessageKey } from './partitioning.utils.js';
+import { DeserializeError, ResponseError, responseError } from '../error.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
+import { deserializePartitionRoute, serializePartitionRoute } from '../partition/partition-route.js';
 /** Size of the confirmation count prefixing the list. */
 const CONFIRMATIONS_COUNT_SIZE = 4;
 /**
@@ -66,9 +70,105 @@ export const SEND_MESSAGES = {
     },
     deserialize: (r) => deserializeSendMessages(r.data)
 };
+/** Rust `calculate_32` hashes message keys with XXH32 under this seed. */
+const MESSAGE_KEY_SEED = 0;
+const TOPIC_ID_NOT_FOUND = 2010;
+const PARTITION_NOT_FOUND = 3007;
+const SEND_TIMEOUT_MS = 30_000;
+const ROUTE_RETRY_INTERVAL_MS = 50;
+const TRANSIENT_NOT_ACCEPTED = 58;
+const NOT_PRIMARY = 89;
+const topicPartitions = new WeakMap();
+const getTopicPartitions = (client, streamId, topicId) => {
+    let topics = topicPartitions.get(client);
+    if (!topics) {
+        const created = new Map();
+        topicPartitions.set(client, created);
+        // The client's own stream, topic or partition change can alter any
+        // count, as it drops the Rust SDK's topic discovery.
+        client.on('topicDiscoveryReset', () => {
+            for (const topic of created.values())
+                topic.count = undefined;
+        });
+        client.on('partitionRoute', (event) => {
+            const { topic, count } = event;
+            const cached = created.get(topic);
+            if (cached)
+                cached.count = count;
+        });
+        topics = created;
+    }
+    const key = Buffer.concat([serializeIdentifier(streamId), serializeIdentifier(topicId)]).toString('hex');
+    let topic = topics.get(key);
+    if (!topic) {
+        topic = { cursor: 0 };
+        topics.set(key, topic);
+    }
+    return topic;
+};
+/**
+ * Resolves Balanced and MessageKey to an explicit partition id as the Rust SDK
+ * does, so the send carries that partition's incarnation.
+ */
+const resolvePartitioning = async (client, { streamId, topicId, partition }, call) => {
+    if (partition?.kind === PartitionKind.PartitionId)
+        return partition;
+    const topic = getTopicPartitions(client, streamId, topicId);
+    if (!topic.count) {
+        for (;;) {
+            try {
+                const response = await client.sendCommand(COMMAND_CODE.GetPartitionRoute, serializePartitionRoute(streamId, topicId, 0), call);
+                topic.count = deserializePartitionRoute(response.data).partitionsCount;
+                break;
+            }
+            catch (error) {
+                if (!(error instanceof ResponseError) ||
+                    (error.errorCode !== TRANSIENT_NOT_ACCEPTED && error.errorCode !== NOT_PRIMARY) ||
+                    call.deadline - Date.now() <= ROUTE_RETRY_INTERVAL_MS)
+                    throw error;
+                await delay(ROUTE_RETRY_INTERVAL_MS);
+            }
+        }
+    }
+    if (!topic.count)
+        throw responseError(COMMAND_CODE.SendMessages, TOPIC_ID_NOT_FOUND);
+    if (partition?.kind === PartitionKind.MessageKey)
+        return Partitioning.PartitionId(xxh32(serializeMessageKey(partition.value), MESSAGE_KEY_SEED) % topic.count);
+    const index = topic.cursor % topic.count;
+    topic.cursor += 1;
+    return Partitioning.PartitionId(index);
+};
 /**
  * Executable send messages command function. Resolves to the commit
  * confirmations of the written partitions, empty against the legacy server.
  */
-export const sendMessages = wrapCommand(SEND_MESSAGES);
+export const sendMessages = (getClient) => async (request) => {
+    const client = await getClient();
+    const release = client.hold?.();
+    try {
+        // No command of the call runs under a session that the caller opened after it started.
+        const call = { deadline: Date.now() + SEND_TIMEOUT_MS, lineage: client.lineage };
+        for (let attempt = 0;; attempt += 1) {
+            const partition = await resolvePartitioning(client, request, call);
+            try {
+                return SEND_MESSAGES.deserialize(await client.sendCommand(SEND_MESSAGES.code, SEND_MESSAGES.serialize({ ...request, partition }), call));
+            }
+            catch (error) {
+                if (attempt !== 0 || request.partition?.kind === PartitionKind.PartitionId ||
+                    !(error instanceof ResponseError) || error.errorCode !== PARTITION_NOT_FOUND)
+                    throw error;
+                getTopicPartitions(client, request.streamId, request.topicId).count = undefined;
+            }
+        }
+    }
+    catch (error) {
+        // A refusal can mean the topic changed shape since its count was read.
+        if (error instanceof ResponseError)
+            getTopicPartitions(client, request.streamId, request.topicId).count = undefined;
+        throw error;
+    }
+    finally {
+        release?.();
+    }
+};
 //# sourceMappingURL=send-messages.command.js.map

package/dist/wire/message/send-messages.command.test.js

@@ -16,10 +16,14 @@
 // under the License.
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
 import { uuidv7, uuidv4 } from "uuidv7";
-import { SEND_MESSAGES, } from "./send-messages.command.js";
+import { SEND_MESSAGES, sendMessages, } from "./send-messages.command.js";
 import { HeaderValue, HeaderKeyFactory } from "./header.utils.js";
-import { DeserializeError } from "../error.utils.js";
+import { Partitioning, PartitionKind } from "./partitioning.utils.js";
+import { serializePartitionRoute } from '../partition/partition-route.js';
+import { COMMAND_CODE } from "../command.code.js";
+import { DeserializeError, responseError } from "../error.utils.js";
 const SUCCESS = 0;
 const CONFIRMATION_SIZE = 20;
 const confirmation = (partitionId) => ({
@@ -226,4 +230,111 @@ describe("SendMessages", () => {
         });
     });
 });
+const routeBody = (partitionsCount) => {
+    const body = Buffer.alloc(25);
+    body.writeUInt32LE(partitionsCount, 20);
+    return body;
+};
+const sendClient = (partitionsCount, refuseFirstSend = false) => {
+    const sent = [];
+    const events = new EventEmitter();
+    const client = {
+        on: events.on.bind(events),
+        emit: events.emit.bind(events),
+        sendCommand: async (code, payload) => {
+            sent.push({ code, payload });
+            if (code === COMMAND_CODE.SendMessages && refuseFirstSend) {
+                refuseFirstSend = false;
+                throw responseError(code, 87);
+            }
+            return response(code === COMMAND_CODE.GetPartitionRoute ? routeBody(partitionsCount) : Buffer.alloc(0));
+        }
+    };
+    return { client, sent };
+};
+const sentPartitions = (sent) => sent.filter(({ code }) => code === COMMAND_CODE.SendMessages).map(({ payload }) => {
+    assert.equal(payload[16], PartitionKind.PartitionId);
+    return payload.readUInt32LE(18);
+});
+const countOf = (sent, code) => sent.filter((entry) => entry.code === code).length;
+const request = { streamId: 1, topicId: 2, messages: [{ payload: "m" }] };
+describe("SendMessages partition resolution", () => {
+    it("resolves Balanced sends round-robin from one route read", async () => {
+        const { client, sent } = sendClient(3);
+        const send = sendMessages(async () => client);
+        for (let index = 0; index < 4; index += 1)
+            await send(request);
+        assert.deepEqual(sentPartitions(sent), [0, 1, 2, 0]);
+        assert.equal(countOf(sent, COMMAND_CODE.GetPartitionRoute), 1);
+    });
+    it("waits for a route to become ready within the original send deadline", async () => {
+        const { client } = sendClient(2);
+        const sendCommand = client.sendCommand;
+        let reads = 0;
+        const deadlines = [];
+        client.sendCommand = async (code, payload, options) => {
+            deadlines.push(options.deadline);
+            if (code === COMMAND_CODE.GetPartitionRoute && ++reads === 1)
+                throw responseError(code, 58);
+            return sendCommand(code, payload, options);
+        };
+        await sendMessages(async () => client)(request);
+        assert.equal(reads, 2);
+        assert.equal(new Set(deadlines).size, 1);
+    });
+    it("uses refreshed route counts for later balanced sends", async () => {
+        const { client, sent } = sendClient(2);
+        const send = sendMessages(async () => client);
+        await send(request);
+        client.emit("partitionRoute", {
+            topic: serializePartitionRoute(1, 2, 0).subarray(0, -4).toString('hex'), count: 3
+        });
+        await send(request);
+        await send(request);
+        assert.deepEqual(sentPartitions(sent), [0, 1, 2]);
+        assert.equal(countOf(sent, COMMAND_CODE.GetPartitionRoute), 1);
+    });
+    it("hashes MessageKey sends with XXH32 seed 0 like the Rust SDK", async () => {
+        const { client, sent } = sendClient(4);
+        const send = sendMessages(async () => client);
+        await send({ ...request, partition: Partitioning.MessageKey("abc") });
+        for (let key = 0; key < 64; key += 1)
+            await send({ ...request, partition: Partitioning.MessageKey(`key-${key}`) });
+        const [first, ...rest] = sentPartitions(sent);
+        assert.equal(first, 0x32D153FF % 4); // XXH32("abc", 0)
+        assert.ok(rest.every((partition) => partition >= 0 && partition < 4));
+    });
+    it("reads the partition count again after a refused send", async () => {
+        const { client, sent } = sendClient(2, true);
+        const send = sendMessages(async () => client);
+        await assert.rejects(send(request));
+        await send(request);
+        assert.equal(countOf(sent, COMMAND_CODE.GetPartitionRoute), 2);
+    });
+    it("reads the partition count again after the client changes topics", async () => {
+        const { client, sent } = sendClient(2);
+        const send = sendMessages(async () => client);
+        await send(request);
+        client.emit("topicDiscoveryReset");
+        await send(request);
+        assert.equal(countOf(sent, COMMAND_CODE.GetPartitionRoute), 2);
+        assert.deepEqual(sentPartitions(sent), [0, 1], "the round-robin position survives");
+    });
+    it("holds the raw client across the route read and the send", async () => {
+        const { client, sent } = sendClient(2);
+        let held = false;
+        client.hold = () => {
+            held = true;
+            return () => { held = false; };
+        };
+        const sendCommand = client.sendCommand;
+        client.sendCommand = (code, payload) => {
+            assert.equal(held, true);
+            return sendCommand(code, payload);
+        };
+        await sendMessages(async () => client)(request);
+        assert.equal(countOf(sent, COMMAND_CODE.GetPartitionRoute), 1);
+        assert.equal(held, false);
+    });
+});
 //# sourceMappingURL=send-messages.command.test.js.map

package/dist/wire/offset/delete-offset.command.d.ts

@@ -1,9 +1,16 @@
+import type { PartitionContext } from '../vsr/header.js';
 import type { GetOffset } from './get-offset.command.js';
 /**
- * Parameters for the delete offset command.
- * Same as GetOffset parameters.
+ * Parameters for the delete offset command: the GetOffset parameters and an
+ * optional partition context. Without a context the client takes the one its
+ * cached route reports: after another client deletes and recreates the
+ * partition, one delete can fail with 87 (5009 for a group consumer). The
+ * failed route is dropped and the next call routes again.
  */
-export type DeleteOffset = GetOffset;
+export type DeleteOffset = GetOffset & {
+    /** Context of the poll the delete belongs to (`PollMessagesResponse.context`) */
+    context?: PartitionContext;
+};
 /**
  * Delete offset command definition.
  * Removes a stored consumer offset.
@@ -16,5 +23,5 @@ export declare const DELETE_OFFSET: {
 /**
  * Executable delete offset command function.
  */
-export declare const deleteOffset: (getClient: import("../../index.js").ClientProvider) => (arg: GetOffset) => Promise<boolean>;
+export declare const deleteOffset: (getClient: import("../../index.js").ClientProvider) => (arg: DeleteOffset) => Promise<boolean>;
 //# sourceMappingURL=delete-offset.command.d.ts.map

package/dist/wire/offset/delete-offset.command.js

@@ -32,5 +32,5 @@ export const DELETE_OFFSET = {
 /**
  * Executable delete offset command function.
  */
-export const deleteOffset = wrapCommand(DELETE_OFFSET);
+export const deleteOffset = wrapCommand(DELETE_OFFSET, ({ context }) => ({ context }));
 //# sourceMappingURL=delete-offset.command.js.map

package/dist/wire/offset/get-offset.command.d.ts

@@ -11,7 +11,7 @@ export type GetOffset = {
     topicId: Id;
     /** Consumer identifier (single or group) */
     consumer: Consumer;
-    /** Partition ID. VSR requires the explicit partition returned by polling. */
+    /** Partition ID. A missing partition reads partition zero. */
     partitionId: number | null;
 };
 /**

package/dist/wire/offset/offset-write.command.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=offset-write.command.test.d.ts.map

package/dist/wire/offset/offset-write.command.test.js

@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { COMMAND_CODE } from '../command.code.js';
+import { Consumer } from './offset.utils.js';
+import { storeOffset } from './store-offset.command.js';
+import { deleteOffset } from './delete-offset.command.js';
+const context = { incarnation: 7n, ownerGeneration: 8n, metadataOp: 9n };
+const target = { streamId: 1, topicId: 2, consumer: Consumer.Single, partitionId: 3 };
+const recordingClient = (sent) => ({
+    sendCommand: async (command, _payload, options) => {
+        sent.push({ command, options });
+        return { status: 0, length: 0, data: Buffer.alloc(0) };
+    }
+});
+describe('offset writes', () => {
+    it('pass the caller context to the store and the delete', async () => {
+        const sent = [];
+        const client = recordingClient(sent);
+        await storeOffset(async () => client)({ ...target, offset: 5n, context });
+        await deleteOffset(async () => client)({ ...target, context });
+        assert.deepEqual(sent, [
+            { command: COMMAND_CODE.StoreOffset, options: { context } },
+            { command: COMMAND_CODE.DeleteConsumerOffset, options: { context } }
+        ]);
+    });
+});
+//# sourceMappingURL=offset-write.command.test.js.map

package/dist/wire/offset/offset.utils.js

@@ -57,8 +57,6 @@ export const Consumer = {
  * @throws Error if partitionId is null for single consumer kind
  */
 export const serializeGetOffset = (streamId, topicId, consumer, partitionId) => {
-    if (consumer.kind === ConsumerKind.Single && partitionId === null)
-        throw new Error('getOffset error: partitionId must be provided for single consumer kind');
     const streamIdentifier = serializeIdentifier(streamId);
     const topicIdentifier = serializeIdentifier(topicId);
     const consumerIdentifier = serializeIdentifier(consumer.id);
@@ -92,6 +90,8 @@ export const serializeGetOffset = (streamId, topicId, consumer, partitionId) =>
  * @returns Buffer containing serialized store offset request
  */
 export const serializeStoreOffset = (streamId, topicId, consumer, partitionId, offset) => {
+    if (partitionId === null)
+        throw new Error('storeOffset error: partitionId must be provided');
     const b = Buffer.allocUnsafe(9);
     b.writeBigUInt64LE(offset, 0);
     b.writeUInt8(ACK_QUORUM, 8);
@@ -109,8 +109,12 @@ export const serializeStoreOffset = (streamId, topicId, consumer, partitionId, o
  * @param partitionId - Partition ID. VSR requires an explicit partition.
  * @returns Buffer containing serialized delete offset request
  */
-export const serializeDeleteOffset = (streamId, topicId, consumer, partitionId) => Buffer.concat([
-    serializeGetOffset(streamId, topicId, consumer, partitionId),
-    uint8ToBuf(ACK_QUORUM)
-]);
+export const serializeDeleteOffset = (streamId, topicId, consumer, partitionId) => {
+    if (partitionId === null)
+        throw new Error('deleteOffset error: partitionId must be provided');
+    return Buffer.concat([
+        serializeGetOffset(streamId, topicId, consumer, partitionId),
+        uint8ToBuf(ACK_QUORUM)
+    ]);
+};
 //# sourceMappingURL=offset.utils.js.map