apache-iggy 0.10.0 → 0.10.1-edge.2

package/dist/client/client.operation.test.js

@@ -0,0 +1,285 @@
+// 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 { COMMAND_CODE } from '../wire/command.code.js';
+import { VsrSession } from '../wire/vsr/index.js';
+import { HEADER_SIZE, REQUEST_OFFSET, EMPTY_PARTITION_CONTEXT } from '../wire/vsr/header.js';
+import { MutationLanes, LaneBlockedError, OperationNotRetainedError } from './client.operation.js';
+import { ResponseError } from '../wire/error.utils.js';
+const body = Buffer.from('frozen body');
+const frameSize = HEADER_SIZE + body.length;
+const session = () => { const state = new VsrSession(1n); state.bind(42n); return state; };
+const enter = (lanes, state, lane, signal = new AbortController().signal, deadline = Date.now() + 1_000) => lanes.enter(lane, COMMAND_CODE.CreateStream, body, EMPTY_PARTITION_CONTEXT, true, state, deadline, signal);
+describe('mutation admission and retained ownership', () => {
+    it('retains the request identifier for a replay and mints one for a restart', async () => {
+        const lanes = new MutationLanes(1, frameSize);
+        const state = session();
+        const operation = await enter(lanes, state, 'metadata');
+        const span = [REQUEST_OFFSET.requestChecksum, REQUEST_OFFSET.requestChecksum + 16];
+        const first = Buffer.from(operation.frame.buffer.subarray(...span));
+        const replay = operation.frame.buffer;
+        assert.deepEqual(replay.subarray(...span), first);
+        await lanes.restart(operation, body, EMPTY_PARTITION_CONTEXT, state, Date.now() + 1_000, new AbortController().signal);
+        assert.notDeepEqual(operation.frame.buffer.subarray(...span), first);
+        lanes.complete(operation);
+    });
+    it('retains one lane while independent groups keep their own order', async () => {
+        const lanes = new MutationLanes(3, 3 * frameSize);
+        const state = session();
+        const first = await enter(lanes, state, 'first');
+        first.uncertain = true;
+        lanes.retain(first);
+        await assert.rejects(enter(lanes, state, 'first'), (error) => error instanceof LaneBlockedError && error.operationId === first.id);
+        const other = await enter(lanes, state, 'other');
+        let admitted = false;
+        const next = enter(lanes, state, 'other').then((operation) => { admitted = true; return operation; });
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(admitted, false);
+        lanes.complete(other);
+        lanes.complete(await next);
+        assert.equal(lanes.retained(first.id), first);
+        lanes.complete(first);
+    });
+    it('preserves FIFO when waiters at the head, middle and tail cancel', async () => {
+        const count = 512;
+        const lanes = new MutationLanes(1, frameSize);
+        const state = session();
+        const active = await enter(lanes, state, 'queued');
+        const controllers = Array.from({ length: count }, () => new AbortController());
+        const admitted = [];
+        const pending = controllers.map((controller, index) => enter(lanes, state, 'queued', controller.signal, Date.now() + 5_000).then((operation) => {
+            admitted.push(index);
+            lanes.complete(operation);
+        }, (error) => { assert.equal(controller.signal.aborted, true, String(error)); }));
+        const cancelled = new Set([0, Math.floor(count / 2), count - 1]);
+        for (const index of cancelled)
+            controllers[index].abort();
+        lanes.complete(active);
+        await Promise.all(pending);
+        assert.deepEqual(admitted, controllers.map((_, index) => index).filter((index) => !cancelled.has(index)));
+    });
+    it('rejects a mutation that cannot fit a positive byte budget', async () => {
+        const lanes = new MutationLanes(1, 1);
+        await assert.rejects(enter(lanes, session(), 'metadata'), ResponseError);
+    });
+    for (const limit of ['count', 'bytes']) {
+        it(`keeps progress polls ordered without consuming the full mutation ${limit} budget`, async () => {
+            const lanes = new MutationLanes(limit === 'count' ? 1 : 3, (limit === 'bytes' ? 1 : 3) * frameSize);
+            const state = session();
+            const cancel = new AbortController();
+            const pending = [];
+            const enterProgress = (lane) => lanes.enter(lane, COMMAND_CODE.PollMessages, body, EMPTY_PARTITION_CONTEXT, false, state, Date.now() + 1_000, cancel.signal);
+            try {
+                const retained = await enter(lanes, state, 'retained');
+                retained.uncertain = true;
+                lanes.retain(retained);
+                await assert.rejects(enterProgress('retained'), (error) => error instanceof LaneBlockedError && error.operationId === retained.id);
+                const first = await enterProgress('progress');
+                const originalId = first.id;
+                await lanes.restart(first, body, EMPTY_PARTITION_CONTEXT, state, Date.now() + 1_000, cancel.signal);
+                assert.equal(first.id, originalId + 1n);
+                let progressAdmitted = false;
+                const progress = enterProgress('progress').then((operation) => { progressAdmitted = true; return operation; });
+                pending.push(progress);
+                let mutationAdmitted = false;
+                const mutation = enter(lanes, state, 'other', cancel.signal).then((operation) => { mutationAdmitted = true; return operation; });
+                pending.push(mutation);
+                await new Promise((resolve) => setImmediate(resolve));
+                assert.equal(progressAdmitted, false);
+                assert.equal(mutationAdmitted, false);
+                lanes.complete(first);
+                lanes.complete(await progress);
+                await new Promise((resolve) => setImmediate(resolve));
+                assert.equal(mutationAdmitted, false);
+                lanes.complete(retained);
+                lanes.complete(await mutation);
+            }
+            finally {
+                cancel.abort();
+                lanes.reset();
+                await Promise.allSettled(pending);
+            }
+        });
+    }
+    it('admits an independent lane when only a later same-lane waiter fits the free bytes', async () => {
+        const sizes = { retained: 900, active: 300, large: 700, small: 500, independent: 500 };
+        const lanes = new MutationLanes(2, 1_500);
+        const state = session();
+        const cancel = new AbortController();
+        const pending = [];
+        const admitted = [];
+        const enterFrame = (lane, size) => lanes.enter(lane, COMMAND_CODE.CreateStream, Buffer.alloc(size - HEADER_SIZE), EMPTY_PARTITION_CONTEXT, true, state, Date.now() + 1_000, cancel.signal);
+        try {
+            const retained = await enterFrame('retained', sizes.retained);
+            retained.uncertain = true;
+            lanes.retain(retained);
+            const active = await enterFrame('active', sizes.active);
+            const large = enterFrame('queued', sizes.large).then((operation) => { admitted.push('large'); return operation; });
+            const small = enterFrame('queued', sizes.small).then((operation) => { admitted.push('small'); return operation; });
+            const independent = enterFrame('independent', sizes.independent).then((operation) => { admitted.push('independent'); return operation; });
+            pending.push(large, small, independent);
+            lanes.complete(active);
+            await new Promise((resolve) => setImmediate(resolve));
+            assert.deepEqual(admitted, ['independent']);
+            lanes.complete(await independent);
+            lanes.complete(retained);
+            lanes.complete(await large);
+            lanes.complete(await small);
+            assert.deepEqual(admitted, ['independent', 'large', 'small']);
+        }
+        finally {
+            cancel.abort();
+            lanes.reset();
+            await Promise.allSettled(pending);
+        }
+    });
+    it('releases logical count immediately but pins bytes through the final writer alias', async () => {
+        const lanes = new MutationLanes(1, 2 * frameSize);
+        const state = session();
+        const first = await enter(lanes, state, 'first');
+        first.frame.retain();
+        lanes.complete(first);
+        const second = await enter(lanes, state, 'second');
+        assert.equal(second.id, first.id + 1n);
+        second.frame.retain();
+        lanes.complete(second);
+        let admitted = false;
+        const third = enter(lanes, state, 'third').then((operation) => { admitted = true; return operation; });
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(admitted, false);
+        first.frame.release();
+        lanes.complete(await third);
+        second.frame.release();
+    });
+    it('checks oversize and expired admission before allocating an operation identity', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, HEADER_SIZE);
+        await assert.rejects(enter(lanes, state, 'oversize'), (error) => error instanceof ResponseError && error.errorCode === 80);
+        assert.equal(state.encode(COMMAND_CODE.Ping, Buffer.alloc(0)).readBigUInt64LE(REQUEST_OFFSET.request), 1n);
+        const expired = new MutationLanes(1, frameSize);
+        await assert.rejects(enter(expired, state, 'expired', undefined, Date.now() - 1), (error) => error instanceof ResponseError && error.errorCode === 58);
+        assert.equal(state.encode(COMMAND_CODE.Ping, Buffer.alloc(0)).readBigUInt64LE(REQUEST_OFFSET.request), 2n);
+    });
+    it('reports a queued admission deadline as not accepted without consuming an identity', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, frameSize);
+        const first = await enter(lanes, state, 'first');
+        await assert.rejects(enter(lanes, state, 'second', undefined, Date.now() + 10), (error) => error instanceof ResponseError && error.errorCode === 58);
+        lanes.complete(first);
+        const next = await enter(lanes, state, 'second');
+        assert.equal(next.id, first.id + 1n);
+        lanes.complete(next);
+    });
+    it('keeps a restarting lane while its old writer pins the entire byte budget', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, frameSize);
+        const first = await enter(lanes, state, 'first');
+        const originalId = first.id;
+        const writer = first.frame;
+        writer.retain();
+        let restarted = false;
+        const restart = lanes.restart(first, body, EMPTY_PARTITION_CONTEXT, state, Date.now() + 1_000, first.lifetime.signal)
+            .then(() => { restarted = true; });
+        let admitted = false;
+        const later = enter(lanes, state, 'first').then((operation) => { admitted = true; return operation; });
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(restarted, false);
+        assert.equal(admitted, false);
+        writer.release();
+        await restart;
+        assert.equal(first.id, originalId + 1n);
+        assert.equal(admitted, false);
+        lanes.complete(first);
+        const next = await later;
+        assert.equal(next.id, first.id + 1n);
+        lanes.complete(next);
+        lanes.complete(await enter(lanes, state, 'independent'));
+    });
+    it('keeps a restart through a reset and frees the bytes of its old writer once', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, frameSize);
+        const first = await enter(lanes, state, 'first');
+        const id = first.id;
+        const writer = first.frame;
+        writer.retain();
+        const restart = lanes.restart(first, body, EMPTY_PARTITION_CONTEXT, state, Date.now() + 1_000, first.lifetime.signal);
+        lanes.reset();
+        writer.release();
+        await restart;
+        assert.ok(lanes.owns(first));
+        assert.notEqual(first.id, id);
+        lanes.complete(first);
+        lanes.complete(await enter(lanes, state, 'first'));
+    });
+    it('cancels budget waiters without copying bodies or consuming identities', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, frameSize);
+        const first = await enter(lanes, state, 'first');
+        const cancel = new AbortController();
+        const waiting = enter(lanes, state, 'other', cancel.signal);
+        cancel.abort();
+        await assert.rejects(waiting);
+        lanes.complete(first);
+        const admitted = await enter(lanes, state, 'other');
+        assert.equal(admitted.id, first.id + 1n);
+        lanes.complete(admitted);
+    });
+    it('serializes concurrent resolvers and frees the slot but not the lane of an abandoned running replay', async () => {
+        const lanes = new MutationLanes(1, 3 * frameSize);
+        const state = session();
+        const operation = await enter(lanes, state, 'first');
+        operation.uncertain = true;
+        lanes.retain(operation);
+        const first = await lanes.acquireResolution(operation, Date.now() + 1_000, operation.lifetime.signal);
+        const waiting = lanes.acquireResolution(operation, Date.now() + 1_000, operation.lifetime.signal);
+        lanes.abandon(operation.id);
+        assert.throws(() => lanes.retained(operation.id), OperationNotRetainedError);
+        lanes.complete(await enter(lanes, state, 'other', undefined, Date.now() + 200));
+        let admitted = false;
+        const next = enter(lanes, state, 'first').then((later) => { admitted = true; return later; });
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(admitted, false);
+        first();
+        await assert.rejects(waiting, OperationNotRetainedError);
+        lanes.complete(await next);
+        const held = await enter(lanes, state, 'other');
+        await assert.rejects(enter(lanes, state, 'last', undefined, Date.now() + 20), (error) => error instanceof ResponseError && error.errorCode === 58);
+        lanes.complete(held);
+    });
+    it('clears retained admission on reset without losing writer byte ownership', async () => {
+        const state = session();
+        const lanes = new MutationLanes(1, frameSize);
+        const old = await enter(lanes, state, 'first');
+        old.frame.retain();
+        old.uncertain = true;
+        lanes.retain(old);
+        lanes.reset();
+        assert.throws(() => lanes.retained(old.id), OperationNotRetainedError);
+        state.reset();
+        state.bind(43n);
+        let admitted = false;
+        const fresh = enter(lanes, state, 'fresh').then((operation) => { admitted = true; return operation; });
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(admitted, false);
+        old.frame.release();
+        const next = await fresh;
+        assert.ok(next.id > old.id);
+        lanes.complete(next);
+    });
+});
+//# sourceMappingURL=client.operation.test.js.map

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

@@ -1,233 +1,116 @@
 import { EventEmitter } from 'node:events';
-import type { ClientConfigOrString, ClientCredentials, CommandResponse, PasswordCredentials, RawClient, SendCommandOptions, TokenCredentials } from '../client/client.type.js';
-export declare class VsrResponseTimeoutError extends Error {
-    constructor(timeout: number);
-}
-/**
- * Manages command execution and response handling for the Iggy server.
- * Implements command queuing, authentication, and heartbeat functionality.
- */
+import type { ClientConfigOrString, ClientCredentials, CommandResponse, PasswordCredentials, RawClient, SendCommandOptions, TokenCredentials } from './client.type.js';
+export { LaneBlockedError, NotConnectedError, OperationNotRetainedError, OperationUncertainError, VsrResponseTimeoutError } from './client.operation.js';
+/** One logical session owns every link, mutation lane and retained operation. */
 export declare class CommandResponseStream extends EventEmitter {
-    /** Client configuration */
-    private options;
-    /** Underlying connection to the server */
-    private connection;
-    /** Queue of pending command jobs */
-    private _execQueue;
-    /** Consensus session used by VSR framing */
-    private vsrSession;
-    /** Shared authentication attempt for concurrent callers */
+    private readonly options;
+    private readonly vsrSession;
+    private readonly lanes;
+    private readonly replicas;
+    private readonly partitionRoutes;
+    private readonly changed;
+    private readonly lifetime;
+    private sessionLifetime;
+    private bootstrap?;
+    private bootstrapPromise?;
+    /**
+     * What the running bootstrap reports when it gives up: the bind failure of
+     * the last endpoint that accepted a dial, else NotConnectedError with the
+     * last dial failure.
+     */
+    private bootstrapFailure?;
     private authenticationPromise?;
-    /** Whether a login is already being moved to the leader */
-    private settlingLeader;
-    /**
-     * The leader re-check a refused request started, shared with every other
-     * request refused by the same node so one demotion moves the client once.
-     */
-    private leaderMoveInFlight?;
+    private sessionAction;
+    private recoveryPromise?;
+    private rosterPromise?;
     /**
-     * Set when a roster walk just redirected this client, so the login that
-     * re-authenticates it stays on the dialed node instead of settling back on
-     * the metadata leader whose partition replica refused the request.
+     * Whom the client signs in as by itself: the caller's last sign-in, else the
+     * configured credentials while the caller never signed in. A logout, a
+     * sign-in of the caller that fails and a refused sign-in clear it.
      */
-    private walkSettleSuppressed;
+    private signInCredentials?;
     /**
-     * Refusals handed out to callers that have not decided what to do with them
-     * yet. The queue holds while any are outstanding: the caller of a refused
-     * command re-checks the leader, and a command written in the meantime goes
-     * out on the socket that check is about to replace.
+     * Raised by each sign-in and sign-out of the caller. A call continues under
+     * a new session only while the lineage it started with is unchanged.
      */
-    private leaderMovesUndecided;
-    /** How long a leaderless roster is polled before settling in place */
-    private leaderlessWaitBudget;
-    /** Delay between roster reads while the cluster elects */
-    private leaderlessPollInterval;
-    /** Calls that have acquired this stream but have not fully settled */
+    private sessionLineage;
+    private knownEndpoints;
+    private readonly configuredEndpoint;
+    private metadataReplica?;
+    private metadataWatermark;
+    private routingGeneration;
+    private activeDials;
     private pendingSubmissions;
-    /** Whether the stream is currently processing a command */
-    busy: boolean;
-    /** Whether the client has been authenticated */
+    private heartbeatIntervalHandler?;
     isAuthenticated: boolean;
-    /** Authenticated user ID */
     userId?: number;
-    /** Heartbeat interval timer handle */
-    heartbeatIntervalHandler?: NodeJS.Timeout;
-    /** Whether a heartbeat ping is still awaiting its response */
-    private heartbeatInFlight;
-    private rememberedCredentials?;
-    private clustered?;
-    private metadataWatermark;
-    private routingGeneration;
-    private pollRoutes;
-    private pollConnections;
-    /**
-     * Creates a new CommandResponseStream.
-     *
-     * @param options - Client configuration
-     */
-    constructor(options: ClientConfigOrString);
-    /**
-     * Initializes the stream by setting up heartbeat and connection event handlers.
-     */
-    _init(): void;
-    /**
-     * Re-submits queued commands through the full send path, so each one
-     * reconnects, re-authenticates and re-checks the leader as if it had just
-     * been called.
-     *
-     * Only for a drop the client caused. Nothing here was written, so there is no
-     * outcome in doubt: a command still in the queue when the socket is replaced
-     * would otherwise fail with a lost-connection error the caller can do nothing
-     * about.
-     */
-    private _reissueQueue;
-    /**
-     * Sends a command to the server.
-     * Automatically handles connection, authentication and leader settlement.
-     *
-     * @param command - Command code to send
-     * @param payload - Command payload buffer
-     * @param options - Response and queue options
-     * @returns Promise resolving to the command response
-     */
+    constructor(config: ClientConfigOrString);
+    get lineage(): number;
+    get busy(): boolean;
     sendCommand(command: number, payload: Buffer, options?: SendCommandOptions): Promise<CommandResponse>;
-    private _queueCommand;
-    /**
-     * Re-reads the roster and moves to the leader it names.
-     *
-     * Best effort: an unreadable roster, or one that still names this node,
-     * leaves the client where it is and the refused request is re-issued anyway.
-     *
-     * Single-flighted, and concurrent callers share the outcome instead of
-     * failing: several commands are refused by the same demoted node, and each
-     * starting its own redirect would move the client once per command. The
-     * first redirect's `'disconnected'` also fails the others' roster reads, so
-     * a caller that raced one would report a refusal it never had to.
-     *
-     * @returns Whether the client moved
-     */
-    private _followLeaderMove;
-    /** Whether a leader move is being decided or carried out. */
-    private _movePending;
-    /**
-     * Releases the queue hold one refusal took, and drains what was held back
-     * once the last of them is decided.
-     */
-    private _releaseUndecidedMove;
-    private _rememberRoster;
-    private _pollOnPrimary;
-    private _pollRoutingControl;
-    private _observeMetadataReply;
+    resolveOperation(operationId: bigint, options?: SendCommandOptions): Promise<void>;
+    abandonOperation(operationId: bigint): void;
+    private replay;
+    private drive;
+    private exchange;
+    private control;
+    private routeFor;
+    /**
+     * Whether the replica that answered a namespace miss on `link` is the
+     * metadata primary. The belief can predate a view change, so one roster read
+     * on `link`, without a retry or another link, must still name that replica.
+     * No lookup reaches a believed metadata primary without a link, so then that
+     * roster also moves the belief.
+     */
+    private isMetadataPrimary;
+    private rememberRoute;
+    private invalidateRoute;
+    private primaryLink;
+    private readyLink;
+    private refreshRoster;
+    private installRoster;
+    private runReplica;
+    /**
+     * Only a heartbeat restarts a link that used its budget, so without one the
+     * link stays down for good.
+     */
+    private budgetFailure;
+    private connectionFor;
+    private connectBootstrap;
+    private serializeSession;
+    private login;
+    private recoverSession;
+    /**
+     * Waits for the sign-in that runs or is queued now, and fails unless it binds
+     * a session of the call's lineage. Only the client's own sign-in continues a
+     * call: after a sign-in or sign-out of the caller, or a refused sign-in, the
+     * call ends with 40, and at its deadline with 58.
+     */
+    private nextSession;
+    /**
+     * The `sessionReset` event says whether the reset ended a signed-in session.
+     * A reset after a refused sign-in ends none.
+     */
+    private resetSession;
+    private ensureLineage;
+    private ensureGeneration;
+    private observeMetadata;
     private _rememberCredentials;
-    private _signInCredentials;
-    private _clearPollRouting;
-    /**
-     * Processes queued commands sequentially.
-     * Emits 'finishQueue' when all commands are processed.
-     *
-     */
-    _processQueue(): Promise<void>;
-    private _emitFinishQueue;
-    /**
-     * Processes a single command by writing it to the connection and waiting for response.
-     *
-     * @param command - Command code
-     * @param payload - Command payload
-     * @param handleResp - Whether to parse the response
-     * @param deadline - When the whole request gives up, shared with the leader
-     * re-checks and the re-issues after a move
-     * @returns Promise resolving to the command response
-     */
-    _processNext(command: number, payload: Buffer, handleResp?: boolean, deadline?: number): Promise<CommandResponse>;
-    private _processVsrLogin;
-    private _processVsr;
-    private _exchange;
-    private isUnloggedCommand;
-    /**
-     * Moves a freshly authenticated session to the cluster leader.
-     *
-     * Only the leader accepts replicated commands, and the roster read is
-     * auth-gated, so the topology cannot be inspected before a login binds a
-     * session. The redirect drops that session along with the socket, so the
-     * login is replayed on the leader and its answer supersedes the one from the
-     * node the client dialed. Leadership can move between the roster read and
-     * the replay, so each freshly bound hop rechecks the roster under a bounded
-     * redirect budget.
-     *
-     * @returns The leader's login response, or undefined when the client stays
-     */
-    private _settleOnLeader;
-    /**
-     * Reads the cluster roster and picks the endpoint to settle on.
-     *
-     * Best effort: an unreadable roster, `Unauthenticated` included (the session
-     * died between the login and this read), keeps the client on its current
-     * node instead of failing a login that already succeeded.
-     */
-    private _readLeaderEndpoint;
-    /**
-     * Fails all queued commands with the given error.
-     *
-     * @param err - Error to reject all queued commands with
-     */
-    _failQueue(err: Error): void;
-    private _resetSession;
     hold(): () => void;
-    /**
-     * Authenticates the client with the server.
-     *
-     * @param creds - Authentication credentials (token or password)
-     * @returns True if authentication succeeded
-     */
-    authenticate(creds: ClientCredentials): Promise<boolean>;
-    private _authenticate;
-    /**
-     * Authenticates using username and password.
-     *
-     * @param creds - Password credentials
-     * @returns Login response with user ID
-     */
-    _authWithPassword(creds: PasswordCredentials): Promise<{
+    authenticate(credentials: ClientCredentials): Promise<boolean>;
+    private loginByCaller;
+    /** Only SDK recovery shares a sign-in; callers always own a fresh attempt. */
+    private signIn;
+    _authWithPassword(credentials: PasswordCredentials): Promise<{
         userId: number;
     }>;
-    /**
-     * Authenticates using a token.
-     *
-     * @param creds - Token credentials
-     * @returns Login response with user ID
-     */
-    _authWithToken(creds: TokenCredentials): Promise<{
+    _authWithToken(credentials: TokenCredentials): Promise<{
         userId: number;
     }>;
-    /**
-     * Sends a ping command to the server.
-     *
-     * @returns Ping response
-     */
     ping(): Promise<boolean>;
-    /**
-     * Starts sending periodic heartbeat pings to keep the connection alive.
-     *
-     * @param interval - Heartbeat interval in milliseconds
-     */
     heartbeat(interval?: number): void;
-    /**
-     * Returns the underlying socket as a readable stream.
-     *
-     * @returns The connection socket
-     */
     getReadStream(): import("node:net").Socket;
-    /**
-     * Destroys the stream and cleans up resources.
-     * Stops heartbeat and destroys the connection.
-     */
     destroy(): void;
 }
-/**
- * Creates a new RawClient instance.
- *
- * @param options - Client configuration
- * @returns RawClient instance
- */
 export declare function getRawClient(options: ClientConfigOrString): RawClient;
 //# sourceMappingURL=client.socket.d.ts.map