@honeybbq/teamspeak 1.0.0-beta.26 → 1.0.0-beta.27

package/README.md

@@ -35,7 +35,7 @@
 - **Typed commands and events.** Every command the voice protocol answers is a typed function, and the server's notifications arrive as typed events with pluggable middleware.
 - **File transfers.** Upload, download and delete files on the server, with avatars and icons covered.
 - **TeamSpeak 6 screen-share signalling.** Find, publish and watch streams, with SDP and ICE as plain strings for any WebRTC stack.
-- **Built for long-running bots.** Opt-in reconnection tuned for TeamSpeak's antiflood ban, and a token-bucket rate limiter that keeps you clear of flood kicks.
+- **Built for long-running bots.** Opt-in reconnection tuned for TeamSpeak's antiflood ban, and a line middleware seam for pacing commands, with recipes for a token bucket, resending a refused command and keeping a query session open.
 - **Identities and server facts.** Generate, import, export and upgrade identities; read the server version, its uid hash (SHA-1 on TS3, SHA-256 on TS6) and its name, icon and banner.
 - **TeamSpeak 3 and 6, ESM with types.** Pure TypeScript, zero native dependencies, full declarations, and a custom-transport hook for proxies and tests.
 
@@ -88,6 +88,7 @@ The full API reference is at [honeybbq.github.io/teamspeak-js](https://honeybbq.
 - [Configuration](https://honeybbq.github.io/teamspeak-js/documents/configuration.html): options, client version, tracing, diagnostics, reconnection, custom transports and server capabilities.
 - [Streams](https://honeybbq.github.io/teamspeak-js/documents/streams.html): TeamSpeak 6 screen-share signalling, and interop with the TeamSpeak 6 client.
 - [ServerQuery](https://honeybbq.github.io/teamspeak-js/documents/serverquery.html): the query client and its SSH host-key policy.
+- [Flood control](https://honeybbq.github.io/teamspeak-js/documents/flood-control.html): what the server counts, what each command costs, and line middleware recipes for pacing, resending and keeping a query session open.
 - [Design](https://honeybbq.github.io/teamspeak-js/documents/design.html): errors, ids, absent values, events, stability, and the server behaviour the SDK works around.
 - [Compatibility](https://honeybbq.github.io/teamspeak-js/documents/compatibility.html): supported environments and the differences from the Go SDK.
 - [Architecture](https://honeybbq.github.io/teamspeak-js/documents/architecture.html): source layout and entry points.

package/dist/client/client.d.ts

@@ -93,9 +93,9 @@ export declare class Client implements CommandExecutor, AsyncDisposable {
      *
      * Says goodbye first, waiting for the server's acknowledgement for a second
      * at most, or less if `signal` aborts sooner. The goodbye is sent at once,
-     * past the flood throttle, and also by a client still connecting whose
-     * clientinit is out; commands still waiting for their turn reject with a
-     * NotConnectedError and are never sent. The connection is closed
+     * past the line middleware, and also by a client still connecting whose
+     * clientinit is out; commands still inside a line middleware have their
+     * signal aborted, and reject with a NotConnectedError without being sent. The connection is closed
      * either way. A `connect()` still waiting for its handshake rejects with a
      * NotConnectedError, and so do the commands still waiting for an answer.
      * Resolves once `disconnected` has been delivered to the listeners, so one
@@ -125,10 +125,9 @@ export declare class Client implements CommandExecutor, AsyncDisposable {
      * Rejects with a NotConnectedError unless the client is connected: while it
      * is still connecting, the session's keys may not exist yet.
      *
-     * A command the server refuses as flooding (`ErrorCode.ClientIsFlooding`)
-     * with a time to wait is sent again after it, and every other command waits
-     * too, up to three times and while its timeout allows; the refusal that
-     * remains rejects as it is.
+     * The line passes the `lineMiddleware`, if any. A command the server refuses
+     * as flooding (`ErrorCode.ClientIsFlooding`) rejects like any server error;
+     * `floodWaitMs` reads the wait it names.
      */
     exec(command: string, options?: CommandOptions): Promise<Record<string, string>[]>;
     /**
@@ -136,9 +135,10 @@ export declare class Client implements CommandExecutor, AsyncDisposable {
      * commands the server answers with nothing at all. `CommandName` lists
      * the command names.
      *
-     * Commands are paced by a flood throttle; aborting `signal` while this waits
-     * for its turn rejects with the signal's reason and sends nothing. Rejects
-     * with a NotConnectedError unless the client is connected.
+     * The line passes the `lineMiddleware`, if any; aborting `signal` while it
+     * waits there rejects with the signal's reason and sends nothing. Resolves
+     * once the line has been handed to the connection. Rejects with a
+     * NotConnectedError unless the client is connected.
      */
     execNoWait(command: string, options?: {
         readonly signal?: AbortSignal | undefined;

package/dist/client/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}

package/dist/client/client.js

@@ -10,7 +10,7 @@ import { RESOLVE_BUDGET_MS, Resolver } from "./discovery/resolver.js";
 import { PacketHandler } from "./transport/handler.js";
 import { PacketType } from "./transport/packet.js";
 import { CommandTracker, appendReturnCode } from "./commands.js";
-import { buildCommand, buildCommandChain, encodeRequest, floodHoldMs, FLOOD_RETRIES, floodRetryDelayMs, parseServerError, resolveBackoffPolicy, } from "../core/internal.js";
+import { buildCommand, buildCommandChain, buildLineChain, encodeRequest, parseServerError, resolveBackoffPolicy, } from "../core/internal.js";
 import { uploadFileData, downloadFileData } from "./transfer.js";
 import { buildSetConnectionInfo } from "./connection-info.js";
 import { buildEventChain } from "./events.js";
@@ -18,9 +18,7 @@ import { processInit1 } from "./handshake/crypt-handshake.js";
 import { handleHandshakeInitIV, handleHandshakeExpand2, defaultClientVersion, handleInitServer, prepareClientPassword, } from "./handshake.js";
 import { handleNotification } from "../core/internal.js";
 import { parseChannel, parseChannelGroup, parseCommand, parseServerGroup, parseUint16, } from "../core/internal.js";
-import { CommandThrottle } from "./throttle.js";
 import { splitCommandRows, sleep } from "../core/internal.js";
-import { isAutoNicknameMatch } from "./helpers.js";
 import { CommandTimeoutError, NotConnectedError } from "@honeybbq/teamspeak";
 import { responseSpec } from "../core/internal.js";
 import { unknownServerCapabilities } from "./capabilities.js";
@@ -241,7 +239,17 @@ export class Client {
     /** Cuts short the reconnect loop's wait, on disconnect(). */
     #stopReconnecting;
     #status = ClientStatus.Disconnected;
-    #throttle = new CommandThrottle();
+    /**
+     * Aborted when the session ends, by `disconnect()` or a drop: what a command
+     * still inside a line middleware sees as its signal. A new one for each
+     * connection attempt.
+     */
+    #down = new AbortController();
+    /** The per-call state of the commands in the line chain, by their signal and their line. */
+    #calls = new WeakMap();
+    /** The line chain around the base that waits for the answer, and the one around the base that resolves once written. */
+    #line;
+    #lineNoWait;
     #cmdTrack = new CommandTracker(() => this.#clid);
     #viewStore;
     #clients;
@@ -319,14 +327,16 @@ export class Client {
             },
             markConnected: (initServer) => this.#markConnected(initServer),
             markHandshakeDone: (serverPublicKey) => this.#markHandshakeDone(serverPublicKey),
-            execNoWait: (command) => this.#execNoWait(command, undefined, true),
             handlePacket: (packet) => this.#handlePacket(packet),
         };
         // Built once: the chains are read on every command and event, and
         // changing them while those run would make the behaviour depend on timing.
         const cmdMiddlewares = options.commandMiddleware ?? [];
         this.#eventMiddlewares = options.eventMiddleware ?? [];
-        this.#send = buildCommandChain(cmdMiddlewares, (request, commandOptions = {}) => this.#exec(encodeRequest(request, prepareClientPassword), commandOptions, false));
+        this.#send = buildCommandChain(cmdMiddlewares, (request, commandOptions = {}) => this.#exec(encodeRequest(request, prepareClientPassword), commandOptions));
+        const lineMiddlewares = options.lineMiddleware ?? [];
+        this.#line = buildLineChain(lineMiddlewares, (line, lineOptions) => this.#writeLine(line, lineOptions, false));
+        this.#lineNoWait = buildLineChain(lineMiddlewares, (line, lineOptions) => this.#writeNoWait(line, lineOptions));
         this.#eventChain = buildEventChain([...this.#eventMiddlewares], (event) => this.#deliver(event.name, event.payload));
     }
     /**
@@ -504,9 +514,9 @@ export class Client {
      *
      * Says goodbye first, waiting for the server's acknowledgement for a second
      * at most, or less if `signal` aborts sooner. The goodbye is sent at once,
-     * past the flood throttle, and also by a client still connecting whose
-     * clientinit is out; commands still waiting for their turn reject with a
-     * NotConnectedError and are never sent. The connection is closed
+     * past the line middleware, and also by a client still connecting whose
+     * clientinit is out; commands still inside a line middleware have their
+     * signal aborted, and reject with a NotConnectedError without being sent. The connection is closed
      * either way. A `connect()` still waiting for its handshake rejects with a
      * NotConnectedError, and so do the commands still waiting for an answer.
      * Resolves once `disconnected` has been delivered to the listeners, so one
@@ -538,9 +548,9 @@ export class Client {
         const holdsSession = this.#status === ClientStatus.Connected ||
             (this.#status === ClientStatus.Connecting && this.#crypt.cryptoInitComplete);
         this.#status = ClientStatus.Disconnected;
-        // Whatever still waits for its turn is rejected and never sent; the
-        // goodbye does not wait for one.
-        this.#throttle.rejectAll(new NotConnectedError());
+        // Whatever still waits in a line middleware is aborted and never sent; the
+        // goodbye does not pass one.
+        this.#down.abort(new NotConnectedError());
         let left;
         this.#attempt.rejectAfter(new NotConnectedError(), new Promise((r) => (left = r)));
         const leaving = this.#leave(holdsSession, options.signal, options.reasonMessage ?? "Shutdown").finally(left);
@@ -568,7 +578,7 @@ export class Client {
             const answered = this.#exec(buildCommand("clientdisconnect", {
                 reasonid: String(Reason.Disconnect),
                 reasonmsg: reasonMessage,
-            }), { signal, timeoutMs: DISCONNECT_TIMEOUT_MS }, true, true).then(() => true, () => false);
+            }), { signal, timeoutMs: DISCONNECT_TIMEOUT_MS }, true).then(() => true, () => false);
             const acknowledged = await Promise.race([answered, left]);
             this.#goodbyeAnswered = undefined;
             this.#callHook(this.#trace?.disconnectDone, () => ({
@@ -597,44 +607,44 @@ export class Client {
      * Rejects with a NotConnectedError unless the client is connected: while it
      * is still connecting, the session's keys may not exist yet.
      *
-     * A command the server refuses as flooding (`ErrorCode.ClientIsFlooding`)
-     * with a time to wait is sent again after it, and every other command waits
-     * too, up to three times and while its timeout allows; the refusal that
-     * remains rejects as it is.
+     * The line passes the `lineMiddleware`, if any. A command the server refuses
+     * as flooding (`ErrorCode.ClientIsFlooding`) rejects like any server error;
+     * `floodWaitMs` reads the wait it names.
      */
     // oxlint-disable-next-line typescript/array-type -- the public API report spells this `[]`; respelling it changes the report
     exec(command, options = {}) {
-        return this.#exec(command, options, false);
+        return this.#exec(command, options);
     }
     /**
      * Send a raw command line without waiting for an answer, for the few
      * commands the server answers with nothing at all. `CommandName` lists
      * the command names.
      *
-     * Commands are paced by a flood throttle; aborting `signal` while this waits
-     * for its turn rejects with the signal's reason and sends nothing. Rejects
-     * with a NotConnectedError unless the client is connected.
+     * The line passes the `lineMiddleware`, if any; aborting `signal` while it
+     * waits there rejects with the signal's reason and sends nothing. Resolves
+     * once the line has been handed to the connection. Rejects with a
+     * NotConnectedError unless the client is connected.
      */
     execNoWait(command, options = {}) {
-        return this.#execNoWait(command, options.signal, false);
+        return this.#execNoWait(command, options.signal);
     }
     /**
-     * Whether a command may go out now. The handshake's own commands (`internal`)
-     * need only an open socket; everything else needs a connected session, so
-     * nothing a caller sends can go out under the public dummy key, or after
+     * Whether a command may go out now. The goodbye (`internal`) needs only an
+     * open socket; everything else needs a connected session, so nothing a
+     * caller sends can go out under the public dummy key, or after
      * disconnect() has begun saying goodbye.
      */
     #canSend(internal) {
         return this.#handler.isOpen && (internal || this.#status === ClientStatus.Connected);
     }
-    async #execNoWait(command, signal, internal) {
+    async #execNoWait(command, signal) {
         signal?.throwIfAborted();
-        if (!this.#canSend(internal))
-            throw new NotConnectedError();
-        await this.#throttle.wait(signal);
-        if (!this.#canSend(internal))
+        if (!this.#canSend(false))
             throw new NotConnectedError();
-        this.#sendLine(command);
+        const name = parseCommand(command)?.name ?? "";
+        // No timeout, as ever for a command nobody waits an answer for: the line
+        // middleware and the caller's signal are what can hold it.
+        await this.#runLine(name, command, { signal, noWait: true });
     }
     /**
      * Send a typed command; this is the CommandExecutor the typed commands run on.
@@ -654,94 +664,130 @@ export class Client {
             hook(this, line);
         this.#handler.sendPacket(PacketType.Command, Buffer.from(line), 0);
     }
-    #exec(command, options, internal, goodbye = false) {
+    #exec(command, options, goodbye = false) {
         if (!commandChannel.hasSubscribers) {
-            return this.#execUntraced(command, options, internal, goodbye);
+            return this.#execUntraced(command, options, goodbye);
         }
         const trace = {
             command: parseCommand(command)?.name ?? "",
             client: this,
         };
-        return commandChannel.tracePromise(() => this.#execUntraced(command, options, internal, goodbye), trace);
+        return commandChannel.tracePromise(() => this.#execUntraced(command, options, goodbye), trace);
     }
-    async #execUntraced(command, options, internal, goodbye) {
+    async #execUntraced(command, options, goodbye) {
         const { signal, timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, onSent } = options;
         signal?.throwIfAborted();
         // A command sent on no socket used to vanish and surface 10 seconds later
         // as a timeout, which reads like a slow server rather than a usage error.
-        if (!this.#canSend(internal))
+        if (!this.#canSend(goodbye))
+            throw new NotConnectedError();
+        const name = parseCommand(command)?.name ?? "";
+        return this.#runLine(name, command, { signal, timeoutMs, onSent, goodbye });
+    }
+    /**
+     * Run one line through the line middleware, or straight to the connection
+     * for the goodbye. The timeout, the caller's signal and the end of the
+     * session each abort the signal the middleware is given, and the call
+     * rejects with the reason: the timeout bounds the whole chain, the waits of
+     * a middleware included.
+     */
+    async #runLine(name, text, call) {
+        const { signal, timeoutMs, goodbye = false } = call;
+        const abort = new AbortController();
+        const down = this.#down.signal;
+        const stop = (reason) => abort.abort(reason);
+        const timer = timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => stop(new CommandTimeoutError(name)), timeoutMs);
+        const onCaller = () => stop(abortReason(signal));
+        // The goodbye leaves as the session ends, which is what aborts `down`.
+        const onDown = () => stop(down.reason);
+        signal?.addEventListener("abort", onCaller, { once: true });
+        if (!goodbye)
+            down.addEventListener("abort", onDown, { once: true });
+        if (!goodbye && down.aborted)
+            onDown();
+        // A middleware that ignores its signal must not hold the call past it.
+        const gaveUp = new Promise((_, reject) => {
+            abort.signal.addEventListener("abort", () => reject(abortReason(abort.signal)), {
+                once: true,
+            });
+        });
+        gaveUp.catch(() => { });
+        const line = { name, text };
+        const state = { onSent: call.onSent, sent: false };
+        this.#calls.set(line, state);
+        this.#calls.set(abort.signal, state);
+        try {
+            // The goodbye goes to its own base: it passes no middleware, and may go
+            // out while the status says Disconnected.
+            const send = goodbye
+                ? (l, o) => this.#writeLine(l, o, true)
+                : call.noWait === true
+                    ? this.#lineNoWait
+                    : this.#line;
+            return await Promise.race([send(line, { signal: abort.signal }), gaveUp]);
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onCaller);
+            down.removeEventListener("abort", onDown);
+        }
+    }
+    /** Tell the call a line belongs to that its line was handed to the connection, the first time only. */
+    #sent(line, signal) {
+        const call = this.#calls.get(line) ?? this.#calls.get(signal);
+        if (call === undefined || call.sent)
+            return;
+        call.sent = true;
+        call.onSent?.();
+    }
+    /**
+     * The base of the line chain for a line nobody answers: write it, and
+     * resolve with no rows once it is written.
+     */
+    async #writeNoWait(line, options) {
+        options.signal.throwIfAborted();
+        if (!this.#canSend(false))
+            throw new NotConnectedError();
+        this.#sendLine(line.text);
+        this.#sent(line, options.signal);
+        return [];
+    }
+    /**
+     * The base of the line chain: write the line, with a return code of its own
+     * each time it is called, and read its answer. Looks at the connection once
+     * more, as a middleware may have waited, and ends when the signal does.
+     */
+    async #writeLine(line, options, goodbye) {
+        const { signal } = options;
+        signal.throwIfAborted();
+        if (!this.#canSend(goodbye))
             throw new NotConnectedError();
         // Which notifications answer this command, and — for answers that arrive
         // after the `error` — the request field they echo back.
-        const parsed = parseCommand(command);
-        const spec = responseSpec(parsed?.name ?? "");
+        const parsed = parseCommand(line.text);
+        const spec = responseSpec(line.name);
         const key = spec?.correlated?.key;
         const correlation = key === undefined ? undefined : parsed?.params[key];
         const echo = spec?.echoKey === undefined ? undefined : parsed?.params[spec.echoKey];
-        let [rc, answered] = this.#cmdTrack.register(spec, correlation, echo);
-        const deadline = performance.now() + timeoutMs;
-        let timer;
-        let onAbort;
-        // Started before the throttle: the timeout bounds the whole command, its
-        // wait for a turn included, and so does the signal.
-        const givenUp = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new CommandTimeoutError(parsed?.name ?? "")), timeoutMs);
-            onAbort = () => reject(abortReason(signal));
-            signal?.addEventListener("abort", onAbort, { once: true });
-        });
-        givenUp.catch(() => { });
-        const throttleAbort = new AbortController();
+        const [rc, answered] = this.#cmdTrack.register(spec, correlation, echo);
+        answered.catch(() => { });
         try {
-            for (let refused = 0;; refused++) {
-                const withRc = appendReturnCode(command, rc);
-                // The goodbye of a disconnect goes out at once: queued behind other
-                // commands it would not leave in time, and the server would keep the
-                // session.
-                if (!goodbye)
-                    await Promise.race([this.#throttle.wait(throttleAbort.signal), givenUp]);
-                if (!this.#canSend(internal))
-                    throw new NotConnectedError();
-                this.#sendLine(withRc);
-                if (refused === 0)
-                    onSent?.();
-                const result = await Promise.race([answered, givenUp]);
-                // Refused as flooding with a time to wait, which the command can
-                // afford: nothing is sent until then, and the command, which the
-                // server did not run, goes out again.
-                const wait = result.err ? floodRetryDelayMs(result.err) : undefined;
-                const hold = wait === undefined ? undefined : floodHoldMs(wait);
-                if (hold !== undefined &&
-                    !goodbye &&
-                    refused < FLOOD_RETRIES &&
-                    hold < deadline - performance.now()) {
-                    this.#logger.debug("the server asked for a pause", {
-                        command: parsed?.name,
-                        waitMs: wait,
-                    });
-                    this.#throttle.hold(hold);
-                    this.#cmdTrack.unregister(rc);
-                    [rc, answered] = this.#cmdTrack.register(spec, correlation, echo);
-                    continue;
-                }
-                if (result.err)
-                    throw result.err;
-                // The server took the rename, so it is what this client now asks for.
-                if (!internal && parsed?.name === "clientupdate") {
-                    const renamed = parsed.params["client_nickname"];
-                    if (renamed !== undefined)
-                        this.#requestedNickname = renamed;
-                }
-                return result.data;
+            this.#sendLine(appendReturnCode(line.text, rc));
+            this.#sent(line, signal);
+            const result = await abortable(answered, signal);
+            if (result.err)
+                throw result.err;
+            // The server took the rename, so it is what this client now asks for.
+            if (!goodbye && line.name === "clientupdate") {
+                const renamed = parsed?.params["client_nickname"];
+                if (renamed !== undefined)
+                    this.#requestedNickname = renamed;
             }
+            return result.data;
         }
         finally {
-            // A command given up while it waited for its turn gives the turn back.
-            throttleAbort.abort();
-            // Cleared, not left to fire: a pending timer keeps the process alive for
-            // the full timeout after the last command has long been answered.
-            clearTimeout(timer);
-            if (onAbort)
-                signal?.removeEventListener("abort", onAbort);
             this.#cmdTrack.unregister(rc);
         }
     }
@@ -1175,6 +1221,8 @@ export class Client {
         this.#handler = this.#newHandler();
         this.#attempt = newConnectAttempt();
         this.#cmdTrack.reset(new NotConnectedError());
+        this.#down.abort(new NotConnectedError());
+        this.#down = new AbortController();
         this.#viewStore.reset();
         this.#clid = 0;
         this.#capabilities = unknownServerCapabilities();
@@ -1470,7 +1518,7 @@ export class Client {
      */
     #answerConnectionInfoRequest() {
         const line = buildSetConnectionInfo(this.#handler.trafficSnapshot(), this.#handler.roundTrip);
-        this.#execNoWait(line, undefined, false).catch((error) => {
+        this.#execNoWait(line, undefined).catch((error) => {
             this.#logger.debug("could not answer a connection info request", {
                 error: String(error),
             });
@@ -1507,12 +1555,12 @@ export class Client {
         switch (result.kind) {
             case "clientEnter": {
                 const info = result.info;
-                // Identify self by the clid initserver already assigned rather than by
-                // nickname: any other client whose nickname happens to be "<our
-                // nick><digits>" — which is how the server renames a client whose
-                // nickname was taken — would otherwise be mistaken for us, poisoning
-                // every outgoing packet header with a foreign clientID until the server
-                // drops the connection for command-resend timeout.
+                // Identify self by the clid initserver assigned, never by nickname: any
+                // other client whose nickname happens to be "<our nick><digits>" — which
+                // is how the server renames a client whose nickname was taken — would
+                // otherwise be mistaken for us, poisoning every outgoing packet header
+                // with a foreign clientID until the server drops the connection for
+                // command-resend timeout.
                 //
                 // This no longer marks the end of the welcome sequence: the server
                 // sends more welcome data after it, and `channellistfinished` is the
@@ -1522,15 +1570,6 @@ export class Client {
                     // the nickname asked for stays as it was.
                     this.#nickname = info.nickname;
                 }
-                else if (this.#clid === 0 &&
-                    isAutoNicknameMatch(this.#requestedNickname, info.nickname)) {
-                    // initserver carried no aclid, so the welcome enter is the only way
-                    // to learn our clid. Gated on clid still being unknown so a later
-                    // lookalike can never hijack an established session.
-                    this.#clid = info.id;
-                    this.#handler.setClientID(info.id);
-                    this.#nickname = info.nickname;
-                }
                 this.#emitServerEvent({ name: "clientEnter", payload: info });
                 break;
             }
@@ -1785,6 +1824,7 @@ export class Client {
         // Nothing in flight can be answered any more; failing it now, with the
         // reason, beats every caller timing out one by one.
         this.#cmdTrack.reset(new NotConnectedError(err ? { cause: err } : undefined));
+        this.#down.abort(new NotConnectedError(err ? { cause: err } : undefined));
         if (this.#status !== ClientStatus.Connected) {
             // The socket closed before the handshake finished, so this is a failed
             // connection attempt rather than a disconnect of a live session.