apache-iggy 0.10.0-edge.1 → 0.10.0-edge.2

package/dist/client/client.socket.d.ts

@@ -18,6 +18,12 @@ export declare class CommandResponseStream extends EventEmitter {
     private vsrSession;
     /** Shared authentication attempt for concurrent callers */
     private authenticationPromise?;
+    /** Whether a login is already being moved to the leader */
+    private settlingLeader;
+    /** How long a leaderless roster is polled before settling in place */
+    private leaderlessWaitBudget;
+    /** Delay between roster reads while the cluster elects */
+    private leaderlessPollInterval;
     /** Calls that have acquired this stream but have not fully settled */
     private pendingSubmissions;
     /** Whether the stream is currently processing a command */
@@ -42,7 +48,7 @@ export declare class CommandResponseStream extends EventEmitter {
     _init(): void;
     /**
      * Sends a command to the server.
-     * Automatically handles connection and authentication if needed.
+     * Automatically handles connection, authentication and leader settlement.
      *
      * @param command - Command code to send
      * @param payload - Command payload buffer
@@ -70,7 +76,28 @@ export declare class CommandResponseStream extends EventEmitter {
     private _processVsr;
     private _exchange;
     private isUnloggedCommand;
-    private _ensureVsrLeader;
+    /**
+     * Moves a freshly authenticated session to the cluster leader.
+     *
+     * Only the leader accepts replicated commands, and the roster read is
+     * auth-gated, so the topology cannot be inspected before a login binds a
+     * session. The redirect drops that session along with the socket, so the
+     * login is replayed on the leader and its answer supersedes the one from the
+     * node the client dialed. Leadership can move between the roster read and
+     * the replay, so each freshly bound hop rechecks the roster under a bounded
+     * redirect budget.
+     *
+     * @returns The leader's login response, or undefined when the client stays
+     */
+    private _settleOnLeader;
+    /**
+     * Reads the cluster roster and picks the endpoint to settle on.
+     *
+     * Best effort: an unreadable roster, `Unauthenticated` included (the session
+     * died between the login and this read), keeps the client on its current
+     * node instead of failing a login that already succeeded.
+     */
+    private _readLeaderEndpoint;
     /**
      * Fails all queued commands with the given error.
      *

package/dist/client/client.socket.js

@@ -26,6 +26,9 @@ import { decodeVsrResponse, prepareVsrCommand, readRegisteredSession, VsrEvictio
 import { normalizeClientConfig } from './client.config.js';
 const VSR_RESPONSE_TIMEOUT_MS = 30_000;
 const VSR_RETRY_INTERVAL_MS = 50;
+const LEADERLESS_WAIT_BUDGET_MS = 5_000;
+const LEADERLESS_POLL_INTERVAL_MS = 250;
+const MAX_LEADER_REDIRECTS = 3;
 const TRANSIENT_NOT_COMMITTED = 57;
 const TRANSIENT_NOT_ACCEPTED = 58;
 /**
@@ -58,6 +61,12 @@ export class CommandResponseStream extends EventEmitter {
     vsrSession;
     /** Shared authentication attempt for concurrent callers */
     authenticationPromise;
+    /** Whether a login is already being moved to the leader */
+    settlingLeader;
+    /** How long a leaderless roster is polled before settling in place */
+    leaderlessWaitBudget;
+    /** Delay between roster reads while the cluster elects */
+    leaderlessPollInterval;
     /** Calls that have acquired this stream but have not fully settled */
     pendingSubmissions;
     /** Whether the stream is currently processing a command */
@@ -85,6 +94,9 @@ export class CommandResponseStream extends EventEmitter {
         this._execQueue = [];
         this.vsrSession = new VsrSession();
         this.authenticationPromise = undefined;
+        this.settlingLeader = false;
+        this.leaderlessWaitBudget = LEADERLESS_WAIT_BUDGET_MS;
+        this.leaderlessPollInterval = LEADERLESS_POLL_INTERVAL_MS;
         this.pendingSubmissions = 0;
         this.heartbeatInFlight = false;
         this._init();
@@ -109,7 +121,7 @@ export class CommandResponseStream extends EventEmitter {
     }
     /**
      * Sends a command to the server.
-     * Automatically handles connection and authentication if needed.
+     * Automatically handles connection, authentication and leader settlement.
      *
      * @param command - Command code to send
      * @param payload - Command payload buffer
@@ -122,11 +134,9 @@ export class CommandResponseStream extends EventEmitter {
             const { handleResponse = true, last = true } = options;
             if (!this.connection.connected)
                 await this.connection.connect();
-            if (isLoginCommand(command))
-                await this._ensureVsrLeader();
             if (!this.isAuthenticated && !this.isUnloggedCommand(command))
                 await this.authenticate(this.options.credentials);
-            return await new Promise((resolve, reject) => {
+            const response = await new Promise((resolve, reject) => {
                 const job = {
                     command,
                     payload,
@@ -140,6 +150,16 @@ export class CommandResponseStream extends EventEmitter {
                     this._execQueue.unshift(job);
                 this._processQueue();
             });
+            if (!isLoginCommand(command) || this.settlingLeader)
+                return response;
+            this.settlingLeader = true;
+            try {
+                const settled = await this._settleOnLeader(command, payload);
+                return settled ?? response;
+            }
+            finally {
+                this.settlingLeader = false;
+            }
         }
         finally {
             this.pendingSubmissions -= 1;
@@ -309,31 +329,82 @@ export class CommandResponseStream extends EventEmitter {
             }
         });
     }
+    // `GetClusterMetadata` is deliberately absent: the server auth-gates it,
+    // so the client authenticates before reading the topology. A login dialed
+    // at a backup still succeeds because the server forwards the register to
+    // the primary.
     isUnloggedCommand(command) {
-        return UNLOGGED_COMMAND_CODE.includes(command) ||
-            command === COMMAND_CODE.GetClusterMetadata;
+        return UNLOGGED_COMMAND_CODE.includes(command);
     }
-    async _ensureVsrLeader() {
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            // Queue the metadata fetch instead of writing directly: a bare write
-            // would race an in-flight exchange and both would wake on the same
-            // response event.
-            const response = await this.sendCommand(GET_CLUSTER_METADATA.code, GET_CLUSTER_METADATA.serialize(), { last: false });
-            const metadata = GET_CLUSTER_METADATA.deserialize(response);
-            if (metadata.nodes.length <= 1)
-                return;
-            const leader = metadata.nodes.find((node) => node.role === 'Leader' && node.status === 'Healthy');
-            if (!leader) {
-                await delay(100);
-                continue;
+    /**
+     * Moves a freshly authenticated session to the cluster leader.
+     *
+     * Only the leader accepts replicated commands, and the roster read is
+     * auth-gated, so the topology cannot be inspected before a login binds a
+     * session. The redirect drops that session along with the socket, so the
+     * login is replayed on the leader and its answer supersedes the one from the
+     * node the client dialed. Leadership can move between the roster read and
+     * the replay, so each freshly bound hop rechecks the roster under a bounded
+     * redirect budget.
+     *
+     * @returns The leader's login response, or undefined when the client stays
+     */
+    async _settleOnLeader(loginCommand, loginPayload) {
+        let settledResponse;
+        for (let redirects = 0; redirects < MAX_LEADER_REDIRECTS; redirects += 1) {
+            const leader = await this._readLeaderEndpoint();
+            if (!leader || this.connection.isConnectedTo(leader.host, leader.port))
+                return settledResponse;
+            await this.connection.redirect(leader.host, leader.port);
+            settledResponse = await this.sendCommand(loginCommand, loginPayload, { last: false });
+        }
+        debug(`leader settlement reached its ${MAX_LEADER_REDIRECTS}-hop budget, ` +
+            'staying on the current node');
+        return settledResponse;
+    }
+    /**
+     * Reads the cluster roster and picks the endpoint to settle on.
+     *
+     * Best effort: an unreadable roster, `Unauthenticated` included (the session
+     * died between the login and this read), keeps the client on its current
+     * node instead of failing a login that already succeeded.
+     */
+    async _readLeaderEndpoint() {
+        // A cluster can be transiently leaderless: a restarted node cedes the
+        // primaryship its stale view assigns it, and the roster reports no leader
+        // until the peers' election completes. That window is roughly one heartbeat
+        // timeout, so poll through it rather than settling on a replica that denies
+        // every replicated command for its whole retry budget.
+        const deadline = Date.now() + this.leaderlessWaitBudget;
+        while (true) {
+            // Reading without a session would re-enter authentication, which awaits
+            // the very login this settlement runs inside of. The session can also die
+            // between polls, so this holds for every pass, not just the first.
+            if (!this.isAuthenticated)
+                return undefined;
+            try {
+                // Queue the metadata fetch instead of writing directly: a bare write
+                // would race an in-flight exchange and both would wake on the same
+                // response event.
+                const response = await this.sendCommand(GET_CLUSTER_METADATA.code, GET_CLUSTER_METADATA.serialize(), { last: false });
+                const metadata = GET_CLUSTER_METADATA.deserialize(response);
+                if (metadata.nodes.length <= 1)
+                    return undefined;
+                const leader = metadata.nodes.find((node) => node.role === 'Leader' && node.status === 'Healthy');
+                if (leader)
+                    return { host: leader.ip, port: leader.endpoints.tcp };
+            }
+            catch (error) {
+                debug('cluster metadata is unreadable, staying on this node', error);
+                return undefined;
             }
-            if (!this.connection.isConnectedTo(leader.ip, leader.endpoints.tcp)) {
-                await this.connection.redirect(leader.ip, leader.endpoints.tcp);
-                continue;
+            if (Date.now() >= deadline) {
+                debug('cluster metadata named no healthy leader within ' +
+                    `${this.leaderlessWaitBudget} ms, staying on this node`);
+                return undefined;
             }
-            return;
+            await delay(this.leaderlessPollInterval);
         }
-        throw new Error('VSR cluster has no healthy leader');
     }
     /**
      * Fails all queued commands with the given error.

package/dist/client/client.socket.test.js

@@ -166,6 +166,12 @@ const vsrConfig = (port) => ({
     credentials: { username: 'iggy', password: 'iggy' },
     reconnect: { enabled: false, interval: 100, maxRetries: 1 }
 });
+/** Shrinks the leaderless poll so a test observes it without waiting on it. */
+const compressLeaderlessPoll = (client, budget) => {
+    const settlement = client;
+    settlement.leaderlessWaitBudget = budget;
+    settlement.leaderlessPollInterval = 1;
+};
 describe('VSR client socket', () => {
     it('exchanges VSR frames over TLS', async () => {
         const server = await startVsrServer((frame, socket) => singleNodeHandler(server.port)(frame, socket), 'TLS');
@@ -197,13 +203,15 @@ describe('VSR client socket', () => {
             assert.equal(response.status, 0);
             const operations = server.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
             assert.deepEqual(operations, [
-                Operation.NonReplicated,
                 Operation.Register,
+                Operation.NonReplicated,
                 Operation.NonReplicated
             ]);
-            const register = server.frames[1];
+            const register = server.frames[0];
             assert.equal(register.readBigUInt64LE(REQUEST_OFFSET.request), 0n);
             assert.equal(register.readBigUInt64LE(REQUEST_OFFSET.session), 0n);
+            const settlement = server.frames[1];
+            assert.equal(settlement.readUInt32LE(REQUEST_OFFSET.reserved), COMMAND_CODE.GetClusterMetadata);
             const request = server.frames[2];
             assert.equal(request.readBigUInt64LE(REQUEST_OFFSET.session), TEST_SESSION);
             assert.equal(request.readUInt32LE(REQUEST_OFFSET.reserved), 60_001);
@@ -292,15 +300,20 @@ describe('VSR client socket', () => {
             await server.close();
         }
     });
-    it('redirects a direct login to the advertised leader before registering', async () => {
+    it('redirects a login to the advertised leader and registers there', async () => {
         const leader = await startVsrServer((frame, socket) => singleNodeHandler(leader.port)(frame, socket));
         const follower = await startVsrServer((frame, socket) => {
-            const code = frame.readUInt32LE(REQUEST_OFFSET.reserved);
-            if (code === COMMAND_CODE.GetClusterMetadata) {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            if (frame.readUInt32LE(REQUEST_OFFSET.reserved) ===
+                COMMAND_CODE.GetClusterMetadata) {
                 socket.write(replyFrame(Operation.NonReplicated, twoNodeMetadataBody(follower.port, leader.port)));
                 return;
             }
-            socket.write(replyFrame(frame.readUInt8(REQUEST_OFFSET.operation), Buffer.alloc(0), 3));
+            socket.write(replyFrame(operation, Buffer.alloc(0), 58));
         });
         const client = new CommandResponseStream(vsrConfig(follower.port));
         try {
@@ -313,12 +326,19 @@ describe('VSR client socket', () => {
             assert.equal(response.status, 0);
             assert.equal(client.isAuthenticated, true);
             const followerOperations = follower.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
-            assert.deepEqual(followerOperations, [Operation.NonReplicated]);
+            assert.deepEqual(followerOperations, [
+                Operation.Register,
+                Operation.NonReplicated
+            ]);
+            await client.sendCommand(60_018, Buffer.alloc(0));
             const leaderOperations = leader.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
             assert.deepEqual(leaderOperations, [
+                Operation.Register,
                 Operation.NonReplicated,
-                Operation.Register
+                Operation.NonReplicated
             ]);
+            assert.equal(leader.frames[2].readUInt32LE(REQUEST_OFFSET.reserved), 60_018);
+            assert.equal(follower.frames.length, 2);
         }
         finally {
             client.destroy();
@@ -326,6 +346,156 @@ describe('VSR client socket', () => {
             await follower.close();
         }
     });
+    it('rechecks leadership after a redirected login', async () => {
+        const leader = await startVsrServer((frame, socket) => singleNodeHandler(leader.port)(frame, socket));
+        const intermediate = await startVsrServer((frame, socket) => {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            socket.write(replyFrame(Operation.NonReplicated, twoNodeMetadataBody(intermediate.port, leader.port)));
+        });
+        const follower = await startVsrServer((frame, socket) => {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            socket.write(replyFrame(Operation.NonReplicated, twoNodeMetadataBody(follower.port, intermediate.port)));
+        });
+        const client = new CommandResponseStream(vsrConfig(follower.port));
+        try {
+            await client.authenticate(vsrConfig(follower.port).credentials);
+            await client.sendCommand(60_019, Buffer.alloc(0));
+            assert.deepEqual(follower.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation)), [Operation.Register, Operation.NonReplicated]);
+            assert.deepEqual(intermediate.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation)), [Operation.Register, Operation.NonReplicated]);
+            assert.equal(leader.frames[2].readUInt32LE(REQUEST_OFFSET.reserved), 60_019);
+        }
+        finally {
+            client.destroy();
+            await follower.close();
+            await intermediate.close();
+            await leader.close();
+        }
+    });
+    it('keeps a single-node login on its node', async () => {
+        const server = await startVsrServer((frame, socket) => singleNodeHandler(server.port)(frame, socket));
+        const client = new CommandResponseStream(vsrConfig(server.port));
+        try {
+            await client.authenticate(vsrConfig(server.port).credentials);
+            const operations = server.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
+            assert.deepEqual(operations, [
+                Operation.Register,
+                Operation.NonReplicated
+            ]);
+            assert.equal(server.frames[1].readUInt32LE(REQUEST_OFFSET.reserved), COMMAND_CODE.GetClusterMetadata);
+            assert.equal(client.isAuthenticated, true);
+        }
+        finally {
+            client.destroy();
+            await server.close();
+        }
+    });
+    it('polls a leaderless roster before redirecting to the elected leader', async () => {
+        const leader = await startVsrServer((frame, socket) => singleNodeHandler(leader.port)(frame, socket));
+        let rosterReads = 0;
+        const follower = await startVsrServer((frame, socket) => {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            rosterReads += 1;
+            // The first answer is mid-election: neither node holds the leader role.
+            socket.write(replyFrame(Operation.NonReplicated, rosterReads === 1
+                ? twoNodeMetadataBody(follower.port, leader.port, 1)
+                : twoNodeMetadataBody(follower.port, leader.port)));
+        });
+        const client = new CommandResponseStream(vsrConfig(follower.port));
+        compressLeaderlessPoll(client, 1_000);
+        try {
+            await client.authenticate(vsrConfig(follower.port).credentials);
+            assert.equal(rosterReads, 2);
+            const leaderOperations = leader.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
+            assert.deepEqual(leaderOperations, [
+                Operation.Register,
+                Operation.NonReplicated
+            ]);
+            assert.equal(client.isAuthenticated, true);
+        }
+        finally {
+            client.destroy();
+            await leader.close();
+            await follower.close();
+        }
+    });
+    it('keeps a login alive when the session dies mid-poll', async () => {
+        let rosterReads = 0;
+        const server = await startVsrServer((frame, socket) => {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            rosterReads += 1;
+            // The roster stays leaderless and the session dies in the same breath.
+            // Polling on without a session would re-enter authentication, which
+            // awaits the login being settled, and the login would never return.
+            socket.write(Buffer.concat([
+                replyFrame(Operation.NonReplicated, twoNodeMetadataBody(server.port, server.port, 1)),
+                evictionFrame(EvictionReason.NoSession)
+            ]));
+        });
+        const client = new CommandResponseStream(vsrConfig(server.port));
+        compressLeaderlessPoll(client, 1_000);
+        try {
+            const outcome = await Promise.race([
+                client.authenticate(vsrConfig(server.port).credentials)
+                    .then(() => 'authenticated'),
+                // Unreferenced so a passing run is not held open by the stall timer.
+                new Promise((resolve) => {
+                    setTimeout(() => resolve('stalled'), 500).unref();
+                })
+            ]);
+            assert.equal(outcome, 'authenticated');
+            assert.equal(rosterReads, 1);
+        }
+        finally {
+            client.destroy();
+            await server.close();
+        }
+    });
+    it('keeps a login on its node when no leader appears in the budget', async () => {
+        const unavailable = await startVsrServer(() => { });
+        const unavailablePort = unavailable.port;
+        await unavailable.close();
+        // The roster marks its leader-role node unhealthy on a dead port, so a
+        // redirect would fail the dial instead of passing unnoticed.
+        const server = await startVsrServer((frame, socket) => {
+            const operation = frame.readUInt8(REQUEST_OFFSET.operation);
+            if (operation === Operation.Register) {
+                socket.write(replyFrame(Operation.Register, registerReplyBody()));
+                return;
+            }
+            socket.write(replyFrame(Operation.NonReplicated, twoNodeMetadataBody(server.port, unavailablePort, 0, 1)));
+        });
+        const client = new CommandResponseStream(vsrConfig(server.port));
+        compressLeaderlessPoll(client, 0);
+        try {
+            await client.authenticate(vsrConfig(server.port).credentials);
+            const operations = server.frames.map((frame) => frame.readUInt8(REQUEST_OFFSET.operation));
+            assert.deepEqual(operations, [
+                Operation.Register,
+                Operation.NonReplicated
+            ]);
+            assert.equal(client.isAuthenticated, true);
+        }
+        finally {
+            client.destroy();
+            await server.close();
+        }
+    });
     it('rejects instead of hanging while a connection attempt is unresolved', async () => {
         const server = await startVsrServer(() => { });
         const port = server.port;
@@ -502,19 +672,6 @@ describe('VSR client socket', () => {
             await server.close();
         }
     });
-    it('rejects a cluster without a healthy leader', async () => {
-        const server = await startVsrServer((frame, socket) => {
-            socket.write(replyFrame(frame.readUInt8(REQUEST_OFFSET.operation), twoNodeMetadataBody(server.port, server.port, 1)));
-        });
-        const client = new CommandResponseStream(vsrConfig(server.port));
-        try {
-            await assert.rejects(() => client.sendCommand(60_010, Buffer.alloc(0)), /VSR cluster has no healthy leader/);
-        }
-        finally {
-            client.destroy();
-            await server.close();
-        }
-    });
     it('shares token authentication between concurrent callers', async () => {
         const server = await startVsrServer((frame, socket) => singleNodeHandler(server.port)(frame, socket));
         const client = new CommandResponseStream({

package/dist/e2e/tls.system.e2e.js

@@ -21,13 +21,11 @@
 // To run them locally:
 //
 //   1. Start the server with TLS:
-//      TODO(hubcio): change to iggy-server once legacy server is removed
-//      (core/server has VSR support)
 //        IGGY_ROOT_USERNAME=iggy IGGY_ROOT_PASSWORD=iggy \
 //        IGGY_TCP_TLS_ENABLED=true \
 //        IGGY_TCP_TLS_CERT_FILE=core/certs/iggy_cert.pem \
 //        IGGY_TCP_TLS_KEY_FILE=core/certs/iggy_key.pem \
-//        cargo r --bin iggy-server-ng --features vsr
+//        cargo r --bin iggy-server
 //
 //   2. Run the tests:
 //        cd foreign/node

package/dist/wire/vsr/header.d.ts

@@ -7,7 +7,15 @@
  */
 /** Size of every consensus header, both directions. */
 export declare const HEADER_SIZE = 256;
-/** `RequestHeader` field offsets the client writes. */
+/**
+ * `RequestHeader` field offsets the client writes.
+ *
+ * The client wire carries no routing namespace: the server derives the
+ * consensus group (plane from `operation`, partition target from the payload)
+ * and stamps it into its own internal header. Everything that followed the
+ * removed field therefore sits eight bytes earlier than in the pre-derivation
+ * layout.
+ */
 export declare const REQUEST_OFFSET: {
     readonly size: 48;
     readonly command: 60;
@@ -15,17 +23,15 @@ export declare const REQUEST_OFFSET: {
     readonly timestamp: 160;
     readonly request: 168;
     readonly operation: 176;
-    readonly namespace: 184;
-    readonly session: 192;
-    readonly reserved: 204;
+    readonly session: 184;
+    readonly reserved: 196;
 };
 /** `ReplyHeader` field offsets the client reads. */
 export declare const REPLY_OFFSET: {
     readonly size: 48;
     readonly command: 60;
     readonly operation: 208;
-    readonly namespace: 216;
-    readonly status: 224;
+    readonly status: 216;
 };
 /** `EvictionHeader` field offsets the client reads. */
 export declare const EVICTION_OFFSET: {
@@ -73,15 +79,13 @@ export type RequestHeaderFields = {
     request: bigint;
     /** `Operation` discriminant. */
     operation: number;
-    /** Routing namespace (u64). */
-    namespace: bigint;
     /** Bound session (u64), or 0n. */
     session: bigint;
     /** Command code for `NonReplicated`, placed in `reserved[0..4]`. */
     nonReplicatedCode?: number;
 };
 /**
- * Encodes a 256-byte request header. Only the seven fields the server reads
+ * Encodes a 256-byte request header. Only the six fields the server reads
  * are written; the checksums stay zero, matching the Rust SDK's contract
  * with the VSR server.
  */

package/dist/wire/vsr/header.js

@@ -24,7 +24,15 @@
  */
 /** Size of every consensus header, both directions. */
 export const HEADER_SIZE = 256;
-/** `RequestHeader` field offsets the client writes. */
+/**
+ * `RequestHeader` field offsets the client writes.
+ *
+ * The client wire carries no routing namespace: the server derives the
+ * consensus group (plane from `operation`, partition target from the payload)
+ * and stamps it into its own internal header. Everything that followed the
+ * removed field therefore sits eight bytes earlier than in the pre-derivation
+ * layout.
+ */
 export const REQUEST_OFFSET = {
     size: 48,
     command: 60,
@@ -32,17 +40,15 @@ export const REQUEST_OFFSET = {
     timestamp: 160,
     request: 168,
     operation: 176,
-    namespace: 184,
-    session: 192,
-    reserved: 204
+    session: 184,
+    reserved: 196
 };
 /** `ReplyHeader` field offsets the client reads. */
 export const REPLY_OFFSET = {
     size: 48,
     command: 60,
     operation: 208,
-    namespace: 216,
-    status: 224
+    status: 216
 };
 /** `EvictionHeader` field offsets the client reads. */
 export const EVICTION_OFFSET = {
@@ -82,7 +88,7 @@ export const EvictionReason = {
 };
 const U64_MASK = 0xffffffffffffffffn;
 /**
- * Encodes a 256-byte request header. Only the seven fields the server reads
+ * Encodes a 256-byte request header. Only the six fields the server reads
  * are written; the checksums stay zero, matching the Rust SDK's contract
  * with the VSR server.
  */
@@ -95,7 +101,6 @@ export const encodeRequestHeader = (fields) => {
     header.writeBigUInt64LE(fields.client >> 64n, REQUEST_OFFSET.client + 8);
     header.writeBigUInt64LE(fields.request, REQUEST_OFFSET.request);
     header.writeUInt8(fields.operation, REQUEST_OFFSET.operation);
-    header.writeBigUInt64LE(fields.namespace, REQUEST_OFFSET.namespace);
     header.writeBigUInt64LE(fields.session, REQUEST_OFFSET.session);
     if (fields.nonReplicatedCode !== undefined)
         header.writeUInt32LE(fields.nonReplicatedCode, REQUEST_OFFSET.reserved);

package/dist/wire/vsr/header.test.js

@@ -25,7 +25,6 @@ describe('VSR request header', () => {
             client,
             request: 0x0102030405060708n,
             operation: 2,
-            namespace: 0x8877665544332211n,
             session: 0x1020304050607080n,
             nonReplicatedCode: 60_001
         });
@@ -36,7 +35,6 @@ describe('VSR request header', () => {
         assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.client + 8), 0x1122334455667788n);
         assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.request), 0x0102030405060708n);
         assert.equal(header.readUInt8(REQUEST_OFFSET.operation), 2);
-        assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.namespace), 0x8877665544332211n);
         assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.session), 0x1020304050607080n);
         assert.equal(header.readUInt32LE(REQUEST_OFFSET.reserved), 60_001);
         assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.timestamp), 0n);
@@ -47,7 +45,6 @@ describe('VSR request header', () => {
             client: 1n,
             request: 0n,
             operation: 1,
-            namespace: 1n << 63n,
             session: 0n
         });
         const expected = Buffer.alloc(HEADER_SIZE);
@@ -55,7 +52,6 @@ describe('VSR request header', () => {
         expected.writeUInt8(Command2.Request, REQUEST_OFFSET.command);
         expected.writeBigUInt64LE(1n, REQUEST_OFFSET.client);
         expected.writeUInt8(1, REQUEST_OFFSET.operation);
-        expected.writeBigUInt64LE(1n << 63n, REQUEST_OFFSET.namespace);
         assert.deepEqual(header, expected);
     });
     it('supports maximum-width unsigned request fields', () => {
@@ -65,7 +61,6 @@ describe('VSR request header', () => {
             client: maximum << 64n | maximum,
             request: maximum,
             operation: 160,
-            namespace: maximum,
             session: maximum
         });
         assert.equal(header.readBigUInt64LE(REQUEST_OFFSET.request), maximum);

package/dist/wire/vsr/index.js

@@ -19,7 +19,6 @@ import { createRequire } from 'node:module';
 import { COMMAND_CODE } from '../command.code.js';
 import { responseError } from '../error.utils.js';
 import { HEADER_SIZE, encodeRequestHeader } from './header.js';
-import { namespaceForRequest } from './namespace.js';
 import { Operation, isPartition, operationForCode, } from './operation.js';
 import { deserializeLoginRegister, serializeLoginRegister, serializeLoginRegisterWithPat, } from './register.js';
 import { decodeResponse } from './reply.js';
@@ -47,7 +46,6 @@ export class VsrSession {
         const operation = registerCommand(command)
             ? Operation.Register
             : operationForCode(command);
-        const namespace = namespaceForRequest(command, payload, operation);
         const size = HEADER_SIZE + payload.length;
         if (size > MAX_U32)
             throw new RangeError('VSR request exceeds the u32 frame-size limit');
@@ -74,7 +72,6 @@ export class VsrSession {
             client: this.state.clientId,
             request,
             operation,
-            namespace,
             session,
             nonReplicatedCode: operation === Operation.NonReplicated ? command : undefined,
         });

package/dist/wire/vsr/vsr.test.js

@@ -33,13 +33,6 @@ describe('VSR custom request framing', () => {
         assert.equal(frame.readUInt32LE(REQUEST_OFFSET.reserved), 60_000);
         assert.deepEqual(frame.subarray(256), payload);
     });
-    it('does not consume a request ID when local routing fails', () => {
-        const session = new VsrSession(7n);
-        session.bind(42n);
-        assert.throws(() => session.encode(COMMAND_CODE.SendMessages, Buffer.alloc(0)));
-        const frame = session.encode(COMMAND_CODE.CreateStream, Buffer.alloc(0));
-        assert.equal(frame.readBigUInt64LE(REQUEST_OFFSET.request), 1n);
-    });
     it('rejects an unbound replicated request with a typed error', () => {
         const session = new VsrSession();
         assert.throws(() => session.encode(COMMAND_CODE.CreateStream, Buffer.alloc(0)), (error) => error instanceof ResponseError && error.errorCode === 40);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.10.0-edge.1",
+  "version": "0.10.0-edge.2",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",
@@ -57,7 +57,7 @@
   "devDependencies": {
     "@commitlint/cli": "21.2.1",
     "@commitlint/config-conventional": "21.2.0",
-    "@cucumber/cucumber": "13.2.0",
+    "@cucumber/cucumber": "13.2.1",
     "@swc-node/register": "1.12.1",
     "@types/debug": "4.1.13",
     "@types/node": "26.1.2",

package/dist/wire/vsr/namespace.d.ts

@@ -1,19 +0,0 @@
-/**
- * Control-plane requests target the metadata replica (shard 0), selected by
- * this exact sentinel. Plain 0 would fall into namespace hashing and land a
- * Register on a peer shard.
- */
-export declare const METADATA_CONSENSUS_NAMESPACE: bigint;
-/** Packs stream / topic / partition ids into a routing namespace. */
-export declare const packNamespace: (streamId: number, topicId: number, partitionId: number) => bigint;
-/**
- * Selects the routing namespace for a request. Partition-plane commands
- * derive it from their own payload; a named stream or topic identifier
- * yields 0 so the server resolves the name.
- *
- * @throws Error mirroring the Rust SDK: invalid-identifier for an
- *   out-of-range field, invalid-command for an undecodable payload, and
- *   feature-unavailable for a partition operation this SDK cannot derive.
- */
-export declare const namespaceForRequest: (code: number, payload: Buffer, operation: number) => bigint;
-//# sourceMappingURL=namespace.d.ts.map

package/dist/wire/vsr/namespace.js

@@ -1,179 +0,0 @@
-// 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.
-//
-/**
- * Namespace packing and the partition-plane payload peeks needed to derive
- * it, ported from `core/binary_protocol/src/namespace.rs` and
- * `namespace_for_request` in `core/sdk/src/vsr.rs`.
- */
-import { COMMAND_CODE } from '../command.code.js';
-import { responseError } from '../error.utils.js';
-import { Operation, isMetadata } from './operation.js';
-/** `IggyError::InvalidCommand`. */
-const INVALID_COMMAND = 3;
-/** `IggyError::FeatureUnavailable`. */
-const FEATURE_UNAVAILABLE = 5;
-/** `IggyError::InvalidIdentifier`. */
-const INVALID_IDENTIFIER = 6;
-const MAX_STREAMS = 4096;
-const MAX_TOPICS = 4096;
-const MAX_PARTITIONS = 1_000_000;
-const bitsRequired = (value) => BigInt(BigInt(value).toString(2).length);
-const TOPIC_SHIFT = bitsRequired(MAX_PARTITIONS - 1);
-const STREAM_SHIFT = TOPIC_SHIFT + bitsRequired(MAX_TOPICS - 1);
-/**
- * Control-plane requests target the metadata replica (shard 0), selected by
- * this exact sentinel. Plain 0 would fall into namespace hashing and land a
- * Register on a peer shard.
- */
-export const METADATA_CONSENSUS_NAMESPACE = 1n << 63n;
-/** Packs stream / topic / partition ids into a routing namespace. */
-export const packNamespace = (streamId, topicId, partitionId) => {
-    validateField(streamId, MAX_STREAMS);
-    validateField(topicId, MAX_TOPICS);
-    validateField(partitionId, MAX_PARTITIONS);
-    return (BigInt(streamId) << STREAM_SHIFT) |
-        (BigInt(topicId) << TOPIC_SHIFT) |
-        BigInt(partitionId);
-};
-/**
- * Selects the routing namespace for a request. Partition-plane commands
- * derive it from their own payload; a named stream or topic identifier
- * yields 0 so the server resolves the name.
- *
- * @throws Error mirroring the Rust SDK: invalid-identifier for an
- *   out-of-range field, invalid-command for an undecodable payload, and
- *   feature-unavailable for a partition operation this SDK cannot derive.
- */
-export const namespaceForRequest = (code, payload, operation) => {
-    if (operation === Operation.Register || operation === Operation.Logout)
-        return METADATA_CONSENSUS_NAMESPACE;
-    if (operation === Operation.NonReplicated || isMetadata(operation))
-        return 0n;
-    switch (code) {
-        case COMMAND_CODE.SendMessages:
-            return namespaceFromSendMessages(payload);
-        case COMMAND_CODE.StoreOffset:
-        case COMMAND_CODE.DeleteConsumerOffset:
-        case COMMAND_CODE.StoreOffset2:
-        case COMMAND_CODE.DeleteConsumerOffset2:
-            return namespaceFromConsumerOffset(payload);
-        case COMMAND_CODE.DeleteSegments:
-            return namespaceFromDeleteSegments(payload);
-        default:
-            // The guard that keeps custom partition operations unreachable.
-            throw responseError(code, FEATURE_UNAVAILABLE);
-    }
-};
-const IDENTIFIER_KIND_NUMERIC = 1;
-const IDENTIFIER_KIND_STRING = 2;
-const peekIdentifier = (payload, offset) => {
-    if (payload.length < offset + 2)
-        throw responseError(0, INVALID_COMMAND);
-    const kind = payload.readUInt8(offset);
-    const length = payload.readUInt8(offset + 1);
-    if (payload.length < offset + 2 + length)
-        throw responseError(0, INVALID_COMMAND);
-    if (kind === IDENTIFIER_KIND_NUMERIC) {
-        if (length !== 4)
-            throw responseError(0, INVALID_COMMAND);
-        return { numeric: payload.readUInt32LE(offset + 2), length: 2 + length };
-    }
-    if (kind === IDENTIFIER_KIND_STRING && length > 0)
-        return { numeric: null, length: 2 + length };
-    throw responseError(0, INVALID_COMMAND);
-};
-const validateField = (value, exclusiveMax) => {
-    if (!Number.isInteger(value) || value < 0 || value >= exclusiveMax)
-        throw responseError(0, INVALID_IDENTIFIER);
-};
-const namespaceFromIds = (stream, topic, partitionId) => {
-    // Named identifiers defer resolution to the server.
-    if (stream.numeric === null || topic.numeric === null)
-        return 0n;
-    return packNamespace(stream.numeric, topic.numeric, partitionId);
-};
-/**
- * `SendMessages`: `[metadata_len u32][stream ident][topic ident]
- * [partitioning kind u8, len u8, value]...`. Only explicit `PartitionId`
- * partitioning is routable under VSR; the broker never picks a partition.
- * TODO(hubcio): Balanced and MessageKey partitioning to be implemented;
- * not decided yet whether it'll be on server side or client side.
- */
-const namespaceFromSendMessages = (payload) => {
-    if (payload.length < 4)
-        throw responseError(COMMAND_CODE.SendMessages, INVALID_COMMAND);
-    const metadataLength = payload.readUInt32LE(0);
-    if (payload.length < 4 + metadataLength)
-        throw responseError(COMMAND_CODE.SendMessages, INVALID_COMMAND);
-    // Rust peeks inside payload[4..4 + metadata_length]; a read past the
-    // declared metadata region must fail rather than spill into message bytes
-    // and derive a namespace the server would never compute.
-    const metadata = payload.subarray(4, 4 + metadataLength);
-    let offset = 0;
-    const stream = peekIdentifier(metadata, offset);
-    offset += stream.length;
-    const topic = peekIdentifier(metadata, offset);
-    offset += topic.length;
-    if (metadata.length < offset + 2)
-        throw responseError(COMMAND_CODE.SendMessages, INVALID_COMMAND);
-    const partitioningKind = metadata.readUInt8(offset);
-    const partitioningLength = metadata.readUInt8(offset + 1);
-    const PARTITIONING_PARTITION_ID = 2;
-    if (partitioningKind !== PARTITIONING_PARTITION_ID)
-        throw responseError(COMMAND_CODE.SendMessages, FEATURE_UNAVAILABLE);
-    if (partitioningLength !== 4 || metadata.length < offset + 2 + 4)
-        throw responseError(COMMAND_CODE.SendMessages, INVALID_COMMAND);
-    const partitionId = metadata.readUInt32LE(offset + 2);
-    return namespaceFromIds(stream, topic, partitionId);
-};
-/**
- * Consumer-offset requests: `[consumer kind u8][consumer ident]
- * [stream ident][topic ident][partition flag u8][partition u32]...`.
- */
-const namespaceFromConsumerOffset = (payload) => {
-    if (payload.length < 1 || (payload.readUInt8(0) !== 1 &&
-        payload.readUInt8(0) !== 2))
-        throw responseError(COMMAND_CODE.StoreOffset, INVALID_COMMAND);
-    let offset = 1;
-    const consumer = peekIdentifier(payload, offset);
-    offset += consumer.length;
-    const stream = peekIdentifier(payload, offset);
-    offset += stream.length;
-    const topic = peekIdentifier(payload, offset);
-    offset += topic.length;
-    if (payload.length < offset + 5)
-        throw responseError(COMMAND_CODE.StoreOffset, INVALID_COMMAND);
-    const hasPartition = payload.readUInt8(offset) === 1;
-    if (!hasPartition)
-        throw responseError(COMMAND_CODE.StoreOffset, INVALID_IDENTIFIER);
-    const partitionId = payload.readUInt32LE(offset + 1);
-    return namespaceFromIds(stream, topic, partitionId);
-};
-/** `DeleteSegments`: `[stream ident][topic ident][partition u32]...`. */
-const namespaceFromDeleteSegments = (payload) => {
-    let offset = 0;
-    const stream = peekIdentifier(payload, offset);
-    offset += stream.length;
-    const topic = peekIdentifier(payload, offset);
-    offset += topic.length;
-    if (payload.length < offset + 4)
-        throw responseError(COMMAND_CODE.DeleteSegments, INVALID_COMMAND);
-    const partitionId = payload.readUInt32LE(offset);
-    return namespaceFromIds(stream, topic, partitionId);
-};
-//# sourceMappingURL=namespace.js.map

package/dist/wire/vsr/namespace.test.d.ts

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

package/dist/wire/vsr/namespace.test.js

@@ -1,133 +0,0 @@
-// 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 { serializeIdentifier } from '../identifier.utils.js';
-import { serializeSendMessages } from '../message/message.utils.js';
-import { Partitioning } from '../message/partitioning.utils.js';
-import { Consumer, serializeStoreOffset } from '../offset/offset.utils.js';
-import { COMMAND_CODE } from '../command.code.js';
-import { ResponseError } from '../error.utils.js';
-import { METADATA_CONSENSUS_NAMESPACE, namespaceForRequest, packNamespace } from './namespace.js';
-import { Operation } from './operation.js';
-describe('VSR namespace routing', () => {
-    it('routes register and logout to metadata consensus', () => {
-        for (const operation of [Operation.Register, Operation.Logout])
-            assert.equal(namespaceForRequest(0, Buffer.alloc(0), operation), METADATA_CONSENSUS_NAMESPACE);
-    });
-    it('routes metadata and non-replicated requests to zero', () => {
-        assert.equal(namespaceForRequest(COMMAND_CODE.CreateStream, Buffer.alloc(0), Operation.CreateStream), 0n);
-        assert.equal(namespaceForRequest(COMMAND_CODE.GetStats, Buffer.alloc(0), Operation.NonReplicated), 0n);
-    });
-    it('packs explicit send-message partition identifiers', () => {
-        const payload = serializeSendMessages(7, 11, [], Partitioning.PartitionId(13));
-        assert.equal(namespaceForRequest(COMMAND_CODE.SendMessages, payload, Operation.SendMessages), packNamespace(7, 11, 13));
-    });
-    it('defers named stream and topic routing to the server', () => {
-        const payload = serializeSendMessages('stream', 'topic', [], Partitioning.PartitionId(1));
-        assert.equal(namespaceForRequest(COMMAND_CODE.SendMessages, payload, Operation.SendMessages), 0n);
-    });
-    it('rejects server-selected message partitioning', () => {
-        const payload = serializeSendMessages(1, 2, [], Partitioning.Balanced);
-        assert.throws(() => namespaceForRequest(COMMAND_CODE.SendMessages, payload, Operation.SendMessages), (error) => error instanceof ResponseError && error.errorCode === 5);
-    });
-    it('routes consumer offsets from their explicit partition', () => {
-        const payload = serializeStoreOffset(1, 2, Consumer.Single, 3, 99n);
-        assert.equal(namespaceForRequest(COMMAND_CODE.StoreOffset, payload, Operation.StoreConsumerOffset), packNamespace(1, 2, 3));
-    });
-    it('routes delete-segments payloads', () => {
-        const payload = Buffer.concat([
-            serializeIdentifier(1),
-            serializeIdentifier(2),
-            Buffer.from([3, 0, 0, 0])
-        ]);
-        assert.equal(namespaceForRequest(COMMAND_CODE.DeleteSegments, payload, Operation.DeleteSegments), packNamespace(1, 2, 3));
-    });
-    it('accepts the maximum packable identifiers', () => {
-        assert.equal(packNamespace(4095, 4095, 999_999), (4095n << 32n) | (4095n << 20n) | 999999n);
-    });
-    it('rejects peeks past the declared send-messages metadata region', () => {
-        const payload = serializeSendMessages(1, 2, [], Partitioning.PartitionId(3));
-        const underDeclared = Buffer.from(payload);
-        // Shrink the declared metadata region so the partitioning bytes sit
-        // outside it; the peek must fail instead of reading them.
-        underDeclared.writeUInt32LE(payload.readUInt32LE(0) - 6, 0);
-        assert.throws(() => namespaceForRequest(COMMAND_CODE.SendMessages, underDeclared, Operation.SendMessages), (error) => error instanceof ResponseError && error.errorCode === 3);
-    });
-    it('rejects unknown codes in partition routing', () => {
-        assert.throws(() => namespaceForRequest(60_001, Buffer.alloc(0), Operation.SendMessages), (error) => error instanceof ResponseError && error.errorCode === 5);
-    });
-    it('requires an explicit consumer-offset partition', () => {
-        const payload = serializeStoreOffset(1, 2, Consumer.Single, 3, 99n);
-        // [kind u8][consumer 6][stream 6][topic 6] puts the partition flag at 19.
-        const withoutPartition = Buffer.from(payload);
-        withoutPartition.writeUInt8(0, 19);
-        assert.throws(() => namespaceForRequest(COMMAND_CODE.StoreOffset, withoutPartition, Operation.StoreConsumerOffset), (error) => error instanceof ResponseError && error.errorCode === 6);
-    });
-    it('rejects namespace fields before masking', () => {
-        for (const [streamId, topicId, partitionId] of [
-            [4096, 0, 0],
-            [0, 4096, 0],
-            [0, 0, 1_000_000]
-        ])
-            assert.throws(() => packNamespace(streamId, topicId, partitionId), (error) => error instanceof ResponseError && error.errorCode === 6);
-    });
-    it('rejects negative and non-integer namespace fields', () => {
-        for (const [streamId, topicId, partitionId] of [
-            [-1, 0, 0],
-            [0, -1, 0],
-            [0, 0, -1],
-            [0.5, 0, 0],
-            [0, Number.NaN, 0]
-        ])
-            assert.throws(() => packNamespace(streamId, topicId, partitionId), (error) => error instanceof ResponseError && error.errorCode === 6);
-    });
-    it('rejects malformed identifiers at every prefix boundary', () => {
-        const payload = serializeSendMessages(1, 2, [], Partitioning.PartitionId(3));
-        for (let length = 0; length < payload.length; length += 1)
-            assert.throws(() => namespaceForRequest(COMMAND_CODE.SendMessages, payload.subarray(0, length), Operation.SendMessages), ResponseError);
-        const invalidKind = Buffer.from(payload);
-        invalidKind.writeUInt8(99, 4);
-        assert.throws(() => namespaceForRequest(COMMAND_CODE.SendMessages, invalidKind, Operation.SendMessages), ResponseError);
-    });
-    it('rejects malformed consumer-offset and delete-segment payloads', () => {
-        const offsetPayload = serializeStoreOffset(1, 2, Consumer.Single, 3, 99n);
-        const invalidConsumerKind = Buffer.from(offsetPayload);
-        invalidConsumerKind.writeUInt8(0, 0);
-        assert.throws(() => namespaceForRequest(COMMAND_CODE.StoreOffset, invalidConsumerKind, Operation.StoreConsumerOffset), ResponseError);
-        for (let length = 1; length < 20; length += 1)
-            assert.throws(() => namespaceForRequest(COMMAND_CODE.StoreOffset, offsetPayload.subarray(0, length), Operation.StoreConsumerOffset), ResponseError);
-        const deletePayload = Buffer.concat([
-            serializeIdentifier(1),
-            serializeIdentifier(2),
-            Buffer.from([3, 0, 0, 0])
-        ]);
-        for (let length = 0; length < deletePayload.length; length += 1)
-            assert.throws(() => namespaceForRequest(COMMAND_CODE.DeleteSegments, deletePayload.subarray(0, length), Operation.DeleteSegments), ResponseError);
-    });
-    it('defers named offset and delete-segment routing to the server', () => {
-        const offsetPayload = serializeStoreOffset('stream', 'topic', Consumer.Single, 3, 99n);
-        assert.equal(namespaceForRequest(COMMAND_CODE.StoreOffset, offsetPayload, Operation.StoreConsumerOffset), 0n);
-        const deletePayload = Buffer.concat([
-            serializeIdentifier('stream'),
-            serializeIdentifier('topic'),
-            Buffer.from([3, 0, 0, 0])
-        ]);
-        assert.equal(namespaceForRequest(COMMAND_CODE.DeleteSegments, deletePayload, Operation.DeleteSegments), 0n);
-    });
-});
-//# sourceMappingURL=namespace.test.js.map