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

package/README.md

@@ -30,6 +30,62 @@ npm i --save apache-iggy
 
 ## basic usage
 
+### Response frame limit
+
+**Compatibility note:** response frames larger than `maxResponseFrameSize` (default 64 MiB) are now rejected and close the connection under both framing modes. This is a behavior change for existing classic-framing clients. Raise the limit in the client configuration when polling very large batches.
+
+### VSR framing
+
+Classic framing remains the default. Select VSR explicitly when connecting to
+an Iggy VSR server:
+
+```typescript
+import { SimpleClient, getRawClient } from "apache-iggy";
+
+const config = {
+  protocol: "vsr" as const,
+  transport: "TCP" as const,
+  options: { host: "127.0.0.1", port: 8090 },
+  credentials: { username: "iggy", password: "iggy" },
+};
+const client = new SimpleClient(getRawClient(config));
+const stats = await client.system.getStats();
+```
+
+VSR is a runtime protocol choice in Node.js, not a build feature. Codes absent
+from the SDK command table use `Operation::NonReplicated` and carry the command
+code in the request header's reserved field. The server remains authoritative
+for classifying or rejecting extension commands.
+
+The same npm package supports both framing modes over TCP and TLS. VSR restricts `Client` to one pooled connection because authentication, request sequencing, and consumer-group assignments belong to one consensus session. Configurations requesting more than one pooled connection fail before a socket is opened.
+
+VSR authentication translates the existing password and personal-access-token
+login APIs into the register handshake required by the consensus protocol. A
+disconnect or eviction invalidates the session, and later work must register a
+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.
+
+`sendBinaryRequest(code, payload)` has the same signature under classic and VSR framing. 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. Classic request bytes remain unchanged.
+
+```typescript
+import { ResponseError } from "apache-iggy";
+
+try {
+  await client.sendBinaryRequest(60_000, Buffer.from("opaque request"));
+} catch (error) {
+  if (error instanceof ResponseError) {
+    console.error(error.commandCode, error.errorCode);
+  }
+}
+```
+
+The client includes its npm package version and the binary protocol crate
+version in VSR registration. An incompatible server rejects registration with
+a protocol-version error instead of accepting a mismatched wire contract.
+
 ```ts
 import { Client } from "apache-iggy";
 
@@ -60,7 +116,8 @@ npm run build
 
 ### test
 
-note: use env var `IGGY_TCP_ADDRESS="host:port"` to set server address for bdd and e2e tests.
+note: use env var `IGGY_TCP_ADDRESS="host:port"` to set the server
+address for bdd and e2e tests.
 
 #### unit tests
 

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

@@ -0,0 +1,6 @@
+import type { ClientConfig, Protocol } from './client.type.js';
+export declare const DEFAULT_MAX_RESPONSE_FRAME_SIZE: number;
+export declare const normalizeClientConfig: (config: ClientConfig) => ClientConfig & {
+    protocol: Protocol;
+};
+//# sourceMappingURL=client.config.d.ts.map

package/dist/client/client.config.js

@@ -0,0 +1,38 @@
+// 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.
+export const DEFAULT_MAX_RESPONSE_FRAME_SIZE = 64 * 1024 * 1024;
+const isProtocol = (value) => value === 'classic' || value === 'vsr';
+export const normalizeClientConfig = (config) => {
+    const protocol = config.protocol ?? 'classic';
+    if (!isProtocol(protocol))
+        throw new TypeError(`unsupported wire protocol: ${String(protocol)}`);
+    const maxResponseFrameSize = config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE;
+    if (!Number.isSafeInteger(maxResponseFrameSize) ||
+        maxResponseFrameSize < 256)
+        throw new TypeError('maxResponseFrameSize must be a safe integer of at least 256 bytes');
+    if (protocol === 'vsr' &&
+        ((config.poolSize?.min ?? 1) > 1 || (config.poolSize?.max ?? 1) > 1))
+        throw new TypeError('VSR clients currently support exactly one pooled connection');
+    return {
+        ...config,
+        protocol,
+        options: { ...config.options },
+        maxResponseFrameSize,
+        ...(protocol === 'vsr' ? { poolSize: { min: 1, max: 1 } } : {})
+    };
+};
+//# sourceMappingURL=client.config.js.map

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

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

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

@@ -0,0 +1,71 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { DEFAULT_MAX_RESPONSE_FRAME_SIZE, normalizeClientConfig } from './client.config.js';
+const config = () => ({
+    transport: 'TCP',
+    options: { host: '127.0.0.1', port: 8090 },
+    credentials: { username: 'iggy', password: 'iggy' }
+});
+describe('normalizeClientConfig', () => {
+    it('defaults to classic without changing classic pool sizing', () => {
+        const normalized = normalizeClientConfig({
+            ...config(),
+            poolSize: { min: 2, max: 4 }
+        });
+        assert.equal(normalized.protocol, 'classic');
+        assert.deepEqual(normalized.poolSize, { min: 2, max: 4 });
+        assert.equal(normalized.maxResponseFrameSize, DEFAULT_MAX_RESPONSE_FRAME_SIZE);
+    });
+    it('restricts VSR to one pooled connection', () => {
+        const normalized = normalizeClientConfig({
+            ...config(),
+            protocol: 'vsr'
+        });
+        assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });
+        assert.throws(() => normalizeClientConfig({
+            ...config(),
+            protocol: 'vsr',
+            poolSize: { max: 2 }
+        }), /exactly one pooled connection/);
+    });
+    it('rejects invalid protocols before opening a socket', () => {
+        assert.throws(() => normalizeClientConfig({
+            ...config(),
+            protocol: 'auto'
+        }), /unsupported wire protocol/);
+    });
+    it('supports VSR over TLS', () => {
+        const normalized = normalizeClientConfig({
+            ...config(),
+            protocol: 'vsr',
+            transport: 'TLS'
+        });
+        assert.equal(normalized.protocol, 'vsr');
+        assert.equal(normalized.transport, 'TLS');
+        assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });
+    });
+    it('rejects unsafe response frame limits', () => {
+        for (const maxResponseFrameSize of [0, 255, 1.5, Number.MAX_VALUE])
+            assert.throws(() => normalizeClientConfig({
+                ...config(),
+                maxResponseFrameSize
+            }), /maxResponseFrameSize/);
+    });
+});
+//# sourceMappingURL=client.config.test.js.map

package/dist/client/client.connection.d.ts

@@ -16,34 +16,54 @@ export declare class IggyConnection extends EventEmitter {
     connecting: boolean;
     /** Whether the connection is being intentionally closed */
     ending: boolean;
-    /** Whether waiting for more data to complete a response */
-    private waitingResponseEnd;
     /** Reconnection configuration */
     private reconnectOption;
     /** Number of reconnection attempts made */
     private reconnectCount;
-    /** Buffer for incomplete response data */
-    private readBuffers;
+    /** Shared promise for concurrent callers waiting on one connection attempt */
+    private connectPromise?;
+    /** Shared promise for callers waiting on automatic reconnection */
+    private reconnectPromise?;
+    /** Endpoint the client was configured with, kept across leader redirects */
+    private readonly seedOptions;
+    /** Incremental response frame decoder */
+    private responseDecoder;
     /**
      * Creates a new IggyConnection.
      *
      * @param config - Client configuration
      */
     constructor(config: ClientConfig);
+    /**
+     * Attaches the lifecycle listeners exactly once per socket instance.
+     * Attaching them in `connect()` would stack duplicate handlers whenever a
+     * failed attempt is retried on the same socket.
+     */
+    private _installSocket;
     /**
      * Establishes the connection to the server.
-     * Sets up event handlers for data, errors, and disconnection.
      *
      * @returns Promise that resolves when connected
      */
-    connect(): Promise<unknown>;
+    connect(): Promise<this>;
+    private _waitForConnection;
     /**
      * Attempts to reconnect to the server.
      * Respects maxRetries limit and emits error when exceeded.
      *
      * @param err - Optional error that triggered the reconnection
      */
-    reconnect(err?: Error): Promise<boolean | undefined>;
+    reconnect(err?: Error): Promise<this | undefined>;
+    private _reconnectUntilConnected;
+    /**
+     * Alternates reconnect dials between the current endpoint and the
+     * configured seed. After a leader redirect the current endpoint may die
+     * with the leader, and the seed is the way back to the rest of the cluster.
+     */
+    private _reconnectTarget;
+    redirect(host: string, port: number): Promise<void>;
+    abort(): void;
+    isConnectedTo(host: string, port: number): boolean;
     /**
      * Destroys the connection and marks it as ending.
      */
@@ -66,6 +86,7 @@ export declare class IggyConnection extends EventEmitter {
      * @param payload - Command payload
      * @returns True if the write was successful
      */
-    writeCommand(command: number, payload: Buffer): boolean;
+    writeCommand(command: number, payload: Buffer): void;
+    writeFrame(frame: Buffer): void;
 }
 //# sourceMappingURL=client.connection.d.ts.map

package/dist/client/client.connection.js

@@ -20,6 +20,10 @@ import { createConnection } from 'node:net';
 import { connect as TLSConnect } from 'node:tls';
 import { serializeCommand } from './client.utils.js';
 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 { evictionError } from '../wire/vsr/reply.js';
 /**
  * Creates a TCP socket connection.
  *
@@ -64,18 +68,14 @@ const DefaultReconnectOption = {
     maxRetries: 12
 };
 /**
- * Recreates a socket after a delay.
- * Used for reconnection attempts.
+ * Waits before a reconnection attempt.
  *
- * @param option - Client configuration
  * @param timer - Delay in milliseconds before recreating
- * @returns Promise resolving to a new socket
+ * @returns Promise resolving after the delay
  */
-function recreate(option, timer = 1000) {
+function waitForReconnect(timer = 1000) {
     return new Promise((resolve) => {
-        setTimeout(() => {
-            resolve(getTransport(option));
-        }, timer);
+        setTimeout(resolve, timer);
     });
 }
 /**
@@ -93,14 +93,18 @@ export class IggyConnection extends EventEmitter {
     connecting;
     /** Whether the connection is being intentionally closed */
     ending;
-    /** Whether waiting for more data to complete a response */
-    waitingResponseEnd;
     /** Reconnection configuration */
     reconnectOption;
     /** Number of reconnection attempts made */
     reconnectCount;
-    /** Buffer for incomplete response data */
-    readBuffers;
+    /** Shared promise for concurrent callers waiting on one connection attempt */
+    connectPromise;
+    /** Shared promise for callers waiting on automatic reconnection */
+    reconnectPromise;
+    /** Endpoint the client was configured with, kept across leader redirects */
+    seedOptions;
+    /** Incremental response frame decoder */
+    responseDecoder;
     /**
      * Creates a new IggyConnection.
      *
@@ -109,46 +113,112 @@ export class IggyConnection extends EventEmitter {
     constructor(config) {
         super();
         this.config = config;
-        this.socket = getTransport(config);
         this.connected = false;
         this.connecting = false;
         this.ending = false;
-        this.waitingResponseEnd = false;
         this.reconnectOption = { ...DefaultReconnectOption, ...config.reconnect };
+        this.seedOptions = { ...config.options };
         this.reconnectCount = 0;
-        this.readBuffers = Buffer.allocUnsafe(0);
+        this.connectPromise = undefined;
+        this.reconnectPromise = undefined;
+        this.responseDecoder = new ResponseFrameDecoder(config.protocol ?? 'classic', config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE);
+        this.socket = this._installSocket(getTransport(config));
     }
     /**
-     * Establishes the connection to the server.
-     * Sets up event handlers for data, errors, and disconnection.
-     *
-     * @returns Promise that resolves when connected
+     * Attaches the lifecycle listeners exactly once per socket instance.
+     * Attaching them in `connect()` would stack duplicate handlers whenever a
+     * failed attempt is retried on the same socket.
      */
-    connect() {
-        this.connecting = true;
-        this.socket.on('data', this._onData.bind(this));
-        this.socket.on('error', async (err) => {
+    _installSocket(socket) {
+        socket.on('data', (data) => {
+            if (this.socket !== socket)
+                return;
+            if (!Buffer.isBuffer(data)) {
+                this.emit('error', new ProtocolFrameError('socket returned text instead of binary data'));
+                socket.destroy();
+                return;
+            }
+            this._onData(data);
+        });
+        socket.on('error', (err) => {
+            if (this.socket !== socket)
+                return;
             debug('socket/error event', err, err.code, this.ending);
-            // errors about disconnections should be ignored during disconnect
             if (this.ending && (err?.code === 'ECONNRESET' || err?.code === 'EPIPE'))
                 return;
-            this.reconnect(err);
+            this.emit('error', err);
         });
-        this.socket.once('end', async (hadError) => {
-            debug('socket/close#END event', hadError);
+        socket.once('connect', () => {
+            if (this.socket !== socket)
+                return;
+            debug('socket/connect event');
+            this.connected = true;
+            this.connecting = false;
+            this.reconnectCount = 0;
+            this.emit('connect');
+        });
+        socket.once('close', (hadError) => {
+            if (this.socket !== socket)
+                return;
+            debug('socket/close event', hadError);
             this.connected = false;
+            this.connecting = false;
+            this.connectPromise = undefined;
+            this._endResponseWait();
             this.emit('disconnected', hadError);
-            this.reconnect();
+            if (!this.ending)
+                void this.reconnect().catch(() => undefined);
         });
-        return new Promise((resolve /**, reject*/) => {
-            this.socket.once('connect', () => {
-                debug('socket/connect event');
-                this.connected = true;
-                this.connecting = false;
-                this.reconnectCount = 0;
-                this.emit('connect');
+        return socket;
+    }
+    /**
+     * Establishes the connection to the server.
+     *
+     * @returns Promise that resolves when connected
+     */
+    connect() {
+        if (this.ending)
+            return Promise.reject(new Error('connection is closed'));
+        if (this.connected)
+            return Promise.resolve(this);
+        if (this.reconnectPromise)
+            return this.reconnectPromise;
+        if (this.connectPromise)
+            return this.connectPromise;
+        if (this.socket.destroyed)
+            this.socket = this._installSocket(getTransport(this.config));
+        this.connecting = true;
+        const socket = this.socket;
+        const connectPromise = this._waitForConnection(socket);
+        this.connectPromise = connectPromise;
+        const clearConnectPromise = () => {
+            if (this.connectPromise === connectPromise)
+                this.connectPromise = undefined;
+        };
+        void connectPromise.then(clearConnectPromise, clearConnectPromise);
+        return connectPromise;
+    }
+    _waitForConnection(socket) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                socket.removeListener('connect', resolveConnect);
+                socket.removeListener('error', rejectConnect);
+                socket.removeListener('close', rejectClosed);
+            };
+            const rejectConnect = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const rejectClosed = () => {
+                rejectConnect(new Error('connection closed before it was established'));
+            };
+            const resolveConnect = () => {
+                cleanup();
                 resolve(this);
-            });
+            };
+            socket.once('error', rejectConnect);
+            socket.once('close', rejectClosed);
+            socket.once('connect', resolveConnect);
         });
     }
     /**
@@ -158,35 +228,128 @@ export class IggyConnection extends EventEmitter {
      * @param err - Optional error that triggered the reconnection
      */
     async reconnect(err) {
+        if (this.ending || this.connected)
+            return;
+        if (this.reconnectPromise)
+            return this.reconnectPromise;
         const { enabled, interval, maxRetries } = this.reconnectOption;
         debug('reconnect# event/reconnect?', {
             reconnect: { enabled, interval, maxRetries },
             count: this.reconnectCount,
             lastError: err
         });
-        if (!enabled || this.reconnectCount > maxRetries) {
-            debug(`reconnect reached maxRetries of ${maxRetries}`, err);
-            return this.emit('error', new Error(`reconnect maxRetries exceeded (count: ${this.reconnectCount})`, { cause: err }));
+        const reconnectPromise = this._reconnectUntilConnected(enabled, interval, maxRetries, err);
+        this.reconnectPromise = reconnectPromise;
+        try {
+            return await reconnectPromise;
+        }
+        catch (error) {
+            if (!this.ending)
+                this.emit('error', error);
+            return;
+        }
+        finally {
+            if (this.reconnectPromise === reconnectPromise)
+                this.reconnectPromise = undefined;
+            this.connecting = false;
         }
-        /** recreate socket */
-        this.connecting = true;
-        this.reconnectCount += 1;
-        this.socket = await recreate(this.config, interval);
-        this.connect();
+    }
+    async _reconnectUntilConnected(enabled, interval, maxRetries, initialError) {
+        let lastError = initialError;
+        let expectedSocket = this.socket;
+        let attempt = 0;
+        while (enabled && this.reconnectCount < maxRetries) {
+            this.connecting = true;
+            this.reconnectCount += 1;
+            await waitForReconnect(interval);
+            if (this.ending)
+                throw new Error('connection is closed', { cause: lastError });
+            // A redirect may replace the socket at any point. Defer to the active
+            // connection instead of dialing the superseded endpoint.
+            if (this.connected || this.socket !== expectedSocket)
+                return this.connect();
+            const options = this._reconnectTarget(attempt);
+            attempt += 1;
+            const socket = this._installSocket(getTransport({ ...this.config, options }));
+            this.socket = socket;
+            expectedSocket = socket;
+            try {
+                await this._waitForConnection(socket);
+                if (this.socket !== socket)
+                    return this.connect();
+                this.config.options = options;
+                return this;
+            }
+            catch (error) {
+                lastError = error instanceof Error
+                    ? error
+                    : new Error(String(error));
+                debug('reconnect attempt failed', lastError);
+            }
+        }
+        debug(`reconnect reached maxRetries of ${maxRetries}`, lastError);
+        throw new Error(`reconnect maxRetries exceeded (count: ${this.reconnectCount})`, { cause: lastError });
+    }
+    /**
+     * Alternates reconnect dials between the current endpoint and the
+     * configured seed. After a leader redirect the current endpoint may die
+     * with the leader, and the seed is the way back to the rest of the cluster.
+     */
+    _reconnectTarget(attempt) {
+        const current = this.config.options;
+        if (this.seedOptions.host === current.host &&
+            this.seedOptions.port === current.port)
+            return current;
+        return attempt % 2 === 0 ? current : this.seedOptions;
+    }
+    async redirect(host, port) {
+        const redirectedOptions = { ...this.config.options, host, port };
+        const redirectedConfig = {
+            ...this.config,
+            options: redirectedOptions
+        };
+        // Destroying the old socket settles any dial still waiting on it. Its
+        // lifecycle listeners stay attached but go inert once the socket is
+        // replaced below, so surface the drop to in-flight exchanges ourselves.
+        this.socket.destroy();
+        this.connected = false;
+        this.connecting = false;
+        this.connectPromise = undefined;
+        this.reconnectPromise = undefined;
+        this._endResponseWait();
+        this.socket = this._installSocket(getTransport(redirectedConfig));
+        this.emit('disconnected', false);
+        await this.connect();
+        this.config.options = redirectedOptions;
+    }
+    abort() {
+        this._endResponseWait();
+        this.socket.destroy();
+    }
+    isConnectedTo(host, port) {
+        const target = normalizeHost(host);
+        if (this.socket.remotePort === port &&
+            normalizeHost(this.socket.remoteAddress) === target)
+            return true;
+        // A roster may advertise a DNS name while the socket reports a resolved
+        // address; falling back to the configured endpoint avoids a redirect to
+        // the peer the client is already connected to.
+        return this.config.options.port === port &&
+            normalizeHost(this.config.options.host) === target;
     }
     /**
      * Destroys the connection and marks it as ending.
      */
     _destroy() {
         this.ending = true;
+        this._endResponseWait();
         this.socket.destroy();
     }
     /**
      * Clears the response buffer and resets the waiting state.
      */
     _endResponseWait() {
-        this.readBuffers = Buffer.allocUnsafe(0);
-        this.waitingResponseEnd = false;
+        this.responseDecoder.clear();
     }
     /**
      * Handles incoming data from the socket.
@@ -195,40 +358,21 @@ export class IggyConnection extends EventEmitter {
      * @param data - Incoming data buffer
      */
     _onData(data) {
-        debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.waitingResponseEnd);
-        // Append new data to any buffered data
-        if (this.waitingResponseEnd && this.readBuffers.length > 0) {
-            data = Buffer.concat([this.readBuffers, data]);
-        }
-        // Keep processing while we have enough data
-        let offset = 0;
-        while (offset < data.length) {
-            const remaining = data.length - offset;
-            // Need at least 8 bytes for the header (4 bytes status + 4 bytes length)
-            if (remaining < 8) {
-                // Buffer the incomplete header and wait for more data
-                this.waitingResponseEnd = true;
-                this.readBuffers = data.subarray(offset);
-                return;
+        debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.responseDecoder.hasBufferedData);
+        try {
+            for (const response of this.responseDecoder.push(data)) {
+                if (this.config.protocol === 'vsr' &&
+                    peekCommand(response) === Command2.Eviction)
+                    this.emit('eviction', evictionError(response));
+                else
+                    this.emit('response', response);
             }
-            // Read the header
-            const responseSize = data.readUInt32LE(offset + 4);
-            const totalSize = 8 + responseSize;
-            // Check if we have the complete response (header + payload)
-            if (remaining < totalSize) {
-                // Buffer the incomplete response and wait for more data
-                this.waitingResponseEnd = true;
-                this.readBuffers = data.subarray(offset);
-                return;
-            }
-            // We have a complete response, extract it and emit
-            const response = data.subarray(offset, offset + totalSize);
-            this.emit('response', response);
-            // Move to the next response
-            offset += totalSize;
         }
-        // All data processed, reset buffers
-        this._endResponseWait();
+        catch (error) {
+            this._endResponseWait();
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            this.socket.destroy();
+        }
     }
     /**
      * Writes a command to the socket.
@@ -239,7 +383,16 @@ export class IggyConnection extends EventEmitter {
      */
     writeCommand(command, payload) {
         const cmd = serializeCommand(command, payload);
-        return this.socket.write(cmd);
+        this.socket.write(cmd);
+    }
+    writeFrame(frame) {
+        this.socket.write(frame);
     }
 }
+const normalizeHost = (host) => {
+    const normalized = (host ?? '').toLowerCase().replace(/^::ffff:/, '');
+    return normalized === 'localhost' || normalized === '::1'
+        ? '127.0.0.1'
+        : normalized;
+};
 //# sourceMappingURL=client.connection.js.map

package/dist/client/client.connection.test.d.ts

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