@exhumer/signalr-client 1.0.2 → 2.1.0

package/dist/index.js

@@ -1,2715 +0,0 @@
-// src/http-client.ts
-import { PassThrough, Readable } from "stream";
-import {
-  request as undiciRequest,
-  stream as undiciStream,
-  pipeline as undiciPipeline,
-  fetch as undiciFetch,
-  getGlobalDispatcher
-} from "undici";
-function prepareBody(body) {
-  if (body == null) return { buf: null, inferredContentType: null };
-  if (typeof body === "string") {
-    return { buf: Buffer.from(body, "utf8"), inferredContentType: null };
-  }
-  return {
-    buf: Buffer.from(JSON.stringify(body), "utf8"),
-    inferredContentType: "application/json"
-  };
-}
-function buildHeaders(defaults, overrides, body, inferredContentType) {
-  const merged = { ...defaults, ...overrides ?? {} };
-  if (body !== null) {
-    merged["content-length"] = String(body.length);
-    if (!merged["content-type"] && inferredContentType !== null) {
-      merged["content-type"] = inferredContentType;
-    }
-  }
-  return merged;
-}
-function normaliseHeaders(h) {
-  return h;
-}
-var BaseUndiciClient = class {
-  /** Default headers merged into every outgoing request. */
-  defaultHeaders;
-  /** Session-level request timeout in milliseconds. */
-  defaultTimeout;
-  /**
-   * Shared undici Dispatcher.  May be an Agent, Pool, Client, ProxyAgent, etc.
-   * Defaults to undici's process-global agent when not specified.
-   */
-  dispatcher;
-  constructor(options = {}) {
-    this.defaultHeaders = options.headers ?? {};
-    this.defaultTimeout = options.timeout ?? 3e4;
-    this.dispatcher = options.dispatcher ?? getGlobalDispatcher();
-  }
-  // Convenience wrappers ──────────────────────────────────────────────────────
-  get(url, options) {
-    return this.request("GET", url, options);
-  }
-  post(url, options) {
-    return this.request("POST", url, options);
-  }
-  delete(url, options) {
-    return this.request("DELETE", url, options);
-  }
-};
-var RequestHttpClient = class extends BaseUndiciClient {
-  /**
-   * Buffered request - collects the entire response body as a string.
-   *
-   * Timeout is implemented via undici's built-in `headersTimeout` /
-   * `bodyTimeout` options rather than an external `setTimeout`.
-   */
-  async request(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const timeout = options.timeout ?? this.defaultTimeout;
-    const { statusCode, headers: respHeaders, body } = await undiciRequest(url, {
-      method,
-      headers,
-      ...buf !== null && { body: buf },
-      headersTimeout: timeout,
-      bodyTimeout: timeout,
-      dispatcher: this.dispatcher
-    });
-    const text = await body.text();
-    return {
-      status: statusCode,
-      headers: normaliseHeaders(respHeaders),
-      body: text
-    };
-  }
-  /**
-   * Streaming request - returns the response body `Readable` without
-   * buffering.  Used by SSE and long-polling transports.
-   *
-   * The `abort()` method destroys the underlying socket and the body stream.
-   */
-  async stream(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const { statusCode, headers: respHeaders, body } = await undiciRequest(url, {
-      method,
-      headers,
-      ...buf !== null && { body: buf },
-      // No bodyTimeout here - SSE connections are intentionally long-lived.
-      headersTimeout: options.timeout ?? this.defaultTimeout,
-      dispatcher: this.dispatcher
-    });
-    return {
-      statusCode,
-      headers: normaliseHeaders(respHeaders),
-      body,
-      abort: () => body.destroy()
-    };
-  }
-};
-var FetchHttpClient = class extends BaseUndiciClient {
-  async request(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const ac = new AbortController();
-    const timeout = options.timeout ?? this.defaultTimeout;
-    const timer = timeout > 0 ? setTimeout(() => ac.abort(new Error(`HTTP request timed out after ${timeout} ms`)), timeout) : null;
-    try {
-      const res = await undiciFetch(url, {
-        method,
-        headers,
-        ...buf !== null && { body: buf },
-        signal: ac.signal,
-        // undici-specific: override the dispatcher for this request.
-        // undici's fetch type is defined in two conflicting locations
-        // (undici-types bundled with @types/node AND undici's own .d.ts),
-        // so the intersection cast doesn't satisfy either.  The double-cast
-        // via `unknown` sidesteps the conflict without losing safety: at
-        // runtime undici.fetch() accepts exactly this shape.
-        dispatcher: this.dispatcher
-      });
-      const text = await res.text();
-      if (timer !== null) clearTimeout(timer);
-      const respHeaders = {};
-      res.headers.forEach((value, key) => {
-        respHeaders[key] = value;
-      });
-      return { status: res.status, headers: respHeaders, body: text };
-    } catch (err) {
-      if (timer !== null) clearTimeout(timer);
-      throw err;
-    }
-  }
-  async stream(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const ac = new AbortController();
-    const res = await undiciFetch(url, {
-      method,
-      headers,
-      ...buf !== null && { body: buf },
-      signal: ac.signal,
-      dispatcher: this.dispatcher
-    });
-    const body = Readable.fromWeb(
-      res.body
-    );
-    const respHeaders = {};
-    res.headers.forEach((value, key) => {
-      respHeaders[key] = value;
-    });
-    return {
-      statusCode: res.status,
-      headers: respHeaders,
-      body,
-      abort: () => {
-        ac.abort();
-        body.destroy();
-      }
-    };
-  }
-};
-var StreamHttpClient = class extends BaseUndiciClient {
-  request(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const timeout = options.timeout ?? this.defaultTimeout;
-    let statusCode = 0;
-    let respHeaders = {};
-    const chunks = [];
-    return undiciStream(
-      url,
-      {
-        method,
-        headers,
-        ...buf !== null && { body: buf },
-        headersTimeout: timeout,
-        bodyTimeout: timeout,
-        dispatcher: this.dispatcher
-      },
-      ({ statusCode: sc, headers: h }) => {
-        statusCode = sc;
-        respHeaders = h;
-        const sink = new PassThrough();
-        sink.on("data", (chunk) => chunks.push(chunk));
-        return sink;
-      }
-    ).then(() => ({
-      status: statusCode,
-      headers: normaliseHeaders(respHeaders),
-      body: Buffer.concat(chunks).toString("utf8")
-    }));
-  }
-  stream(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    return new Promise((resolve, reject) => {
-      const pt = new PassThrough();
-      undiciStream(
-        url,
-        {
-          method,
-          headers,
-          ...buf !== null && { body: buf },
-          headersTimeout: options.timeout ?? this.defaultTimeout,
-          dispatcher: this.dispatcher
-        },
-        ({ statusCode, headers: h }) => {
-          resolve({
-            statusCode,
-            headers: normaliseHeaders(h),
-            body: pt,
-            abort: () => pt.destroy()
-          });
-          return pt;
-        }
-      ).catch((err) => {
-        pt.destroy();
-        reject(err);
-      });
-    });
-  }
-};
-var PipelineHttpClient = class extends BaseUndiciClient {
-  request(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const timeout = options.timeout ?? this.defaultTimeout;
-    return new Promise((resolve, reject) => {
-      let statusCode = 0;
-      let respHeaders = {};
-      const chunks = [];
-      const duplex = undiciPipeline(
-        url,
-        {
-          method,
-          headers,
-          ...buf !== null && { body: buf },
-          headersTimeout: timeout,
-          bodyTimeout: timeout,
-          dispatcher: this.dispatcher
-        },
-        ({ statusCode: sc, headers: h, body }) => {
-          statusCode = sc;
-          respHeaders = h;
-          return body;
-        }
-      );
-      duplex.on("data", (chunk) => chunks.push(chunk));
-      duplex.on(
-        "end",
-        () => resolve({
-          status: statusCode,
-          headers: normaliseHeaders(respHeaders),
-          body: Buffer.concat(chunks).toString("utf8")
-        })
-      );
-      duplex.on("error", reject);
-      if (buf !== null) {
-        duplex.write(buf);
-      }
-      duplex.end();
-    });
-  }
-  stream(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      let duplex;
-      duplex = undiciPipeline(
-        url,
-        {
-          method,
-          headers,
-          ...buf !== null && { body: buf },
-          headersTimeout: options.timeout ?? this.defaultTimeout,
-          dispatcher: this.dispatcher
-        },
-        ({ statusCode, headers: h, body }) => {
-          if (!resolved) {
-            resolved = true;
-            resolve({
-              statusCode,
-              headers: normaliseHeaders(h),
-              // The duplex IS the readable - its output is the body.
-              body: duplex,
-              abort: () => duplex.destroy()
-            });
-          }
-          return body;
-        }
-      );
-      duplex.on("error", (err) => {
-        if (!resolved) reject(err);
-      });
-      if (buf !== null) duplex.write(buf);
-      duplex.end();
-    });
-  }
-};
-var DispatchHttpClient = class extends BaseUndiciClient {
-  request(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const parsed = new URL(url);
-    const timeout = options.timeout ?? this.defaultTimeout;
-    return new Promise((resolve, reject) => {
-      let statusCode = 0;
-      let respHeaders = {};
-      const chunks = [];
-      let timer = null;
-      if (timeout > 0) {
-        timer = setTimeout(() => {
-          reject(new Error(`HTTP request timed out after ${timeout} ms`));
-        }, timeout);
-      }
-      const clearTimer = () => {
-        if (timer !== null) {
-          clearTimeout(timer);
-          timer = null;
-        }
-      };
-      this.dispatcher.dispatch(
-        {
-          origin: parsed.origin,
-          path: parsed.pathname + parsed.search,
-          method,
-          headers,
-          ...buf !== null && { body: buf }
-        },
-        {
-          onRequestStart: (_controller, _context) => {
-          },
-          onResponseError: (_controller, err) => {
-            clearTimer();
-            reject(err);
-          },
-          onResponseStart: (_controller, sc, headers2) => {
-            statusCode = sc;
-            respHeaders = headers2;
-          },
-          onResponseData: (_controller, chunk) => {
-            chunks.push(Buffer.from(chunk));
-          },
-          onResponseEnd: (_controller, _trailers) => {
-            clearTimer();
-            resolve({
-              status: statusCode,
-              headers: respHeaders,
-              body: Buffer.concat(chunks).toString("utf8")
-            });
-          }
-        }
-      );
-    });
-  }
-  stream(method, url, options = {}) {
-    const { buf, inferredContentType } = prepareBody(options.body);
-    const headers = buildHeaders(
-      this.defaultHeaders,
-      options.headers,
-      buf,
-      inferredContentType
-    );
-    const parsed = new URL(url);
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      const pt = new PassThrough();
-      let controller = null;
-      this.dispatcher.dispatch(
-        {
-          origin: parsed.origin,
-          path: parsed.pathname + parsed.search,
-          method,
-          headers,
-          ...buf !== null && { body: buf },
-          headersTimeout: options.timeout ?? this.defaultTimeout
-        },
-        {
-          onRequestStart: (ctrl, _context) => {
-            controller = ctrl;
-          },
-          onResponseError: (_ctrl, err) => {
-            if (!resolved) {
-              resolved = true;
-              pt.destroy();
-              reject(err);
-            } else {
-              pt.destroy(err);
-            }
-          },
-          onResponseStart: (_ctrl, statusCode, headers2) => {
-            if (!resolved) {
-              resolved = true;
-              resolve({
-                statusCode,
-                headers: headers2,
-                body: pt,
-                abort: () => {
-                  controller?.abort(new Error("Stream aborted"));
-                  pt.destroy();
-                }
-              });
-            }
-          },
-          onResponseData: (_ctrl, chunk) => {
-            pt.write(chunk);
-          },
-          onResponseEnd: (_ctrl, _trailers) => {
-            pt.end();
-          }
-        }
-      );
-    });
-  }
-};
-
-// src/constants.ts
-var MessageType = Object.freeze({
-  Invocation: 1,
-  StreamItem: 2,
-  Completion: 3,
-  StreamInvocation: 4,
-  CancelInvocation: 5,
-  Ping: 6,
-  Close: 7
-});
-var HubConnectionState = Object.freeze({
-  Disconnected: "Disconnected",
-  Connecting: "Connecting",
-  Connected: "Connected",
-  Disconnecting: "Disconnecting",
-  Reconnecting: "Reconnecting"
-});
-var LogLevel = {
-  Trace: 0,
-  Debug: 1,
-  Information: 2,
-  Warning: 3,
-  Error: 4,
-  Critical: 5,
-  None: 6
-};
-var HttpTransportType = {
-  None: 0,
-  WebSockets: 1,
-  ServerSentEvents: 2,
-  LongPolling: 4
-};
-var TransferFormat = {
-  Text: 1,
-  Binary: 2
-};
-var RECORD_SEPARATOR = "";
-var NEGOTIATE_VERSION = 1;
-var DEFAULT_TIMEOUT_IN_MS = 3e4;
-var DEFAULT_PING_INTERVAL_IN_MS = 15e3;
-var DEFAULT_SERVER_TIMEOUT_IN_MS = 3e4;
-
-// src/messages.ts
-function toInvocationId(s) {
-  return s;
-}
-function assertNever(_x, label) {
-  throw new Error(`Unexpected value${label ? ` for ${label}` : ""}: ${JSON.stringify(_x)}`);
-}
-function isInvocationMessage(msg) {
-  return msg.type === 1;
-}
-function isStreamItemMessage(msg) {
-  return msg.type === 2;
-}
-function isCompletionMessage(msg) {
-  return msg.type === 3;
-}
-function isStreamInvocationMessage(msg) {
-  return msg.type === 4;
-}
-function isCancelInvocationMessage(msg) {
-  return msg.type === 5;
-}
-function isPingMessage(msg) {
-  return msg.type === 6;
-}
-function isCloseMessage(msg) {
-  return msg.type === 7;
-}
-
-// src/protocols/json-hub-protocol.ts
-var HANDSHAKE_REQUEST = JSON.stringify({ protocol: "json", version: 1 }) + RECORD_SEPARATOR;
-function parseHandshakeResponse(data) {
-  const idx = data.indexOf(RECORD_SEPARATOR);
-  if (idx === -1) {
-    throw new Error("Handshake response is missing the record separator.");
-  }
-  const raw = data.slice(0, idx);
-  const response = JSON.parse(raw);
-  if (response.error) {
-    throw new Error(`Server rejected the handshake with the error: "${response.error}"`);
-  }
-  return { remainder: data.slice(idx + 1) };
-}
-var JsonHubProtocol = class {
-  name = "json";
-  version = 1;
-  transferFormat = TransferFormat.Text;
-  // ─── IHubProtocol: parseMessages ─────────────────────────────────────
-  parseMessages(input, logger) {
-    const text = typeof input === "string" ? input : new TextDecoder().decode(input);
-    if (!text) return [];
-    const messages = [];
-    const parts = text.split(RECORD_SEPARATOR);
-    for (const part of parts) {
-      const trimmed = part.trim();
-      if (!trimmed) continue;
-      let raw;
-      try {
-        raw = JSON.parse(trimmed);
-      } catch (e) {
-        throw new Error(`Error parsing message: ${e.message}. Raw value: "${trimmed}"`);
-      }
-      const msg = this.#coerce(raw);
-      if (msg !== null) {
-        messages.push(msg);
-      } else {
-        logger.log(3, `Ignoring message with unknown type ${String(raw.type)}.`);
-      }
-    }
-    return messages;
-  }
-  // ─── IHubProtocol: writeMessage ───────────────────────────────────────
-  writeMessage(message) {
-    return JSON.stringify(message) + RECORD_SEPARATOR;
-  }
-  // ─── Coercion / narrowing ─────────────────────────────────────────────
-  /**
-   * Validate and narrow a raw parsed object into a typed `HubMessage`.
-   * Returns `null` for unknown types (not an error - new protocol versions
-   * may add types we don't know about).
-   */
-  #coerce(raw) {
-    const type = raw.type;
-    if (typeof type !== "number") {
-      throw new Error(`Invalid message: 'type' must be a number, got ${JSON.stringify(type)}.`);
-    }
-    switch (type) {
-      case MessageType.Invocation:
-        return this.#coerceInvocation(raw);
-      case MessageType.StreamItem:
-        return this.#coerceStreamItem(raw);
-      case MessageType.Completion:
-        return this.#coerceCompletion(raw);
-      case MessageType.StreamInvocation:
-        return this.#coerceStreamInvocation(raw);
-      case MessageType.CancelInvocation:
-        return this.#coerceCancelInvocation(raw);
-      case MessageType.Ping:
-        return this.#coercePing();
-      case MessageType.Close:
-        return this.#coerceClose(raw);
-      default:
-        return null;
-    }
-  }
-  #coerceInvocation(raw) {
-    if (typeof raw.target !== "string") {
-      throw new Error("Invalid Invocation message: 'target' must be a string.");
-    }
-    if (!Array.isArray(raw.arguments)) {
-      throw new Error("Invalid Invocation message: 'arguments' must be an array.");
-    }
-    return {
-      type: MessageType.Invocation,
-      target: raw.target,
-      arguments: raw.arguments,
-      ...raw.invocationId != null && { invocationId: toInvocationId(String(raw.invocationId)) },
-      ...Array.isArray(raw.streamIds) && { streamIds: raw.streamIds },
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  #coerceStreamItem(raw) {
-    if (raw.invocationId == null) {
-      throw new Error("Invalid StreamItem message: 'invocationId' is required.");
-    }
-    return {
-      type: MessageType.StreamItem,
-      invocationId: toInvocationId(String(raw.invocationId)),
-      item: raw.item,
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  #coerceCompletion(raw) {
-    if (raw.invocationId == null) {
-      throw new Error("Invalid Completion message: 'invocationId' is required.");
-    }
-    if (raw.error != null && raw.result != null) {
-      throw new Error("Invalid Completion message: 'error' and 'result' are mutually exclusive.");
-    }
-    return {
-      type: MessageType.Completion,
-      invocationId: toInvocationId(String(raw.invocationId)),
-      ...raw.error != null && { error: String(raw.error) },
-      ...raw.result != null && { result: raw.result },
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  #coerceStreamInvocation(raw) {
-    if (raw.invocationId == null) {
-      throw new Error("Invalid StreamInvocation message: 'invocationId' is required.");
-    }
-    if (typeof raw.target !== "string") {
-      throw new Error("Invalid StreamInvocation message: 'target' must be a string.");
-    }
-    if (!Array.isArray(raw.arguments)) {
-      throw new Error("Invalid StreamInvocation message: 'arguments' must be an array.");
-    }
-    return {
-      type: MessageType.StreamInvocation,
-      invocationId: toInvocationId(String(raw.invocationId)),
-      target: raw.target,
-      arguments: raw.arguments,
-      ...Array.isArray(raw.streamIds) && { streamIds: raw.streamIds },
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  #coerceCancelInvocation(raw) {
-    if (raw.invocationId == null) {
-      throw new Error("Invalid CancelInvocation message: 'invocationId' is required.");
-    }
-    return {
-      type: MessageType.CancelInvocation,
-      invocationId: toInvocationId(String(raw.invocationId)),
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  #coercePing() {
-    return { type: MessageType.Ping };
-  }
-  #coerceClose(raw) {
-    return {
-      type: MessageType.Close,
-      ...raw.error != null && { error: String(raw.error) },
-      ...raw.allowReconnect != null && { allowReconnect: Boolean(raw.allowReconnect) },
-      ...raw.headers != null && { headers: raw.headers }
-    };
-  }
-  // ─── Static message factories ─────────────────────────────────────────
-  static invocation(invocationId, target, args, streamIds) {
-    return {
-      type: MessageType.Invocation,
-      invocationId,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  /**
-   * Fire-and-forget (no `invocationId` → server won't send a Completion).
-   */
-  static send(target, args, streamIds) {
-    return {
-      type: MessageType.Invocation,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  static streamInvocation(invocationId, target, args, streamIds) {
-    return {
-      type: MessageType.StreamInvocation,
-      invocationId,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  static cancelInvocation(invocationId) {
-    return { type: MessageType.CancelInvocation, invocationId };
-  }
-  static streamItem(invocationId, item) {
-    return { type: MessageType.StreamItem, invocationId, item };
-  }
-  static completion(invocationId, result, error) {
-    return {
-      type: MessageType.Completion,
-      invocationId,
-      ...error != null && { error },
-      ...result != null && { result }
-    };
-  }
-  static ping() {
-    return { type: MessageType.Ping };
-  }
-};
-
-// src/transports/websocket-transport.ts
-import { WebSocket } from "undici";
-var WebSocketReadyState = Object.freeze({
-  Connecting: 0,
-  Open: 1,
-  Closing: 2,
-  Closed: 3
-});
-var WebSocketTransport = class {
-  name = "WebSockets";
-  #accessTokenFactory;
-  #logger;
-  #extraHeaders;
-  #dispatcher;
-  #ws = null;
-  onreceive = null;
-  onclose = null;
-  /**
-   * @param accessTokenFactory  Async factory for Bearer tokens, or null.
-   * @param logger              Logger instance.
-   * @param extraHeaders        Headers forwarded on every upgrade request.
-   * @param dispatcher          Optional undici Dispatcher (Agent/Pool/Client/
-   *                            ProxyAgent).  When omitted, undici's default
-   *                            global agent is used.  Pass the same dispatcher
-   *                            used by your HTTP clients to share the pool.
-   */
-  constructor(accessTokenFactory, logger, extraHeaders = {}, dispatcher) {
-    this.#accessTokenFactory = accessTokenFactory;
-    this.#logger = logger;
-    this.#extraHeaders = extraHeaders;
-    this.#dispatcher = dispatcher;
-  }
-  async connect(url, _transferFormat) {
-    this.#logger.log(LogLevel.Trace, `(WebSockets transport) Connecting to ${url}.`);
-    const headers = { ...this.#extraHeaders };
-    if (this.#accessTokenFactory) {
-      const token = await this.#accessTokenFactory();
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    }
-    const wsUrl = url.replace(/^http/, "ws");
-    const ws = new WebSocket(wsUrl, {
-      headers,
-      ...this.#dispatcher !== void 0 && { dispatcher: this.#dispatcher }
-    });
-    this.#ws = ws;
-    ws.binaryType = "arraybuffer";
-    await new Promise((resolve, reject) => {
-      ws.addEventListener("open", () => {
-        this.#logger.log(LogLevel.Information, "(WebSockets transport) Connected.");
-        resolve();
-      });
-      ws.addEventListener("error", (event) => {
-        const e = event;
-        let err;
-        if (e.error instanceof Error) {
-          err = e.error.message ? e.error : e.error.cause instanceof Error ? e.error.cause : new Error("WebSocket connection failed");
-        } else {
-          err = new Error(String(e.message ?? "WebSocket error"));
-        }
-        this.#logger.log(LogLevel.Error, `(WebSockets transport) Error during connect: ${err.message}`);
-        reject(err);
-      });
-    });
-    ws.addEventListener("message", (event) => {
-      const data = event.data;
-      if (typeof data === "string") {
-        this.#logger.log(
-          LogLevel.Trace,
-          `(WebSockets transport) Received text (${data.length} chars).`
-        );
-        this.onreceive?.(data);
-      } else if (data instanceof ArrayBuffer) {
-        const buf = Buffer.from(data);
-        this.#logger.log(
-          LogLevel.Trace,
-          `(WebSockets transport) Received binary (${buf.length} bytes).`
-        );
-        this.onreceive?.(buf);
-      }
-    });
-    ws.addEventListener("close", (event) => {
-      const closeEvent = event;
-      this.#logger.log(
-        LogLevel.Information,
-        `(WebSockets transport) Socket closed (code=${closeEvent.code}).`
-      );
-      if (this.#ws !== null) {
-        this.#ws = null;
-        this.onclose?.();
-      }
-    });
-    ws.addEventListener("error", (event) => {
-      if (ws.readyState !== WebSocket.CONNECTING) {
-        const e = event;
-        const err = e.error instanceof Error ? e.error : new Error(String(e.message ?? "WebSocket error"));
-        this.#logger.log(LogLevel.Error, `(WebSockets transport) Error: ${err.message}`);
-        if (this.#ws !== null) {
-          this.#ws = null;
-          this.onclose?.(err);
-        }
-      }
-    });
-  }
-  send(data) {
-    if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) {
-      return Promise.reject(new Error("WebSocket is not open."));
-    }
-    try {
-      this.#ws.send(data);
-      return Promise.resolve();
-    } catch (err) {
-      return Promise.reject(err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-  stop() {
-    if (this.#ws) {
-      const ws = this.#ws;
-      this.#ws = null;
-      ws.close(1e3, "Normal closure");
-    }
-    return Promise.resolve();
-  }
-};
-
-// src/transports/sse-transport.ts
-var ServerSentEventsTransport = class {
-  name = "ServerSentEvents";
-  #httpClient;
-  #accessTokenFactory;
-  #logger;
-  #extraHeaders;
-  #url = null;
-  #abort = null;
-  // replaces the old ClientRequest handle
-  #sseBuffer = "";
-  onreceive = null;
-  onclose = null;
-  constructor(httpClient, accessTokenFactory, logger, extraHeaders = {}) {
-    this.#httpClient = httpClient;
-    this.#accessTokenFactory = accessTokenFactory;
-    this.#logger = logger;
-    this.#extraHeaders = extraHeaders;
-  }
-  async connect(url, transferFormat) {
-    if (transferFormat === TransferFormat.Binary) {
-      throw new Error("The Server-Sent Events transport only supports the Text transfer format.");
-    }
-    this.#logger.log(LogLevel.Trace, `(SSE transport) Connecting to ${url}.`);
-    this.#url = url;
-    const headers = {
-      Accept: "text/event-stream",
-      ...this.#extraHeaders
-    };
-    if (this.#accessTokenFactory) {
-      const token = await this.#accessTokenFactory();
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    }
-    const result = await this.#httpClient.stream("GET", url, { headers });
-    if (result.statusCode !== 200) {
-      result.body.on("error", () => {
-      });
-      result.abort();
-      throw new Error(
-        `Unexpected status code ${result.statusCode} from SSE endpoint.`
-      );
-    }
-    this.#abort = result.abort;
-    result.body.setEncoding("utf8");
-    result.body.on("data", (chunk) => this.#onData(chunk));
-    result.body.on("end", () => {
-      this.#logger.log(LogLevel.Information, "(SSE transport) EventSource closed.");
-      this.#abort = null;
-      this.onclose?.();
-    });
-    result.body.on("error", (err) => {
-      this.#logger.log(LogLevel.Error, `(SSE transport) Stream error: ${err.message}`);
-      this.#abort = null;
-      this.onclose?.(err);
-    });
-    this.#logger.log(LogLevel.Information, "(SSE transport) Connected.");
-  }
-  async send(data) {
-    if (!this.#url) throw new Error("SSE transport is not connected.");
-    const headers = {
-      "Content-Type": typeof data === "string" ? "text/plain;charset=UTF-8" : "application/octet-stream",
-      ...this.#extraHeaders
-    };
-    if (this.#accessTokenFactory) {
-      const token = await this.#accessTokenFactory();
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    }
-    const body = typeof data === "string" ? data : Buffer.from(data).toString("binary");
-    const result = await this.#httpClient.post(this.#url, { headers, body });
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`SSE send failed with status ${result.status}.`);
-    }
-  }
-  stop() {
-    if (this.#abort) {
-      this.#abort();
-      this.#abort = null;
-    }
-    return Promise.resolve();
-  }
-  // ─── SSE parser ───────────────────────────────────────────────────────────
-  #onData(chunk) {
-    this.#sseBuffer += chunk;
-    let boundary;
-    while ((boundary = findEventBoundary(this.#sseBuffer)) !== -1) {
-      const block = this.#sseBuffer.slice(0, boundary);
-      this.#sseBuffer = this.#sseBuffer.slice(boundary).replace(/^[\r\n]+/, "");
-      this.#dispatchEvent(block);
-    }
-  }
-  #dispatchEvent(block) {
-    const lines = block.split(/\r?\n/);
-    const dataParts = [];
-    for (const line of lines) {
-      if (line.startsWith("data:")) {
-        dataParts.push(line.slice(5).replace(/^ /, ""));
-      }
-    }
-    if (dataParts.length === 0) return;
-    const message = dataParts.join("\n");
-    this.#logger.log(LogLevel.Trace, `(SSE transport) Received data: ${message}`);
-    this.onreceive?.(message);
-  }
-};
-function findEventBoundary(str) {
-  const i1 = str.indexOf("\n\n");
-  const i2 = str.indexOf("\r\n\r\n");
-  if (i1 === -1 && i2 === -1) return -1;
-  if (i1 === -1) return i2 + 4;
-  if (i2 === -1) return i1 + 2;
-  return Math.min(i1 + 2, i2 + 4);
-}
-
-// src/transports/long-polling-transport.ts
-var POLL_TIMEOUT_MS = 1e5;
-var LongPollingTransport = class {
-  name = "LongPolling";
-  #httpClient;
-  #accessTokenFactory;
-  #logger;
-  #extraHeaders;
-  #url = null;
-  #running = false;
-  #pollImmediate = null;
-  onreceive = null;
-  onclose = null;
-  constructor(httpClient, accessTokenFactory, logger, extraHeaders = {}) {
-    this.#httpClient = httpClient;
-    this.#accessTokenFactory = accessTokenFactory;
-    this.#logger = logger;
-    this.#extraHeaders = extraHeaders;
-  }
-  async connect(url, _transferFormat) {
-    this.#logger.log(LogLevel.Trace, `(LongPolling transport) Connecting to ${url}.`);
-    this.#url = url;
-    this.#running = true;
-    await this.#poll(
-      url,
-      /* isConnect */
-      true
-    );
-    this.#schedulePoll();
-    this.#logger.log(LogLevel.Information, "(LongPolling transport) Connected.");
-  }
-  async send(data) {
-    if (!this.#running || !this.#url) {
-      throw new Error("LongPolling transport is not connected.");
-    }
-    const headers = await this.#buildHeaders({
-      "Content-Type": typeof data === "string" ? "text/plain;charset=UTF-8" : "application/octet-stream"
-    });
-    const body = typeof data === "string" ? data : Buffer.from(data).toString("binary");
-    const result = await this.#httpClient.post(this.#url, { headers, body });
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Long polling send failed with status ${result.status}.`);
-    }
-  }
-  async stop() {
-    this.#running = false;
-    if (this.#pollImmediate !== null) {
-      clearImmediate(this.#pollImmediate);
-      this.#pollImmediate = null;
-    }
-    if (this.#url) {
-      try {
-        const headers = await this.#buildHeaders();
-        await this.#httpClient.delete(this.#url, { headers });
-      } catch (e) {
-        this.#logger.log(
-          LogLevel.Warning,
-          `(LongPolling transport) Error sending DELETE: ${e.message}`
-        );
-      }
-    }
-  }
-  // ─── Internal polling ─────────────────────────────────────────────────────
-  #schedulePoll() {
-    if (!this.#running) return;
-    this.#pollImmediate = setImmediate(() => void this.#pollLoop());
-  }
-  async #pollLoop() {
-    if (!this.#running || !this.#url) return;
-    try {
-      await this.#poll(
-        this.#url,
-        /* isConnect */
-        false
-      );
-    } catch (err) {
-      if (this.#running) {
-        this.#logger.log(
-          LogLevel.Error,
-          `(LongPolling transport) Poll error: ${err.message}`
-        );
-        this.#running = false;
-        this.onclose?.(err instanceof Error ? err : new Error(String(err)));
-        return;
-      }
-    }
-    this.#schedulePoll();
-  }
-  async #poll(url, isConnect) {
-    const headers = await this.#buildHeaders();
-    let res;
-    try {
-      res = await this.#httpClient.get(url, { headers, timeout: POLL_TIMEOUT_MS });
-    } catch (err) {
-      if (!this.#running) return;
-      throw err;
-    }
-    if (res.status === 204) {
-      this.#logger.log(LogLevel.Information, "(LongPolling transport) Server closed (204).");
-      this.#running = false;
-      this.onclose?.();
-      return;
-    }
-    if (res.status < 200 || res.status >= 300) {
-      const err = new Error(`Long polling received unexpected status ${res.status}.`);
-      if (!isConnect) {
-        this.#running = false;
-        this.onclose?.(err);
-      } else {
-        throw err;
-      }
-      return;
-    }
-    if (res.body.length > 0) {
-      this.#logger.log(LogLevel.Trace, `(LongPolling transport) Received: ${res.body}`);
-      this.onreceive?.(res.body);
-    }
-  }
-  async #buildHeaders(extra = {}) {
-    const headers = { ...this.#extraHeaders, ...extra };
-    if (this.#accessTokenFactory) {
-      const token = await this.#accessTokenFactory();
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    }
-    return headers;
-  }
-};
-
-// src/logger.ts
-var ConsoleLogger = class {
-  #minimumLevel;
-  constructor(minimumLevel = LogLevel.Information) {
-    this.#minimumLevel = minimumLevel;
-  }
-  log(level, message) {
-    if (level < this.#minimumLevel) return;
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const label = logLevelName(level);
-    const line = `[${ts}] [${label}] ${message}`;
-    switch (level) {
-      case LogLevel.Trace:
-      case LogLevel.Debug:
-        console.debug(line);
-        break;
-      case LogLevel.Warning:
-        console.warn(line);
-        break;
-      case LogLevel.Error:
-      case LogLevel.Critical:
-        console.error(line);
-        break;
-      default:
-        console.log(line);
-        break;
-    }
-  }
-};
-var NullLogger = class _NullLogger {
-  /** Singleton - no state, so one instance is enough. */
-  static instance = new _NullLogger();
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  log(_logLevel, _message) {
-  }
-};
-function logLevelName(level) {
-  const entry = Object.entries(LogLevel).find(
-    ([, v]) => v === level
-  );
-  return entry?.[0] ?? String(level);
-}
-function resolveLogger(logLevelOrLogger) {
-  if (typeof logLevelOrLogger === "number") {
-    return new ConsoleLogger(logLevelOrLogger);
-  }
-  if (logLevelOrLogger != null && typeof logLevelOrLogger === "object" && typeof logLevelOrLogger.log === "function") {
-    return logLevelOrLogger;
-  }
-  throw new TypeError(
-    "configureLogging expects a LogLevel number or an object with a log(level, message) method."
-  );
-}
-
-// src/errors.ts
-var HubError = class extends Error {
-  name = "HubError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var AbortError = class extends Error {
-  name = "AbortError";
-  constructor(message = "The operation was aborted.") {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var TransportError = class extends Error {
-  name = "TransportError";
-  statusCode;
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var HandshakeError = class extends Error {
-  name = "HandshakeError";
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var UnsupportedTransportError = class extends Error {
-  name = "UnsupportedTransportError";
-  transport;
-  constructor(message, transport) {
-    super(message);
-    this.transport = transport;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-function isHubError(e) {
-  return e instanceof HubError;
-}
-function isAbortError(e) {
-  return e instanceof AbortError;
-}
-function isTransportError(e) {
-  return e instanceof TransportError;
-}
-
-// src/hub-connection.ts
-var MAX_REDIRECTS = 100;
-var StreamSubscription = class {
-  #disposed = false;
-  #cancel;
-  constructor(cancel) {
-    this.#cancel = cancel;
-  }
-  dispose() {
-    if (!this.#disposed) {
-      this.#disposed = true;
-      this.#cancel();
-    }
-  }
-  /** TS 5.2+ `using` keyword support. */
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-};
-var HubConnection = class {
-  #url;
-  #logger;
-  #accessTokenFactory;
-  #requestedTransport;
-  #extraHeaders;
-  #skipNegotiation;
-  #serverTimeout;
-  #pingInterval;
-  #handshakeTimeout;
-  #reconnectPolicy;
-  #protocol;
-  #http;
-  #dispatcher;
-  #transport = null;
-  #connectionId = null;
-  #connectionToken = null;
-  #state = HubConnectionState.Disconnected;
-  #stopping = false;
-  /** Pending `invoke()` calls awaiting a Completion message. */
-  #callbacks = /* @__PURE__ */ new Map();
-  /** Active server-streaming subscriptions awaiting StreamItem/Completion. */
-  #streamCbs = /* @__PURE__ */ new Map();
-  /** Client-method handlers registered via `on()`. */
-  #methods = /* @__PURE__ */ new Map();
-  /** Registered `onclose` callbacks. */
-  #closedCallbacks = [];
-  /** Registered `onreconnecting` callbacks. */
-  #reconnectingCallbacks = [];
-  /** Registered `onreconnected` callbacks. */
-  #reconnectedCallbacks = [];
-  #pingTimer = null;
-  #serverTimeoutTimer = null;
-  #handshakeTimer = null;
-  #handshakeResolver = null;
-  #handshakeRejecter = null;
-  #messageBuffer = "";
-  #invocationSeq = 0;
-  constructor(url, options = {}) {
-    this.#url = url;
-    this.#logger = options.logger ?? NullLogger.instance;
-    this.#accessTokenFactory = options.accessTokenFactory ?? null;
-    this.#requestedTransport = options.transport ?? HttpTransportType.WebSockets | HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling;
-    this.#extraHeaders = options.headers ?? {};
-    this.#skipNegotiation = options.skipNegotiation ?? false;
-    this.#serverTimeout = options.serverTimeoutInMilliseconds ?? DEFAULT_SERVER_TIMEOUT_IN_MS;
-    this.#pingInterval = options.keepAliveIntervalInMilliseconds ?? DEFAULT_PING_INTERVAL_IN_MS;
-    this.#handshakeTimeout = options.handshakeTimeoutInMilliseconds ?? 15e3;
-    this.#reconnectPolicy = options.reconnectPolicy ?? null;
-    this.#protocol = new JsonHubProtocol();
-    this.#dispatcher = options.dispatcher;
-    this.#http = options.httpClient ?? new DispatchHttpClient({
-      headers: this.#extraHeaders,
-      ...options.dispatcher !== void 0 && { dispatcher: options.dispatcher }
-    });
-  }
-  // ─── State ───────────────────────────────────────────────────────────────
-  get state() {
-    return this.#state;
-  }
-  get connectionId() {
-    return this.#connectionId;
-  }
-  // ─── Lifecycle ───────────────────────────────────────────────────────────
-  async start() {
-    if (this.#state !== HubConnectionState.Disconnected) {
-      throw new Error(
-        `Cannot start: connection is not Disconnected (current: ${this.#state}).`
-      );
-    }
-    this.#state = HubConnectionState.Connecting;
-    this.#stopping = false;
-    this.#logger.log(LogLevel.Debug, "Starting HubConnection.");
-    try {
-      await this.#startInternal();
-      this.#state = HubConnectionState.Connected;
-      this.#logger.log(LogLevel.Information, "HubConnection connected.");
-    } catch (err) {
-      this.#state = HubConnectionState.Disconnected;
-      this.#logger.log(LogLevel.Error, `Failed to start: ${err.message}`);
-      throw err;
-    }
-  }
-  async stop() {
-    this.#stopping = true;
-    this.#logger.log(LogLevel.Debug, "Stopping HubConnection.");
-    this.#clearTimers();
-    const stopErr = new AbortError("Connection stopped before the invocation completed.");
-    this.#rejectAllPending(stopErr);
-    if (this.#transport) {
-      try {
-        await this.#transport.stop();
-      } catch {
-      }
-      this.#transport = null;
-    }
-    this.#state = HubConnectionState.Disconnected;
-    this.#logger.log(LogLevel.Information, "HubConnection stopped.");
-  }
-  // ─── Sending ─────────────────────────────────────────────────────────────
-  /**
-   * Invoke a hub method and return the server's result.
-   *
-   * @typeParam T  The expected return type.  Asserted at runtime - the server
-   *               decides the actual value.
-   */
-  invoke(methodName, ...args) {
-    this.#assertConnected("invoke");
-    const id = this.#nextId();
-    const msg = this.#protocol.writeMessage(
-      JsonHubProtocol.invocation(id, methodName, args)
-    );
-    return new Promise((resolve, reject) => {
-      this.#callbacks.set(id, {
-        resolve,
-        reject
-      });
-      this.#send(msg).catch((err) => {
-        this.#callbacks.delete(id);
-        reject(err);
-      });
-    });
-  }
-  /**
-   * Fire-and-forget hub method invocation.
-   * The server does not send a completion message.
-   */
-  send(methodName, ...args) {
-    this.#assertConnected("send");
-    const msg = this.#protocol.writeMessage(
-      JsonHubProtocol.send(methodName, args)
-    );
-    return this.#send(msg);
-  }
-  // ─── Server-streaming ────────────────────────────────────────────────────
-  /**
-   * Start a server-streaming invocation.
-   * The call is not sent until `subscribe` is called.
-   * The returned `ISubscription` implements `Symbol.dispose` for `using`.
-   *
-   * @typeParam T  Type of each streamed item.
-   *
-   * @example
-   * ```ts
-   * using sub = connection.stream<number>('Counter', 10).subscribe({
-   *   next:     (n) => console.log(n),
-   *   complete: ()  => console.log('done'),
-   * });
-   * ```
-   */
-  stream(methodName, ...args) {
-    this.#assertConnected("stream");
-    const id = this.#nextId();
-    return {
-      subscribe: (subscriber) => {
-        const msg = this.#protocol.writeMessage(
-          JsonHubProtocol.streamInvocation(id, methodName, args)
-        );
-        this.#streamCbs.set(id, {
-          next: (v) => subscriber.next?.(v),
-          error: (e) => subscriber.error?.(e),
-          complete: () => subscriber.complete?.()
-        });
-        this.#send(msg).catch((err) => {
-          this.#streamCbs.delete(id);
-          subscriber.error?.(err);
-        });
-        return new StreamSubscription(() => {
-          if (this.#streamCbs.has(id)) {
-            this.#streamCbs.delete(id);
-            this.#send(
-              this.#protocol.writeMessage(JsonHubProtocol.cancelInvocation(id))
-            ).catch(() => {
-            });
-          }
-        });
-      }
-    };
-  }
-  // ─── Event registration ───────────────────────────────────────────────────
-  /**
-   * Register a handler for a server→client hub method.
-   * Multiple handlers for the same method are supported.
-   *
-   * @typeParam TArgs  Tuple of argument types for the hub method.
-   */
-  on(methodName, handler) {
-    const key = methodName.toLowerCase();
-    if (!this.#methods.has(key)) this.#methods.set(key, /* @__PURE__ */ new Set());
-    this.#methods.get(key).add(handler);
-  }
-  /**
-   * Remove a previously registered handler, or all handlers for a method.
-   */
-  off(methodName, handler) {
-    const key = methodName.toLowerCase();
-    if (!this.#methods.has(key)) return;
-    if (handler == null) {
-      this.#methods.delete(key);
-    } else {
-      this.#methods.get(key).delete(handler);
-      if (this.#methods.get(key).size === 0) this.#methods.delete(key);
-    }
-  }
-  onclose(callback) {
-    this.#closedCallbacks.push(callback);
-  }
-  onreconnecting(callback) {
-    this.#reconnectingCallbacks.push(callback);
-  }
-  onreconnected(callback) {
-    this.#reconnectedCallbacks.push(callback);
-  }
-  // ─── Internal: start sequence ────────────────────────────────────────────
-  async #startInternal() {
-    let url = this.#url;
-    if (this.#skipNegotiation) {
-      if ((this.#requestedTransport & HttpTransportType.WebSockets) === 0) {
-        throw new Error("skipNegotiation requires the WebSockets transport.");
-      }
-      this.#transport = this.#createTransport(HttpTransportType.WebSockets);
-      await this.#connectTransport(url, TransferFormat.Text);
-    } else {
-      let redirectCount = 0;
-      for (; ; ) {
-        const neg = await this.#negotiate(url);
-        if (neg.url) {
-          if (redirectCount++ >= MAX_REDIRECTS) throw new Error("Too many negotiate redirects.");
-          url = neg.url;
-          if (neg.accessToken) {
-            const staticToken = neg.accessToken;
-            this.#overrideAccessToken(() => Promise.resolve(staticToken));
-          }
-          continue;
-        }
-        this.#connectionId = neg.connectionId ?? null;
-        this.#connectionToken = neg.connectionToken ?? neg.connectionId ?? null;
-        await this.#selectTransport(url, neg.availableTransports ?? []);
-        break;
-      }
-    }
-    this.#transport.onreceive = (data) => this.#processIncoming(
-      typeof data === "string" ? data : Buffer.from(data).toString("utf8")
-    );
-    this.#transport.onclose = (err) => this.#onTransportClosed(err);
-    await this.#performHandshake();
-    this.#resetPingTimer();
-    this.#resetServerTimeoutTimer();
-  }
-  // Rebinds the access token factory (used after Azure SignalR redirect).
-  // Stored as a field to allow rebinding without recreating the instance.
-  #_accessTokenFactory = null;
-  #overrideAccessToken(factory) {
-    this.#_accessTokenFactory = factory;
-  }
-  #getAccessTokenFactory() {
-    return this.#_accessTokenFactory ?? this.#accessTokenFactory;
-  }
-  async #negotiate(baseUrl) {
-    const negotiateUrl = new URL(baseUrl);
-    negotiateUrl.pathname = negotiateUrl.pathname.replace(/\/$/, "") + "/negotiate";
-    negotiateUrl.searchParams.set("negotiateVersion", String(NEGOTIATE_VERSION));
-    const url = negotiateUrl.toString();
-    this.#logger.log(LogLevel.Debug, `Sending negotiate request to ${url}.`);
-    const headers = { ...this.#extraHeaders };
-    const factory = this.#getAccessTokenFactory();
-    if (factory) {
-      const token = await factory();
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    }
-    const res = await this.#http.post(url, { headers });
-    if (res.status !== 200) {
-      throw new TransportError(
-        `Unexpected status code ${res.status} from negotiate.`,
-        res.status
-      );
-    }
-    const body = JSON.parse(res.body);
-    if (body.error) throw new Error(`Negotiate returned error: ${body.error}`);
-    return body;
-  }
-  async #selectTransport(url, available) {
-    const ORDERED = [
-      { flag: HttpTransportType.WebSockets, name: "WebSockets", format: TransferFormat.Text },
-      { flag: HttpTransportType.ServerSentEvents, name: "ServerSentEvents", format: TransferFormat.Text },
-      { flag: HttpTransportType.LongPolling, name: "LongPolling", format: TransferFormat.Text }
-    ];
-    const serverSet = new Set(available.map((t) => t.transport));
-    for (const pref of ORDERED) {
-      if ((this.#requestedTransport & pref.flag) === 0) continue;
-      if (!serverSet.has(pref.name)) continue;
-      this.#logger.log(LogLevel.Debug, `Trying ${pref.name} transport.`);
-      const transport = this.#createTransport(pref.flag);
-      const token = this.#connectionToken ?? "";
-      const tUrl = appendParam(url, "id", token);
-      try {
-        await transport.connect(tUrl, pref.format);
-        this.#transport = transport;
-        return;
-      } catch (err) {
-        this.#logger.log(LogLevel.Warning, `${pref.name} failed: ${err.message}`);
-      }
-    }
-    throw new UnsupportedTransportError(
-      "Unable to connect with any of the available transports.",
-      null
-    );
-  }
-  async #connectTransport(url, format) {
-    await this.#transport.connect(url, format);
-  }
-  #createTransport(type) {
-    const factory = this.#getAccessTokenFactory();
-    const headers = this.#extraHeaders;
-    switch (type) {
-      case HttpTransportType.WebSockets:
-        return new WebSocketTransport(factory, this.#logger, headers, this.#dispatcher);
-      case HttpTransportType.ServerSentEvents:
-        return new ServerSentEventsTransport(this.#http, factory, this.#logger, headers);
-      case HttpTransportType.LongPolling:
-        return new LongPollingTransport(this.#http, factory, this.#logger, headers);
-      /* istanbul ignore next */
-      default:
-        throw new UnsupportedTransportError(`Unknown transport type: ${type}`, type);
-    }
-  }
-  // ─── Internal: handshake ─────────────────────────────────────────────────
-  #performHandshake() {
-    return new Promise((resolve, reject) => {
-      this.#handshakeResolver = resolve;
-      this.#handshakeRejecter = reject;
-      this.#transport.send(HANDSHAKE_REQUEST).catch(reject);
-      this.#handshakeTimer = setTimeout(() => {
-        reject(new Error("Server timeout: no handshake response received."));
-      }, this.#handshakeTimeout);
-    });
-  }
-  // ─── Internal: incoming data ─────────────────────────────────────────────
-  #processIncoming(text) {
-    this.#resetServerTimeoutTimer();
-    this.#messageBuffer += text;
-    if (this.#handshakeResolver) {
-      try {
-        const { remainder } = parseHandshakeResponse(this.#messageBuffer);
-        this.#messageBuffer = remainder;
-        this.#logger.log(LogLevel.Debug, "Handshake complete.");
-        clearTimeout(this.#handshakeTimer);
-        const r = this.#handshakeResolver;
-        this.#handshakeResolver = null;
-        this.#handshakeRejecter = null;
-        r();
-      } catch (err) {
-        clearTimeout(this.#handshakeTimer);
-        const r = this.#handshakeRejecter;
-        this.#handshakeResolver = null;
-        this.#handshakeRejecter = null;
-        r(err instanceof Error ? err : new Error(String(err)));
-        return;
-      }
-    }
-    if (!this.#messageBuffer) return;
-    let messages;
-    try {
-      messages = this.#protocol.parseMessages(this.#messageBuffer, this.#logger);
-    } catch (err) {
-      this.#logger.log(LogLevel.Error, `Error parsing messages: ${err.message}`);
-      this.#stopWithError(err instanceof Error ? err : new Error(String(err)));
-      return;
-    }
-    this.#messageBuffer = "";
-    for (const msg of messages) {
-      switch (msg.type) {
-        // ── Type 1: Server calls a client method ──────────────────────────
-        case MessageType.Invocation: {
-          const key = msg.target.toLowerCase();
-          const handlers = this.#methods.get(key);
-          if (!handlers || handlers.size === 0) {
-            this.#logger.log(LogLevel.Warning, `No handler for "${msg.target}".`);
-            break;
-          }
-          for (const h of handlers) {
-            try {
-              h(...msg.arguments);
-            } catch (e) {
-              this.#logger.log(LogLevel.Error, `Handler for "${msg.target}" threw: ${e.message}`);
-            }
-          }
-          break;
-        }
-        // ── Type 2: One item from a server stream ─────────────────────────
-        // Per spec, StreamItem carries only `item`; there is no `error` field.
-        case MessageType.StreamItem: {
-          const sc = this.#streamCbs.get(msg.invocationId);
-          if (!sc) break;
-          sc.next(msg.item);
-          break;
-        }
-        // ── Type 3: Completion of an invoke() or stream ───────────────────
-        case MessageType.Completion: {
-          const cb = this.#callbacks.get(msg.invocationId);
-          if (cb) {
-            this.#callbacks.delete(msg.invocationId);
-            if (msg.error) cb.reject(new HubError(msg.error));
-            else cb.resolve(msg.result ?? null);
-          }
-          const sc = this.#streamCbs.get(msg.invocationId);
-          if (sc) {
-            this.#streamCbs.delete(msg.invocationId);
-            if (msg.error) sc.error(new HubError(msg.error));
-            else sc.complete();
-          }
-          break;
-        }
-        // ── Type 6: Ping ──────────────────────────────────────────────────
-        case MessageType.Ping:
-          break;
-        // ── Type 7: Server-initiated close ────────────────────────────────
-        case MessageType.Close: {
-          this.#logger.log(LogLevel.Information, "Server sent Close message.");
-          const closeErr = msg.error ? new HubError(msg.error) : null;
-          if (msg.allowReconnect && this.#reconnectPolicy && !this.#stopping) {
-            this.#clearTimers();
-            if (this.#transport) this.#transport.onclose = null;
-            const t = this.#transport;
-            this.#transport = null;
-            void t?.stop().catch(() => {
-            });
-            void this.#doReconnect(closeErr);
-          } else {
-            this.#stopWithError(closeErr);
-          }
-          break;
-        }
-        default:
-          this.#logger.log(LogLevel.Warning, `Unknown message type: ${msg.type}`);
-          break;
-      }
-    }
-  }
-  // ─── Internal: transport closed ──────────────────────────────────────────
-  #onTransportClosed(err) {
-    if (this.#stopping) return;
-    this.#logger.log(
-      LogLevel.Warning,
-      err ? `Transport closed with error: ${err.message}` : "Transport closed."
-    );
-    this.#clearTimers();
-    if (this.#reconnectPolicy) {
-      void this.#doReconnect(err ?? null);
-    } else {
-      this.#completeClose(err);
-    }
-  }
-  #stopWithError(err) {
-    this.#clearTimers();
-    void this.#transport?.stop().catch(() => {
-    });
-    this.#transport = null;
-    this.#completeClose(err ?? void 0);
-  }
-  #completeClose(err) {
-    const closeErr = err ?? new AbortError("Connection closed.");
-    this.#rejectAllPending(closeErr);
-    this.#state = HubConnectionState.Disconnected;
-    for (const cb of this.#closedCallbacks) {
-      try {
-        cb(err);
-      } catch {
-      }
-    }
-  }
-  #rejectAllPending(err) {
-    this.#callbacks.forEach((cb) => cb.reject(err));
-    this.#callbacks.clear();
-    this.#streamCbs.forEach((sc) => sc.error(err));
-    this.#streamCbs.clear();
-  }
-  // ─── Internal: auto-reconnect ─────────────────────────────────────────────
-  async #doReconnect(disconnectError) {
-    this.#state = HubConnectionState.Reconnecting;
-    for (const cb of this.#reconnectingCallbacks) {
-      try {
-        cb(disconnectError ?? void 0);
-      } catch {
-      }
-    }
-    let retryCount = 0;
-    const startTime = Date.now();
-    let lastError = disconnectError;
-    while (!this.#stopping) {
-      const ctx = {
-        previousRetryCount: retryCount,
-        elapsedMilliseconds: Date.now() - startTime,
-        retryReason: lastError
-      };
-      const delay = this.#reconnectPolicy.nextRetryDelayInMilliseconds(ctx);
-      if (delay === null) {
-        this.#logger.log(LogLevel.Debug, "Reconnect policy returned null - giving up.");
-        break;
-      }
-      this.#logger.log(LogLevel.Information, `Reconnecting in ${delay} ms (attempt ${retryCount + 1}).`);
-      await sleep(delay);
-      if (this.#stopping) break;
-      try {
-        await this.#startInternal();
-        this.#state = HubConnectionState.Connected;
-        this.#logger.log(LogLevel.Information, "Reconnected successfully.");
-        for (const cb of this.#reconnectedCallbacks) {
-          try {
-            cb(this.#connectionId);
-          } catch {
-          }
-        }
-        return;
-      } catch (err) {
-        retryCount++;
-        lastError = err instanceof Error ? err : new Error(String(err));
-        this.#logger.log(LogLevel.Warning, `Reconnect attempt ${retryCount} failed: ${lastError.message}`);
-      }
-    }
-    this.#completeClose(lastError ?? void 0);
-  }
-  // ─── Internal: timers ────────────────────────────────────────────────────
-  #resetPingTimer() {
-    clearTimeout(this.#pingTimer);
-    this.#pingTimer = setTimeout(async () => {
-      if (this.#state !== HubConnectionState.Connected) return;
-      try {
-        await this.#send(this.#protocol.writeMessage(JsonHubProtocol.ping()));
-      } catch (err) {
-        this.#logger.log(LogLevel.Warning, `Ping failed: ${err.message}`);
-      }
-      this.#resetPingTimer();
-    }, this.#pingInterval);
-  }
-  #resetServerTimeoutTimer() {
-    clearTimeout(this.#serverTimeoutTimer);
-    this.#serverTimeoutTimer = setTimeout(() => {
-      this.#logger.log(LogLevel.Warning, "Server timeout - closing connection.");
-      this.#stopWithError(new AbortError("Server timeout: no message received within the timeout period."));
-    }, this.#serverTimeout);
-  }
-  #clearTimers() {
-    clearTimeout(this.#pingTimer);
-    clearTimeout(this.#serverTimeoutTimer);
-    clearTimeout(this.#handshakeTimer);
-    this.#pingTimer = null;
-    this.#serverTimeoutTimer = null;
-    this.#handshakeTimer = null;
-  }
-  // ─── Internal: helpers ────────────────────────────────────────────────────
-  #send(message) {
-    this.#resetPingTimer();
-    return this.#transport.send(message);
-  }
-  #assertConnected(method) {
-    if (this.#state !== HubConnectionState.Connected) {
-      throw new Error(
-        `Cannot call "${method}" when connection is not Connected (current: ${this.#state}).`
-      );
-    }
-  }
-  #nextId() {
-    return toInvocationId(String(++this.#invocationSeq));
-  }
-};
-function appendParam(url, name, value) {
-  const u = new URL(url);
-  u.searchParams.append(name, value);
-  return u.toString();
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/hub-connection-builder.ts
-import { CookieAgent } from "@exhumer/undici-cookie-agent";
-import { CookieJar } from "tough-cookie";
-var DEFAULT_RETRY_DELAYS = [0, 2e3, 1e4, 3e4];
-var HubConnectionBuilder = class {
-  #url = null;
-  #urlOptions = {};
-  #logger = null;
-  #reconnectPolicy = null;
-  #dispatcher = null;
-  #httpClient = null;
-  #cookieJar = null;
-  // ─── withUrl ─────────────────────────────────────────────────────────────
-  withUrl(url, options) {
-    if (!url || typeof url !== "string") {
-      throw new TypeError("withUrl requires a non-empty string URL.");
-    }
-    this.#url = url;
-    this.#urlOptions = options ?? {};
-    return this;
-  }
-  // ─── withCookies ─────────────────────────────────────────────────────────
-  /**
-   * Enable automatic cookie handling for the entire connection session using
-   * a `tough-cookie` `CookieJar` and an `@exhumer/undici-cookie-agent` `CookieAgent`.
-   *
-   * When enabled, the `CookieAgent` wraps every outgoing request - including
-   * the `/negotiate` POST, WebSocket upgrade, SSE long-lived GET, and all
-   * long-polling requests - so that:
-   *
-   *  1. `Set-Cookie` headers in the **negotiate response** (and any subsequent
-   *     response) are stored in the jar automatically.
-   *  2. All subsequent requests from the same session include the matching
-   *     `Cookie` header, exactly as a browser would.
-   *
-   * @param jar
-   *   An existing `CookieJar` to use.  Pass your own jar when you need to
-   *   pre-seed cookies (e.g. an auth session cookie obtained before calling
-   *   `start()`) or inspect the jar after the session ends.
-   *   When omitted a new, empty jar is created automatically.
-   *
-   * @throws if {@link withDispatcher} has already been called.  To combine a
-   *   custom dispatcher (e.g. `ProxyAgent`) with cookie support, compose the
-   *   `cookie` interceptor onto your dispatcher and pass it to `withDispatcher()`:
-   *
-   * ```ts
-   * import { ProxyAgent } from 'undici';
-   * import { cookie, CookieJar } from '@exhumer/signalr-client';
-   *
-   * const jar   = new CookieJar();
-   * const agent = new ProxyAgent('http://proxy:8080').compose(cookie({ jar }));
-   *
-   * const conn = new HubConnectionBuilder()
-   *   .withUrl('https://example.com/hub')
-   *   .withDispatcher(agent)
-   *   .build();
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Automatic jar - no pre-configuration needed
-   * const conn = new HubConnectionBuilder()
-   *   .withUrl('https://example.com/hub')
-   *   .withCookies()
-   *   .build();
-   *
-   * // Pre-seeded jar - inject a session cookie before connecting
-   * import { CookieJar } from '@exhumer/signalr-client';
-   * const jar = new CookieJar();
-   * await jar.setCookie('session=abc123', 'https://example.com');
-   *
-   * const conn = new HubConnectionBuilder()
-   *   .withUrl('https://example.com/hub')
-   *   .withCookies(jar)
-   *   .build();
-   * ```
-   */
-  withCookies(jar) {
-    if (this.#dispatcher !== null) {
-      throw new Error(
-        "withCookies() cannot be used after withDispatcher(). To combine a custom dispatcher with cookie support, compose the cookie interceptor from @exhumer/undici-cookie-agent onto your dispatcher and pass it to withDispatcher() instead."
-      );
-    }
-    this.#cookieJar = jar ?? new CookieJar();
-    return this;
-  }
-  // ─── withDispatcher ──────────────────────────────────────────────────────
-  /**
-   * Set the undici `Dispatcher` for the entire connection session.
-   *
-   * The same dispatcher is used for:
-   *   • the `/negotiate` HTTP POST
-   *   • the WebSocket upgrade request
-   *   • SSE long-lived GET and send POSTs
-   *   • long-polling GETs, POSTs, and DELETE
-   *
-   * Accepts any `Dispatcher` subclass: `Agent`, `Pool`, `Client`,
-   * `ProxyAgent`, `MockAgent`, etc.
-   *
-   * To combine a custom dispatcher with automatic cookie handling, use
-   * `createCookieAgentClass()` to build a cookie-aware variant of your
-   * dispatcher and pass that here.  Do **not** chain both
-   * `withDispatcher()` and `withCookies()` - they are mutually exclusive
-   * because `withCookies()` creates its own dispatcher internally.
-   *
-   * @example
-   * ```ts
-   * import { ProxyAgent } from 'undici';
-   *
-   * const conn = new HubConnectionBuilder()
-   *   .withUrl('https://example.com/hub')
-   *   .withDispatcher(new ProxyAgent('http://proxy:8080'))
-   *   .build();
-   * ```
-   */
-  withDispatcher(dispatcher) {
-    if (this.#cookieJar !== null) {
-      throw new Error(
-        "withDispatcher() cannot be used after withCookies(). To combine a custom dispatcher with cookie support, compose the cookie interceptor from @exhumer/undici-cookie-agent onto your dispatcher and pass it to withDispatcher() instead."
-      );
-    }
-    this.#dispatcher = dispatcher;
-    return this;
-  }
-  /**
-   * Provide a custom HTTP client implementation.
-   *
-   * By default `HubConnection` uses `DispatchHttpClient` (undici `dispatch`).
-   * Use this to substitute any of the other undici-backed clients, or
-   * to inject a mock for testing.
-   *
-   * @example
-   * ```ts
-   * import { FetchHttpClient } from '@signalr/client';
-   *
-   * const conn = new HubConnectionBuilder()
-   *   .withUrl('https://example.com/hub')
-   *   .withHttpClient(new FetchHttpClient())
-   *   .build();
-   * ```
-   */
-  withHttpClient(httpClient) {
-    this.#httpClient = httpClient;
-    return this;
-  }
-  // ─── configureLogging ────────────────────────────────────────────────────
-  /**
-   * Set the minimum log level or provide a custom logger.
-   *
-   * @param logLevelOrLogger
-   *   - `LogLevel` number  →  uses the built-in ConsoleLogger
-   *   - `ILogger` object   →  used as-is
-   */
-  configureLogging(logLevelOrLogger) {
-    this.#logger = resolveLogger(logLevelOrLogger);
-    return this;
-  }
-  withAutomaticReconnect(arg) {
-    if (arg === void 0) {
-      this.#reconnectPolicy = new DefaultReconnectPolicy([...DEFAULT_RETRY_DELAYS]);
-    } else if (Array.isArray(arg)) {
-      this.#reconnectPolicy = new DefaultReconnectPolicy(arg);
-    } else if (typeof arg === "object" && typeof arg.nextRetryDelayInMilliseconds === "function") {
-      this.#reconnectPolicy = arg;
-    } else {
-      throw new TypeError(
-        "withAutomaticReconnect expects no args, a number[], or an IRetryPolicy."
-      );
-    }
-    return this;
-  }
-  // ─── build ───────────────────────────────────────────────────────────────
-  build() {
-    if (!this.#url) {
-      throw new Error("withUrl() must be called before build().");
-    }
-    const effectiveDispatcher = this.#cookieJar !== null ? new CookieAgent({ cookies: { jar: this.#cookieJar } }) : this.#dispatcher;
-    const options = {
-      ...this.#logger != null && { logger: this.#logger },
-      ...this.#urlOptions.accessTokenFactory != null && { accessTokenFactory: this.#urlOptions.accessTokenFactory },
-      ...this.#urlOptions.transport != null && { transport: this.#urlOptions.transport },
-      ...this.#urlOptions.headers != null && { headers: this.#urlOptions.headers },
-      ...this.#urlOptions.skipNegotiation != null && { skipNegotiation: this.#urlOptions.skipNegotiation },
-      ...this.#urlOptions.serverTimeoutInMilliseconds != null && { serverTimeoutInMilliseconds: this.#urlOptions.serverTimeoutInMilliseconds },
-      ...this.#urlOptions.keepAliveIntervalInMilliseconds != null && { keepAliveIntervalInMilliseconds: this.#urlOptions.keepAliveIntervalInMilliseconds },
-      ...this.#urlOptions.handshakeTimeoutInMilliseconds != null && { handshakeTimeoutInMilliseconds: this.#urlOptions.handshakeTimeoutInMilliseconds },
-      ...this.#reconnectPolicy != null && { reconnectPolicy: this.#reconnectPolicy },
-      ...effectiveDispatcher != null && { dispatcher: effectiveDispatcher },
-      ...this.#httpClient != null && { httpClient: this.#httpClient }
-    };
-    return new HubConnection(this.#url, options);
-  }
-};
-var DefaultReconnectPolicy = class {
-  #retryDelays;
-  constructor(retryDelays = [...DEFAULT_RETRY_DELAYS]) {
-    this.#retryDelays = retryDelays;
-  }
-  nextRetryDelayInMilliseconds(context) {
-    const delay = this.#retryDelays[context.previousRetryCount];
-    return delay ?? null;
-  }
-};
-
-// src/protocols/msgpack-hub-protocol.ts
-import { encode, decode } from "@msgpack/msgpack";
-var HANDSHAKE_REQUEST2 = JSON.stringify({ protocol: "messagepack", version: 1 }) + RECORD_SEPARATOR;
-var ResultKind = Object.freeze({
-  Error: 1,
-  Void: 2,
-  NonVoid: 3
-});
-function writeVarInt(n) {
-  const bytes = [];
-  do {
-    let b = n & 127;
-    n >>>= 7;
-    if (n > 0) b |= 128;
-    bytes.push(b);
-  } while (n > 0);
-  return new Uint8Array(bytes);
-}
-function readVarInt(data, offset) {
-  let value = 0;
-  let shift = 0;
-  let bytesRead = 0;
-  let hasMore = true;
-  while (hasMore) {
-    if (offset + bytesRead >= data.length) {
-      throw new Error("MessagePack: unexpected end of data reading VarInt frame length.");
-    }
-    const byte = data[offset + bytesRead];
-    hasMore = (byte & 128) !== 0;
-    value |= (byte & 127) << shift;
-    shift += 7;
-    bytesRead++;
-  }
-  return { value, bytesRead };
-}
-function pack(arr) {
-  const payload = encode(arr);
-  const lenPrefix = writeVarInt(payload.length);
-  const result = new Uint8Array(lenPrefix.length + payload.length);
-  result.set(lenPrefix, 0);
-  result.set(payload, lenPrefix.length);
-  return result.buffer.slice(0, result.byteLength);
-}
-var MsgpackHubProtocol = class {
-  name = "messagepack";
-  version = 1;
-  transferFormat = TransferFormat.Binary;
-  // ─── IHubProtocol: parseMessages ─────────────────────────────────────
-  parseMessages(input, logger) {
-    const raw = typeof input === "string" ? new TextEncoder().encode(input).buffer : input;
-    const data = new Uint8Array(raw);
-    if (data.length === 0) return [];
-    const messages = [];
-    let offset = 0;
-    while (offset < data.length) {
-      const { value: msgLen, bytesRead } = readVarInt(data, offset);
-      offset += bytesRead;
-      if (offset + msgLen > data.length) {
-        throw new Error(
-          `MessagePack hub message: declared length ${msgLen} B exceeds remaining data (${data.length - offset} B).`
-        );
-      }
-      const frame = data.subarray(offset, offset + msgLen);
-      offset += msgLen;
-      const rawArr = decode(frame);
-      if (!Array.isArray(rawArr) || rawArr.length === 0) {
-        throw new Error(
-          "Invalid MessagePack hub message: top-level value must be a non-empty array."
-        );
-      }
-      const msg = this.#coerce(rawArr, logger);
-      if (msg !== null) messages.push(msg);
-    }
-    return messages;
-  }
-  // ─── IHubProtocol: writeMessage ───────────────────────────────────────
-  writeMessage(message) {
-    switch (message.type) {
-      case MessageType.Invocation:
-        return pack([
-          MessageType.Invocation,
-          message.headers ?? {},
-          message.invocationId ?? null,
-          message.target,
-          message.arguments,
-          message.streamIds ?? []
-        ]);
-      case MessageType.StreamItem:
-        return pack([
-          MessageType.StreamItem,
-          message.headers ?? {},
-          message.invocationId,
-          message.item
-        ]);
-      case MessageType.Completion: {
-        const hasError = message.error != null;
-        const hasResult = message.result != null;
-        if (hasError) {
-          return pack([
-            MessageType.Completion,
-            message.headers ?? {},
-            message.invocationId,
-            ResultKind.Error,
-            message.error
-          ]);
-        } else if (hasResult) {
-          return pack([
-            MessageType.Completion,
-            message.headers ?? {},
-            message.invocationId,
-            ResultKind.NonVoid,
-            message.result
-          ]);
-        } else {
-          return pack([
-            MessageType.Completion,
-            message.headers ?? {},
-            message.invocationId,
-            ResultKind.Void
-          ]);
-        }
-      }
-      case MessageType.StreamInvocation:
-        return pack([
-          MessageType.StreamInvocation,
-          message.headers ?? {},
-          message.invocationId,
-          message.target,
-          message.arguments,
-          message.streamIds ?? []
-        ]);
-      case MessageType.CancelInvocation:
-        return pack([
-          MessageType.CancelInvocation,
-          message.headers ?? {},
-          message.invocationId
-        ]);
-      case MessageType.Ping:
-        return pack([MessageType.Ping]);
-      case MessageType.Close: {
-        const arr = [MessageType.Close, message.error ?? null];
-        if (message.allowReconnect !== void 0) arr.push(message.allowReconnect);
-        return pack(arr);
-      }
-    }
-  }
-  // ─── Coercion / narrowing ─────────────────────────────────────────────
-  /**
-   * Validate and narrow a raw decoded array into a typed `HubMessage`.
-   * Returns `null` for unknown types - they are logged as warnings.
-   */
-  #coerce(arr, logger) {
-    const type = arr[0];
-    if (typeof type !== "number") {
-      throw new Error(
-        `Invalid MessagePack hub message: first element (type) must be a number, got ${JSON.stringify(type)}.`
-      );
-    }
-    switch (type) {
-      case MessageType.Invocation:
-        return this.#coerceInvocation(arr);
-      case MessageType.StreamItem:
-        return this.#coerceStreamItem(arr);
-      case MessageType.Completion:
-        return this.#coerceCompletion(arr);
-      case MessageType.StreamInvocation:
-        return this.#coerceStreamInvocation(arr);
-      case MessageType.CancelInvocation:
-        return this.#coerceCancelInvocation(arr);
-      case MessageType.Ping:
-        return this.#coercePing();
-      case MessageType.Close:
-        return this.#coerceClose(arr);
-      default:
-        logger.log(3, `Ignoring MessagePack message with unknown type ${String(type)}.`);
-        return null;
-    }
-  }
-  // ── [1, headers, invocationId|null, target, arguments, streamIds] ─────
-  #coerceInvocation(arr) {
-    const target = arr[3];
-    const args = arr[4];
-    if (typeof target !== "string") {
-      throw new Error("Invalid Invocation message: index 3 ('target') must be a string.");
-    }
-    if (!Array.isArray(args)) {
-      throw new Error("Invalid Invocation message: index 4 ('arguments') must be an array.");
-    }
-    const rawId = arr[2];
-    const rawSids = arr[5];
-    const rawHdrs = arr[1];
-    return {
-      type: MessageType.Invocation,
-      target,
-      arguments: args,
-      ...rawId != null && rawId !== "" && rawId !== null && { invocationId: toInvocationId(String(rawId)) },
-      ...Array.isArray(rawSids) && rawSids.length > 0 && { streamIds: rawSids },
-      ...isNonEmptyObject(rawHdrs) && { headers: rawHdrs }
-    };
-  }
-  // ── [2, headers, invocationId, item] ─────────────────────────────────
-  #coerceStreamItem(arr) {
-    const rawId = arr[2];
-    if (rawId == null) {
-      throw new Error("Invalid StreamItem message: index 2 ('invocationId') is required.");
-    }
-    return {
-      type: MessageType.StreamItem,
-      invocationId: toInvocationId(String(rawId)),
-      item: arr[3],
-      ...isNonEmptyObject(arr[1]) && { headers: arr[1] }
-    };
-  }
-  // ── [3, headers, invocationId, resultKind, value?] ───────────────────
-  #coerceCompletion(arr) {
-    const rawId = arr[2];
-    if (rawId == null) {
-      throw new Error("Invalid Completion message: index 2 ('invocationId') is required.");
-    }
-    const invocationId = toInvocationId(String(rawId));
-    const resultKind = arr[3];
-    const hdrs = isNonEmptyObject(arr[1]) ? { headers: arr[1] } : {};
-    switch (resultKind) {
-      case ResultKind.Error:
-        return { type: MessageType.Completion, invocationId, error: String(arr[4] ?? ""), ...hdrs };
-      case ResultKind.Void:
-        return { type: MessageType.Completion, invocationId, ...hdrs };
-      case ResultKind.NonVoid:
-        return { type: MessageType.Completion, invocationId, result: arr[4], ...hdrs };
-      default:
-        throw new Error(`Invalid Completion message: unknown resultKind ${String(resultKind)}.`);
-    }
-  }
-  // ── [4, headers, invocationId, target, arguments, streamIds] ─────────
-  #coerceStreamInvocation(arr) {
-    const rawId = arr[2];
-    const target = arr[3];
-    const args = arr[4];
-    if (rawId == null) {
-      throw new Error("Invalid StreamInvocation message: index 2 ('invocationId') is required.");
-    }
-    if (typeof target !== "string") {
-      throw new Error("Invalid StreamInvocation message: index 3 ('target') must be a string.");
-    }
-    if (!Array.isArray(args)) {
-      throw new Error("Invalid StreamInvocation message: index 4 ('arguments') must be an array.");
-    }
-    const rawSids = arr[5];
-    return {
-      type: MessageType.StreamInvocation,
-      invocationId: toInvocationId(String(rawId)),
-      target,
-      arguments: args,
-      ...Array.isArray(rawSids) && rawSids.length > 0 && { streamIds: rawSids },
-      ...isNonEmptyObject(arr[1]) && { headers: arr[1] }
-    };
-  }
-  // ── [5, headers, invocationId] ───────────────────────────────────────
-  #coerceCancelInvocation(arr) {
-    const rawId = arr[2];
-    if (rawId == null) {
-      throw new Error("Invalid CancelInvocation message: index 2 ('invocationId') is required.");
-    }
-    return {
-      type: MessageType.CancelInvocation,
-      invocationId: toInvocationId(String(rawId)),
-      ...isNonEmptyObject(arr[1]) && { headers: arr[1] }
-    };
-  }
-  // ── [6] ──────────────────────────────────────────────────────────────
-  #coercePing() {
-    return { type: MessageType.Ping };
-  }
-  // ── [7, error|null, allowReconnect] ──────────────────────────────────
-  #coerceClose(arr) {
-    return {
-      type: MessageType.Close,
-      ...arr[1] != null && { error: String(arr[1]) },
-      ...arr[2] != null && { allowReconnect: Boolean(arr[2]) }
-    };
-  }
-  // ─── Static message factories (mirrors JsonHubProtocol API) ──────────
-  static invocation(invocationId, target, args, streamIds) {
-    return {
-      type: MessageType.Invocation,
-      invocationId,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  /** Fire-and-forget (no `invocationId`). */
-  static send(target, args, streamIds) {
-    return {
-      type: MessageType.Invocation,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  static streamInvocation(invocationId, target, args, streamIds) {
-    return {
-      type: MessageType.StreamInvocation,
-      invocationId,
-      target,
-      arguments: args,
-      ...streamIds != null && streamIds.length > 0 ? { streamIds } : {}
-    };
-  }
-  static cancelInvocation(invocationId) {
-    return { type: MessageType.CancelInvocation, invocationId };
-  }
-  static streamItem(invocationId, item) {
-    return { type: MessageType.StreamItem, invocationId, item };
-  }
-  static completion(invocationId, result, error) {
-    return {
-      type: MessageType.Completion,
-      invocationId,
-      ...error != null && { error },
-      ...result != null && { result }
-    };
-  }
-  static ping() {
-    return { type: MessageType.Ping };
-  }
-};
-function isNonEmptyObject(v) {
-  return v !== null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0;
-}
-
-// src/ws-client.ts
-import * as net from "net";
-import * as tls from "tls";
-import * as crypto from "crypto";
-import { EventEmitter } from "events";
-var WebSocketReadyState2 = /* @__PURE__ */ ((WebSocketReadyState3) => {
-  WebSocketReadyState3[WebSocketReadyState3["Connecting"] = 0] = "Connecting";
-  WebSocketReadyState3[WebSocketReadyState3["Open"] = 1] = "Open";
-  WebSocketReadyState3[WebSocketReadyState3["Closing"] = 2] = "Closing";
-  WebSocketReadyState3[WebSocketReadyState3["Closed"] = 3] = "Closed";
-  return WebSocketReadyState3;
-})(WebSocketReadyState2 || {});
-var WS_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-var WebSocketClient = class extends EventEmitter {
-  #socket = null;
-  #state = 3 /* Closed */;
-  #frameBuf = Buffer.alloc(0);
-  #fragments = [];
-  #fragmentOpcode = null;
-  #handshakeBuf = Buffer.alloc(0);
-  #handshakeResolve = null;
-  #handshakeReject = null;
-  get readyState() {
-    return this.#state;
-  }
-  // ─── Public API ─────────────────────────────────────────────────────────
-  /**
-   * Open a WebSocket connection.
-   * @param url      ws:// or wss:// URL
-   * @param headers  Extra HTTP headers for the upgrade request
-   */
-  connect(url, headers = {}) {
-    return new Promise((resolve, reject) => {
-      if (this.#state !== 3 /* Closed */) {
-        reject(new Error("WebSocket is already open or connecting."));
-        return;
-      }
-      this.#state = 0 /* Connecting */;
-      this.#handshakeResolve = resolve;
-      this.#handshakeReject = reject;
-      const parsed = new URL(url);
-      const isSecure = parsed.protocol === "wss:";
-      const host = parsed.hostname;
-      const port = Number(parsed.port) || (isSecure ? 443 : 80);
-      const resource = (parsed.pathname || "/") + (parsed.search || "");
-      const portSuffix = parsed.port ? `:${parsed.port}` : "";
-      const nonce = crypto.randomBytes(16).toString("base64");
-      const expected = computeAccept(nonce);
-      const upgradeLines = [
-        `GET ${resource} HTTP/1.1`,
-        `Host: ${host}${portSuffix}`,
-        "Upgrade: websocket",
-        "Connection: Upgrade",
-        `Sec-WebSocket-Key: ${nonce}`,
-        "Sec-WebSocket-Version: 13",
-        ...Object.entries(headers).map(([k, v]) => `${k}: ${v}`),
-        "",
-        ""
-      ];
-      const request = upgradeLines.join("\r\n");
-      const onSocketData = (chunk) => {
-        this.#onHandshakeData(chunk, expected);
-      };
-      const socketOpts = { host, port };
-      if (isSecure) {
-        this.#socket = tls.connect({ ...socketOpts, servername: host }, () => {
-          this.#socket.write(request);
-        });
-      } else {
-        this.#socket = net.connect(socketOpts, () => {
-          this.#socket.write(request);
-        });
-      }
-      this.#socket.on("data", onSocketData);
-      this.#socket.on("error", (err) => {
-        if (this.#state === 0 /* Connecting */) {
-          this.#state = 3 /* Closed */;
-          this.#handshakeReject(err);
-        } else if (this.#state !== 2 /* Closing */) {
-          this.emit("error", err);
-        }
-      });
-      this.#socket.on("close", () => this.#onSocketClose());
-      this.#socket.on("end", () => this.#socket?.destroy());
-    });
-  }
-  /**
-   * Send a text or binary message.
-   * @throws if the socket is not open.
-   */
-  send(data) {
-    if (this.#state !== 1 /* Open */) {
-      throw new Error("WebSocket is not open.");
-    }
-    if (typeof data === "string") {
-      this.#writeFrame(1 /* Text */, Buffer.from(data, "utf8"));
-    } else {
-      this.#writeFrame(2 /* Binary */, Buffer.isBuffer(data) ? data : Buffer.from(data));
-    }
-  }
-  /**
-   * Initiate a clean close handshake.
-   * @param code    WebSocket close code (default 1000 = Normal Closure)
-   * @param reason  UTF-8 reason string (max 123 bytes)
-   */
-  close(code = 1e3, reason = "") {
-    if (this.#state !== 1 /* Open */) return;
-    this.#state = 2 /* Closing */;
-    const reasonBuf = Buffer.from(reason, "utf8");
-    const payload = Buffer.allocUnsafe(2 + reasonBuf.length);
-    payload.writeUInt16BE(code, 0);
-    reasonBuf.copy(payload, 2);
-    this.#writeFrame(8 /* Close */, payload);
-  }
-  // ─── Handshake ───────────────────────────────────────────────────────────
-  #onHandshakeData(chunk, expectedAccept) {
-    this.#handshakeBuf = Buffer.concat([this.#handshakeBuf, chunk]);
-    const idx = indexOfCRLFCRLF(this.#handshakeBuf);
-    if (idx === -1) return;
-    const headerStr = this.#handshakeBuf.subarray(0, idx).toString("ascii");
-    const remainder = this.#handshakeBuf.subarray(idx + 4);
-    const lines = headerStr.split("\r\n");
-    const statusLine = lines[0] ?? "";
-    if (!statusLine.includes("101")) {
-      this.#failHandshake(
-        new Error(`WebSocket upgrade failed - server replied: ${statusLine}`)
-      );
-      return;
-    }
-    let accept = "";
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i];
-      const colon = line.indexOf(":");
-      if (colon === -1) continue;
-      if (line.slice(0, colon).trim().toLowerCase() === "sec-websocket-accept") {
-        accept = line.slice(colon + 1).trim();
-        break;
-      }
-    }
-    if (accept !== expectedAccept) {
-      this.#failHandshake(
-        new Error(`Invalid Sec-WebSocket-Accept (got "${accept}", expected "${expectedAccept}")`)
-      );
-      return;
-    }
-    this.#state = 1 /* Open */;
-    this.#handshakeBuf = Buffer.alloc(0);
-    this.#socket.removeAllListeners("data");
-    this.#socket.on("data", (c) => this.#onFrameData(c));
-    const r = this.#handshakeResolve;
-    this.#handshakeResolve = null;
-    this.#handshakeReject = null;
-    r();
-    this.emit("open");
-    if (remainder.length > 0) this.#onFrameData(remainder);
-  }
-  #failHandshake(err) {
-    this.#state = 3 /* Closed */;
-    this.#socket?.destroy();
-    const r = this.#handshakeReject;
-    this.#handshakeResolve = null;
-    this.#handshakeReject = null;
-    r(err);
-  }
-  // ─── Frame parsing ───────────────────────────────────────────────────────
-  #onFrameData(chunk) {
-    this.#frameBuf = Buffer.concat([this.#frameBuf, chunk]);
-    this.#drainFrames();
-  }
-  #drainFrames() {
-    for (; ; ) {
-      const result = tryParseFrame(this.#frameBuf);
-      if (!result) break;
-      this.#frameBuf = this.#frameBuf.subarray(result.consumed);
-      this.#dispatchFrame(result.frame);
-    }
-  }
-  #dispatchFrame({ fin, opcode, payload }) {
-    switch (opcode) {
-      case 1 /* Text */:
-      case 2 /* Binary */:
-        if (!fin) {
-          this.#fragmentOpcode = opcode;
-          this.#fragments = [payload];
-        } else {
-          this.#emitData(opcode, payload);
-        }
-        break;
-      case 0 /* Continuation */:
-        this.#fragments.push(payload);
-        if (fin) {
-          const full = Buffer.concat(this.#fragments);
-          const op = this.#fragmentOpcode;
-          this.#fragments = [];
-          this.#fragmentOpcode = null;
-          this.#emitData(op, full);
-        }
-        break;
-      case 9 /* Ping */:
-        this.#writeFrame(10 /* Pong */, payload);
-        this.emit("ping", payload);
-        break;
-      case 10 /* Pong */:
-        this.emit("pong", payload);
-        break;
-      case 8 /* Close */:
-        if (this.#state === 1 /* Open */) {
-          this.#writeFrame(8 /* Close */, payload);
-        }
-        this.#state = 3 /* Closed */;
-        this.#socket?.destroy();
-        this.emit("close");
-        break;
-      default:
-        break;
-    }
-  }
-  #emitData(opcode, payload) {
-    if (opcode === 1 /* Text */) {
-      this.emit("message", payload.toString("utf8"));
-    } else {
-      this.emit("binary", payload);
-    }
-  }
-  // ─── Frame writing ───────────────────────────────────────────────────────
-  /**
-   * Encode and send one WebSocket frame.
-   * All client→server frames MUST be masked (RFC 6455 §5.3).
-   */
-  #writeFrame(opcode, payload = Buffer.alloc(0), fin = true) {
-    if (!this.#socket || this.#socket.destroyed) return;
-    const len = payload.length;
-    let header;
-    if (len < 126) {
-      header = Buffer.allocUnsafe(2);
-      header[1] = 128 | len;
-    } else if (len < 65536) {
-      header = Buffer.allocUnsafe(4);
-      header[1] = 128 | 126;
-      header.writeUInt16BE(len, 2);
-    } else {
-      header = Buffer.allocUnsafe(10);
-      header[1] = 128 | 127;
-      header.writeUInt32BE(0, 2);
-      header.writeUInt32BE(len, 6);
-    }
-    header[0] = (fin ? 128 : 0) | opcode;
-    const maskKey = crypto.randomBytes(4);
-    const maskedPayload = Buffer.allocUnsafe(len);
-    for (let i = 0; i < len; i++) {
-      maskedPayload[i] = payload[i] ^ maskKey[i % 4];
-    }
-    this.#socket.write(Buffer.concat([header, maskKey, maskedPayload]));
-  }
-  // ─── Socket events ───────────────────────────────────────────────────────
-  #onSocketClose() {
-    if (this.#state !== 3 /* Closed */) {
-      this.#state = 3 /* Closed */;
-      this.emit("close");
-    }
-  }
-};
-function computeAccept(key) {
-  return crypto.createHash("sha1").update(key + WS_MAGIC).digest("base64");
-}
-function indexOfCRLFCRLF(buf) {
-  for (let i = 0; i <= buf.length - 4; i++) {
-    if (buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13 && buf[i + 3] === 10) {
-      return i;
-    }
-  }
-  return -1;
-}
-function tryParseFrame(buf) {
-  if (buf.length < 2) return null;
-  const b0 = buf[0];
-  const b1 = buf[1];
-  const fin = (b0 & 128) !== 0;
-  const opcode = b0 & 15;
-  const masked = (b1 & 128) !== 0;
-  let payLen = b1 & 127;
-  let offset = 2;
-  if (payLen === 126) {
-    if (buf.length < offset + 2) return null;
-    payLen = buf.readUInt16BE(offset);
-    offset += 2;
-  } else if (payLen === 127) {
-    if (buf.length < offset + 8) return null;
-    const hi = buf.readUInt32BE(offset);
-    if (hi !== 0) throw new Error("Received a frame with payload > 4 GB - not supported.");
-    payLen = buf.readUInt32BE(offset + 4);
-    offset += 8;
-  }
-  let maskBytes = null;
-  if (masked) {
-    if (buf.length < offset + 4) return null;
-    maskBytes = buf.subarray(offset, offset + 4);
-    offset += 4;
-  }
-  if (buf.length < offset + payLen) return null;
-  let payload = buf.subarray(offset, offset + payLen);
-  if (masked && maskBytes !== null) {
-    payload = Buffer.from(payload);
-    for (let i = 0; i < payload.length; i++) {
-      payload[i] = payload[i] ^ maskBytes[i % 4];
-    }
-  }
-  return { frame: { fin, opcode, payload }, consumed: offset + payLen };
-}
-
-// src/index.ts
-import { CookieJar as CookieJar2 } from "tough-cookie";
-import { CookieAgent as CookieAgent2, cookie } from "@exhumer/undici-cookie-agent";
-export {
-  AbortError,
-  ConsoleLogger,
-  CookieAgent2 as CookieAgent,
-  CookieJar2 as CookieJar,
-  DEFAULT_PING_INTERVAL_IN_MS,
-  DEFAULT_SERVER_TIMEOUT_IN_MS,
-  DEFAULT_TIMEOUT_IN_MS,
-  DefaultReconnectPolicy,
-  DispatchHttpClient,
-  FetchHttpClient,
-  HANDSHAKE_REQUEST,
-  HandshakeError,
-  DispatchHttpClient as HttpClient,
-  HttpTransportType,
-  HubConnection,
-  HubConnectionBuilder,
-  HubConnectionState,
-  HubError,
-  JsonHubProtocol,
-  LogLevel,
-  LongPollingTransport,
-  HANDSHAKE_REQUEST2 as MSGPACK_HANDSHAKE_REQUEST,
-  MessageType,
-  MsgpackHubProtocol,
-  NEGOTIATE_VERSION,
-  NullLogger,
-  PipelineHttpClient,
-  RECORD_SEPARATOR,
-  RequestHttpClient,
-  ServerSentEventsTransport,
-  StreamHttpClient,
-  TransferFormat,
-  TransportError,
-  UnsupportedTransportError,
-  WebSocketClient,
-  WebSocketReadyState2 as WebSocketReadyState,
-  WebSocketTransport,
-  assertNever,
-  cookie,
-  isAbortError,
-  isCancelInvocationMessage,
-  isCloseMessage,
-  isCompletionMessage,
-  isHubError,
-  isInvocationMessage,
-  isPingMessage,
-  isStreamInvocationMessage,
-  isStreamItemMessage,
-  isTransportError,
-  parseHandshakeResponse,
-  toInvocationId
-};
-//# sourceMappingURL=index.js.map