apache-iggy 0.10.0-edge.3 → 0.10.0-edge.4

package/dist/client/client.connection.js

@@ -21,7 +21,7 @@ import { connect as TLSConnect } from 'node:tls';
 import { debug } from './client.debug.js';
 import { DEFAULT_MAX_RESPONSE_FRAME_SIZE } from './client.config.js';
 import { ProtocolFrameError, ResponseFrameDecoder } from './client.frame.js';
-import { Command2, peekCommand } from '../wire/vsr/header.js';
+import { Command, peekCommand } from '../wire/vsr/header.js';
 import { evictionError } from '../wire/vsr/reply.js';
 /**
  * Creates a TCP socket connection.
@@ -360,7 +360,7 @@ export class IggyConnection extends EventEmitter {
         debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.responseDecoder.hasBufferedData);
         try {
             for (const response of this.responseDecoder.push(data)) {
-                if (peekCommand(response) === Command2.Eviction)
+                if (peekCommand(response) === Command.Eviction)
                     this.emit('eviction', evictionError(response));
                 else
                     this.emit('response', response);

package/dist/client/client.connection.test.js

@@ -21,7 +21,7 @@ import { createServer, } from 'node:net';
 import { describe, it } from 'node:test';
 import { ProtocolFrameError } from './client.frame.js';
 import { IggyConnection } from './client.connection.js';
-import { Command2, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
+import { Command, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
 const FRAME_LIMIT = 2 * HEADER_SIZE;
 const startServer = async () => {
     const server = createServer();
@@ -42,7 +42,7 @@ const connectionConfig = (server) => ({
 const replyFrame = (body) => {
     const frame = Buffer.alloc(HEADER_SIZE + body.length);
     frame.writeUInt32LE(frame.length, REPLY_OFFSET.size);
-    frame.writeUInt8(Command2.Reply, REPLY_OFFSET.command);
+    frame.writeUInt8(Command.Reply, REPLY_OFFSET.command);
     body.copy(frame, HEADER_SIZE);
     return frame;
 };

package/dist/client/client.frame.test.js

@@ -17,12 +17,12 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import { extractResponseFrames, ProtocolFrameError, ResponseFrameDecoder } from './client.frame.js';
-import { Command2, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
+import { Command, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
 const LIMIT = 1024;
 const vsrFrame = (body) => {
     const frame = Buffer.alloc(HEADER_SIZE + body.length);
     frame.writeUInt32LE(frame.length, REPLY_OFFSET.size);
-    frame.writeUInt8(Command2.Reply, REPLY_OFFSET.command);
+    frame.writeUInt8(Command.Reply, REPLY_OFFSET.command);
     body.copy(frame, HEADER_SIZE);
     return frame;
 };

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

@@ -23,7 +23,7 @@ import { describe, it } from 'node:test';
 import { createServer as createTlsServer } from 'node:tls';
 import { COMMAND_CODE } from '../wire/command.code.js';
 import { ResponseError } from '../wire/error.utils.js';
-import { Command2, EVICTION_OFFSET, EvictionReason, HEADER_SIZE, REPLY_OFFSET, REQUEST_OFFSET } from '../wire/vsr/header.js';
+import { Command, EVICTION_OFFSET, EvictionReason, HEADER_SIZE, REPLY_OFFSET, REQUEST_OFFSET } from '../wire/vsr/header.js';
 import { Operation } from '../wire/vsr/operation.js';
 import { VsrEvictionError } from '../wire/vsr/reply.js';
 import { CommandResponseStream } from './client.socket.js';
@@ -64,7 +64,7 @@ const startVsrServer = async (handler, transport = 'TCP') => {
 const replyFrame = (operation, body = Buffer.alloc(0), status = 0) => {
     const frame = Buffer.alloc(HEADER_SIZE + body.length);
     frame.writeUInt32LE(frame.length, REPLY_OFFSET.size);
-    frame.writeUInt8(Command2.Reply, REPLY_OFFSET.command);
+    frame.writeUInt8(Command.Reply, REPLY_OFFSET.command);
     frame.writeUInt8(operation, REPLY_OFFSET.operation);
     frame.writeUInt32LE(status, REPLY_OFFSET.status);
     body.copy(frame, HEADER_SIZE);
@@ -73,7 +73,7 @@ const replyFrame = (operation, body = Buffer.alloc(0), status = 0) => {
 const evictionFrame = (reason) => {
     const frame = Buffer.alloc(HEADER_SIZE);
     frame.writeUInt32LE(HEADER_SIZE, REPLY_OFFSET.size);
-    frame.writeUInt8(Command2.Eviction, REPLY_OFFSET.command);
+    frame.writeUInt8(Command.Eviction, REPLY_OFFSET.command);
     frame.writeUInt8(reason, EVICTION_OFFSET.reason);
     return frame;
 };

package/dist/wire/command.code.d.ts

@@ -28,8 +28,6 @@ export declare const COMMAND_CODE: {
     GetOffset: number;
     StoreOffset: number;
     DeleteConsumerOffset: number;
-    StoreOffset2: number;
-    DeleteConsumerOffset2: number;
     GetStream: number;
     GetStreams: number;
     CreateStream: number;

package/dist/wire/command.code.js

@@ -46,8 +46,6 @@ export const COMMAND_CODE = {
     GetOffset: 120,
     StoreOffset: 121,
     DeleteConsumerOffset: 122,
-    StoreOffset2: 123,
-    DeleteConsumerOffset2: 124,
     GetStream: 200,
     GetStreams: 201,
     CreateStream: 202,

package/dist/wire/error.code.js

@@ -35,11 +35,15 @@ export const translateErrorCode = (code) => {
         case '16': return "Invalid state entry checksum: {0}, expected: {1}, for index: {2}";
         case '19': return "Cannot open database, Path: {0}";
         case '20': return "Resource with key: {0} was not found.";
+        case '21': return "Cannot close WebSocket connection";
         case '30': return "Stale client";
         case '31': return "TCP error";
         case '32': return "QUIC error";
         case '33': return "Invalid server address";
         case '34': return "Invalid client address";
+        case '35': return "Invalid IP address: {0}:{1}";
+        case '36': return "Http error {0}";
+        case '37': return "Invalid API URL: {0}";
         case '40': return "Unauthenticated";
         case '41': return "Unauthorized";
         case '42': return "Invalid credentials";
@@ -56,6 +60,10 @@ export const translateErrorCode = (code) => {
         case '53': return "Invalid personal access token";
         case '54': return "Personal access token: {0} for user with ID: {1} has expired.";
         case '55': return "Users limit reached.";
+        case '56': return "Invalid personal access token expiry";
+        case '57': return "Request transiently not committed; retry";
+        case '58': return "Request transiently not accepted; retry, on any replica";
+        case '59': return "Request already applied; its reply is no longer available";
         case '61': return "Not connected";
         case '63': return "Client shutdown";
         case '64': return "Invalid TLS domain";
@@ -71,6 +79,7 @@ export const translateErrorCode = (code) => {
         case '76': return "Cannot generate JWT";
         case '77': return "Access token is missing";
         case '78': return "Invalid access token";
+        case '79': return "Cannot fetch JWKS from URL: {0}";
         case '80': return "Invalid size bytes";
         case '81': return "Invalid UTF-8";
         case '82': return "Invalid number encoding";
@@ -87,6 +96,11 @@ export const translateErrorCode = (code) => {
         case '304': return "Empty response";
         case '305': return "Cannot create endpoint";
         case '306': return "Cannot parse URL";
+        case '400': return "WebSocket error";
+        case '401': return "WebSocket connection error";
+        case '402': return "WebSocket close error";
+        case '403': return "WebSocket receive error";
+        case '404': return "WebSocket send error";
         // STREAM
         case '1000': return "Cannot create streams directory, Path: {0}";
         case '1001': return "Cannot create stream with ID: {0} directory, Path: {1}";
@@ -99,15 +113,13 @@ export const translateErrorCode = (code) => {
         case '1008': return "Failed to delete stream directory with ID: {0}";
         case '1009': return "Stream with ID: {0} was not found.";
         case '1010': return "Stream with name: {0} was not found.";
-        case '1011': return "Stream with ID: {0} already exists.";
+        case '1011': return "Stream with directory {0} was not found.";
         case '1012': return "Stream with name: {0} already exists.";
         case '1013': return "Invalid stream name";
         case '1014': return "Invalid stream ID";
         case '1015': return "Cannot read streams";
-        case '1016': return "Missing streams";
-        case '1017': return "Missing topics for stream with ID: {0}";
-        case '1018': return "Missing partitions for topic with ID: {0} for stream with ID: {1}.";
         case '1019': return "Max topic size cannot be lower than segment size. Max topic size: {0} < segment size: {1}.";
+        case '1020': return "Too many streams";
         case '2000': return "Cannot create topics directory for stream with ID: {0}, Path: {1}";
         case '2001': return "Failed to create directory for topic with ID: {0} for stream with ID: {1}, Path: {2}";
         case '2002': return "Failed to create topic info file for topic with ID: {0} for stream with ID: {1}.";
@@ -120,13 +132,15 @@ export const translateErrorCode = (code) => {
         case '2009': return "Cannot poll topic";
         case '2010': return "Topic with ID: {0} for stream with ID: {1} was not found.";
         case '2011': return "Topic with name: {0} for stream with ID: {1} was not found.";
-        case '2012': return "Topic with ID: {0} for stream with ID: {1} already exists.";
         case '2013': return "Topic with name: {0} for stream with ID: {1} already exists.";
         case '2014': return "Invalid topic name";
         case '2015': return "Too many partitions";
         case '2016': return "Invalid topic ID";
         case '2017': return "Cannot read topics for stream with ID: {0}";
         case '2018': return "Invalid replication factor";
+        case '2019': return "Invalid partitions count";
+        case '2020': return "Topic directory: {0} not found";
+        case '2021': return "Too many topics";
         // TOPIC
         case '3000': return "Cannot create partition with ID: {0} for stream with ID: {1} and topic with ID: {2}";
         case '3001': return "Failed to create directory for partitions for stream with ID: {0} and topic with ID: {1}";
@@ -143,6 +157,9 @@ export const translateErrorCode = (code) => {
         case '3012': return "Failed to create consumer offsets directory for path: {0}";
         case '3020': return "Failed to read consumers offsets from path: {0}";
         case '3021': return "Consumer offset for consumer with ID: {0} was not found.";
+        case '3022': return "Failed to resolve consumer with ID: {0}";
+        case '3023': return "Cannot open consumer offsets file for path: {0}";
+        case '3013': return "Partition id space exhausted for this topic";
         // MESSAGE
         case '4000': return "Segment not found";
         case '4001': return "Segment with start offset: {0} and partition with ID: {1} is closed";
@@ -172,17 +189,75 @@ export const translateErrorCode = (code) => {
         case '4025': return "Invalid message payload length";
         case '4026': return "Cannot read message checksum";
         case '4027': return "Invalid message checksum: {0}, expected: {1}, for offset: {2}";
-        case '4028': return "Cannot append message to segment at offset: {0}";
+        case '4028': return "Invalid key value length";
+        case '4029': return "Command length error: {0}";
+        case '4030': return "Incorrect Segments Count size: {0}";
+        case '4031': return "Non-zero offset: {0} at index: {1}";
+        case '4032': return "Non-zero timestamp: {0} at index: {1}";
+        case '4033': return "Missing index: {0}";
+        case '4034': return "Invalid indexes byte size: {0}B, should be divisible by 16";
+        case '4035': return "Invalid indexes count: {0}, expected: {1}";
+        case '4036': return "Invalid messages byte size: {0}B, expected: {1}B";
+        case '4037': return "Too small message: {0}B, expected: {1}B";
+        case '4038': return "Invalid message timestamp delta: {0} microseconds exceeds the per-batch limit";
+        case '4039': return "Invalid batch checksum: {0}, expected: {1}, for base offset: {2}";
+        case '4040': return "Invalid header kind code: {0}";
+        case '4041': return "Unsupported option key: {0}";
+        case '4042': return "Invalid option value for key: {0}";
+        case '4043': return "Options block exceeds its limits: {0}";
+        case '4050': return "Cannot sed messages due to client disconnection";
+        case '4051': return "Background send error";
+        case '4052': return "Background send timeout";
+        case '4053': return "Background send buffer is full";
+        case '4054': return "Background worker disconnected";
+        case '4055': return "Background send buffer overflow";
+        case '4057': return "Producer closed";
+        case '4100': return "Invalid offset: {0}";
+        case '4101': return "Invalid reserved field value: {0}, expected: 0";
         // CONSUMER GROUP
-        case '5000': return "Consumer group ID not found";
+        case '5000': return "Consumer group with ID: {0} for topic with ID: {1} was not found.";
         case '5002': return "Invalid consumer group ID";
-        case '5003': return "Consumer group name not found";
-        case '5004': return "Consumer group name already exists";
+        case '5003': return "Consumer group with name: {0} for topic with ID: {1} was not found.";
+        case '5004': return "Consumer group with name: {0} for topic with ID: {1} already exists.";
         case '5005': return "Invalid consumer group name";
-        case '5006': return "Consumer group member not found";
-        case '5007': return "Cannot create consumer group info";
-        case '5008': return "Cannot delete consumer group info";
-        case '5009': return "Consumer group partition not owned";
+        case '5006': return "Consumer group member with client ID: {0} for group with ID: {1} for topic with ID: {2} was not found.";
+        case '5007': return "Failed to create consumer group info file for ID: {0} for topic with ID: {1} for stream with ID: {2}.";
+        case '5008': return "Failed to delete consumer group info file for ID: {0} for topic with ID: {1} for stream with ID: {2}.";
+        case '5009': return "Consumer group member with client ID: {0} does not own partition: {1} at the current generation (rebalance in progress).";
+        case '6000': return "Base offset is missing";
+        case '6001': return "Last offset delta is missing";
+        case '6002': return "Max timestamp is missing";
+        case '6003': return "Length is missing";
+        case '6004': return "Payload is missing";
+        case '7000': return "Cannot read batch base offset";
+        case '7001': return "Cannot read batch length";
+        case '7002': return "Cannot read batch last offset delta";
+        case '7003': return "Cannot read batch maximum timestamp";
+        case '7004': return "Cannot read batch payload";
+        case '8000': return "Invalid connection string";
+        case '9000': return "Snapshot file completion failed";
+        case '10000': return "Cannot serialize resource";
+        case '10001': return "Cannot deserialize resource";
+        case '10002': return "Cannot read file";
+        case '10003': return "Cannot read file metadata";
+        case '10004': return "Cannot seek file";
+        case '10005': return "Cannot append to file";
+        case '10006': return "Cannot write to file";
+        case '10007': return "Cannot overwrite file";
+        case '10008': return "Cannot delete file";
+        case '10009': return "Cannot sync file";
+        case '10010': return "Cannot read index offset";
+        case '10011': return "Cannot read index position";
+        case '10012': return "Cannot read index timestamp";
+        case '10013': return "Timestamp out of range: {0}";
+        case '11000': return "Shard not found for stream ID: {0}, topic ID: {1}, partition ID: {2}";
+        case '11001': return "Shard communication error";
+        case '12000': return "Cannot bind to socket with addr: {0}";
+        case '12001': return "Task execution timeout";
+        case '13000': return "IO error: {0}";
+        case '14000': return "VSR session already bound; reset before re-binding";
+        case '14001': return "VSR session value {0} is invalid (must be non-zero)";
+        case '14003': return "Incompatible binary protocol version: client {}, server accepts [{}, {}]";
         default: return 'error';
     }
 };

package/dist/wire/error.code.test.js

@@ -18,16 +18,16 @@ import assert from 'node:assert/strict';
 import { it } from 'node:test';
 import { translateErrorCode } from './error.code.js';
 it('translates the consumer-group error range', () => {
-    assert.equal(translateErrorCode(5000), 'Consumer group ID not found');
+    assert.equal(translateErrorCode(5000), 'Consumer group with ID: {0} for topic with ID: {1} was not found.');
     assert.equal(translateErrorCode(5001), 'error');
     assert.equal(translateErrorCode(5002), 'Invalid consumer group ID');
-    assert.equal(translateErrorCode(5003), 'Consumer group name not found');
-    assert.equal(translateErrorCode(5004), 'Consumer group name already exists');
+    assert.equal(translateErrorCode(5003), 'Consumer group with name: {0} for topic with ID: {1} was not found.');
+    assert.equal(translateErrorCode(5004), 'Consumer group with name: {0} for topic with ID: {1} already exists.');
     assert.equal(translateErrorCode(5005), 'Invalid consumer group name');
-    assert.equal(translateErrorCode(5006), 'Consumer group member not found');
-    assert.equal(translateErrorCode(5007), 'Cannot create consumer group info');
-    assert.equal(translateErrorCode(5008), 'Cannot delete consumer group info');
-    assert.equal(translateErrorCode(5009), 'Consumer group partition not owned');
+    assert.equal(translateErrorCode(5006), 'Consumer group member with client ID: {0} for group with ID: {1} for topic with ID: {2} was not found.');
+    assert.equal(translateErrorCode(5007), 'Failed to create consumer group info file for ID: {0} for topic with ID: {1} for stream with ID: {2}.');
+    assert.equal(translateErrorCode(5008), 'Failed to delete consumer group info file for ID: {0} for topic with ID: {1} for stream with ID: {2}.');
+    assert.equal(translateErrorCode(5009), 'Consumer group member with client ID: {0} does not own partition: {1} at the current generation (rebalance in progress).');
     assert.equal(translateErrorCode(5010), 'error');
 });
 //# sourceMappingURL=error.code.test.js.map

package/dist/wire/message/iggy-header.utils.d.ts

@@ -1,5 +1,99 @@
 /**
- * Iggy message header containing metadata for each message.
+ * Size of the batch header in bytes.
+ * Layout: u64 (partitionId) + u64 (baseOffset) + u64 (baseTimestamp) +
+ * u64 (originTimestamp) + u64 (batchLength) + u64 (batchChecksum) +
+ * u32 (messageCount) + zero padding up to 256 bytes.
+ */
+export declare const BATCH_HEADER_SIZE = 256;
+/**
+ * Size of the per-message frame header in bytes.
+ * Layout: u64 (checksum) + u128 (id) + u32 (offsetDelta) +
+ * u32 (timestampDelta) + u32 (userHeadersLength) + u32 (payloadLength) +
+ * u64 (reserved).
+ */
+export declare const FRAME_HEADER_SIZE = 48;
+/**
+ * Batch header describing a run of message frames.
+ */
+export type BatchHeader = {
+    /** Partition the batch belongs to (zero when sent by a client) */
+    partitionId: bigint;
+    /** Offset of the first message in the batch (zero when sent by a client) */
+    baseOffset: bigint;
+    /** Server timestamp of the batch in microseconds (zero when sent by a client) */
+    baseTimestamp: bigint;
+    /** Smallest origin timestamp of the batched messages in microseconds */
+    originTimestamp: bigint;
+    /** Total batch size in bytes, header included */
+    batchLength: bigint;
+    /** XXH3-64 checksum of the batch header fields and frame checksums */
+    batchChecksum: bigint;
+    /** Number of message frames in the batch */
+    messageCount: number;
+};
+/**
+ * Per-message frame header.
+ */
+export type FrameHeader = {
+    /** XXH3-64 checksum of the frame past this field, payload and user headers included */
+    checksum: bigint;
+    /** Unique message identifier */
+    id: bigint;
+    /** Index of the message within the batch */
+    offsetDelta: number;
+    /** Message origin timestamp minus batch origin timestamp in microseconds */
+    timestampDelta: number;
+    /** Length of user-defined headers in bytes */
+    userHeadersLength: number;
+    /** Length of message payload in bytes */
+    payloadLength: number;
+    /** Reserved for future use, must be zero */
+    reserved: bigint;
+};
+/**
+ * Serializes a batch header to its 256-byte wire format.
+ *
+ * @param header - Batch header to serialize
+ * @returns Serialized batch header buffer
+ */
+export declare const serializeBatchHeader: (header: BatchHeader) => Buffer;
+/**
+ * Deserializes a batch header from a buffer.
+ *
+ * @param b - Buffer containing the serialized batch header
+ * @param pos - Starting position in the buffer
+ * @returns Parsed BatchHeader object
+ */
+export declare const deserializeBatchHeader: (b: Buffer, pos?: number) => BatchHeader;
+/**
+ * Deserializes a frame header from a buffer.
+ *
+ * @param b - Buffer containing the serialized frame header
+ * @param pos - Starting position in the buffer
+ * @returns Parsed FrameHeader object
+ */
+export declare const deserializeFrameHeader: (b: Buffer, pos?: number) => FrameHeader;
+/**
+ * Computes the XXH3-64 checksum of a complete frame.
+ * Covers everything past the checksum field: the remaining frame header,
+ * the payload, and the user headers.
+ *
+ * @param frame - Complete frame buffer [header][payload][user headers]
+ * @returns Frame checksum
+ */
+export declare const frameChecksum: (frame: Buffer) => bigint;
+/**
+ * Computes the XXH3-64 checksum of a batch.
+ * Covers the batch header fields up to the checksum, the message count,
+ * and each frame checksum in message order.
+ *
+ * @param header - Batch header fields, batchChecksum ignored
+ * @param frameChecksums - Frame checksums in message order
+ * @returns Batch checksum
+ */
+export declare const batchChecksum: (header: Omit<BatchHeader, "batchChecksum" | "messageCount">, frameChecksums: bigint[]) => bigint;
+/**
+ * Iggy message header containing metadata for each polled message.
  */
 export type IggyMessageHeader = {
     /** Message checksum for integrity verification */
@@ -19,21 +113,6 @@ export type IggyMessageHeader = {
     /** Reserved for future use */
     reserved: bigint;
 };
-/**
- * Size of the Iggy message header in bytes.
- * Layout: u64 (checksum) + u128 (id) + u64 (offset) + u64 (timestamp) + u64 (originTimestamp) + u32 (userHeadersLength) + u32 (payloadLength) + u64 (reserved)
- */
-export declare const IGGY_MESSAGE_HEADER_SIZE: number;
-/**
- * Serializes an Iggy message header to wire format.
- * Sets checksum, offset, and timestamp to zero (filled by server).
- *
- * @param id - Message ID as 16-byte buffer
- * @param payload - Message payload
- * @param userHeaders - Serialized user headers
- * @returns Serialized header buffer
- */
-export declare const serializeIggyMessageHeader: (id: Buffer, payload: Buffer, userHeaders: Buffer) => Buffer<ArrayBuffer>;
 /**
  * Deserializes a message ID from a 16-byte buffer to BigInt.
  *
@@ -41,12 +120,4 @@ export declare const serializeIggyMessageHeader: (id: Buffer, payload: Buffer, u
  * @returns Message ID as BigInt
  */
 export declare const deserialiseMessageId: (b: Buffer) => bigint;
-/**
- * Deserializes Iggy message headers from a buffer.
- *
- * @param b - Buffer containing the serialized header
- * @returns Parsed IggyMessageHeader object
- * @throws Error if buffer length doesn't match expected header size
- */
-export declare const deserializeIggyMessageHeaders: (b: Buffer) => IggyMessageHeader;
 //# sourceMappingURL=iggy-header.utils.d.ts.map

package/dist/wire/message/iggy-header.utils.js

@@ -15,62 +15,109 @@
 // specific language governing permissions and limitations
 // under the License.
 //
-import { toDate } from "../serialize.utils.js";
+import { xxh3 } from "@node-rs/xxhash";
 import { u128LEBufToBigint } from "../number.utils.js";
 /**
- * Size of the Iggy message header in bytes.
- * Layout: u64 (checksum) + u128 (id) + u64 (offset) + u64 (timestamp) + u64 (originTimestamp) + u32 (userHeadersLength) + u32 (payloadLength) + u64 (reserved)
+ * Size of the batch header in bytes.
+ * Layout: u64 (partitionId) + u64 (baseOffset) + u64 (baseTimestamp) +
+ * u64 (originTimestamp) + u64 (batchLength) + u64 (batchChecksum) +
+ * u32 (messageCount) + zero padding up to 256 bytes.
  */
-export const IGGY_MESSAGE_HEADER_SIZE = 8 + 16 + 8 + 8 + 8 + 4 + 4 + 8;
+export const BATCH_HEADER_SIZE = 256;
 /**
- * Serializes an Iggy message header to wire format.
- * Sets checksum, offset, and timestamp to zero (filled by server).
+ * Size of the per-message frame header in bytes.
+ * Layout: u64 (checksum) + u128 (id) + u32 (offsetDelta) +
+ * u32 (timestampDelta) + u32 (userHeadersLength) + u32 (payloadLength) +
+ * u64 (reserved).
+ */
+export const FRAME_HEADER_SIZE = 48;
+/** Size of the frame checksum field prefixing the frame header. */
+const FRAME_CHECKSUM_SIZE = 8;
+/**
+ * Serializes a batch header to its 256-byte wire format.
  *
- * @param id - Message ID as 16-byte buffer
- * @param payload - Message payload
- * @param userHeaders - Serialized user headers
- * @returns Serialized header buffer
+ * @param header - Batch header to serialize
+ * @returns Serialized batch header buffer
  */
-export const serializeIggyMessageHeader = (id, payload, userHeaders) => {
-    const b = Buffer.allocUnsafe(IGGY_MESSAGE_HEADER_SIZE);
-    b.writeBigUInt64LE(0n, 0); // checksum u64
-    b.fill(id, 8, 24); // id u128
-    b.writeBigUInt64LE(0n, 24); // offset u64
-    b.writeBigUInt64LE(0n, 32); // timestamp u64
-    b.writeBigUint64LE(BigInt(new Date().getTime()), 40); // originTimestamp u64
-    b.writeUInt32LE(userHeaders.length, 48); // userHeaders len u32
-    b.writeUInt32LE(payload.length, 52); // payload len u32
-    b.writeBigUInt64LE(0n, 56); // reserved u64
+export const serializeBatchHeader = (header) => {
+    const b = Buffer.alloc(BATCH_HEADER_SIZE);
+    b.writeBigUInt64LE(header.partitionId, 0);
+    b.writeBigUInt64LE(header.baseOffset, 8);
+    b.writeBigUInt64LE(header.baseTimestamp, 16);
+    b.writeBigUInt64LE(header.originTimestamp, 24);
+    b.writeBigUInt64LE(header.batchLength, 32);
+    b.writeBigUInt64LE(header.batchChecksum, 40);
+    b.writeUInt32LE(header.messageCount, 48);
     return b;
 };
 /**
- * Deserializes a message ID from a 16-byte buffer to BigInt.
+ * Deserializes a batch header from a buffer.
  *
- * @param b - 16-byte buffer containing the message ID
- * @returns Message ID as BigInt
+ * @param b - Buffer containing the serialized batch header
+ * @param pos - Starting position in the buffer
+ * @returns Parsed BatchHeader object
  */
-export const deserialiseMessageId = (b) => u128LEBufToBigint(b);
+export const deserializeBatchHeader = (b, pos = 0) => ({
+    partitionId: b.readBigUInt64LE(pos),
+    baseOffset: b.readBigUInt64LE(pos + 8),
+    baseTimestamp: b.readBigUInt64LE(pos + 16),
+    originTimestamp: b.readBigUInt64LE(pos + 24),
+    batchLength: b.readBigUInt64LE(pos + 32),
+    batchChecksum: b.readBigUInt64LE(pos + 40),
+    messageCount: b.readUInt32LE(pos + 48),
+});
 /**
- * Deserializes Iggy message headers from a buffer.
+ * Deserializes a frame header from a buffer.
  *
- * @param b - Buffer containing the serialized header
- * @returns Parsed IggyMessageHeader object
- * @throws Error if buffer length doesn't match expected header size
+ * @param b - Buffer containing the serialized frame header
+ * @param pos - Starting position in the buffer
+ * @returns Parsed FrameHeader object
  */
-export const deserializeIggyMessageHeaders = (b) => {
-    if (b.length !== IGGY_MESSAGE_HEADER_SIZE)
-        throw new Error(`deserialize message headers error, length = ${b.length} ` +
-            `expected ${IGGY_MESSAGE_HEADER_SIZE}`);
-    const headers = {
-        checksum: b.readBigUInt64LE(0),
-        id: deserialiseMessageId(b.subarray(8, 24)),
-        offset: b.readBigUInt64LE(24),
-        timestamp: toDate(b.readBigUInt64LE(32)),
-        originTimestamp: toDate(b.readBigUInt64LE(40)),
-        userHeadersLength: b.readUInt32LE(48),
-        payloadLength: b.readUInt32LE(52),
-        reserved: b.readBigUInt64LE(56),
-    };
-    return headers;
+export const deserializeFrameHeader = (b, pos = 0) => ({
+    checksum: b.readBigUInt64LE(pos),
+    id: b.readBigUInt64LE(pos + 8) | (b.readBigUInt64LE(pos + 16) << 64n),
+    offsetDelta: b.readUInt32LE(pos + 24),
+    timestampDelta: b.readUInt32LE(pos + 28),
+    userHeadersLength: b.readUInt32LE(pos + 32),
+    payloadLength: b.readUInt32LE(pos + 36),
+    reserved: b.readBigUInt64LE(pos + 40),
+});
+/**
+ * Computes the XXH3-64 checksum of a complete frame.
+ * Covers everything past the checksum field: the remaining frame header,
+ * the payload, and the user headers.
+ *
+ * @param frame - Complete frame buffer [header][payload][user headers]
+ * @returns Frame checksum
+ */
+export const frameChecksum = (frame) => xxh3.xxh64(frame.subarray(FRAME_CHECKSUM_SIZE));
+/**
+ * Computes the XXH3-64 checksum of a batch.
+ * Covers the batch header fields up to the checksum, the message count,
+ * and each frame checksum in message order.
+ *
+ * @param header - Batch header fields, batchChecksum ignored
+ * @param frameChecksums - Frame checksums in message order
+ * @returns Batch checksum
+ */
+export const batchChecksum = (header, frameChecksums) => {
+    const b = Buffer.allocUnsafe(44 + frameChecksums.length * 8);
+    b.writeBigUInt64LE(header.partitionId, 0);
+    b.writeBigUInt64LE(header.baseOffset, 8);
+    b.writeBigUInt64LE(header.baseTimestamp, 16);
+    b.writeBigUInt64LE(header.originTimestamp, 24);
+    b.writeBigUInt64LE(header.batchLength, 32);
+    b.writeUInt32LE(frameChecksums.length, 40);
+    frameChecksums.forEach((checksum, index) => {
+        b.writeBigUInt64LE(checksum, 44 + index * 8);
+    });
+    return xxh3.xxh64(b);
 };
+/**
+ * Deserializes a message ID from a 16-byte buffer to BigInt.
+ *
+ * @param b - 16-byte buffer containing the message ID
+ * @returns Message ID as BigInt
+ */
+export const deserialiseMessageId = (b) => u128LEBufToBigint(b);
 //# sourceMappingURL=iggy-header.utils.js.map

package/dist/wire/message/message-batch.test.d.ts

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