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

package/README.md

@@ -71,7 +71,13 @@ new session. Transient not-committed responses retry the exact encoded request
 within one bounded deadline. A disconnected mutation is never replayed under a
 new session.
 
-When the server's `[heartbeat]` eviction is enabled, configure the client's `heartbeatInterval` below the server heartbeat interval. Client heartbeats are disabled when `heartbeatInterval` is unset.
+The client pings every `heartbeatInterval` milliseconds, 5000 by default, which
+keeps an idle session alive when the server's `[heartbeat]` eviction is enabled.
+The server evicts a connection silent for 36 s, which is 1.2 x its 30 s
+heartbeat interval. Raising the client interval past that window, or setting it
+to 0 to disable client heartbeats, exposes an idle consumer-group member to
+eviction; a connection holding no group membership is left alone. Any other
+unusable value is rejected instead of silently disabling the heartbeat.
 
 `sendBinaryRequest(code, payload)` sends an arbitrary command code. Known replicated commands use their registered operation, while unknown codes reach the server as non-replicated requests and are rejected by servers that do not register them.
 

package/dist/client/client.config.d.ts

@@ -1,4 +1,11 @@
 import type { ClientConfig } from './client.type.js';
 export declare const DEFAULT_MAX_RESPONSE_FRAME_SIZE: number;
+/**
+ * The server evicts a connection silent for 36 s (1.2 x its 30 s heartbeat
+ * interval). 5 s matches the other SDKs and survives several skipped pings.
+ */
+export declare const DEFAULT_HEARTBEAT_INTERVAL: number;
+/** Node's largest timer delay: setInterval clamps anything above it to 1 ms. */
+export declare const MAX_HEARTBEAT_INTERVAL = 2147483647;
 export declare const normalizeClientConfig: (config: ClientConfig) => ClientConfig;
 //# sourceMappingURL=client.config.d.ts.map

package/dist/client/client.config.js

@@ -15,6 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 export const DEFAULT_MAX_RESPONSE_FRAME_SIZE = 64 * 1024 * 1024;
+/**
+ * The server evicts a connection silent for 36 s (1.2 x its 30 s heartbeat
+ * interval). 5 s matches the other SDKs and survives several skipped pings.
+ */
+export const DEFAULT_HEARTBEAT_INTERVAL = 5 * 1000;
+/** Node's largest timer delay: setInterval clamps anything above it to 1 ms. */
+export const MAX_HEARTBEAT_INTERVAL = 2_147_483_647;
 export const normalizeClientConfig = (config) => {
     const maxResponseFrameSize = config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE;
     if (!Number.isSafeInteger(maxResponseFrameSize) ||
@@ -22,10 +29,20 @@ export const normalizeClientConfig = (config) => {
         throw new TypeError('maxResponseFrameSize must be a safe integer of at least 256 bytes');
     if ((config.poolSize?.min ?? 1) > 1 || (config.poolSize?.max ?? 1) > 1)
         throw new TypeError('VSR clients currently support exactly one pooled connection');
+    // Only 0 disables the heartbeat. Anything else unusable has to throw here:
+    // the default below is nullish-only, so a value that is negative, fractional
+    // or above MAX_HEARTBEAT_INTERVAL reaches setInterval, which clamps it to
+    // 1 ms and floods the server.
+    const heartbeatInterval = config.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL;
+    if (!Number.isSafeInteger(heartbeatInterval) ||
+        heartbeatInterval < 0 ||
+        heartbeatInterval > MAX_HEARTBEAT_INTERVAL)
+        throw new TypeError(`heartbeatInterval must be a safe integer of milliseconds between 0 and ${MAX_HEARTBEAT_INTERVAL} (0 disables heartbeats)`);
     return {
         ...config,
         options: { ...config.options },
         maxResponseFrameSize,
+        heartbeatInterval,
         poolSize: { min: 1, max: 1 }
     };
 };

package/dist/client/client.config.test.js

@@ -16,7 +16,7 @@
 // under the License.
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import { DEFAULT_MAX_RESPONSE_FRAME_SIZE, normalizeClientConfig } from './client.config.js';
+import { DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_MAX_RESPONSE_FRAME_SIZE, normalizeClientConfig } from './client.config.js';
 const config = () => ({
     transport: 'TCP',
     options: { host: '127.0.0.1', port: 8090 },
@@ -27,6 +27,23 @@ describe('normalizeClientConfig', () => {
         const normalized = normalizeClientConfig(config());
         assert.equal(normalized.maxResponseFrameSize, DEFAULT_MAX_RESPONSE_FRAME_SIZE);
     });
+    it('enables the heartbeat by default and honours an explicit interval', () => {
+        assert.equal(DEFAULT_HEARTBEAT_INTERVAL, 5000);
+        assert.equal(normalizeClientConfig(config()).heartbeatInterval, DEFAULT_HEARTBEAT_INTERVAL);
+        assert.equal(normalizeClientConfig({ ...config(), heartbeatInterval: 1000 })
+            .heartbeatInterval, 1000);
+        assert.equal(normalizeClientConfig({ ...config(), heartbeatInterval: 0 })
+            .heartbeatInterval, 0);
+    });
+    it('rejects unusable heartbeat intervals', () => {
+        for (const heartbeatInterval of [
+            -1, -5000, Number.NaN, 1.5, 2_147_483_648, 2 ** 32, Number.MAX_VALUE
+        ])
+            assert.throws(() => normalizeClientConfig({
+                ...config(),
+                heartbeatInterval
+            }), /heartbeatInterval/);
+    });
     it('restricts the client to one pooled connection', () => {
         const normalized = normalizeClientConfig(config());
         assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });

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.js

@@ -519,6 +519,9 @@ export class CommandResponseStream extends EventEmitter {
                 }
             }
         }, interval);
+        // A pending heartbeat must not be the reason the process stays up: a script
+        // that never calls destroy() would otherwise hang on exit.
+        this.heartbeatIntervalHandler.unref();
     }
     /**
      * Returns the underlying socket as a readable stream.

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/client/client.type.d.ts

@@ -125,7 +125,12 @@ export type ClientConfig = {
     poolSize?: PoolSizeOption;
     /** Automatic reconnection configuration */
     reconnect?: ReconnectOption;
-    /** Interval for sending heartbeat pings in milliseconds */
+    /**
+     * Interval for sending heartbeat pings in milliseconds, as an integer
+     * between 0 and Node's timer ceiling. Defaults to 5000. Set to 0 to disable
+     * client heartbeats; any other unusable value is rejected rather than
+     * silently disabling them.
+     */
     heartbeatInterval?: number;
     /** Maximum accepted response frame size in bytes */
     maxResponseFrameSize?: number;

package/dist/debug.js

@@ -16,7 +16,7 @@
 // under the License.
 //
 import assert from 'node:assert/strict';
-import { Client } from './client/index.js';
+import { Client, DEFAULT_HEARTBEAT_INTERVAL } from './client/index.js';
 import { uuidv7, uuidv4 } from 'uuidv7';
 import { groupConsumerStream } from './stream/consumer-stream.js';
 import { PollingStrategy } from './wire/index.js';
@@ -41,7 +41,7 @@ const opt = {
         interval: 10 * 1000,
         maxRetries: 10
     },
-    heartbeatInterval: 5 * 1000
+    heartbeatInterval: DEFAULT_HEARTBEAT_INTERVAL
 };
 const c = new Client(opt);
 const cleanup = async () => {

package/dist/e2e/tcp.topic.e2e.js

@@ -29,8 +29,7 @@ describe('e2e -> topic', async () => {
             name: topicName,
             partitionCount: 0,
             compressionAlgorithm: 1,
-            messageExpiry: 0n,
-            replicationFactor: 1
+            messageExpiry: 0n
         });
         assert.ok(TOPIC);
     });

package/dist/wire/command-set.d.ts

@@ -82,6 +82,7 @@ type MessageAPI = ReturnType<typeof messageAPI>;
 declare const systemAPI: (c: ClientProvider) => {
     ping: (arg: void) => Promise<boolean>;
     getStats: (arg: void) => Promise<import("./system/get-stats.command.js").Stats>;
+    describeOptions: (arg: import("./system/describe-options.command.js").DescribeOptions) => Promise<import("./system/describe-options.command.js").OptionSpec[]>;
 };
 type SystemAPI = ReturnType<typeof systemAPI>;
 declare const clusterAPI: (c: ClientProvider) => {

package/dist/wire/command-set.js

@@ -53,6 +53,7 @@ import { ensureStream } from './stream/ensure-stream.virtual.command.js';
 import { createPartition } from './partition/create-partition.command.js';
 import { deletePartition } from './partition/delete-partition.command.js';
 import { deleteSegments } from './segment/delete-segments.command.js';
+import { describeOptions } from './system/describe-options.command.js';
 import { getStats } from './system/get-stats.command.js';
 import { ping } from './system/ping.command.js';
 import { getClusterMetadata } from './cluster/get-cluster-metadata.command.js';
@@ -137,7 +138,8 @@ const messageAPI = (c) => ({
 });
 const systemAPI = (c) => ({
     ping: ping(c),
-    getStats: getStats(c)
+    getStats: getStats(c),
+    describeOptions: describeOptions(c)
 });
 const clusterAPI = (c) => ({
     getClusterMetadata: getClusterMetadata(c)

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

@@ -3,6 +3,7 @@ export declare const COMMAND_CODE: {
     GetStats: number;
     GetSnapshot: number;
     GetClusterMetadata: number;
+    DescribeOptions: number;
     GetMe: number;
     GetClient: number;
     GetClients: number;
@@ -27,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

@@ -21,6 +21,7 @@ export const COMMAND_CODE = {
     GetStats: 10,
     GetSnapshot: 11, // @TODO GET_SNAPSHOT_FILE_CODE: u32 = 11
     GetClusterMetadata: 12,
+    DescribeOptions: 13,
     GetMe: 20,
     GetClient: 21,
     GetClients: 22,
@@ -45,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/header.type.d.ts

@@ -27,7 +27,7 @@ export type HeaderKindId = keyof HeaderKind;
 /** Numeric values of header kinds */
 export type HeaderKindValue = ValueOf<HeaderKind>;
 /** Reverse mapping from numeric value to header kind name */
-export declare const ReverseHeaderKind: Record<2 | 1 | 10 | 11 | 12 | 5 | 8 | 13 | 3 | 4 | 6 | 7 | 9 | 14 | 15, "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double">;
+export declare const ReverseHeaderKind: Record<2 | 1 | 10 | 11 | 12 | 13 | 5 | 8 | 3 | 4 | 6 | 7 | 9 | 14 | 15, "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double">;
 /** Returns expected byte size for a header kind, or -1 for variable-size kinds */
 export declare const expectedSize: (kind: number) => number;
 /** Raw binary header value */