apache-iggy 0.10.0 → 0.10.1-edge.2

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

@@ -16,30 +16,50 @@
 // under the License.
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import { deserializeLoginRegister, IGGY_PROTOCOL_VERSION, serializeLoginRegister, serializeLoginRegisterWithPat } from './register.js';
+import { deserializeLoginRegister, BIND_SECRET_BYTES, IGGY_PROTOCOL_VERSION, serializeBindSession, serializeLoginRegister, serializeLoginRegisterWithPat } from './register.js';
+const BIND_SECRET = Buffer.alloc(BIND_SECRET_BYTES, 0x5a);
 describe('VSR register payloads', () => {
     it('encodes protocol, SDK, credentials, and empty context', () => {
-        const body = serializeLoginRegister('iggy', 'secret', '0.8.1-edge.3');
+        const body = serializeLoginRegister('iggy', 'secret', '0.8.1-edge.3', BIND_SECRET);
         assert.equal(body.readUInt32LE(0), IGGY_PROTOCOL_VERSION);
         assert.match(body.toString('utf8'), /node-sdk/);
         assert.match(body.toString('utf8'), /0\.8\.1-edge\.3/);
         assert.match(body.toString('utf8'), /iggy/);
         assert.match(body.toString('utf8'), /secret/);
+        const secretOffset = 4 + 1 + Buffer.byteLength('node-sdk')
+            + 1 + Buffer.byteLength('0.8.1-edge.3');
+        assert.deepEqual(body.subarray(secretOffset, secretOffset + BIND_SECRET_BYTES), BIND_SECRET);
         assert.equal(body.readUInt32LE(body.length - 4), 0);
     });
     it('uses UTF-8 byte lengths and enforces one-byte bounds', () => {
-        const body = serializeLoginRegister('żółw', 'hasło', '版本');
+        const body = serializeLoginRegister('żółw', 'hasło', '版本', BIND_SECRET);
         assert.equal(body.readUInt8(4), Buffer.byteLength('node-sdk'));
         assert.match(body.toString('utf8'), /żółw/);
-        assert.throws(() => serializeLoginRegister('', 'secret', '1.0.0'), /1\.\.255 bytes/);
-        assert.throws(() => serializeLoginRegister('x'.repeat(256), 'secret', '1.0.0'), /1\.\.255 bytes/);
-        const maximum = serializeLoginRegister('x'.repeat(255), 'secret', '1.0.0');
+        assert.throws(() => serializeLoginRegister('', 'secret', '1.0.0', BIND_SECRET), /1\.\.255 bytes/);
+        assert.throws(() => serializeLoginRegister('x'.repeat(256), 'secret', '1.0.0', BIND_SECRET), /1\.\.255 bytes/);
+        const maximum = serializeLoginRegister('x'.repeat(255), 'secret', '1.0.0', BIND_SECRET);
         assert.match(maximum.toString('utf8'), /x{255}/);
     });
     it('encodes PAT registration and rejects oversized tokens', () => {
-        const body = serializeLoginRegisterWithPat('token', '0.8.1-edge.3');
+        const body = serializeLoginRegisterWithPat('token', '0.8.1-edge.3', BIND_SECRET);
         assert.match(body.toString('utf8'), /token/);
-        assert.throws(() => serializeLoginRegisterWithPat('x'.repeat(256), '0.8.1-edge.3'), /token exceeds/);
+        assert.throws(() => serializeLoginRegisterWithPat('x'.repeat(256), '0.8.1-edge.3', BIND_SECRET), /token exceeds/);
+        const secretOffset = 4 + 1 + Buffer.byteLength('node-sdk')
+            + 1 + Buffer.byteLength('0.8.1-edge.3');
+        assert.deepEqual(body.subarray(secretOffset, secretOffset + BIND_SECRET_BYTES), BIND_SECRET);
+        assert.equal(body.readUInt32LE(body.length - 4), 0);
+    });
+    it('encodes version, shared identity and proof and rejects invalid bounds', () => {
+        const identity = Buffer.alloc(32);
+        identity.writeBigUInt64LE(42n, 16);
+        const body = serializeBindSession(identity, '1.0.0', BIND_SECRET);
+        assert.equal(body.readUInt32LE(0), IGGY_PROTOCOL_VERSION);
+        assert.deepEqual(body.subarray(-64, -32), identity);
+        assert.deepEqual(body.subarray(-32), BIND_SECRET);
+        for (const length of [0, 31, 33]) {
+            assert.throws(() => serializeBindSession(Buffer.alloc(length), '1.0.0', BIND_SECRET), /identity must be 32/);
+            assert.throws(() => serializeLoginRegister('iggy', 'iggy', '1.0.0', Buffer.alloc(length)), /secret must be 32/);
+        }
     });
     it('decodes a complete login response', () => {
         const version = Buffer.from('0.10.3');

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

@@ -7,8 +7,11 @@
  */
 import { ResponseError } from '../error.utils.js';
 export declare class VsrEvictionError extends ResponseError {
-    constructor(errorCode: number);
+    readonly reason?: number | undefined;
+    constructor(errorCode: number, reason?: number | undefined);
 }
+/** Validate correlation before a marked receipt can affect operation or session state. */
+export declare const validateReplyForRequest: (reply: Buffer, request: Buffer, command: number) => void;
 /**
  * Decodes one complete consensus frame into the reply body, stripping the
  * committed result section for result-framed operations and mapping every

package/dist/wire/vsr/reply.js

@@ -22,8 +22,8 @@
  * result section for result-framed operations.
  */
 import { ResponseError, responseError } from '../error.utils.js';
-import { Command, EvictionReason, HEADER_SIZE, peekCommand, readEviction, readReplyOperation, readSize, readStatus } from './header.js';
-import { Operation, isKnownOperation, isResultFramed } from './operation.js';
+import { Command, EvictionReason, HEADER_SIZE, peekCommand, readEviction, readReplyOperation, readSize, readStatus, hasCommittedResult, REQUEST_OFFSET, REPLY_OFFSET } from './header.js';
+import { Operation, isKnownOperation, isResultFramed, requestOperation } from './operation.js';
 /** `IggyError` codes this funnel raises client-side. */
 const INVALID_COMMAND = 3;
 const UNAUTHENTICATED = 40;
@@ -33,15 +33,43 @@ const STALE_CLIENT = 30;
 const INVALID_FORMAT = 4;
 const EMPTY_RESPONSE = 304;
 const INCOMPATIBLE_PROTOCOL_VERSION = 14003;
+const TRANSIENT_NOT_COMMITTED = 57;
+const TRANSIENT_NOT_ACCEPTED = 58;
+const NOT_PRIMARY = 89;
 const RESULT_COUNT_LEN = 4;
 const RESULT_ENTRY_LEN = 8;
 export class VsrEvictionError extends ResponseError {
-    constructor(errorCode) {
+    reason;
+    constructor(errorCode, reason) {
         super(0, errorCode);
+        this.reason = reason;
         this.name = 'VsrEvictionError';
         Object.setPrototypeOf(this, VsrEvictionError.prototype);
     }
 }
+const serverError = (command, code) => {
+    const error = responseError(command, code);
+    error.fromServer = true;
+    return error;
+};
+/** Validate correlation before a marked receipt can affect operation or session state. */
+export const validateReplyForRequest = (reply, request, command) => {
+    const operation = request[REQUEST_OFFSET.operation];
+    const actual = readReplyOperation(reply);
+    if (reply.readBigUInt64LE(REPLY_OFFSET.request) !== request.readBigUInt64LE(REQUEST_OFFSET.request) ||
+        requestOperation(actual) !== operation)
+        throw responseError(command, INVALID_COMMAND, 'reply does not match request');
+    if (!hasCommittedResult(reply))
+        return;
+    const op = reply.readBigUInt64LE(REPLY_OFFSET.op);
+    if (!reply.subarray(REPLY_OFFSET.client, REPLY_OFFSET.client + 16)
+        .equals(request.subarray(REQUEST_OFFSET.client, REQUEST_OFFSET.client + 16)) ||
+        !reply.subarray(REPLY_OFFSET.requestChecksum, REPLY_OFFSET.requestChecksum + 16)
+            .equals(request.subarray(REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16)) ||
+        reply.readBigUInt64LE(REPLY_OFFSET.partitionIncarnation) !== request.readBigUInt64LE(REQUEST_OFFSET.partitionIncarnation) ||
+        op === 0n || op !== reply.readBigUInt64LE(REPLY_OFFSET.commit))
+        throw responseError(command, INVALID_COMMAND, 'committed receipt does not match original request');
+};
 /**
  * Decodes one complete consensus frame into the reply body, stripping the
  * committed result section for result-framed operations and mapping every
@@ -65,12 +93,19 @@ export const decodeResponse = (frame, commandCode = 0) => {
     // A pre-commit denial always ships an empty body; the status channel and
     // the committed result section are mutually exclusive.
     if (status !== 0)
-        throw responseError(commandCode, status);
+        throw serverError(commandCode, status);
     const operation = readReplyOperation(frame);
     if (!isKnownOperation(operation))
         throw responseError(commandCode, INVALID_COMMAND);
     const body = frame.subarray(HEADER_SIZE, size);
-    return splitMetadataResult(operation, body, commandCode);
+    try {
+        return splitMetadataResult(operation, body, commandCode);
+    }
+    catch (error) {
+        if (error instanceof ResponseError && error.fromServer)
+            error.committed = hasCommittedResult(frame) && ![TRANSIENT_NOT_COMMITTED, TRANSIENT_NOT_ACCEPTED, NOT_PRIMARY].includes(error.errorCode);
+        throw error;
+    }
 };
 /**
  * Strips the committed result section leading a result-framed reply body.
@@ -95,7 +130,7 @@ export const splitMetadataResult = (operation, body, commandCode = 0) => {
         // IggyError space.
         const code = body.readUInt32LE(RESULT_COUNT_LEN + 4);
         if (code !== 0)
-            throw responseError(commandCode, code);
+            throw serverError(commandCode, code);
     }
     return body.subarray(sectionLength);
 };
@@ -145,6 +180,6 @@ export const evictionError = (frame) => {
         default:
             errorCode = UNAUTHENTICATED;
     }
-    return new VsrEvictionError(errorCode);
+    return new VsrEvictionError(errorCode, eviction.reason);
 };
 //# sourceMappingURL=reply.js.map

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

@@ -53,7 +53,7 @@ describe('VSR reply decoding', () => {
         assert.throws(() => decodeResponse(frame), ResponseError);
     });
     it('rejects an undeclared reply operation discriminant', () => {
-        for (const operation of [69, 150, 163, 255])
+        for (const operation of [69, 129, 133, 142, 163, 255])
             assert.throws(() => decodeResponse(reply(operation)), (error) => error instanceof ResponseError && error.errorCode === 3);
     });
     it('passes an empty register body through as a terminal failure', () => {
@@ -73,6 +73,16 @@ describe('VSR reply decoding', () => {
         const body = Buffer.concat([Buffer.alloc(4), Buffer.from('stream')]);
         assert.deepEqual(decodeResponse(reply(Operation.CreateStream, body)), Buffer.from('stream'));
     });
+    it('strips the result section of every resolved update reply', () => {
+        for (const operation of [Operation.UpdateStreamResolved, Operation.UpdateTopicResolved,
+            Operation.UpdateUserResolved]) {
+            assert.deepEqual(decodeResponse(reply(operation, Buffer.alloc(4))), Buffer.alloc(0));
+            const refused = Buffer.alloc(12);
+            refused.writeUInt32LE(1, 0);
+            refused.writeUInt32LE(4103, 8);
+            assert.throws(() => decodeResponse(reply(operation, refused), COMMAND_CODE.UpdateResource), (error) => error instanceof ResponseError && error.errorCode === 4103);
+        }
+    });
     it('strips a non-empty successful result section', () => {
         const body = Buffer.alloc(12 + 6);
         body.writeUInt32LE(1, 0);

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

@@ -3,16 +3,19 @@
  *
  * Each client instance generates an ephemeral random `clientId` (u128).
  * After a Register commits, the server assigns a `session` number (commit op
- * number). Every replicated request (metadata and partition) advances a
- * monotonic request watermark; non-replicated requests reuse the current
- * value because they bypass server-side request sequencing.
+ * number). Every request in a bound session advances its shared counter, including
+ * reads and requests on auxiliary connections.
  */
 export declare class ConsensusSession {
     private _clientId;
     private _session;
     private requestCounter;
     private registerConsumed;
+    private sessionRequestStart;
+    readonly bindSecret: Buffer;
+    readonly registerRequestIdentifier: Buffer;
     constructor(clientId?: bigint);
+    reset(): void;
     get clientId(): bigint;
     /** The bound session number, or null before Register commits. */
     get session(): bigint | null;
@@ -21,18 +24,14 @@ export declare class ConsensusSession {
     /** Binds the session after Register commits through consensus. */
     bind(session: bigint): void;
     /**
-     * Begins a registration, re-arming the session for a re-login. A prior
-     * consumed or bound session is replaced wholesale (fresh client id,
-     * unbound), so a repeat login encodes a clean Register instead of tripping
-     * the one-shot guard. Returns the register request id, always 0.
+     * Retains the identity and secret so a lost login reply can be retried.
+     * A new logical session is created only after explicit logout.
      */
     beginRegister(): bigint;
     /**
      * Next application request id, advancing the counter: 1, 2, 3, ...
      * Request 0 is reserved for Register.
      */
-    nextRequestId(): bigint;
-    /** Current counter value without advancing it. */
-    currentRequestId(): bigint;
+    nextRequestId(requireBound?: boolean): bigint;
 }
 //# sourceMappingURL=session.d.ts.map

package/dist/wire/vsr/session.js

@@ -15,26 +15,40 @@
 // specific language governing permissions and limitations
 // under the License.
 import { randomBytes } from 'node:crypto';
+import { BIND_SECRET_BYTES } from './register.js';
 const MAX_U64 = 0xffffffffffffffffn;
+const CLIENT_ID_MASK = (1n << 127n) - 1n;
 /**
  * Consensus-level session state, ported from `core/sdk/src/session.rs`.
  *
  * Each client instance generates an ephemeral random `clientId` (u128).
  * After a Register commits, the server assigns a `session` number (commit op
- * number). Every replicated request (metadata and partition) advances a
- * monotonic request watermark; non-replicated requests reuse the current
- * value because they bypass server-side request sequencing.
+ * number). Every request in a bound session advances its shared counter, including
+ * reads and requests on auxiliary connections.
  */
 export class ConsensusSession {
     _clientId;
     _session;
     requestCounter;
     registerConsumed;
+    sessionRequestStart = 1n;
+    bindSecret;
+    registerRequestIdentifier;
     constructor(clientId) {
         this._clientId = clientId ?? generateClientId();
         this._session = null;
         this.requestCounter = 1n;
         this.registerConsumed = false;
+        this.bindSecret = randomBytes(BIND_SECRET_BYTES);
+        this.registerRequestIdentifier = nonzeroIdentifier();
+    }
+    reset() {
+        this._clientId = generateClientId();
+        this._session = null;
+        this.registerConsumed = false;
+        this.sessionRequestStart = this.requestCounter;
+        randomBytes(BIND_SECRET_BYTES).copy(this.bindSecret);
+        nonzeroIdentifier().copy(this.registerRequestIdentifier);
     }
     get clientId() {
         return this._clientId;
@@ -49,29 +63,21 @@ export class ConsensusSession {
     get hasActivity() {
         return this.registerConsumed ||
             this._session !== null ||
-            this.requestCounter > 1n;
+            this.requestCounter > this.sessionRequestStart;
     }
     /** Binds the session after Register commits through consensus. */
     bind(session) {
-        if (this._session !== null)
+        if (this._session !== null && this._session !== session)
             throw new Error(`session already bound (session=${this._session})`);
         if (session <= 0n)
             throw new Error('session must be > 0');
         this._session = session;
     }
     /**
-     * Begins a registration, re-arming the session for a re-login. A prior
-     * consumed or bound session is replaced wholesale (fresh client id,
-     * unbound), so a repeat login encodes a clean Register instead of tripping
-     * the one-shot guard. Returns the register request id, always 0.
+     * Retains the identity and secret so a lost login reply can be retried.
+     * A new logical session is created only after explicit logout.
      */
     beginRegister() {
-        if (this.registerConsumed || this.isBound) {
-            this._clientId = generateClientId();
-            this._session = null;
-            this.requestCounter = 1n;
-            this.registerConsumed = false;
-        }
         this.registerConsumed = true;
         return 0n;
     }
@@ -79,8 +85,8 @@ export class ConsensusSession {
      * Next application request id, advancing the counter: 1, 2, 3, ...
      * Request 0 is reserved for Register.
      */
-    nextRequestId() {
-        if (!this.isBound)
+    nextRequestId(requireBound = true) {
+        if (requireBound && !this.isBound)
             throw new Error('nextRequestId called before bind');
         if (this.requestCounter === MAX_U64)
             throw new RangeError('VSR request counter exhausted');
@@ -88,15 +94,18 @@ export class ConsensusSession {
         this.requestCounter += 1n;
         return id;
     }
-    /** Current counter value without advancing it. */
-    currentRequestId() {
-        return this.requestCounter;
-    }
 }
-/** Ephemeral random u128, non-zero (retry on the astronomically unlikely 0). */
+function nonzeroIdentifier() {
+    let identifier;
+    do {
+        identifier = randomBytes(16);
+    } while (identifier.every(byte => byte === 0));
+    return identifier;
+}
+/** Keep the top bit clear so generated IDs cannot enter the server-only range. */
 const generateClientId = () => {
     for (;;) {
-        const id = randomBytes(16).reduce((acc, byte) => (acc << 8n) | BigInt(byte), 0n);
+        const id = randomBytes(16).reduce((acc, byte) => (acc << 8n) | BigInt(byte), 0n) & CLIENT_ID_MASK;
         if (id !== 0n)
             return id;
     }

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

@@ -22,7 +22,15 @@ describe('ConsensusSession', () => {
         const session = new ConsensusSession();
         assert.notEqual(session.clientId, 0n);
         assert.equal(session.session, null);
-        assert.equal(session.currentRequestId(), 1n);
+        assert.equal(session.nextRequestId(false), 1n);
+    });
+    it('generates client IDs with the top bit clear', () => {
+        const samples = 64;
+        const clientIdLimit = 1n << 127n;
+        for (let sample = 0; sample < samples; sample++) {
+            const session = new ConsensusSession();
+            assert.ok(session.clientId > 0n && session.clientId < clientIdLimit);
+        }
     });
     it('binds once to a positive server session', () => {
         const session = new ConsensusSession(7n);
@@ -30,6 +38,7 @@ describe('ConsensusSession', () => {
         assert.throws(() => session.bind(0n), /must be > 0/);
         session.bind(42n);
         assert.equal(session.session, 42n);
+        session.bind(42n);
         assert.throws(() => session.bind(43n), /already bound/);
     });
     it('advances metadata IDs monotonically', () => {
@@ -38,7 +47,18 @@ describe('ConsensusSession', () => {
         session.bind(42n);
         assert.equal(session.nextRequestId(), 1n);
         assert.equal(session.nextRequestId(), 2n);
-        assert.equal(session.currentRequestId(), 3n);
+        assert.equal(session.nextRequestId(), 3n);
+    });
+    it('resets activity and identity while preserving the shared request counter', () => {
+        const session = new ConsensusSession(7n);
+        assert.equal(session.hasActivity, false);
+        assert.equal(session.nextRequestId(false), 1n);
+        assert.equal(session.hasActivity, true);
+        session.reset();
+        assert.equal(session.hasActivity, false);
+        assert.notEqual(session.clientId, 7n);
+        assert.equal(session.nextRequestId(false), 2n);
+        assert.equal(session.hasActivity, true);
     });
     it('rejects request IDs before binding and after exhaustion', () => {
         const session = new ConsensusSession(7n);
@@ -47,14 +67,20 @@ describe('ConsensusSession', () => {
         session.requestCounter = 0xffffffffffffffffn;
         assert.throws(() => session.nextRequestId(), /counter exhausted/);
     });
-    it('rearms registration with a fresh client ID', () => {
+    it('retains identity, proof and request numbering across login retries', () => {
         const session = new ConsensusSession(7n);
+        const proof = Buffer.from(session.bindSecret);
         session.beginRegister();
-        session.bind(42n);
         session.beginRegister();
-        assert.equal(session.session, null);
-        assert.equal(session.currentRequestId(), 1n);
-        assert.notEqual(session.clientId, 7n);
+        assert.equal(session.clientId, 7n);
+        assert.deepEqual(session.bindSecret, proof);
+        session.bind(42n);
+        assert.equal(session.nextRequestId(), 1n);
+        assert.equal(session.beginRegister(), 0n);
+        assert.equal(session.session, 42n);
+        assert.equal(session.nextRequestId(), 2n);
+        assert.equal(session.clientId, 7n);
+        assert.deepEqual(session.bindSecret, proof);
     });
 });
 //# sourceMappingURL=session.test.js.map

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

@@ -17,13 +17,64 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { ResponseError } from '../error.utils.js';
-import { HEADER_SIZE, REQUEST_OFFSET } from './header.js';
+import { Command, COMMITTED_RESULT_MARKER, HEADER_SIZE, REPLY_OFFSET, REQUEST_OFFSET } from './header.js';
 import { prepareVsrCommand, VsrSession } from './index.js';
 import { Operation } from './operation.js';
+import { validateReplyForRequest } from './reply.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeSendMessages } from '../message/message.utils.js';
 import { Partitioning } from '../message/partitioning.utils.js';
+const BIND_SECRET = Buffer.alloc(32, 0x5a);
 describe('VSR custom request framing', () => {
+    it('stamps distinct random identifiers for metadata and session requests', () => {
+        const payloads = [Buffer.alloc(0), Buffer.from([1, 2, 3]), Buffer.from('abc')];
+        for (const command of [COMMAND_CODE.LoginRegister, COMMAND_CODE.LoginRegisterWithAccessToken,
+            COMMAND_CODE.LogoutUser, COMMAND_CODE.CreateStream, COMMAND_CODE.DeleteSegments]) {
+            const session = new VsrSession(7n);
+            session.bind(42n);
+            for (const payload of payloads) {
+                const frame = session.encode(command, payload);
+                const another = session.encode(command, payload);
+                const identifier = frame.subarray(REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16);
+                assert.notDeepEqual(identifier, Buffer.alloc(16));
+                const repeated = another.subarray(REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16);
+                if (command === COMMAND_CODE.LoginRegister || command === COMMAND_CODE.LoginRegisterWithAccessToken)
+                    assert.deepEqual(identifier, repeated);
+                else
+                    assert.notDeepEqual(identifier, repeated);
+                assert.deepEqual(frame.subarray(HEADER_SIZE), payload);
+            }
+        }
+    });
+    it('leaves partition and non-replicated request checksums unstamped', () => {
+        const session = new VsrSession(7n);
+        session.bind(42n);
+        for (const command of [COMMAND_CODE.SendMessages, COMMAND_CODE.StoreOffset,
+            COMMAND_CODE.DeleteConsumerOffset, COMMAND_CODE.Ping, COMMAND_CODE.GetPartitionRoute,
+            COMMAND_CODE.BindSession, 60_000]) {
+            const frame = session.encode(command, Buffer.from([1, 2, 3]));
+            assert.deepEqual(frame.subarray(REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16), Buffer.alloc(16), `command ${command}`);
+        }
+    });
+    it('checks marked metadata receipts against their original payload stamp', () => {
+        const session = new VsrSession(7n);
+        session.bind(42n);
+        const request = session.encode(COMMAND_CODE.CreateStream, Buffer.from([1, 2, 3]));
+        const differentPayload = session.encode(COMMAND_CODE.CreateStream, Buffer.from('abc'));
+        const receipt = Buffer.alloc(HEADER_SIZE);
+        receipt.writeUInt32LE(HEADER_SIZE, REPLY_OFFSET.size);
+        receipt[REPLY_OFFSET.command] = Command.Reply;
+        receipt[REPLY_OFFSET.operation] = Operation.CreateStream;
+        receipt[REPLY_OFFSET.reserved] = COMMITTED_RESULT_MARKER;
+        receipt.writeBigUInt64LE(1n, REPLY_OFFSET.op);
+        receipt.writeBigUInt64LE(1n, REPLY_OFFSET.commit);
+        receipt.writeBigUInt64LE(request.readBigUInt64LE(REQUEST_OFFSET.request), REPLY_OFFSET.request);
+        request.copy(receipt, REPLY_OFFSET.client, REQUEST_OFFSET.client, REQUEST_OFFSET.client + 16);
+        request.copy(receipt, REPLY_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16);
+        assert.doesNotThrow(() => validateReplyForRequest(receipt, request, COMMAND_CODE.CreateStream));
+        differentPayload.copy(receipt, REPLY_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16);
+        assert.throws(() => validateReplyForRequest(receipt, request, COMMAND_CODE.CreateStream), (error) => error instanceof ResponseError && error.commandCode === COMMAND_CODE.CreateStream && error.errorCode === 3);
+    });
     it('encodes a custom non-replicated code and opaque payload', () => {
         const session = new VsrSession();
         const payload = Buffer.from([0xAA, 0xBB, 0xCC]);
@@ -37,24 +88,24 @@ describe('VSR custom request framing', () => {
         assert.throws(() => session.encode(COMMAND_CODE.CreateStream, Buffer.alloc(0)), (error) => error instanceof ResponseError && error.errorCode === 40);
     });
     it('rejects a truncated legacy login payload locally', () => {
-        assert.throws(() => prepareVsrCommand(COMMAND_CODE.LoginUser, Buffer.alloc(0)));
-        assert.throws(() => prepareVsrCommand(COMMAND_CODE.LoginUser, Buffer.from([4, 0x69, 0x67])));
+        assert.throws(() => prepareVsrCommand(COMMAND_CODE.LoginUser, Buffer.alloc(0), BIND_SECRET));
+        assert.throws(() => prepareVsrCommand(COMMAND_CODE.LoginUser, Buffer.from([4, 0x69, 0x67]), BIND_SECRET));
     });
     it('converts legacy token login to VSR registration', () => {
         const token = Buffer.from('secret');
-        const prepared = prepareVsrCommand(COMMAND_CODE.LoginWithAccessToken, Buffer.concat([Buffer.from([token.length]), token]));
+        const prepared = prepareVsrCommand(COMMAND_CODE.LoginWithAccessToken, Buffer.concat([Buffer.from([token.length]), token]), BIND_SECRET);
         assert.equal(prepared.command, COMMAND_CODE.LoginRegisterWithAccessToken);
         assert.ok(prepared.payload.includes(token));
         const frame = new VsrSession(7n).encode(prepared.command, prepared.payload);
         assert.equal(frame.readUInt8(REQUEST_OFFSET.operation), Operation.Register);
     });
-    it('does not advance for non-replicated operations', () => {
+    it('assigns distinct request ids to bound reads and writes', () => {
         const session = new VsrSession(7n);
         session.bind(42n);
         const custom = session.encode(60_001, Buffer.alloc(0));
         assert.equal(custom.readBigUInt64LE(REQUEST_OFFSET.request), 1n);
         const metadata = session.encode(COMMAND_CODE.CreateStream, Buffer.alloc(0));
-        assert.equal(metadata.readBigUInt64LE(REQUEST_OFFSET.request), 1n);
+        assert.equal(metadata.readBigUInt64LE(REQUEST_OFFSET.request), 2n);
         assert.equal(metadata.length, HEADER_SIZE);
     });
     it('partition operations consume a distinct id per send', () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.10.1-edge.2",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",
@@ -50,18 +50,17 @@
   "author": "github.com/T1B0",
   "license": "Apache-2.0",
   "dependencies": {
-    "@node-rs/xxhash": "1.7.7",
+    "@node-rs/xxhash": "1.7.8",
     "debug": "4.4.3",
-    "generic-pool": "3.9.0",
     "uuidv7": "1.2.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "21.2.2",
-    "@commitlint/config-conventional": "21.2.2",
-    "@cucumber/cucumber": "13.2.1",
+    "@commitlint/cli": "21.2.3",
+    "@commitlint/config-conventional": "21.2.3",
+    "@cucumber/cucumber": "13.3.0",
     "@swc-node/register": "1.12.1",
     "@types/debug": "4.1.13",
-    "@types/node": "26.4.1",
+    "@types/node": "26.6.4",
     "c8": "^12.0.0",
     "husky": "9.1.7",
     "typescript": "6.0.3",

package/dist/wire/message/flush-unsaved-buffers.command.d.ts

@@ -1,26 +0,0 @@
-import { type Id } from '../identifier.utils.js';
-/**
- * Parameters for the flush unsaved buffers command.
- */
-export type FlushUnsavedBuffer = {
-    /** Stream identifier */
-    streamId: Id;
-    /** Topic identifier */
-    topicId: Id;
-    /** Partition ID to flush */
-    partitionId: number;
-};
-/**
- * Flush unsaved buffers command definition.
- * Forces buffered messages to be persisted to disk.
- */
-export declare const FLUSH_UNSAVED_BUFFERS: {
-    code: number;
-    serialize: ({ streamId, topicId, partitionId }: FlushUnsavedBuffer) => Buffer<ArrayBuffer>;
-    deserialize: (r: import("../../index.js").CommandResponse) => boolean;
-};
-/**
- * Executable flush unsaved buffers command function.
- */
-export declare const flushUnsavedBuffers: (getClient: import("../../index.js").ClientProvider) => (arg: FlushUnsavedBuffer) => Promise<boolean>;
-//# sourceMappingURL=flush-unsaved-buffers.command.d.ts.map

package/dist/wire/message/flush-unsaved-buffers.command.js

@@ -1,36 +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 { serializeFlushUnsavedBuffers } from './message.utils.js';
-import { deserializeVoidResponse } from '../../client/client.utils.js';
-import { wrapCommand } from '../command.utils.js';
-import { COMMAND_CODE } from '../command.code.js';
-/**
- * Flush unsaved buffers command definition.
- * Forces buffered messages to be persisted to disk.
- */
-export const FLUSH_UNSAVED_BUFFERS = {
-    code: COMMAND_CODE.FlushUnsavedBuffers,
-    serialize: ({ streamId, topicId, partitionId }) => {
-        return serializeFlushUnsavedBuffers(streamId, topicId, partitionId);
-    },
-    deserialize: deserializeVoidResponse
-};
-/**
- * Executable flush unsaved buffers command function.
- */
-export const flushUnsavedBuffers = wrapCommand(FLUSH_UNSAVED_BUFFERS);
-//# sourceMappingURL=flush-unsaved-buffers.command.js.map

package/dist/wire/stream/purge-stream.command.d.ts

@@ -1,22 +0,0 @@
-import { type Id } from '../identifier.utils.js';
-/**
- * Parameters for the purge stream command.
- */
-export type PurgeStream = {
-    /** Stream identifier (ID or name) */
-    streamId: Id;
-};
-/**
- * Purge stream command definition.
- * Deletes all messages from a stream while keeping the stream itself.
- */
-export declare const PURGE_STREAM: {
-    code: number;
-    serialize: ({ streamId }: PurgeStream) => Buffer<ArrayBufferLike>;
-    deserialize: (r: import("../../index.js").CommandResponse) => boolean;
-};
-/**
- * Executable purge stream command function.
- */
-export declare const purgeStream: (getClient: import("../../index.js").ClientProvider) => (arg: PurgeStream) => Promise<boolean>;
-//# sourceMappingURL=purge-stream.command.d.ts.map