@azure/web-pubsub-chat-client 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,2620 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/@typespec/ts-http-runtime/dist/esm/env.js
+import process from "node:process";
+function getEnvironmentVariable(name) {
+  return process.env[name];
+}
+var isDeno = typeof process.versions.deno === "string" && process.versions.deno.length > 0;
+var isBun = typeof process.versions.bun === "string" && process.versions.bun.length > 0;
+
+// node_modules/@azure/abort-controller/dist/esm/AbortError.js
+var AbortError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+
+// node_modules/@azure/core-util/dist/esm/createAbortablePromise.js
+function createAbortablePromise(buildPromise, options) {
+  const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
+  return new Promise((resolve, reject) => {
+    function rejectOnAbort() {
+      reject(new AbortError(abortErrorMsg ?? "The operation was aborted."));
+    }
+    function removeListeners() {
+      abortSignal?.removeEventListener("abort", onAbort);
+    }
+    function onAbort() {
+      cleanupBeforeAbort?.();
+      removeListeners();
+      rejectOnAbort();
+    }
+    if (abortSignal?.aborted) {
+      return rejectOnAbort();
+    }
+    try {
+      buildPromise((x) => {
+        removeListeners();
+        resolve(x);
+      }, (x) => {
+        removeListeners();
+        reject(x);
+      });
+    } catch (err) {
+      reject(err);
+    }
+    abortSignal?.addEventListener("abort", onAbort);
+  });
+}
+
+// node_modules/@azure/core-util/dist/esm/delay.js
+var StandardAbortMessage = "The delay was aborted.";
+function delay(timeInMs, options) {
+  let token;
+  const { abortSignal, abortErrorMsg } = options ?? {};
+  return createAbortablePromise((resolve) => {
+    token = setTimeout(resolve, timeInMs);
+  }, {
+    cleanupBeforeAbort: () => clearTimeout(token),
+    abortSignal,
+    abortErrorMsg: abortErrorMsg ?? StandardAbortMessage
+  });
+}
+
+// node_modules/@azure/web-pubsub-client/dist/esm/webPubSubClient.js
+import EventEmitter from "events";
+
+// node_modules/@azure/web-pubsub-client/dist/esm/errors/index.js
+var SendMessageError = class extends Error {
+  /**
+   * Initialize a SendMessageError
+   * @param message - The error message
+   * @param ackMessage - The ack message
+   */
+  constructor(message, options) {
+    super(message);
+    /**
+     * Error name
+     */
+    __publicField(this, "name");
+    /**
+     * The ack id of the message
+     */
+    __publicField(this, "ackId");
+    /**
+     * The error details from the service
+     */
+    __publicField(this, "errorDetail");
+    this.name = "SendMessageError";
+    this.ackId = options.ackId;
+    this.errorDetail = options.errorDetail;
+  }
+};
+var InvocationError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    /**
+     * The invocation id of the request.
+     */
+    __publicField(this, "invocationId");
+    /**
+     * Error details from the service if available.
+     */
+    __publicField(this, "errorDetail");
+    this.name = "InvocationError";
+    this.invocationId = options.invocationId;
+    this.errorDetail = options.errorDetail;
+  }
+};
+
+// node_modules/@typespec/ts-http-runtime/dist/esm/logger/log.js
+import { EOL } from "node:os";
+import util from "node:util";
+import process2 from "node:process";
+function log(message, ...args) {
+  process2.stderr.write(`${util.format(message, ...args)}${EOL}`);
+}
+
+// node_modules/@typespec/ts-http-runtime/dist/esm/logger/debug.js
+var debugEnvVariable = getEnvironmentVariable("DEBUG");
+var enabledString;
+var enabledNamespaces = [];
+var skippedNamespaces = [];
+var debuggers = [];
+if (debugEnvVariable) {
+  enable(debugEnvVariable);
+}
+var debugObj = Object.assign((namespace) => {
+  return createDebugger(namespace);
+}, {
+  enable,
+  enabled,
+  disable,
+  log
+});
+function enable(namespaces) {
+  enabledString = namespaces;
+  enabledNamespaces = [];
+  skippedNamespaces = [];
+  const namespaceList = namespaces.split(",").map((ns) => ns.trim());
+  for (const ns of namespaceList) {
+    if (ns.startsWith("-")) {
+      skippedNamespaces.push(ns.substring(1));
+    } else {
+      enabledNamespaces.push(ns);
+    }
+  }
+  for (const instance of debuggers) {
+    instance.enabled = enabled(instance.namespace);
+  }
+}
+function enabled(namespace) {
+  if (namespace.endsWith("*")) {
+    return true;
+  }
+  for (const skipped of skippedNamespaces) {
+    if (namespaceMatches(namespace, skipped)) {
+      return false;
+    }
+  }
+  for (const enabledNamespace of enabledNamespaces) {
+    if (namespaceMatches(namespace, enabledNamespace)) {
+      return true;
+    }
+  }
+  return false;
+}
+function namespaceMatches(namespace, patternToMatch) {
+  if (patternToMatch.indexOf("*") === -1) {
+    return namespace === patternToMatch;
+  }
+  let pattern = patternToMatch;
+  if (patternToMatch.indexOf("**") !== -1) {
+    const patternParts = [];
+    let lastCharacter = "";
+    for (const character of patternToMatch) {
+      if (character === "*" && lastCharacter === "*") {
+        continue;
+      } else {
+        lastCharacter = character;
+        patternParts.push(character);
+      }
+    }
+    pattern = patternParts.join("");
+  }
+  let namespaceIndex = 0;
+  let patternIndex = 0;
+  const patternLength = pattern.length;
+  const namespaceLength = namespace.length;
+  let lastWildcard = -1;
+  let lastWildcardNamespace = -1;
+  while (namespaceIndex < namespaceLength && patternIndex < patternLength) {
+    if (pattern[patternIndex] === "*") {
+      lastWildcard = patternIndex;
+      patternIndex++;
+      if (patternIndex === patternLength) {
+        return true;
+      }
+      while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+        namespaceIndex++;
+        if (namespaceIndex === namespaceLength) {
+          return false;
+        }
+      }
+      lastWildcardNamespace = namespaceIndex;
+      namespaceIndex++;
+      patternIndex++;
+      continue;
+    } else if (pattern[patternIndex] === namespace[namespaceIndex]) {
+      patternIndex++;
+      namespaceIndex++;
+    } else if (lastWildcard >= 0) {
+      patternIndex = lastWildcard + 1;
+      namespaceIndex = lastWildcardNamespace + 1;
+      if (namespaceIndex === namespaceLength) {
+        return false;
+      }
+      while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+        namespaceIndex++;
+        if (namespaceIndex === namespaceLength) {
+          return false;
+        }
+      }
+      lastWildcardNamespace = namespaceIndex;
+      namespaceIndex++;
+      patternIndex++;
+      continue;
+    } else {
+      return false;
+    }
+  }
+  const namespaceDone = namespaceIndex === namespace.length;
+  const patternDone = patternIndex === pattern.length;
+  const trailingWildCard = patternIndex === pattern.length - 1 && pattern[patternIndex] === "*";
+  return namespaceDone && (patternDone || trailingWildCard);
+}
+function disable() {
+  const result = enabledString || "";
+  enable("");
+  return result;
+}
+function createDebugger(namespace) {
+  const newDebugger = Object.assign(debug, {
+    enabled: enabled(namespace),
+    destroy,
+    log: debugObj.log,
+    namespace,
+    extend
+  });
+  function debug(...args) {
+    if (!newDebugger.enabled) {
+      return;
+    }
+    if (args.length > 0) {
+      args[0] = `${namespace} ${args[0]}`;
+    }
+    newDebugger.log(...args);
+  }
+  debuggers.push(newDebugger);
+  return newDebugger;
+}
+function destroy() {
+  const index = debuggers.indexOf(this);
+  if (index >= 0) {
+    debuggers.splice(index, 1);
+    return true;
+  }
+  return false;
+}
+function extend(namespace) {
+  const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
+  newDebugger.log = this.log;
+  return newDebugger;
+}
+var debug_default = debugObj;
+
+// node_modules/@typespec/ts-http-runtime/dist/esm/logger/logger.js
+var TYPESPEC_RUNTIME_LOG_LEVELS = ["verbose", "info", "warning", "error"];
+var levelMap = {
+  verbose: 400,
+  info: 300,
+  warning: 200,
+  error: 100
+};
+function patchLogMethod(parent, child) {
+  child.log = (...args) => {
+    parent.log(...args);
+  };
+}
+function isTypeSpecRuntimeLogLevel(level) {
+  return TYPESPEC_RUNTIME_LOG_LEVELS.includes(level);
+}
+function createLoggerContext(options) {
+  const registeredLoggers = /* @__PURE__ */ new Set();
+  const logLevelFromEnv = getEnvironmentVariable(options.logLevelEnvVarName);
+  let logLevel;
+  const clientLogger = debug_default(options.namespace);
+  clientLogger.log = (...args) => {
+    debug_default.log(...args);
+  };
+  function contextSetLogLevel(level) {
+    if (level && !isTypeSpecRuntimeLogLevel(level)) {
+      throw new Error(`Unknown log level '${level}'. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(",")}`);
+    }
+    logLevel = level;
+    const enabledNamespaces2 = [];
+    for (const logger3 of registeredLoggers) {
+      if (shouldEnable(logger3)) {
+        enabledNamespaces2.push(logger3.namespace);
+      }
+    }
+    debug_default.enable(enabledNamespaces2.join(","));
+  }
+  if (logLevelFromEnv) {
+    if (isTypeSpecRuntimeLogLevel(logLevelFromEnv)) {
+      contextSetLogLevel(logLevelFromEnv);
+    } else {
+      console.error(`${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(", ")}.`);
+    }
+  }
+  function shouldEnable(logger3) {
+    return Boolean(logLevel && levelMap[logger3.level] <= levelMap[logLevel]);
+  }
+  function createLogger(parent, level) {
+    const logger3 = Object.assign(parent.extend(level), {
+      level
+    });
+    patchLogMethod(parent, logger3);
+    if (shouldEnable(logger3)) {
+      const enabledNamespaces2 = debug_default.disable();
+      debug_default.enable(enabledNamespaces2 + "," + logger3.namespace);
+    }
+    registeredLoggers.add(logger3);
+    return logger3;
+  }
+  function contextGetLogLevel() {
+    return logLevel;
+  }
+  function contextCreateClientLogger(namespace) {
+    const clientRootLogger = clientLogger.extend(namespace);
+    patchLogMethod(clientLogger, clientRootLogger);
+    return {
+      error: createLogger(clientRootLogger, "error"),
+      warning: createLogger(clientRootLogger, "warning"),
+      info: createLogger(clientRootLogger, "info"),
+      verbose: createLogger(clientRootLogger, "verbose")
+    };
+  }
+  return {
+    setLogLevel: contextSetLogLevel,
+    getLogLevel: contextGetLogLevel,
+    createClientLogger: contextCreateClientLogger,
+    logger: clientLogger
+  };
+}
+var context = createLoggerContext({
+  logLevelEnvVarName: "TYPESPEC_RUNTIME_LOG_LEVEL",
+  namespace: "typeSpecRuntime"
+});
+var TypeSpecRuntimeLogger = context.logger;
+
+// node_modules/@azure/logger/dist/esm/index.js
+var context2 = createLoggerContext({
+  logLevelEnvVarName: "AZURE_LOG_LEVEL",
+  namespace: "azure"
+});
+var AzureLogger = context2.logger;
+function createClientLogger(namespace) {
+  return context2.createClientLogger(namespace);
+}
+
+// node_modules/@azure/web-pubsub-client/dist/esm/logger.js
+var logger = createClientLogger("web-pubsub-client");
+
+// node_modules/@azure/web-pubsub-client/dist/esm/protocols/jsonProtocolBase.js
+import { Buffer as Buffer2 } from "buffer";
+function parseMessages(input) {
+  if (typeof input !== "string") {
+    throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+  }
+  if (!input) {
+    throw new Error("No input");
+  }
+  const parsedMessage = JSON.parse(input);
+  const typedMessage = parsedMessage;
+  let returnMessage;
+  if (typedMessage.type === "system") {
+    if (typedMessage.event === "connected") {
+      returnMessage = { ...parsedMessage, kind: "connected" };
+    } else if (typedMessage.event === "disconnected") {
+      returnMessage = { ...parsedMessage, kind: "disconnected" };
+    } else {
+      return null;
+    }
+  } else if (typedMessage.type === "message") {
+    if (typedMessage.from === "group") {
+      const data = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (data === null) {
+        return null;
+      }
+      returnMessage = { ...parsedMessage, data, kind: "groupData" };
+    } else if (typedMessage.from === "server") {
+      const data = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (data === null) {
+        return null;
+      }
+      returnMessage = {
+        ...parsedMessage,
+        data,
+        kind: "serverData"
+      };
+    } else {
+      return null;
+    }
+  } else if (typedMessage.type === "ack") {
+    returnMessage = { ...parsedMessage, kind: "ack" };
+  } else if (typedMessage.type === "invokeResponse") {
+    let data;
+    if (parsedMessage.dataType != null) {
+      const parsedData = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (parsedData === null) {
+        return null;
+      }
+      data = parsedData;
+    }
+    returnMessage = {
+      kind: "invokeResponse",
+      invocationId: parsedMessage.invocationId,
+      success: parsedMessage.success,
+      dataType: parsedMessage.dataType,
+      data,
+      error: parsedMessage.error
+    };
+  } else if (typedMessage.type === "cancelInvocation") {
+    returnMessage = {
+      ...parsedMessage,
+      kind: "cancelInvocation"
+    };
+  } else if (typedMessage.type === "pong") {
+    returnMessage = { ...parsedMessage, kind: "pong" };
+  } else {
+    return null;
+  }
+  return returnMessage;
+}
+function writeMessage(message) {
+  let data;
+  switch (message.kind) {
+    case "joinGroup": {
+      data = { type: "joinGroup", group: message.group, ackId: message.ackId };
+      break;
+    }
+    case "leaveGroup": {
+      data = { type: "leaveGroup", group: message.group, ackId: message.ackId };
+      break;
+    }
+    case "sendEvent": {
+      data = {
+        type: "event",
+        event: message.event,
+        ackId: message.ackId,
+        dataType: message.dataType,
+        data: getPayload(message.data, message.dataType)
+      };
+      break;
+    }
+    case "sendToGroup": {
+      data = {
+        type: "sendToGroup",
+        group: message.group,
+        ackId: message.ackId,
+        dataType: message.dataType,
+        data: getPayload(message.data, message.dataType),
+        noEcho: message.noEcho
+      };
+      break;
+    }
+    case "sequenceAck": {
+      data = { type: "sequenceAck", sequenceId: message.sequenceId };
+      break;
+    }
+    case "invoke": {
+      const invokePayload = {
+        type: "invoke",
+        invocationId: message.invocationId,
+        target: message.target,
+        event: message.event
+      };
+      if (message.dataType != null && message.data != null) {
+        invokePayload.dataType = message.dataType;
+        invokePayload.data = getPayload(message.data, message.dataType);
+      }
+      data = invokePayload;
+      break;
+    }
+    case "invokeResponse": {
+      const invokeResponse = {
+        type: "invokeResponse",
+        invocationId: message.invocationId,
+        success: message.success,
+        error: message.error
+      };
+      if (message.dataType != null && message.data != null) {
+        invokeResponse.dataType = message.dataType;
+        invokeResponse.data = getPayload(message.data, message.dataType);
+      }
+      data = invokeResponse;
+      break;
+    }
+    case "cancelInvocation": {
+      data = {
+        type: "cancelInvocation",
+        invocationId: message.invocationId
+      };
+      break;
+    }
+    case "ping": {
+      data = { type: "ping" };
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported type: ${message.kind}`);
+    }
+  }
+  return JSON.stringify(data);
+}
+function getPayload(data, dataType) {
+  switch (dataType) {
+    case "text": {
+      if (typeof data !== "string") {
+        throw new TypeError("Message must be a string.");
+      }
+      return data;
+    }
+    case "json": {
+      return data;
+    }
+    case "binary":
+    case "protobuf": {
+      if (data instanceof ArrayBuffer) {
+        return Buffer2.from(data).toString("base64");
+      }
+      throw new TypeError("Message must be a ArrayBuffer");
+    }
+  }
+}
+function parsePayload(data, dataType) {
+  if (dataType === "text") {
+    if (typeof data !== "string") {
+      throw new TypeError("Message must be a string when dataType is text");
+    }
+    return data;
+  } else if (dataType === "json") {
+    return data;
+  } else if (dataType === "binary" || dataType === "protobuf") {
+    const buf = Buffer2.from(data, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  } else {
+    return null;
+  }
+}
+
+// node_modules/@azure/web-pubsub-client/dist/esm/protocols/webPubSubJsonReliableProtocol.js
+var WebPubSubJsonReliableProtocolImpl = class {
+  constructor() {
+    /**
+     * True if the protocol supports reliable features
+     */
+    __publicField(this, "isReliableSubProtocol", true);
+    /**
+     * The name of subprotocol. Name will be used in websocket subprotocol
+     */
+    __publicField(this, "name", "json.reliable.webpubsub.azure.v1");
+  }
+  /**
+   * Creates WebPubSubMessage objects from the specified serialized representation.
+   * @param input - The serialized representation
+   */
+  parseMessages(input) {
+    return parseMessages(input);
+  }
+  /**
+   * Write WebPubSubMessage to string
+   * @param message - The message to be written
+   */
+  writeMessage(message) {
+    return writeMessage(message);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/esm/protocols/index.js
+var WebPubSubJsonReliableProtocol = () => {
+  return new WebPubSubJsonReliableProtocolImpl();
+};
+
+// node_modules/@azure/web-pubsub-client/dist/esm/websocket/websocketClient.js
+import WebSocket from "ws";
+var WebSocketClient = class {
+  constructor(uri, protocolName) {
+    __publicField(this, "_socket");
+    this._socket = new WebSocket(uri, protocolName);
+    this._socket.binaryType = "arraybuffer";
+  }
+  onopen(fn) {
+    this._socket.onopen = fn;
+  }
+  onclose(fn) {
+    this._socket.onclose = (event) => fn(event.code, event.reason);
+  }
+  onerror(fn) {
+    this._socket.onerror = (event) => fn(event.error);
+  }
+  onmessage(fn) {
+    this._socket.onmessage = (event) => fn(event.data);
+  }
+  close(code, reason) {
+    this._socket.close(code, reason);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  send(data, _) {
+    return new Promise((resolve, reject) => {
+      this._socket.send(data, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  isOpen() {
+    return this._socket.readyState === WebSocket.OPEN;
+  }
+};
+var WebSocketClientFactory = class {
+  create(uri, protocolName) {
+    return new WebSocketClient(uri, protocolName);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/esm/utils/abortablePromise.js
+async function abortablePromise(promise, signal) {
+  if (signal.aborted) {
+    throw new AbortError("The operation was aborted.");
+  }
+  let onAbort;
+  const p = new Promise((_, reject) => {
+    onAbort = () => {
+      reject(new AbortError("The operation was aborted."));
+    };
+    signal.addEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([promise, p]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// node_modules/@azure/web-pubsub-client/dist/esm/ackManager.js
+var AckManager = class {
+  constructor(initialAckId = 0) {
+    __publicField(this, "_ackEntries", /* @__PURE__ */ new Map());
+    __publicField(this, "_ackId");
+    this._ackId = initialAckId;
+  }
+  registerAck(ackId) {
+    const resolvedAckId = ackId ?? this._generateAckId();
+    let entry = this._ackEntries.get(resolvedAckId);
+    if (!entry) {
+      entry = new AckEntity(resolvedAckId);
+      this._ackEntries.set(resolvedAckId, entry);
+    }
+    const ackEntry = entry;
+    return {
+      ackId: resolvedAckId,
+      wait: (abortSignal) => this._waitForEntry(ackEntry, abortSignal)
+    };
+  }
+  resolveAck(ackId, result) {
+    const entry = this._ackEntries.get(ackId);
+    if (!entry) {
+      return false;
+    }
+    this._ackEntries.delete(ackId);
+    entry.resolve(result);
+    return true;
+  }
+  rejectAck(ackId, reason) {
+    const entry = this._ackEntries.get(ackId);
+    if (!entry) {
+      return false;
+    }
+    this._ackEntries.delete(ackId);
+    entry.reject(reason);
+    return true;
+  }
+  discard(ackId) {
+    this._ackEntries.delete(ackId);
+  }
+  rejectAll(createReason) {
+    this._ackEntries.forEach((entry, ackId) => {
+      if (this._ackEntries.delete(ackId)) {
+        entry.reject(createReason(ackId));
+      }
+    });
+  }
+  _waitForEntry(entry, abortSignal) {
+    if (!abortSignal) {
+      return entry.promise();
+    }
+    return abortablePromise(entry.promise(), abortSignal).catch((err) => {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new SendMessageError("Cancelled by abortSignal", { ackId: entry.ackId });
+      }
+      throw err;
+    });
+  }
+  _generateAckId() {
+    this._ackId += 1;
+    return this._ackId;
+  }
+};
+var AckEntity = class {
+  constructor(ackId) {
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    this.ackId = ackId;
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  promise() {
+    return this._promise;
+  }
+  resolve(value) {
+    const callback = this._resolve;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(value);
+  }
+  reject(reason) {
+    const callback = this._reject;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(reason);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/esm/invocationManager.js
+var InvocationManager = class {
+  constructor() {
+    __publicField(this, "_entries", /* @__PURE__ */ new Map());
+    __publicField(this, "_nextId", 0);
+  }
+  registerInvocation(invocationId) {
+    const resolvedId = invocationId ?? this._generateInvocationId();
+    if (this._entries.has(resolvedId)) {
+      throw new InvocationError("Invocation id is already registered.", {
+        invocationId: resolvedId
+      });
+    }
+    const entity = new InvocationEntity(resolvedId);
+    this._entries.set(resolvedId, entity);
+    return {
+      invocationId: resolvedId,
+      wait: (options) => this._waitForEntry(entity, options)
+    };
+  }
+  resolveInvocation(message) {
+    const entry = this._entries.get(message.invocationId);
+    if (!entry) {
+      return false;
+    }
+    this._entries.delete(message.invocationId);
+    entry.resolve(message);
+    return true;
+  }
+  rejectInvocation(invocationId, reason) {
+    const entry = this._entries.get(invocationId);
+    if (!entry) {
+      return false;
+    }
+    this._entries.delete(invocationId);
+    entry.reject(reason);
+    return true;
+  }
+  discard(invocationId) {
+    this._entries.delete(invocationId);
+  }
+  rejectAll(createReason) {
+    this._entries.forEach((entry, invocationId) => {
+      if (this._entries.delete(invocationId)) {
+        entry.reject(createReason(invocationId));
+      }
+    });
+  }
+  _waitForEntry(entry, options) {
+    const waitPromise = entry.promise();
+    const abortSignal = options?.abortSignal;
+    if (!abortSignal) {
+      return waitPromise;
+    }
+    if (abortSignal.aborted) {
+      if (this._entries.delete(entry.invocationId)) {
+        entry.reject(this._createAbortError(entry.invocationId));
+      }
+      return waitPromise;
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        abortSignal.removeEventListener("abort", onAbort);
+        if (this._entries.delete(entry.invocationId)) {
+          entry.reject(this._createAbortError(entry.invocationId));
+        }
+      };
+      abortSignal.addEventListener("abort", onAbort);
+      waitPromise.then((result) => {
+        abortSignal.removeEventListener("abort", onAbort);
+        return resolve(result);
+      }).catch((err) => {
+        abortSignal.removeEventListener("abort", onAbort);
+        return reject(err);
+      });
+    });
+  }
+  _generateInvocationId() {
+    this._nextId += 1;
+    return this._nextId.toString();
+  }
+  _createAbortError(invocationId) {
+    return new InvocationError("Invocation cancelled by abortSignal.", {
+      invocationId
+    });
+  }
+};
+var InvocationEntity = class {
+  constructor(invocationId) {
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    this.invocationId = invocationId;
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  promise() {
+    return this._promise;
+  }
+  resolve(value) {
+    const callback = this._resolve;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(value);
+  }
+  reject(reason) {
+    const callback = this._reject;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(reason);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/esm/webPubSubClient.js
+var WebPubSubClient = class {
+  constructor(credential, options) {
+    __publicField(this, "_protocol");
+    __publicField(this, "_credential");
+    __publicField(this, "_options");
+    __publicField(this, "_groupMap");
+    __publicField(this, "_ackManager");
+    __publicField(this, "_invocationManager");
+    __publicField(this, "_sequenceId");
+    __publicField(this, "_messageRetryPolicy");
+    __publicField(this, "_reconnectRetryPolicy");
+    __publicField(this, "_quickSequenceAckDiff", 300);
+    // The timeout for keep alive
+    __publicField(this, "_keepAliveTimeoutInMs");
+    // The interval at which to send keep-alive ping messages to the runtime
+    __publicField(this, "_keepAliveIntervalInMs");
+    __publicField(this, "_emitter", new EventEmitter());
+    __publicField(this, "_state");
+    __publicField(this, "_isStopping", false);
+    __publicField(this, "_pingKeepaliveTask");
+    __publicField(this, "_timeoutMonitorTask");
+    // connection lifetime
+    __publicField(this, "_wsClient");
+    __publicField(this, "_uri");
+    __publicField(this, "_lastCloseEvent");
+    __publicField(this, "_lastDisconnectedMessage");
+    __publicField(this, "_connectionId");
+    __publicField(this, "_reconnectionToken");
+    __publicField(this, "_isInitialConnected", false);
+    __publicField(this, "_sequenceAckTask");
+    __publicField(this, "_lastMessageReceived", Date.now());
+    if (typeof credential === "string") {
+      this._credential = { getClientAccessUrl: credential };
+    } else {
+      this._credential = credential;
+    }
+    if (options == null) {
+      options = {};
+    }
+    this._buildDefaultOptions(options);
+    this._options = options;
+    this._messageRetryPolicy = new RetryPolicy(this._options.messageRetryOptions);
+    this._reconnectRetryPolicy = new RetryPolicy(this._options.reconnectRetryOptions);
+    this._protocol = this._options.protocol;
+    this._groupMap = /* @__PURE__ */ new Map();
+    this._ackManager = new AckManager();
+    this._invocationManager = new InvocationManager();
+    this._sequenceId = new SequenceId();
+    this._keepAliveTimeoutInMs = this._options.keepAliveTimeoutInMs ?? 12e4;
+    this._keepAliveIntervalInMs = this._options.keepAliveIntervalInMs ?? 2e4;
+    this._state = "Stopped";
+  }
+  /**
+   * Start to start to the service.
+   * @param abortSignal - The abort signal
+   */
+  async start(options) {
+    if (this._isStopping) {
+      throw new Error("Can't start a client during stopping");
+    }
+    if (this._state !== "Stopped") {
+      throw new Error("Client can be only started when it's Stopped");
+    }
+    let abortSignal;
+    if (options) {
+      abortSignal = options.abortSignal;
+    }
+    if (!this._pingKeepaliveTask && this._keepAliveIntervalInMs > 0) {
+      this._pingKeepaliveTask = this._getPingKeepaliveTask();
+    }
+    if (!this._timeoutMonitorTask && this._keepAliveTimeoutInMs > 0) {
+      this._timeoutMonitorTask = this._getTimeoutMonitorTask();
+    }
+    try {
+      await this._startCore(abortSignal);
+    } catch (err) {
+      this._changeState(
+        "Stopped"
+        /* Stopped */
+      );
+      this._disposeKeepaliveTasks();
+      this._isStopping = false;
+      throw err;
+    }
+  }
+  async _startFromRestarting(abortSignal) {
+    if (this._state !== "Disconnected") {
+      throw new Error("Client can be only restarted when it's Disconnected");
+    }
+    try {
+      logger.verbose("Staring reconnecting.");
+      await this._startCore(abortSignal);
+    } catch (err) {
+      this._changeState(
+        "Disconnected"
+        /* Disconnected */
+      );
+      throw err;
+    }
+  }
+  async _startCore(abortSignal) {
+    this._changeState(
+      "Connecting"
+      /* Connecting */
+    );
+    logger.info("Staring a new connection");
+    this._sequenceId.reset();
+    this._isInitialConnected = false;
+    this._lastCloseEvent = void 0;
+    this._lastDisconnectedMessage = void 0;
+    this._connectionId = void 0;
+    this._reconnectionToken = void 0;
+    this._uri = void 0;
+    if (typeof this._credential.getClientAccessUrl === "string") {
+      this._uri = this._credential.getClientAccessUrl;
+    } else {
+      this._uri = await this._credential.getClientAccessUrl({
+        abortSignal
+      });
+    }
+    if (typeof this._uri !== "string") {
+      throw new Error(
+        `The clientAccessUrl must be a string but currently it's ${typeof this._uri}`
+      );
+    }
+    await this._connectCore(this._uri);
+  }
+  /**
+   * Stop the client.
+   */
+  stop() {
+    if (this._state === "Stopped" || this._isStopping) {
+      return;
+    }
+    this._isStopping = true;
+    if (this._wsClient && this._wsClient.isOpen()) {
+      this._wsClient.close();
+    } else {
+      this._isStopping = false;
+    }
+    this._disposeKeepaliveTasks();
+  }
+  _disposeKeepaliveTasks() {
+    if (this._pingKeepaliveTask) {
+      this._pingKeepaliveTask.abort();
+      this._pingKeepaliveTask = void 0;
+    }
+    if (this._timeoutMonitorTask) {
+      this._timeoutMonitorTask.abort();
+      this._timeoutMonitorTask = void 0;
+    }
+  }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this._emitter.removeListener(event, listener);
+  }
+  _emitEvent(event, args) {
+    this._emitter.emit(event, args);
+  }
+  /**
+   * Send custom event to server.
+   * @param eventName - The event name
+   * @param content - The data content
+   * @param dataType - The data type
+   * @param options - The options
+   * @param abortSignal - The abort signal
+   */
+  async sendEvent(eventName, content, dataType, options) {
+    return this._operationExecuteWithRetry(
+      () => this._sendEventAttempt(eventName, content, dataType, options),
+      options?.abortSignal
+    );
+  }
+  async _sendEventAttempt(eventName, content, dataType, options) {
+    const fireAndForget = options?.fireAndForget ?? false;
+    if (!fireAndForget) {
+      return this._sendMessageWithAckId(
+        (id) => {
+          return {
+            kind: "sendEvent",
+            dataType,
+            data: content,
+            ackId: id,
+            event: eventName
+          };
+        },
+        options?.ackId,
+        options?.abortSignal
+      );
+    }
+    const message = {
+      kind: "sendEvent",
+      dataType,
+      data: content,
+      event: eventName
+    };
+    await this._sendMessage(message, options?.abortSignal);
+    return { isDuplicated: false };
+  }
+  async _invokeEventAttempt(eventName, content, dataType, options) {
+    const invokeOptions = options ?? {};
+    const { invocationId, wait } = this._invocationManager.registerInvocation(
+      invokeOptions.invocationId
+    );
+    const invokeMessage = {
+      kind: "invoke",
+      invocationId,
+      target: "event",
+      event: eventName,
+      dataType,
+      data: content
+    };
+    const responsePromise = wait({
+      abortSignal: invokeOptions.abortSignal
+    });
+    try {
+      await this._sendMessage(invokeMessage, invokeOptions.abortSignal);
+    } catch (err) {
+      const invocationError = err instanceof InvocationError ? err : new InvocationError(
+        err instanceof Error ? err.message : "Failed to send invocation message.",
+        {
+          invocationId
+        }
+      );
+      this._invocationManager.rejectInvocation(invocationId, invocationError);
+      void responsePromise.catch(() => {
+      });
+      throw invocationError;
+    }
+    try {
+      const response = await responsePromise;
+      return this._mapInvokeResponse(response);
+    } catch (err) {
+      const shouldCancel = err instanceof InvocationError && err.errorDetail == null || invokeOptions.abortSignal?.aborted === true;
+      if (shouldCancel) {
+        await this._sendCancelInvocation(invocationId).catch(() => {
+        });
+      }
+      throw err;
+    } finally {
+      this._invocationManager.discard(invocationId);
+    }
+  }
+  /**
+   * Invoke an upstream event and wait for the correlated response.
+   * @param eventName - The event name
+   * @param content - The payload
+   * @param dataType - The payload type
+   * @param options - Invoke options
+   */
+  async invokeEvent(eventName, content, dataType, options) {
+    return this._operationExecuteWithRetry(
+      () => this._invokeEventAttempt(eventName, content, dataType, options),
+      options?.abortSignal
+    );
+  }
+  /**
+   * Join the client to group
+   * @param groupName - The group name
+   * @param options - The join group options
+   */
+  async joinGroup(groupName, options) {
+    return this._operationExecuteWithRetry(
+      () => this._joinGroupAttempt(groupName, options),
+      options?.abortSignal
+    );
+  }
+  async _joinGroupAttempt(groupName, options) {
+    const group = this._getOrAddGroup(groupName);
+    const result = await this._joinGroupCore(groupName, options);
+    group.isJoined = true;
+    return result;
+  }
+  async _joinGroupCore(groupName, options) {
+    return this._sendMessageWithAckId(
+      (id) => {
+        return {
+          group: groupName,
+          ackId: id,
+          kind: "joinGroup"
+        };
+      },
+      options?.ackId,
+      options?.abortSignal
+    );
+  }
+  /**
+   * Leave the client from group
+   * @param groupName - The group name
+   * @param ackId - The optional ackId. If not specified, client will generate one.
+   * @param abortSignal - The abort signal
+   */
+  async leaveGroup(groupName, options) {
+    return this._operationExecuteWithRetry(
+      () => this._leaveGroupAttempt(groupName, options),
+      options?.abortSignal
+    );
+  }
+  async _leaveGroupAttempt(groupName, options) {
+    const group = this._getOrAddGroup(groupName);
+    const result = await this._sendMessageWithAckId(
+      (id) => {
+        return {
+          group: groupName,
+          ackId: id,
+          kind: "leaveGroup"
+        };
+      },
+      options?.ackId,
+      options?.abortSignal
+    );
+    group.isJoined = false;
+    return result;
+  }
+  /**
+   * Send message to group.
+   * @param groupName - The group name
+   * @param content - The data content
+   * @param dataType - The data type
+   * @param options - The options
+   * @param abortSignal - The abort signal
+   */
+  async sendToGroup(groupName, content, dataType, options) {
+    return this._operationExecuteWithRetry(
+      () => this._sendToGroupAttempt(groupName, content, dataType, options),
+      options?.abortSignal
+    );
+  }
+  async _sendToGroupAttempt(groupName, content, dataType, options) {
+    const fireAndForget = options?.fireAndForget ?? false;
+    const noEcho = options?.noEcho ?? false;
+    if (!fireAndForget) {
+      return this._sendMessageWithAckId(
+        (id) => {
+          return {
+            kind: "sendToGroup",
+            group: groupName,
+            dataType,
+            data: content,
+            ackId: id,
+            noEcho
+          };
+        },
+        options?.ackId,
+        options?.abortSignal
+      );
+    }
+    const message = {
+      kind: "sendToGroup",
+      group: groupName,
+      dataType,
+      data: content,
+      noEcho
+    };
+    await this._sendMessage(message, options?.abortSignal);
+    return { isDuplicated: false };
+  }
+  _getWebSocketClientFactory() {
+    return new WebSocketClientFactory();
+  }
+  async _trySendSequenceAck() {
+    if (!this._protocol.isReliableSubProtocol) {
+      return;
+    }
+    const [isUpdated, seqId] = this._sequenceId.tryGetSequenceId();
+    if (isUpdated && seqId !== null && seqId !== void 0) {
+      const message = {
+        kind: "sequenceAck",
+        sequenceId: seqId
+      };
+      try {
+        await this._sendMessage(message);
+      } catch {
+        this._sequenceId.tryUpdate(seqId);
+      }
+    }
+  }
+  _connectCore(uri) {
+    if (this._isStopping) {
+      throw new Error("Can't start a client during stopping");
+    }
+    return new Promise((resolve, reject) => {
+      const client = this._wsClient = this._getWebSocketClientFactory().create(
+        uri,
+        this._protocol.name
+      );
+      client.onopen(() => {
+        if (this._isStopping) {
+          try {
+            client.close();
+          } catch {
+          }
+          reject(new Error(`The client is stopped`));
+        }
+        logger.verbose("WebSocket connection has opened");
+        this._lastMessageReceived = Date.now();
+        this._changeState(
+          "Connected"
+          /* Connected */
+        );
+        if (this._protocol.isReliableSubProtocol) {
+          if (this._sequenceAckTask != null) {
+            this._sequenceAckTask.abort();
+          }
+          this._sequenceAckTask = new AbortableTask(async () => {
+            await this._trySendSequenceAck();
+          }, 1e3);
+        }
+        resolve();
+      });
+      client.onerror((e) => {
+        if (this._sequenceAckTask != null) {
+          this._sequenceAckTask.abort();
+        }
+        reject(e);
+      });
+      client.onclose((code, reason) => {
+        if (this._state === "Connected") {
+          logger.verbose("WebSocket closed after open");
+          if (this._sequenceAckTask != null) {
+            this._sequenceAckTask.abort();
+          }
+          logger.info(`WebSocket connection closed. Code: ${code}, Reason: ${reason}`);
+          this._lastCloseEvent = { code, reason };
+          this._handleConnectionClose.call(this);
+        } else {
+          logger.verbose("WebSocket closed before open");
+          reject(new Error(`Failed to start WebSocket: ${code}`));
+        }
+      });
+      client.onmessage((data) => {
+        const handleAckMessage = (message) => {
+          const isDuplicated = message.error != null && message.error.name === "Duplicate";
+          if (message.success || isDuplicated) {
+            this._ackManager.resolveAck(message.ackId, {
+              ackId: message.ackId,
+              isDuplicated
+            });
+          } else {
+            this._ackManager.rejectAck(
+              message.ackId,
+              new SendMessageError("Failed to send message.", {
+                ackId: message.ackId,
+                errorDetail: message.error
+              })
+            );
+          }
+        };
+        const handleConnectedMessage = async (message) => {
+          this._connectionId = message.connectionId;
+          this._reconnectionToken = message.reconnectionToken;
+          if (!this._isInitialConnected) {
+            this._isInitialConnected = true;
+            if (this._options.autoRejoinGroups) {
+              const groupPromises = [];
+              this._groupMap.forEach((g) => {
+                if (g.isJoined) {
+                  groupPromises.push(
+                    (async () => {
+                      try {
+                        await this._joinGroupCore(g.name);
+                      } catch (err) {
+                        this._safeEmitRejoinGroupFailed(g.name, err);
+                      }
+                    })()
+                  );
+                }
+              });
+              await Promise.all(groupPromises).catch(() => {
+              });
+            }
+            this._safeEmitConnected(message.connectionId, message.userId);
+          }
+        };
+        const handleDisconnectedMessage = (message) => {
+          this._lastDisconnectedMessage = message;
+        };
+        const handleGroupDataMessage = (message) => {
+          if (message.sequenceId != null) {
+            const diff = this._sequenceId.tryUpdate(message.sequenceId);
+            if (diff === 0) {
+              return;
+            }
+            if (diff > this._quickSequenceAckDiff) {
+              this._trySendSequenceAck();
+            }
+          }
+          this._safeEmitGroupMessage(message);
+        };
+        const handleServerDataMessage = (message) => {
+          if (message.sequenceId != null) {
+            const diff = this._sequenceId.tryUpdate(message.sequenceId);
+            if (diff === 0) {
+              return;
+            }
+            if (diff > this._quickSequenceAckDiff) {
+              this._trySendSequenceAck();
+            }
+          }
+          this._safeEmitServerMessage(message);
+        };
+        const handleInvokeResponseMessage = (message) => {
+          const resolved = this._invocationManager.resolveInvocation(message);
+          if (!resolved) {
+            logger.verbose(
+              `Received invokeResponse for unknown invocationId: ${message.invocationId}`
+            );
+          }
+        };
+        this._lastMessageReceived = Date.now();
+        let messages;
+        try {
+          let convertedData;
+          if (Array.isArray(data)) {
+            convertedData = Buffer.concat(data);
+          } else {
+            convertedData = data;
+          }
+          messages = this._protocol.parseMessages(convertedData);
+          if (messages === null) {
+            return;
+          }
+        } catch (err) {
+          logger.warning("An error occurred while parsing the message from service", err);
+          throw err;
+        }
+        if (!Array.isArray(messages)) {
+          messages = [messages];
+        }
+        messages.forEach((message) => {
+          try {
+            switch (message.kind) {
+              case "pong": {
+                break;
+              }
+              case "ack": {
+                handleAckMessage(message);
+                break;
+              }
+              case "connected": {
+                handleConnectedMessage(message);
+                break;
+              }
+              case "disconnected": {
+                handleDisconnectedMessage(message);
+                break;
+              }
+              case "groupData": {
+                handleGroupDataMessage(message);
+                break;
+              }
+              case "serverData": {
+                handleServerDataMessage(message);
+                break;
+              }
+              case "invokeResponse": {
+                handleInvokeResponseMessage(message);
+                break;
+              }
+            }
+          } catch (err) {
+            logger.warning(
+              `An error occurred while handling the message with kind: ${message.kind} from service`,
+              err
+            );
+          }
+        });
+      });
+    });
+  }
+  async _handleConnectionCloseAndNoRecovery() {
+    this._state = "Disconnected";
+    this._safeEmitDisconnected(this._connectionId, this._lastDisconnectedMessage);
+    if (this._options.autoReconnect) {
+      await this._autoReconnect();
+    } else {
+      await this._handleConnectionStopped();
+    }
+  }
+  async _autoReconnect() {
+    let isSuccess = false;
+    let attempt = 0;
+    try {
+      while (!this._isStopping) {
+        try {
+          await this._startFromRestarting();
+          isSuccess = true;
+          break;
+        } catch (err) {
+          logger.warning("An attempt to reconnect connection failed.", err);
+          attempt++;
+          const delayInMs = this._reconnectRetryPolicy.nextRetryDelayInMs(attempt);
+          if (delayInMs == null) {
+            break;
+          }
+          logger.verbose(`Delay time for reconnect attempt ${attempt}: ${delayInMs}`);
+          await delay(delayInMs).catch(() => {
+          });
+        }
+      }
+    } finally {
+      if (!isSuccess) {
+        this._handleConnectionStopped();
+      }
+    }
+  }
+  _handleConnectionStopped() {
+    this._isStopping = false;
+    this._state = "Stopped";
+    this._disposeKeepaliveTasks();
+    this._safeEmitStopped();
+  }
+  async _trySendPing() {
+    if (this._state !== "Connected" || !this._wsClient?.isOpen()) {
+      return;
+    }
+    const message = {
+      kind: "ping"
+    };
+    try {
+      await this._sendMessage(message);
+    } catch {
+      logger.warning("Failed to send keepalive message to the service");
+    }
+  }
+  async _checkKeepAliveTimeout() {
+    if (this._state !== "Connected" || !this._wsClient?.isOpen()) {
+      return;
+    }
+    const now = Date.now();
+    if (now - this._lastMessageReceived > this._keepAliveTimeoutInMs) {
+      logger.warning(
+        `No messages received for ${now - this._lastMessageReceived} ms. Closing. The keep alive timeout is set to ${this._keepAliveTimeoutInMs} ms.`
+      );
+      this._wsClient?.close();
+    }
+  }
+  _getPingKeepaliveTask() {
+    return new AbortableTask(async () => {
+      await this._trySendPing();
+    }, this._keepAliveIntervalInMs);
+  }
+  _getTimeoutMonitorTask() {
+    const timeout = this._keepAliveTimeoutInMs;
+    const checkInterval = Math.floor(timeout / 3);
+    return new AbortableTask(async () => {
+      await this._checkKeepAliveTimeout();
+    }, checkInterval);
+  }
+  async _sendMessage(message, abortSignal) {
+    if (!this._wsClient || !this._wsClient.isOpen()) {
+      throw new Error("The connection is not connected.");
+    }
+    const payload = this._protocol.writeMessage(message);
+    await this._wsClient.send(payload, abortSignal);
+  }
+  async _sendMessageWithAckId(messageProvider, ackId, abortSignal) {
+    const { ackId: resolvedAckId, wait } = this._ackManager.registerAck(ackId);
+    const message = messageProvider(resolvedAckId);
+    try {
+      await this._sendMessage(message, abortSignal);
+    } catch (error) {
+      this._ackManager.discard(resolvedAckId);
+      let errorMessage = "";
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+      throw new SendMessageError(errorMessage, { ackId: resolvedAckId });
+    }
+    return wait(abortSignal);
+  }
+  async _handleConnectionClose() {
+    this._ackManager.rejectAll((ackId) => {
+      return new SendMessageError(
+        "Connection is disconnected before receive ack from the service",
+        {
+          ackId
+        }
+      );
+    });
+    this._invocationManager.rejectAll((invocationId) => {
+      return new InvocationError(
+        "Connection is disconnected before receiving invoke response from the service",
+        {
+          invocationId
+        }
+      );
+    });
+    if (this._isStopping) {
+      logger.warning("The client is stopping state. Stop recovery.");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    if (this._lastCloseEvent && this._lastCloseEvent.code === 1008) {
+      logger.warning("The websocket close with status code 1008. Stop recovery.");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    if (!this._protocol.isReliableSubProtocol) {
+      logger.warning("The protocol is not reliable, recovery is not applicable");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    const recoveryUri = this._buildRecoveryUri();
+    if (!recoveryUri) {
+      logger.warning("Connection id or reconnection token is not available");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    let recovered = false;
+    this._state = "Recovering";
+    const abortSignal = AbortSignal.timeout(30 * 1e3);
+    try {
+      while (!abortSignal.aborted || this._isStopping) {
+        try {
+          await this._connectCore.call(this, recoveryUri);
+          recovered = true;
+          return;
+        } catch {
+          await delay(1e3);
+        }
+      }
+    } finally {
+      if (!recovered) {
+        logger.warning("Recovery attempts failed more then 30 seconds or the client is stopping");
+        this._handleConnectionCloseAndNoRecovery();
+      }
+    }
+  }
+  _safeEmitConnected(connectionId, userId) {
+    this._emitEvent("connected", {
+      connectionId,
+      userId
+    });
+  }
+  _safeEmitDisconnected(connectionId, lastDisconnectedMessage) {
+    this._emitEvent("disconnected", {
+      connectionId,
+      message: lastDisconnectedMessage
+    });
+  }
+  _safeEmitGroupMessage(message) {
+    this._emitEvent("group-message", {
+      message
+    });
+  }
+  _safeEmitServerMessage(message) {
+    this._emitEvent("server-message", {
+      message
+    });
+  }
+  _safeEmitStopped() {
+    this._emitEvent("stopped", {});
+  }
+  _safeEmitRejoinGroupFailed(groupName, err) {
+    this._emitEvent("rejoin-group-failed", {
+      group: groupName,
+      error: err
+    });
+  }
+  _mapInvokeResponse(message) {
+    if (message.success !== true) {
+      if (message.success === false) {
+        throw new InvocationError(message.error?.message ?? "Invocation failed.", {
+          invocationId: message.invocationId,
+          errorDetail: message.error
+        });
+      }
+      throw new InvocationError("Unsupported invoke response frame.", {
+        invocationId: message.invocationId
+      });
+    }
+    return {
+      invocationId: message.invocationId,
+      dataType: message.dataType,
+      data: message.data
+    };
+  }
+  async _sendCancelInvocation(invocationId) {
+    const message = {
+      kind: "cancelInvocation",
+      invocationId
+    };
+    try {
+      await this._sendMessage(message);
+    } catch (err) {
+      logger.verbose(`Failed to send cancelInvocation for ${invocationId}`, err);
+    }
+  }
+  _buildDefaultOptions(clientOptions) {
+    if (clientOptions.autoReconnect == null) {
+      clientOptions.autoReconnect = true;
+    }
+    if (clientOptions.autoRejoinGroups == null) {
+      clientOptions.autoRejoinGroups = true;
+    }
+    if (clientOptions.protocol == null) {
+      clientOptions.protocol = WebPubSubJsonReliableProtocol();
+    }
+    if (clientOptions.keepAliveTimeoutInMs == null) {
+      clientOptions.keepAliveTimeoutInMs = 12e4;
+    }
+    if (clientOptions.keepAliveTimeoutInMs < 0) {
+      throw new RangeError("keepAliveTimeoutInMs must be greater than or equal to 0.");
+    }
+    if (clientOptions.keepAliveIntervalInMs == null) {
+      clientOptions.keepAliveIntervalInMs = 2e4;
+    }
+    if (clientOptions.keepAliveIntervalInMs < 0) {
+      throw new RangeError("keepAliveIntervalInMs must be greater than or equal to 0.");
+    }
+    this._buildMessageRetryOptions(clientOptions);
+    this._buildReconnectRetryOptions(clientOptions);
+    return clientOptions;
+  }
+  _buildMessageRetryOptions(clientOptions) {
+    if (!clientOptions.messageRetryOptions) {
+      clientOptions.messageRetryOptions = {};
+    }
+    if (clientOptions.messageRetryOptions.maxRetries == null || clientOptions.messageRetryOptions.maxRetries < 0) {
+      clientOptions.messageRetryOptions.maxRetries = 3;
+    }
+    if (clientOptions.messageRetryOptions.retryDelayInMs == null || clientOptions.messageRetryOptions.retryDelayInMs < 0) {
+      clientOptions.messageRetryOptions.retryDelayInMs = 1e3;
+    }
+    if (clientOptions.messageRetryOptions.maxRetryDelayInMs == null || clientOptions.messageRetryOptions.maxRetryDelayInMs < 0) {
+      clientOptions.messageRetryOptions.maxRetryDelayInMs = 3e4;
+    }
+    if (clientOptions.messageRetryOptions.mode == null) {
+      clientOptions.messageRetryOptions.mode = "Fixed";
+    }
+  }
+  _buildReconnectRetryOptions(clientOptions) {
+    if (!clientOptions.reconnectRetryOptions) {
+      clientOptions.reconnectRetryOptions = {};
+    }
+    if (clientOptions.reconnectRetryOptions.maxRetries == null || clientOptions.reconnectRetryOptions.maxRetries < 0) {
+      clientOptions.reconnectRetryOptions.maxRetries = Number.MAX_VALUE;
+    }
+    if (clientOptions.reconnectRetryOptions.retryDelayInMs == null || clientOptions.reconnectRetryOptions.retryDelayInMs < 0) {
+      clientOptions.reconnectRetryOptions.retryDelayInMs = 1e3;
+    }
+    if (clientOptions.reconnectRetryOptions.maxRetryDelayInMs == null || clientOptions.reconnectRetryOptions.maxRetryDelayInMs < 0) {
+      clientOptions.reconnectRetryOptions.maxRetryDelayInMs = 3e4;
+    }
+    if (clientOptions.reconnectRetryOptions.mode == null) {
+      clientOptions.reconnectRetryOptions.mode = "Fixed";
+    }
+  }
+  _buildRecoveryUri() {
+    if (this._connectionId && this._reconnectionToken && this._uri) {
+      const url = new URL(this._uri);
+      url.searchParams.append("awps_connection_id", this._connectionId);
+      url.searchParams.append("awps_reconnection_token", this._reconnectionToken);
+      return url.toString();
+    }
+    return null;
+  }
+  _getOrAddGroup(name) {
+    if (!this._groupMap.has(name)) {
+      this._groupMap.set(name, new WebPubSubGroup(name));
+    }
+    return this._groupMap.get(name);
+  }
+  _changeState(newState) {
+    logger.verbose(
+      `The client state transfer from ${this._state.toString()} to ${newState.toString()}`
+    );
+    this._state = newState;
+  }
+  async _operationExecuteWithRetry(inner, signal) {
+    let retryAttempt = 0;
+    while (true) {
+      try {
+        return await inner.call(this);
+      } catch (err) {
+        if (err instanceof InvocationError) {
+          throw err;
+        }
+        retryAttempt++;
+        const delayInMs = this._messageRetryPolicy.nextRetryDelayInMs(retryAttempt);
+        if (delayInMs == null) {
+          throw err;
+        }
+        await delay(delayInMs);
+        if (signal?.aborted) {
+          throw err;
+        }
+      }
+    }
+  }
+};
+var RetryPolicy = class {
+  constructor(retryOptions) {
+    __publicField(this, "_retryOptions");
+    __publicField(this, "_maxRetriesToGetMaxDelay");
+    this._retryOptions = retryOptions;
+    this._maxRetriesToGetMaxDelay = Math.ceil(
+      Math.log2(this._retryOptions.maxRetryDelayInMs) - Math.log2(this._retryOptions.retryDelayInMs) + 1
+    );
+  }
+  nextRetryDelayInMs(retryAttempt) {
+    if (retryAttempt > this._retryOptions.maxRetries) {
+      return null;
+    } else {
+      if (this._retryOptions.mode === "Fixed") {
+        return this._retryOptions.retryDelayInMs;
+      } else {
+        return this._calculateExponentialDelay(retryAttempt);
+      }
+    }
+  }
+  _calculateExponentialDelay(attempt) {
+    if (attempt >= this._maxRetriesToGetMaxDelay) {
+      return this._retryOptions.maxRetryDelayInMs;
+    } else {
+      return (1 << attempt - 1) * this._retryOptions.retryDelayInMs;
+    }
+  }
+};
+var WebPubSubGroup = class {
+  constructor(name) {
+    __publicField(this, "name");
+    __publicField(this, "isJoined", false);
+    this.name = name;
+  }
+};
+var SequenceId = class {
+  constructor() {
+    __publicField(this, "_sequenceId");
+    __publicField(this, "_isUpdate");
+    this._sequenceId = 0;
+    this._isUpdate = false;
+  }
+  tryUpdate(sequenceId) {
+    this._isUpdate = true;
+    if (sequenceId > this._sequenceId) {
+      const diff = sequenceId - this._sequenceId;
+      this._sequenceId = sequenceId;
+      return diff;
+    }
+    return 0;
+  }
+  tryGetSequenceId() {
+    if (this._isUpdate) {
+      this._isUpdate = false;
+      return [true, this._sequenceId];
+    }
+    return [false, null];
+  }
+  reset() {
+    this._sequenceId = 0;
+    this._isUpdate = false;
+  }
+};
+var AbortableTask = class {
+  constructor(func, interval, obj) {
+    __publicField(this, "_func");
+    __publicField(this, "_abortController");
+    __publicField(this, "_interval");
+    __publicField(this, "_obj");
+    this._func = func;
+    this._abortController = new AbortController();
+    this._interval = interval;
+    this._obj = obj;
+    this._start();
+  }
+  abort() {
+    try {
+      this._abortController.abort();
+    } catch {
+    }
+  }
+  async _start() {
+    const signal = this._abortController.signal;
+    while (!signal.aborted) {
+      try {
+        await this._func(this._obj);
+      } catch {
+      } finally {
+        await delay(this._interval);
+      }
+    }
+  }
+};
+
+// node_modules/tslib/tslib.es6.mjs
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+
+// node_modules/@azure/core-paging/dist/esm/getPagedAsyncIterator.js
+function getPagedAsyncIterator(pagedResult) {
+  var _a;
+  const iter = getItemAsyncIterator(pagedResult);
+  return {
+    next() {
+      return iter.next();
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    byPage: (_a = pagedResult === null || pagedResult === void 0 ? void 0 : pagedResult.byPage) !== null && _a !== void 0 ? _a : ((settings) => {
+      const { continuationToken, maxPageSize } = settings !== null && settings !== void 0 ? settings : {};
+      return getPageAsyncIterator(pagedResult, {
+        pageLink: continuationToken,
+        maxPageSize
+      });
+    })
+  };
+}
+function getItemAsyncIterator(pagedResult) {
+  return __asyncGenerator(this, arguments, function* getItemAsyncIterator_1() {
+    var _a, e_1, _b, _c, _d, e_2, _e, _f;
+    const pages = getPageAsyncIterator(pagedResult);
+    const firstVal = yield __await(pages.next());
+    if (!Array.isArray(firstVal.value)) {
+      const { toElements } = pagedResult;
+      if (toElements) {
+        yield __await(yield* __asyncDelegator(__asyncValues(toElements(firstVal.value))));
+        try {
+          for (var _g = true, pages_1 = __asyncValues(pages), pages_1_1; pages_1_1 = yield __await(pages_1.next()), _a = pages_1_1.done, !_a; _g = true) {
+            _c = pages_1_1.value;
+            _g = false;
+            const page = _c;
+            yield __await(yield* __asyncDelegator(__asyncValues(toElements(page))));
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (!_g && !_a && (_b = pages_1.return)) yield __await(_b.call(pages_1));
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      } else {
+        yield yield __await(firstVal.value);
+        yield __await(yield* __asyncDelegator(__asyncValues(pages)));
+      }
+    } else {
+      yield __await(yield* __asyncDelegator(__asyncValues(firstVal.value)));
+      try {
+        for (var _h = true, pages_2 = __asyncValues(pages), pages_2_1; pages_2_1 = yield __await(pages_2.next()), _d = pages_2_1.done, !_d; _h = true) {
+          _f = pages_2_1.value;
+          _h = false;
+          const page = _f;
+          yield __await(yield* __asyncDelegator(__asyncValues(page)));
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (!_h && !_d && (_e = pages_2.return)) yield __await(_e.call(pages_2));
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+    }
+  });
+}
+function getPageAsyncIterator(pagedResult, options = {}) {
+  return __asyncGenerator(this, arguments, function* getPageAsyncIterator_1() {
+    const { pageLink, maxPageSize } = options;
+    let response = yield __await(pagedResult.getPage(pageLink !== null && pageLink !== void 0 ? pageLink : pagedResult.firstPageLink, maxPageSize));
+    if (!response) {
+      return yield __await(void 0);
+    }
+    yield yield __await(response.page);
+    while (response.nextPageLink) {
+      response = yield __await(pagedResult.getPage(response.nextPageLink, maxPageSize));
+      if (!response) {
+        return yield __await(void 0);
+      }
+      yield yield __await(response.page);
+    }
+  });
+}
+
+// src/chatClient.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/constant.ts
+var INVOCATION_NAME = {
+  LOGIN: "chat.login",
+  LIST_USER_CONVERSATION: "chat.listUserConversation",
+  GET_USER_PROPERTIES: "chat.getUserProperties",
+  GET_ROOM: "chat.getRoom",
+  LIST_MESSAGES: "chat.queryMessageHistory",
+  SEND_TEXT_MESSAGE: "chat.sendTextMessage",
+  CREATE_ROOM: "chat.createRoom",
+  JOIN_ROOM: "chat.joinRoom",
+  MANAGE_ROOM_MEMBER: "chat.manageRoomMember"
+};
+var ERRORS = {
+  RoomAlreadyExists: "RoomAlreadyExists",
+  UserAlreadyInRoom: "UserAlreadyInRoom",
+  NoPermissionInRoom: "NoPermissionInRoom",
+  NotStarted: "NotStarted",
+  UnknownRoom: "UnknownRoom",
+  InvalidServerResponse: "InvalidServerResponse"
+};
+
+// src/logger.ts
+var logger2 = createClientLogger("web-pubsub-chat-client:*");
+
+// src/utils.ts
+function isWebPubSubClient(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const anyObj = obj;
+  return typeof anyObj === "object" && (typeof anyObj.start === "function" || typeof anyObj.stop === "function" || typeof anyObj.on === "function");
+}
+
+// src/chatClient.ts
+var ChatError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    /** Stable, machine-readable error code. Compare against {@link KnownChatErrorCode}. */
+    __publicField(this, "code");
+    this.name = "ChatError";
+    this.code = code;
+  }
+};
+var PromiseCompletionSource = class {
+  constructor() {
+    __publicField(this, "promise");
+    __publicField(this, "resolvePromise");
+    this.promise = new Promise((resolve) => {
+      this.resolvePromise = resolve;
+    });
+  }
+  setResult() {
+    this.resolvePromise();
+  }
+  wait() {
+    return this.promise;
+  }
+};
+var ChatClient = class _ChatClient {
+  // Implementation also accepts a pre-built connection (test seam); this is
+  // not a public overload, so it does not appear in the public API surface.
+  constructor(credentialOrConnection) {
+    /** The underlying transport. Private — `ChatClient` builds and owns it. */
+    __publicField(this, "_connection");
+    __publicField(this, "_emitter", new EventEmitter2());
+    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
+    __publicField(this, "_conversationIds", /* @__PURE__ */ new Set());
+    __publicField(this, "_userId");
+    __publicField(this, "_isStarted", false);
+    __publicField(this, "_startPromise");
+    // Created after the underlying connection starts so stop() can wait for the single "stopped" event.
+    __publicField(this, "_connectionStoppedTCS");
+    __publicField(this, "_isConnectionStopping", false);
+    this._connection = isWebPubSubClient(credentialOrConnection) ? credentialOrConnection : new WebPubSubClient(credentialOrConnection);
+    this._connection.on("group-message", (e) => {
+      this._handleNotification(e.message.data);
+    });
+    this._connection.on("server-message", (e) => {
+      this._handleNotification(e.message.data);
+    });
+    this._connection.on("stopped", () => {
+      this._connectionStoppedTCS?.setResult();
+      this._connectionStoppedTCS = void 0;
+      this._isConnectionStopping = false;
+      this.resetState();
+    });
+  }
+  async _handleNotification(data) {
+    if (!this._isStarted && !this._startPromise) {
+      return;
+    }
+    logger2.info("Received notification:", data);
+    try {
+      const type = data.notificationType;
+      switch (type) {
+        case "MessageCreated": {
+          const body = data.body;
+          if (!body.conversation.roomId) {
+            logger2.warning(
+              `MessageCreated notification missing roomId; skipping emit. conversationId=${body.conversation.conversationId}`
+            );
+            break;
+          }
+          const event = {
+            roomId: body.conversation.roomId,
+            message: body.message
+          };
+          this._emitter.emit("message", event);
+          break;
+        }
+        case "RoomJoined": {
+          const roomInfo = data.body;
+          this._rooms.set(roomInfo.roomId, roomInfo);
+          const event = { room: roomInfo };
+          this._emitter.emit("room-joined", event);
+          break;
+        }
+        case "RoomMemberJoined": {
+          const body = data.body;
+          const event = { roomId: body.roomId, title: body.title, userId: body.userId };
+          this._emitter.emit("member-joined", event);
+          break;
+        }
+        // someone (not self) left a specific room
+        case "RoomMemberLeft": {
+          const body = data.body;
+          const event = { roomId: body.roomId, title: body.title, userId: body.userId };
+          this._emitter.emit("member-left", event);
+          break;
+        }
+        // self left a specific room
+        case "RoomLeft": {
+          const body = data.body;
+          if (!this._rooms.has(body.roomId)) {
+            break;
+          }
+          const event = { roomId: body.roomId, title: body.title };
+          this._emitter.emit("room-left", event);
+          this._rooms.delete(body.roomId);
+          break;
+        }
+        case "MessageUpdated":
+        case "MessageDeleted":
+        case "RoomClosed":
+        case "AddContact":
+          logger2.warning(`Known notification type ${type} received but not implemented yet.`);
+          break;
+        default:
+          logger2.warning(`Unknown notification type received: ${type}`);
+      }
+    } catch (err) {
+      logger2.error(`Error processing notification, error = ${err}, data: `, data);
+    }
+  }
+  /** Invoke server event and return typed data */
+  async invokeWithReturnType(eventName, payload, dataType, options) {
+    logger2.verbose(`invoke event: '${eventName}', dataType: ${dataType}, payload:`, payload);
+    try {
+      const rawResponse = await this._connection.invokeEvent(eventName, payload, dataType, {
+        abortSignal: options?.abortSignal
+      });
+      logger2.verbose(`invoke response for '${eventName}':`, rawResponse);
+      const data = rawResponse.data;
+      if (data && typeof data === "object" && typeof data.code === "string") {
+        throw new ChatError(`Invocation of event "${eventName}" failed: ${data.code}`, data.code);
+      }
+      return data;
+    } catch (e) {
+      if (e instanceof ChatError) throw e;
+      if (e instanceof InvocationError && e.errorDetail?.name) {
+        throw new ChatError(e.message, e.errorDetail.name);
+      }
+      throw e;
+    }
+  }
+  static async start(clientAccessUrlOrCredential, options) {
+    const credential = typeof clientAccessUrlOrCredential === "string" ? { getClientAccessUrl: async () => clientAccessUrlOrCredential } : clientAccessUrlOrCredential;
+    const chatClient = new _ChatClient(credential);
+    await chatClient.start({ abortSignal: options?.abortSignal });
+    return chatClient;
+  }
+  /**
+   * Connect the underlying transport and authenticate with the chat
+   * service.
+   *
+   * Idempotent: concurrent calls share a single in-flight promise, and
+   * calls made on an already-started client resolve immediately. After
+   * `stop()` the client can be started again; state from the previous
+   * session is reset.
+   *
+   * @param options - Cancellation token for the start operation. Aborting
+   *   leaves the client in its initial (not-started) state.
+   */
+  async start(options) {
+    if (this._startPromise) return this._startPromise;
+    if (this._isStarted) return;
+    if (this._connectionStoppedTCS && this._isConnectionStopping) {
+      await this._connectionStoppedTCS.wait();
+      if (this._startPromise) return this._startPromise;
+      if (this._isStarted) return;
+    }
+    const startPromise = this.startCore(options);
+    this._startPromise = startPromise;
+    try {
+      await startPromise;
+    } finally {
+      if (this._startPromise === startPromise) {
+        this._startPromise = void 0;
+      }
+    }
+  }
+  async startCore(options) {
+    this.resetState();
+    try {
+      await this._connection.start({ abortSignal: options?.abortSignal });
+      this._connectionStoppedTCS = new PromiseCompletionSource();
+      this._isConnectionStopping = false;
+      const loginResponse = await this.invokeWithReturnType(
+        INVOCATION_NAME.LOGIN,
+        "",
+        "text",
+        options
+      );
+      logger2.info("loginResponse", loginResponse);
+      const conversationIds = new Set(loginResponse.conversationIds || []);
+      const roomInfos = await Promise.all(
+        (loginResponse.roomIds || []).map(async (roomId) => {
+          const roomInfo = await this.fetchRoomDetail(roomId, {
+            abortSignal: options?.abortSignal,
+            withMembers: false
+          });
+          return { roomId, roomInfo };
+        })
+      );
+      this._userId = loginResponse.userId;
+      this._conversationIds = conversationIds;
+      roomInfos.forEach(({ roomId, roomInfo }) => {
+        this._rooms.set(roomId, roomInfo);
+      });
+      this._isStarted = true;
+      const startedEvent = { userId: loginResponse.userId };
+      this._emitter.emit("started", startedEvent);
+    } catch (err) {
+      this.resetState();
+      await this.stopConnection();
+      throw err;
+    }
+  }
+  ensureStarted() {
+    if (!this._isStarted) {
+      throw new ChatError("Not started. Please call start() first.", ERRORS.NotStarted);
+    }
+  }
+  /**
+   * Fetch a user's profile.
+   *
+   * @param userId - Id of the user to look up.
+   * @param options - Optional `{ abortSignal }`.
+   */
+  async getUserProfile(userId, options) {
+    this.ensureStarted();
+    return this.invokeWithReturnType(
+      INVOCATION_NAME.GET_USER_PROPERTIES,
+      { userId },
+      "json",
+      options
+    );
+  }
+  async sendToConversation(conversationId, message, options) {
+    this.ensureStarted();
+    const payload = {
+      conversation: { conversationId },
+      content: message
+    };
+    const resp = await this.invokeWithReturnType(
+      INVOCATION_NAME.SEND_TEXT_MESSAGE,
+      payload,
+      "json",
+      options
+    );
+    if (!resp || !resp.id) {
+      throw new ChatError(
+        `Failed to send message to conversation ${conversationId}, got invalid invoke response: ${JSON.stringify(resp)}`,
+        ERRORS.InvalidServerResponse
+      );
+    }
+    const msgId = resp.id;
+    const roomId = Array.from(this._rooms.values()).find((r) => r.defaultConversationId === conversationId)?.roomId;
+    if (!roomId) {
+      logger2.warning(
+        `Failed to find roomId for conversationId ${conversationId} when sending message; skipping local sender-echo emit.`
+      );
+      return { messageId: msgId };
+    }
+    const event = {
+      roomId,
+      message: {
+        messageId: msgId,
+        createdBy: this.userId,
+        messageBodyType: "Inline",
+        content: {
+          text: message,
+          binary: null
+        }
+      }
+    };
+    this._emitter.emit("message", event);
+    return { messageId: msgId };
+  }
+  /**
+   * Send a text message to a room and return the service-assigned message id.
+   *
+   * The room must be one this client has created or joined. The sender also
+   * observes the message through the `"message"` event.
+   *
+   * @param roomId - Target room.
+   * @param message - Message text to send.
+   * @param options - Optional `{ abortSignal }`.
+   * @returns A {@link SendMessageResult} with the service-assigned `messageId`.
+   */
+  async sendToRoom(roomId, message, options) {
+    this.ensureStarted();
+    const conversationId = this._rooms.get(roomId)?.defaultConversationId;
+    if (!conversationId) {
+      throw new ChatError(`Failed to sendToRoom, not found roomId ${roomId}`, ERRORS.UnknownRoom);
+    }
+    return await this.sendToConversation(conversationId, message, options);
+  }
+  // Internal: fetch a room's full wire shape (including its conversation id)
+  // to populate the local cache. Public callers go through getRoomDetail().
+  async fetchRoomDetail(roomId, options) {
+    return this.invokeWithReturnType(
+      INVOCATION_NAME.GET_ROOM,
+      { id: roomId, withMembers: options?.withMembers ?? false },
+      "json",
+      options
+    );
+  }
+  /**
+   * Fetch the detailed view of a room.
+   *
+   * @param roomId - Room to query.
+   * @param options - Optional `{ withMembers, abortSignal }`. Pass
+   *   `withMembers: true` to populate the returned `members` list; it is
+   *   left undefined otherwise.
+   */
+  async getRoomDetail(roomId, options) {
+    this.ensureStarted();
+    return this.fetchRoomDetail(roomId, options);
+  }
+  /**
+   * Create a room and its initial members. The current user is always
+   * included in the resulting member list.
+   *
+   * @param title - Display title for the room.
+   * @param members - Other user ids to invite. The caller is added
+   *   automatically; duplicates are de-duplicated.
+   * @param options - Optional `{ roomId, abortSignal }`. Pass `roomId`
+   *   to choose an id explicitly; omit to let the service assign one.
+   */
+  async createRoom(title, members, options) {
+    this.ensureStarted();
+    let roomDetails = {
+      title,
+      members: [.../* @__PURE__ */ new Set([...members, this.userId])]
+      // deduplicate and add self
+    };
+    if (options?.roomId) {
+      roomDetails = { ...roomDetails, roomId: options.roomId };
+    }
+    const roomInfo = await this.invokeWithReturnType(
+      INVOCATION_NAME.CREATE_ROOM,
+      roomDetails,
+      "json",
+      options
+    );
+    this._rooms.set(roomInfo.roomId, roomInfo);
+    const event = { room: roomInfo };
+    this._emitter.emit("room-joined", event);
+    return roomInfo;
+  }
+  async manageRoomMember(request, options) {
+    await this.invokeWithReturnType(INVOCATION_NAME.MANAGE_ROOM_MEMBER, request, "json", options);
+  }
+  async ensureRoomCached(roomId, options) {
+    if (this._rooms.has(roomId)) {
+      return;
+    }
+    const roomInfo = await this.fetchRoomDetail(roomId, options);
+    this._rooms.set(roomId, roomInfo);
+  }
+  /** Add a user to a room. This is an admin operation where one user adds another user to a room. */
+  async addUserToRoom(roomId, userId, options) {
+    this.ensureStarted();
+    const payload = { roomId, operation: "Add", userId };
+    const isSelf = userId === this.userId;
+    const shouldCacheRoomAfterSelfAdd = isSelf && !this._rooms.has(roomId);
+    try {
+      await this.manageRoomMember(payload, options);
+    } catch (error) {
+      if (!isSelf || !(error instanceof ChatError && error.code === ERRORS.UserAlreadyInRoom)) {
+        throw error;
+      }
+    }
+    if (shouldCacheRoomAfterSelfAdd) {
+      await this.ensureRoomCached(roomId, options);
+    }
+  }
+  /** Remove a user from a room. This is an admin operation where one user removes another user from a room. */
+  async removeUserFromRoom(roomId, userId, options) {
+    this.ensureStarted();
+    const payload = { roomId, operation: "Delete", userId };
+    await this.manageRoomMember(payload, options);
+    if (userId === this.userId) {
+      const roomInfo = this._rooms.get(roomId);
+      if (roomInfo) {
+        this._rooms.delete(roomId);
+        const event = { roomId, title: roomInfo.title };
+        this._emitter.emit("room-left", event);
+      }
+    }
+  }
+  /**
+   * List messages in a room as a paged async iterator.
+   *
+   * The iterator transparently fetches additional pages from the
+   * service as you iterate. For Teams-style infinite scrolling, drive
+   * the iterator one page at a time via `byPage(...)`:
+   *
+   * @example Stream every message (e.g. for export or full sync):
+   * ```ts
+   * for await (const msg of client.listRoomMessages(roomId)) {
+   *   console.log(msg.content.text);
+   * }
+   * ```
+   *
+   * @example Load history one page at a time (Teams-style scroll-back):
+   * ```ts
+   * // Load up to 50 messages per page.
+   * const pages = client.listRoomMessages(roomId).byPage({ maxPageSize: 50 });
+   * const first = await pages.next();
+   * displayMessages(first.value);
+   * // later, when the user scrolls up:
+   * const more = await pages.next();
+   * displayMessages(more.value);
+   * ```
+   *
+   * The room must be one this client has created or joined.
+   */
+  listRoomMessages(roomId, options) {
+    this.ensureStarted();
+    const conversationId = this._rooms.get(roomId)?.defaultConversationId;
+    if (!conversationId) {
+      throw new ChatError(`Failed to listRoomMessages, not found roomId ${roomId}`, ERRORS.UnknownRoom);
+    }
+    const defaultPageSize = options?.maxPageSize ?? 100;
+    const firstPageLink = {
+      conversation: { conversationId },
+      start: options?.startId ?? null,
+      end: options?.endId ?? null,
+      maxCount: defaultPageSize
+    };
+    const fetchPage = async (link, maxPageSize) => {
+      const query = {
+        ...link,
+        maxCount: maxPageSize ?? link.maxCount ?? defaultPageSize
+      };
+      const result = await this.invokeWithReturnType(
+        INVOCATION_NAME.LIST_MESSAGES,
+        query,
+        "json",
+        { abortSignal: options?.abortSignal }
+      );
+      if (result.messages.length === 0) {
+        return void 0;
+      }
+      return { page: result.messages, nextPageLink: result.nextQuery ?? void 0 };
+    };
+    return getPagedAsyncIterator({
+      firstPageLink,
+      getPage: (link, maxPageSize) => fetchPage(link, maxPageSize)
+    });
+  }
+  /** Cached rooms known to the client. */
+  get rooms() {
+    return Array.from(this._rooms.values());
+  }
+  /** Whether the current client has the room in its local joined-room cache. */
+  hasJoinedRoom(roomId) {
+    return this._rooms.has(roomId);
+  }
+  /**
+   * The chat-domain identity of this client, established by `start()`.
+   *
+   * @throws `ChatError` with code `NotStarted` if the client is not started.
+   */
+  get userId() {
+    if (!this._userId) {
+      throw new ChatError("User ID is not set. Please call start() first.", ERRORS.NotStarted);
+    }
+    return this._userId;
+  }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this._emitter.off(event, listener);
+  }
+  /**
+   * Stop the underlying connection and reset client state. Idempotent.
+   *
+   * After resolution the client returns to its initial state and may
+   * be started again via `start()`. Callers that want the same identity
+   * should keep their authentication source (URL or credential)
+   * constant.
+   *
+   * Stopping is not cancellable: it tears down the transport and clears
+   * local state, mirroring the underlying `WebPubSubClient.stop()`, which
+   * takes no options.
+   */
+  async stop() {
+    const startPromise = this._startPromise;
+    if (startPromise) {
+      await startPromise.catch(() => void 0);
+    }
+    this._startPromise = void 0;
+    this.resetState();
+    await this.stopConnection();
+  }
+  /**
+   * Reset chat-domain state. Emits `"stopped"` exactly once per
+   * started → not-started transition: if `_isStarted` was already
+   * false on entry (e.g. the pre-start guard inside `startCore()` or
+   * the post-failure rollback), no event fires.
+   */
+  resetState() {
+    const wasStarted = this._isStarted;
+    this._isStarted = false;
+    this._userId = void 0;
+    this._rooms.clear();
+    this._conversationIds.clear();
+    if (wasStarted) {
+      const stoppedEvent = {};
+      this._emitter.emit("stopped", stoppedEvent);
+    }
+  }
+  async stopConnection() {
+    const connectionStoppedTCS = this._connectionStoppedTCS;
+    if (!connectionStoppedTCS) {
+      return;
+    }
+    if (!this._isConnectionStopping) {
+      this._isConnectionStopping = true;
+      try {
+        this._connection.stop();
+      } catch (err) {
+        this._isConnectionStopping = false;
+        throw err;
+      }
+    }
+    await connectionStoppedTCS.wait();
+  }
+};
+
+// src/index.ts
+var KnownChatErrorCode = ERRORS;
+export {
+  ChatClient,
+  ChatError,
+  KnownChatErrorCode
+};
+//# sourceMappingURL=index.js.map