@tonytomo/gosocket-client 0.0.0-stage → 1.0.1

package/dist/index.js

@@ -0,0 +1,3060 @@
+// src/clock.ts
+var RealClock = class {
+  now() {
+    return Date.now();
+  }
+  setTimeout(fn, ms) {
+    const id = globalThis.setTimeout(fn, ms);
+    let stopped = false;
+    return {
+      stop: () => {
+        if (!stopped) {
+          stopped = true;
+          globalThis.clearTimeout(id);
+        }
+      }
+    };
+  }
+  clearTimeout(t) {
+    t.stop();
+  }
+};
+
+// src/events.ts
+var SyncEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+    };
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (set) {
+      for (const handler of Array.from(set)) {
+        try {
+          handler(payload);
+        } catch {
+        }
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/heartbeat.ts
+var HeartbeatManager = class {
+  constructor(config, clock, actions) {
+    this.clock = clock;
+    this.actions = actions;
+    this.enabled = config?.enabled ?? true;
+    this.intervalMs = config?.intervalMs && config.intervalMs > 0 ? config.intervalMs : 25e3;
+    this.timeoutMs = config?.timeoutMs && config.timeoutMs > 0 ? config.timeoutMs : 1e4;
+  }
+  clock;
+  actions;
+  enabled;
+  intervalMs;
+  timeoutMs;
+  intervalTimer = null;
+  pongTimer = null;
+  pingSentAt = 0;
+  isRunning = false;
+  start() {
+    if (!this.enabled) return;
+    this.stop();
+    this.isRunning = true;
+    this.scheduleNextPing();
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.intervalTimer) {
+      this.clock.clearTimeout(this.intervalTimer);
+      this.intervalTimer = null;
+    }
+    if (this.pongTimer) {
+      this.clock.clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+    this.pingSentAt = 0;
+  }
+  handlePong() {
+    if (!this.isRunning) return;
+    if (this.pongTimer) {
+      this.clock.clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+      const sample = Math.max(0, this.clock.now() - this.pingSentAt);
+      this.pingSentAt = 0;
+      this.actions.onPong?.(sample);
+      this.scheduleNextPing();
+    }
+  }
+  scheduleNextPing() {
+    if (!this.isRunning) return;
+    this.intervalTimer = this.clock.setTimeout(() => {
+      this.intervalTimer = null;
+      this.tick();
+    }, this.intervalMs);
+  }
+  tick() {
+    if (!this.isRunning) return;
+    this.pingSentAt = this.clock.now();
+    try {
+      this.actions.sendPing();
+    } catch {
+      return;
+    }
+    this.pongTimer = this.clock.setTimeout(() => {
+      this.pongTimer = null;
+      if (!this.isRunning) return;
+      const elapsed = this.clock.now() - this.pingSentAt;
+      this.stop();
+      this.actions.onTimeout(elapsed > 0 ? elapsed : this.timeoutMs);
+    }, this.timeoutMs);
+  }
+};
+
+// src/logger.ts
+function redactUrl(rawUrl) {
+  if (!rawUrl) return rawUrl;
+  try {
+    const u = new URL(rawUrl);
+    if (u.searchParams.has("key")) {
+      u.searchParams.set("key", "***");
+    }
+    return u.toString();
+  } catch {
+    return rawUrl.replace(/([?&]key=)[^& \s'"]*/g, "$1***");
+  }
+}
+function redactString(str, secrets) {
+  if (!str) return str;
+  let result = redactUrl(str);
+  for (const secret of secrets) {
+    if (secret && secret.length > 0) {
+      result = result.split(secret).join("***");
+    }
+  }
+  return result;
+}
+function redactValue(value, secrets) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return redactString(value, secrets);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, secrets));
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redactValue(v, secrets);
+    }
+    return out;
+  }
+  return value;
+}
+var RedactingLogger = class {
+  constructor(logger, getSecrets) {
+    this.logger = logger;
+    this.getSecrets = getSecrets;
+  }
+  logger;
+  getSecrets;
+  log(level, msg, fields) {
+    if (!this.logger) return;
+    const secrets = this.getSecrets().filter((s) => Boolean(s && s.length > 0));
+    const redactedMsg = redactString(msg, secrets);
+    const redactedFields = fields ? redactValue(fields, secrets) : void 0;
+    this.logger(level, redactedMsg, redactedFields);
+  }
+  debug(msg, fields) {
+    this.log("debug", msg, fields);
+  }
+  info(msg, fields) {
+    this.log("info", msg, fields);
+  }
+  warn(msg, fields) {
+    this.log("warn", msg, fields);
+  }
+  error(msg, fields) {
+    this.log("error", msg, fields);
+  }
+};
+
+// src/reconnect.ts
+function computeReconnectDelay(attempt, config = {}) {
+  const base = config.baseDelayMs && config.baseDelayMs > 0 ? config.baseDelayMs : 500;
+  const max = config.maxDelayMs && config.maxDelayMs > 0 ? config.maxDelayMs : 3e4;
+  const jitter = config.jitter ?? "full";
+  const rand = config.random ?? Math.random;
+  const shift = Math.min(Math.max(0, attempt), 30);
+  const backoff = Math.min(max, base * Math.pow(2, shift));
+  if (jitter === "none") {
+    return backoff;
+  }
+  if (jitter === "equal") {
+    const half = backoff / 2;
+    return half + rand() * half;
+  }
+  return rand() * backoff;
+}
+
+// src/types/error-base.ts
+function redactSecrets(text) {
+  if (!text) return text;
+  return text.replace(/([?&]key=)[^& \s'"]*/g, "$1***");
+}
+var SdkError = class extends Error {
+  constructor(message, options) {
+    super(redactSecrets(message), options);
+    this.name = "SdkError";
+  }
+};
+
+// src/validate.ts
+var ROOM_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+var CHANNEL_NAME_RE = /^[a-zA-Z0-9_-]{1,32}$/;
+var ValidationError = class extends SdkError {
+  field;
+  rule;
+  value;
+  limit;
+  constructor(field, rule, value, limit) {
+    let msg;
+    if (rule === "too_large") {
+      msg = `Validation failed on ${field}: ${rule} (limit ${limit} bytes, got ${value})`;
+    } else {
+      msg = `Validation failed on ${field}: ${rule} ("${value}")`;
+    }
+    super(msg);
+    this.name = "ValidationError";
+    this.field = field;
+    this.rule = rule;
+    this.value = value;
+    this.limit = limit;
+  }
+};
+var BinaryPayloadTooLargeError = class extends ValidationError {
+  byteLength;
+  maxBytes;
+  constructor(byteLength, maxBytes) {
+    super("binary_payload", "too_large", `${byteLength} bytes`, maxBytes);
+    this.name = "BinaryPayloadTooLargeError";
+    this.byteLength = byteLength;
+    this.maxBytes = maxBytes;
+  }
+};
+function truncateString(s, maxLen) {
+  if (s.length <= maxLen) {
+    return s;
+  }
+  return s.slice(0, maxLen) + "...";
+}
+function validateRoomName(room, config) {
+  if (config?.enabled === false) {
+    return;
+  }
+  if (!ROOM_NAME_RE.test(room)) {
+    throw new ValidationError("room", "name_syntax", truncateString(room, 64));
+  }
+}
+function validateChannelName(channel, config) {
+  if (config?.enabled === false) {
+    return;
+  }
+  if (channel === "presence") {
+    throw new ValidationError("channel", "reserved_channel", channel);
+  }
+  if (!CHANNEL_NAME_RE.test(channel)) {
+    throw new ValidationError("channel", "name_syntax", truncateString(channel, 32));
+  }
+}
+function validateTextPayloadSize(marshaledLength, config) {
+  if (config?.enabled === false) {
+    return;
+  }
+  const max = config?.maxTextPayloadBytes ?? 65536 - 512;
+  if (marshaledLength > max) {
+    throw new ValidationError("payload", "too_large", `${marshaledLength} bytes`, max);
+  }
+}
+function validateBinaryPayloadSize(byteLength, config) {
+  if (config?.enabled === false) {
+    return;
+  }
+  const max = config?.maxBinaryPayloadBytes ?? 65535;
+  if (byteLength > max) {
+    throw new BinaryPayloadTooLargeError(byteLength, max);
+  }
+}
+
+// src/policy.ts
+function presetsFor(kind, overrides) {
+  const presets = {};
+  presets["presence"] = {
+    reliable: true,
+    maxRate: 0,
+    coalesce: false
+  };
+  switch (kind) {
+    case "chat":
+      presets["chat"] = {
+        reliable: true,
+        maxRate: 5,
+        coalesce: false
+      };
+      break;
+    case "game":
+      presets["state"] = {
+        reliable: false,
+        maxRate: 60,
+        coalesce: false
+      };
+      presets["chat"] = {
+        reliable: true,
+        maxRate: 5,
+        coalesce: false
+      };
+      presets["actions"] = {
+        reliable: true,
+        maxRate: 20,
+        coalesce: false
+      };
+      break;
+    case "custom":
+    default:
+      presets["default"] = {
+        reliable: true,
+        maxRate: 0,
+        coalesce: false
+      };
+      break;
+  }
+  if (overrides) {
+    for (const [ch, override] of Object.entries(overrides)) {
+      presets[ch] = {
+        ...presets[ch] ?? { reliable: true, maxRate: 0, coalesce: false },
+        ...override
+      };
+    }
+  }
+  return presets;
+}
+function resolvePolicy(room, channel, provider, overrides) {
+  const overrideKey = `${room}:${channel}`;
+  if (overrides[overrideKey]) {
+    return overrides[overrideKey];
+  }
+  if (provider) {
+    const policy = provider.channelPolicy(room, channel);
+    if (policy) {
+      return policy;
+    }
+  }
+  return {
+    reliable: true,
+    maxRate: 0,
+    coalesce: false
+  };
+}
+
+// src/preflight.ts
+var CapabilityLimitError = class extends SdkError {
+  limit;
+  requested;
+  allowed;
+  constructor(limit, requested, allowed) {
+    super(`Capability limit exceeded for "${limit}": requested ${requested}, allowed ${allowed}`);
+    this.name = "CapabilityLimitError";
+    this.limit = limit;
+    this.requested = requested;
+    this.allowed = allowed;
+  }
+};
+function checkCapabilityPreflight(capabilities, req, ownedRoomsCount) {
+  if (!capabilities || !capabilities.limits) {
+    return;
+  }
+  const limits = capabilities.limits;
+  if (req.metadata !== void 0 && req.metadata !== null && limits.max_metadata_bytes !== null && limits.max_metadata_bytes !== void 0) {
+    const metaBytes = new TextEncoder().encode(JSON.stringify(req.metadata)).length;
+    if (metaBytes > limits.max_metadata_bytes) {
+      throw new CapabilityLimitError(
+        "max_metadata_bytes",
+        metaBytes,
+        limits.max_metadata_bytes
+      );
+    }
+  }
+  if (limits.max_channels_per_room !== null && limits.max_channels_per_room !== void 0) {
+    const effective = /* @__PURE__ */ new Set(["presence"]);
+    const preset = presetsFor(req.kind ?? "custom");
+    for (const ch of Object.keys(preset)) {
+      effective.add(ch);
+    }
+    if (req.channels) {
+      for (const ch of Object.keys(req.channels)) {
+        effective.add(ch);
+      }
+    }
+    if (effective.size > limits.max_channels_per_room) {
+      throw new CapabilityLimitError(
+        "max_channels_per_room",
+        effective.size,
+        limits.max_channels_per_room
+      );
+    }
+  }
+  if (limits.max_rooms_per_key !== null && limits.max_rooms_per_key !== void 0) {
+    if (ownedRoomsCount >= limits.max_rooms_per_key) {
+      throw new CapabilityLimitError(
+        "max_rooms_per_key",
+        ownedRoomsCount + 1,
+        limits.max_rooms_per_key
+      );
+    }
+  }
+}
+
+// src/types/errors.ts
+var AuthError = class extends SdkError {
+  code = "AUTH_FAILED";
+  constructor(message = "Authentication failed", options) {
+    super(message, options);
+    this.name = "AuthError";
+  }
+};
+var ConnectError = class extends SdkError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "ConnectError";
+    if (cause && typeof cause === "object") {
+      const sanitizedCause = {};
+      for (const [k, v] of Object.entries(cause)) {
+        if (typeof v === "string") {
+          sanitizedCause[k] = redactSecrets(v);
+        } else {
+          sanitizedCause[k] = v;
+        }
+      }
+      this.cause = sanitizedCause;
+    } else {
+      this.cause = cause;
+    }
+  }
+  get closeCode() {
+    if (this.cause && typeof this.cause === "object" && "closeCode" in this.cause) {
+      return this.cause.closeCode;
+    }
+    return void 0;
+  }
+  get reason() {
+    if (this.cause && typeof this.cause === "object" && "reason" in this.cause) {
+      return this.cause.reason;
+    }
+    return void 0;
+  }
+};
+var PolicyViolationError = class extends SdkError {
+  code = "POLICY_VIOLATION";
+  closeCode;
+  reason;
+  constructor(message = "Policy violation", closeCode = 1008, reason) {
+    super(message);
+    this.name = "PolicyViolationError";
+    this.closeCode = closeCode;
+    this.reason = reason;
+  }
+};
+var RequestTimeoutError = class extends SdkError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "RequestTimeoutError";
+  }
+};
+var ConcurrentRequestError = class extends SdkError {
+  constructor(message = "Concurrent request for the same operation and room is not permitted") {
+    super(message);
+    this.name = "ConcurrentRequestError";
+  }
+};
+var ServerError = class extends SdkError {
+  code;
+  channel;
+  retryAfterMs;
+  constructor(code, message, channel, retryAfterMs) {
+    super(message);
+    this.name = "ServerError";
+    this.code = code;
+    this.channel = channel;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var NotReadyError = class extends SdkError {
+  constructor(message = "Client is not ready for outbound operations") {
+    super(message);
+    this.name = "NotReadyError";
+  }
+};
+var ChannelNotReliableError = class extends SdkError {
+  channel;
+  constructor(channel, message = `Channel "${channel}" does not support reliable delivery`) {
+    super(message);
+    this.name = "ChannelNotReliableError";
+    this.channel = channel;
+  }
+};
+var RateLimitedError = class extends SdkError {
+  retryAfterMs;
+  channel;
+  source;
+  constructor(retryAfterMs, channel, source, message = `Rate limit exceeded on channel "${channel}"; retry after ${retryAfterMs}ms (${source})`) {
+    super(message);
+    this.name = "RateLimitedError";
+    this.retryAfterMs = retryAfterMs;
+    this.channel = channel;
+    this.source = source;
+  }
+};
+var BinaryMapValidationError = class extends SdkError {
+  channel;
+  id;
+  reason;
+  constructor(channel, id, reason) {
+    super(`Binary map validation failed for channel "${channel}" (id ${id}): ${reason}`);
+    this.name = "BinaryMapValidationError";
+    this.channel = channel;
+    this.id = id;
+    this.reason = reason;
+  }
+};
+var BinaryMapExhaustedError = class extends SdkError {
+  constructor(message = "All 254 binary channel IDs are in use") {
+    super(message);
+    this.name = "BinaryMapExhaustedError";
+  }
+};
+var BinaryIdCollisionError = class extends SdkError {
+  id;
+  existing;
+  rejected;
+  constructor(id, existing, rejected) {
+    super(`Binary channel ID ${id} collides with existing assignment (${existing.join(", ")})`);
+    this.name = "BinaryIdCollisionError";
+    this.id = id;
+    this.existing = existing;
+    this.rejected = rejected;
+  }
+};
+var BinaryChannelUnmappedError = class extends SdkError {
+  room;
+  channel;
+  constructor(room, channel) {
+    super(`Channel "${channel}" in room "${room}" is not mapped to a binary channel ID`);
+    this.name = "BinaryChannelUnmappedError";
+    this.room = room;
+    this.channel = channel;
+  }
+};
+
+// src/transport.ts
+var BrowserWebSocketTransport = class {
+  ws = null;
+  onopen = null;
+  onmessage = () => {
+  };
+  onclose = () => {
+  };
+  onerror = () => {
+  };
+  bufferedAmount() {
+    return this.ws ? this.ws.bufferedAmount : 0;
+  }
+  get readyState() {
+    return this.ws ? this.ws.readyState : 3;
+  }
+  connect(url) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const redacted = redactUrl(url);
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.binaryType = "arraybuffer";
+      } catch (err) {
+        settled = true;
+        reject(
+          new ConnectError(`Failed to construct WebSocket for ${redacted}`, err)
+        );
+        return;
+      }
+      const handleOpen = () => {
+        if (!settled) {
+          settled = true;
+          this.cleanupPreOpen();
+          this.onopen?.();
+          resolve();
+        }
+      };
+      const handleErrorPreOpen = (ev) => {
+        this.onerror(ev);
+      };
+      const handleClosePreOpen = (ev) => {
+        if (!settled) {
+          settled = true;
+          this.cleanupPreOpen();
+          const cause = {
+            closeCode: ev.code,
+            reason: ev.reason,
+            wasClean: ev.wasClean
+          };
+          const err = new ConnectError(
+            `Connection closed before open for ${redacted} (code: ${ev.code}, reason: ${ev.reason || "none"})`,
+            cause
+          );
+          this.onclose({ code: ev.code, reason: ev.reason, wasClean: ev.wasClean });
+          reject(err);
+        }
+      };
+      this.cleanupPreOpen = () => {
+        this.ws?.removeEventListener("open", handleOpen);
+        this.ws?.removeEventListener("error", handleErrorPreOpen);
+        this.ws?.removeEventListener("close", handleClosePreOpen);
+      };
+      this.ws.addEventListener("open", handleOpen);
+      this.ws.addEventListener("error", handleErrorPreOpen);
+      this.ws.addEventListener("close", handleClosePreOpen);
+      this.ws.onmessage = (ev) => {
+        this.onmessage({ data: ev.data });
+      };
+      this.ws.onclose = (ev) => {
+        if (settled) {
+          this.onclose({ code: ev.code, reason: ev.reason, wasClean: ev.wasClean });
+        }
+      };
+      this.ws.onerror = (ev) => {
+        if (settled) {
+          this.onerror(ev);
+        }
+      };
+    });
+  }
+  cleanupPreOpen = () => {
+  };
+  send(data) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      throw new ConnectError("Cannot send on closed WebSocket");
+    }
+    this.ws.send(data);
+  }
+  close(code, reason) {
+    if (this.ws) {
+      try {
+        this.ws.close(code, reason);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/types/protocol.ts
+function isErrorFrame(x) {
+  return typeof x === "object" && x !== null && x.type === "error";
+}
+function isMessageFrame(x) {
+  return typeof x === "object" && x !== null && x.type === "message";
+}
+function isWelcomeFrame(x) {
+  return typeof x === "object" && x !== null && x.type === "welcome";
+}
+
+// src/backpressure.ts
+var BackpressureManager = class {
+  enabled;
+  highWaterMarkBytes;
+  lowWaterMarkBytes;
+  pollIntervalMs;
+  blocked = false;
+  pollTimer = null;
+  transport;
+  clock;
+  onStateChange;
+  onWakeWriter;
+  constructor(transport, clock, config, onStateChange, onWakeWriter) {
+    this.transport = transport;
+    this.clock = clock;
+    this.enabled = config?.enabled ?? true;
+    this.highWaterMarkBytes = config?.highWaterMarkBytes ?? 1 << 20;
+    this.lowWaterMarkBytes = config?.lowWaterMarkBytes ?? 1 << 19;
+    this.pollIntervalMs = config?.pollIntervalMs ?? 50;
+    this.onStateChange = onStateChange;
+    this.onWakeWriter = onWakeWriter;
+  }
+  start() {
+    if (!this.enabled || this.highWaterMarkBytes <= 0) {
+      return;
+    }
+    this.stop();
+    this.scheduleNextPoll();
+  }
+  scheduleNextPoll() {
+    this.pollTimer = this.clock.setTimeout(() => {
+      this.check();
+      if (this.pollTimer) {
+        this.scheduleNextPoll();
+      }
+    }, this.pollIntervalMs);
+  }
+  stop() {
+    if (this.pollTimer) {
+      this.clock.clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.blocked = false;
+  }
+  isBlocked() {
+    if (!this.enabled || this.highWaterMarkBytes <= 0) {
+      return false;
+    }
+    return this.blocked;
+  }
+  check() {
+    if (!this.enabled || this.highWaterMarkBytes <= 0) {
+      return false;
+    }
+    const current = this.transport.bufferedAmount();
+    if (!this.blocked && current >= this.highWaterMarkBytes) {
+      this.blocked = true;
+      this.onStateChange({
+        state: "high",
+        bufferedAmount: current
+      });
+    } else if (this.blocked && current <= this.lowWaterMarkBytes) {
+      this.blocked = false;
+      this.onStateChange({
+        state: "low",
+        bufferedAmount: current
+      });
+      this.onWakeWriter();
+    }
+    return this.blocked;
+  }
+};
+
+// src/coalesce.ts
+var CoalesceManager = class {
+  slots = /* @__PURE__ */ new Map();
+  slotKeys = [];
+  rrIndex = 0;
+  clock;
+  onWake;
+  onCoalesced;
+  constructor(clock, onWake, onCoalesced) {
+    this.clock = clock;
+    this.onWake = onWake;
+    this.onCoalesced = onCoalesced;
+  }
+  makeKey(room, channel, frameType) {
+    return `${room}:${channel}:${frameType}`;
+  }
+  update(room, channel, frameType, payload, wire, policy, includeSender) {
+    const key = this.makeKey(room, channel, frameType);
+    let slot = this.slots.get(key);
+    if (!slot) {
+      slot = {
+        room,
+        channel,
+        frameType,
+        latestWire: wire,
+        latestPayload: payload,
+        includeSender,
+        hasNew: true,
+        isReady: false
+      };
+      this.slots.set(key, slot);
+      this.slotKeys.push(key);
+      this.scheduleSlotFlush(slot, policy);
+      return;
+    }
+    if (slot.hasNew) {
+      if (policy.merge && frameType === "text") {
+        const result = policy.merge(slot.latestPayload, payload);
+        if (result.skip) {
+          this.onCoalesced({
+            room,
+            channel,
+            merged: false,
+            skipped: true
+          });
+          return;
+        }
+        slot.latestPayload = result.value;
+        const frameObj = {
+          type: "publish",
+          room,
+          channel,
+          payload: result.value,
+          reliable: false
+        };
+        if (includeSender !== void 0) {
+          frameObj.include_sender = includeSender;
+        }
+        slot.latestWire = JSON.stringify(frameObj);
+        this.onCoalesced({
+          room,
+          channel,
+          merged: true,
+          skipped: false
+        });
+      } else {
+        slot.latestPayload = payload;
+        slot.latestWire = wire;
+        slot.includeSender = includeSender;
+        this.onCoalesced({
+          room,
+          channel,
+          merged: false,
+          skipped: false
+        });
+      }
+    } else {
+      slot.latestPayload = payload;
+      slot.latestWire = wire;
+      slot.includeSender = includeSender;
+      slot.hasNew = true;
+      slot.isReady = false;
+      this.scheduleSlotFlush(slot, policy);
+    }
+  }
+  scheduleSlotFlush(slot, policy) {
+    const driver = policy.coalesceDriver ?? "timer";
+    if (driver === "raf") {
+      if (typeof requestAnimationFrame === "function") {
+        if (slot.rafHandle) {
+          cancelAnimationFrame(slot.rafHandle);
+        }
+        slot.rafHandle = requestAnimationFrame(() => {
+          slot.rafHandle = null;
+          slot.isReady = true;
+          this.onWake();
+        });
+        return;
+      }
+      if (slot.timerHandle) {
+        this.clock.clearTimeout(slot.timerHandle);
+      }
+      slot.timerHandle = this.clock.setTimeout(() => {
+        slot.timerHandle = null;
+        slot.isReady = true;
+        this.onWake();
+      }, 16);
+      return;
+    }
+    queueMicrotask(() => {
+      if (slot.hasNew) {
+        slot.isReady = true;
+        this.onWake();
+      }
+    });
+  }
+  takeReady() {
+    const n = this.slotKeys.length;
+    if (n === 0) return void 0;
+    for (let i = 0; i < n; i++) {
+      const idx = (this.rrIndex + i) % n;
+      const key = this.slotKeys[idx];
+      const slot = this.slots.get(key);
+      if (slot && slot.hasNew && slot.isReady) {
+        const item = {
+          room: slot.room,
+          channel: slot.channel,
+          frameType: slot.frameType,
+          wire: slot.latestWire
+        };
+        slot.hasNew = false;
+        slot.isReady = false;
+        slot.latestPayload = void 0;
+        slot.latestWire = "";
+        this.rrIndex = (idx + 1) % n;
+        return item;
+      }
+    }
+    return void 0;
+  }
+  readyAllPending() {
+    for (const slot of this.slots.values()) {
+      if (slot.hasNew) {
+        slot.isReady = true;
+      }
+    }
+  }
+  flushChannel(room, channel, onFlush) {
+    for (const slot of this.slots.values()) {
+      if (slot.room === room && slot.channel === channel && slot.hasNew) {
+        const wire = slot.latestWire;
+        slot.hasNew = false;
+        slot.isReady = false;
+        slot.latestPayload = void 0;
+        slot.latestWire = "";
+        if (slot.timerHandle) {
+          this.clock.clearTimeout(slot.timerHandle);
+          slot.timerHandle = null;
+        }
+        if (slot.rafHandle && typeof cancelAnimationFrame === "function") {
+          cancelAnimationFrame(slot.rafHandle);
+          slot.rafHandle = null;
+        }
+        onFlush(wire);
+      }
+    }
+  }
+  clearRoom(room) {
+    const toDelete = [];
+    for (const [key, slot] of this.slots.entries()) {
+      if (slot.room === room) {
+        if (slot.timerHandle) {
+          this.clock.clearTimeout(slot.timerHandle);
+          slot.timerHandle = null;
+        }
+        if (slot.rafHandle && typeof cancelAnimationFrame === "function") {
+          cancelAnimationFrame(slot.rafHandle);
+          slot.rafHandle = null;
+        }
+        toDelete.push(key);
+      }
+    }
+    for (const key of toDelete) {
+      this.slots.delete(key);
+      const idx = this.slotKeys.indexOf(key);
+      if (idx !== -1) {
+        this.slotKeys.splice(idx, 1);
+      }
+    }
+  }
+  countPending() {
+    let count = 0;
+    for (const slot of this.slots.values()) {
+      if (slot.hasNew) {
+        count++;
+      }
+    }
+    return count;
+  }
+  clear() {
+    const count = this.countPending();
+    for (const slot of this.slots.values()) {
+      if (slot.timerHandle) {
+        this.clock.clearTimeout(slot.timerHandle);
+        slot.timerHandle = null;
+      }
+      if (slot.rafHandle && typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(slot.rafHandle);
+        slot.rafHandle = null;
+      }
+    }
+    this.slots.clear();
+    this.slotKeys.length = 0;
+    this.rrIndex = 0;
+    return count;
+  }
+};
+
+// src/outbound.ts
+var OutboundQueue = class {
+  items = [];
+  head = 0;
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get size() {
+    return this.items.length - this.head;
+  }
+  enqueue(item) {
+    this.items.push(item);
+  }
+  dequeue() {
+    if (this.head >= this.items.length) {
+      return void 0;
+    }
+    const item = this.items[this.head];
+    this.items[this.head] = void 0;
+    this.head++;
+    if (this.head > 64 && this.head * 2 >= this.items.length) {
+      this.items = this.items.slice(this.head);
+      this.head = 0;
+    }
+    return item;
+  }
+  dropOldest() {
+    return this.dequeue();
+  }
+  peek() {
+    if (this.head >= this.items.length) {
+      return void 0;
+    }
+    return this.items[this.head];
+  }
+  clear() {
+    const count = this.size;
+    this.items = [];
+    this.head = 0;
+    return count;
+  }
+};
+
+// src/ratelimit.ts
+var TokenBucket = class {
+  ratePerSec;
+  burst;
+  tokens;
+  lastRefillMs;
+  clock;
+  constructor(ratePerSec, burst, clock) {
+    this.ratePerSec = ratePerSec;
+    this.burst = burst;
+    this.clock = clock;
+    this.tokens = burst;
+    this.lastRefillMs = clock.now();
+  }
+  advanceTo(now) {
+    if (now > this.lastRefillMs) {
+      const elapsedSec = (now - this.lastRefillMs) / 1e3;
+      this.tokens = Math.min(this.burst, this.tokens + elapsedSec * this.ratePerSec);
+      this.lastRefillMs = now;
+    }
+  }
+  tryConsume() {
+    const now = this.clock.now();
+    this.advanceTo(now);
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  retryAfterMs(now) {
+    this.advanceTo(now);
+    if (this.tokens >= 1) {
+      return 0;
+    }
+    const needed = 1 - this.tokens;
+    const ms = Math.ceil(needed / this.ratePerSec * 1e3);
+    return Math.max(1, ms);
+  }
+};
+var RateLimiterRegistry = class {
+  limiters = /* @__PURE__ */ new Map();
+  serverBackoffs = /* @__PURE__ */ new Map();
+  recentRoomByChan = /* @__PURE__ */ new Map();
+  clock;
+  constructor(clock) {
+    this.clock = clock;
+  }
+  makeKey(room, channel) {
+    return `${room}:${channel}`;
+  }
+  get(room, channel, ratePerSec) {
+    const key = this.makeKey(room, channel);
+    let bucket = this.limiters.get(key);
+    if (!bucket || bucket.ratePerSec !== ratePerSec) {
+      const burst = Math.max(2, ratePerSec * 2);
+      bucket = new TokenBucket(ratePerSec, burst, this.clock);
+      this.limiters.set(key, bucket);
+    }
+    return bucket;
+  }
+  recordPublish(room, channel) {
+    this.recentRoomByChan.set(channel, room);
+  }
+  getRecentRoom(channel) {
+    return this.recentRoomByChan.get(channel);
+  }
+  pause(room, channel, untilMs) {
+    const key = this.makeKey(room, channel);
+    const existing = this.serverBackoffs.get(key) ?? 0;
+    if (untilMs > existing) {
+      this.serverBackoffs.set(key, untilMs);
+    }
+  }
+  isPaused(room, channel, now) {
+    const key = this.makeKey(room, channel);
+    const until = this.serverBackoffs.get(key);
+    if (until !== void 0 && until > now) {
+      return {
+        paused: true,
+        retryAfterMs: Math.max(1, until - now)
+      };
+    }
+    if (room !== "") {
+      const fallbackKey = this.makeKey("", channel);
+      const fallbackUntil = this.serverBackoffs.get(fallbackKey);
+      if (fallbackUntil !== void 0 && fallbackUntil > now) {
+        return {
+          paused: true,
+          retryAfterMs: Math.max(1, fallbackUntil - now)
+        };
+      }
+    }
+    return { paused: false, retryAfterMs: 0 };
+  }
+  clearRoom(room) {
+    const prefix = `${room}:`;
+    for (const key of this.limiters.keys()) {
+      if (key.startsWith(prefix)) {
+        this.limiters.delete(key);
+      }
+    }
+    for (const key of this.serverBackoffs.keys()) {
+      if (key.startsWith(prefix)) {
+        this.serverBackoffs.delete(key);
+      }
+    }
+    for (const [ch, r] of this.recentRoomByChan.entries()) {
+      if (r === room) {
+        this.recentRoomByChan.delete(ch);
+      }
+    }
+  }
+  clearAll() {
+    this.limiters.clear();
+    this.serverBackoffs.clear();
+    this.recentRoomByChan.clear();
+  }
+};
+
+// src/writer.ts
+var WriterLoop = class {
+  transport;
+  reliableQueue;
+  unreliableQueue;
+  coalesceManager;
+  backpressure;
+  reliableBurst;
+  unreliableBurst;
+  canWrite;
+  onError;
+  pumping = false;
+  scheduled = false;
+  stopped = false;
+  activePumpPromise = null;
+  constructor(options) {
+    this.transport = options.transport;
+    this.reliableQueue = options.reliableQueue;
+    this.unreliableQueue = options.unreliableQueue;
+    this.coalesceManager = options.coalesceManager;
+    this.backpressure = options.backpressure;
+    this.reliableBurst = options.reliableBurst ?? 32;
+    this.unreliableBurst = options.unreliableBurst ?? 8;
+    this.canWrite = options.canWrite;
+    this.onError = options.onError;
+  }
+  hasWork() {
+    return this.reliableQueue.size > 0 || this.unreliableQueue.size > 0 || this.coalesceManager.countPending() > 0;
+  }
+  wake() {
+    if (this.stopped || this.scheduled || this.pumping || !this.canWrite() || this.backpressure.isBlocked()) {
+      return;
+    }
+    this.pump().catch((err) => {
+      this.onError(err);
+    });
+  }
+  async pump() {
+    if (this.stopped || this.pumping || !this.canWrite() || this.backpressure.isBlocked()) {
+      return;
+    }
+    this.pumping = true;
+    let writeErrorOccurred = false;
+    let resolveActive = () => {
+    };
+    this.activePumpPromise = new Promise((resolve) => {
+      resolveActive = resolve;
+    });
+    try {
+      for (let i = 0; i < this.reliableBurst && this.canWrite(); i++) {
+        if (this.backpressure.isBlocked()) break;
+        const frame = this.reliableQueue.dequeue();
+        if (!frame) break;
+        try {
+          this.transport.send(frame.wire);
+        } catch (err) {
+          writeErrorOccurred = true;
+          this.stop();
+          this.onError(err);
+          return;
+        }
+        this.backpressure.check();
+        await Promise.resolve();
+      }
+      for (let i = 0; i < this.unreliableBurst && this.canWrite(); i++) {
+        if (this.backpressure.isBlocked()) break;
+        const slot = this.coalesceManager.takeReady();
+        if (slot) {
+          try {
+            this.transport.send(slot.wire);
+          } catch (err) {
+            writeErrorOccurred = true;
+            this.stop();
+            this.onError(err);
+            return;
+          }
+          this.backpressure.check();
+          await Promise.resolve();
+        } else {
+          const frame = this.unreliableQueue.dequeue();
+          if (!frame) break;
+          try {
+            this.transport.send(frame.wire);
+          } catch (err) {
+            writeErrorOccurred = true;
+            this.stop();
+            this.onError(err);
+            return;
+          }
+          this.backpressure.check();
+          await Promise.resolve();
+        }
+      }
+    } finally {
+      this.pumping = false;
+      this.activePumpPromise = null;
+      resolveActive();
+    }
+    if (!writeErrorOccurred && !this.stopped && this.hasWork() && !this.backpressure.isBlocked() && this.canWrite()) {
+      queueMicrotask(() => {
+        this.wake();
+      });
+    }
+  }
+  async flushNow() {
+    this.coalesceManager.readyAllPending();
+    while (!this.stopped && this.hasWork() && !this.backpressure.isBlocked() && this.canWrite()) {
+      if (this.activePumpPromise) {
+        await this.activePumpPromise;
+      } else {
+        await this.pump();
+      }
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.scheduled = false;
+    this.pumping = false;
+  }
+  resume() {
+    this.stopped = false;
+    this.wake();
+  }
+};
+
+// src/binary.ts
+var BinaryMapBuilder = class {
+  byChannel = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  set(channel, id) {
+    if (channel === "" || channel === "presence") {
+      throw new BinaryMapValidationError(channel, id, "reserved_channel");
+    }
+    if (!Number.isInteger(id) || id < 1 || id > 254) {
+      throw new BinaryMapValidationError(channel, id, "out_of_range");
+    }
+    const existingId = this.byChannel.get(channel);
+    if (existingId !== void 0) {
+      if (existingId === id) {
+        return this;
+      }
+      throw new BinaryMapValidationError(channel, id, "duplicate_channel");
+    }
+    const existingChannel = this.byId.get(id);
+    if (existingChannel !== void 0) {
+      if (existingChannel === channel) {
+        return this;
+      }
+      throw new BinaryMapValidationError(channel, id, "duplicate_id");
+    }
+    this.byChannel.set(channel, id);
+    this.byId.set(id, channel);
+    return this;
+  }
+  autoSet(channel) {
+    if (channel === "" || channel === "presence") {
+      throw new BinaryMapValidationError(channel, 0, "reserved_channel");
+    }
+    const existingId = this.byChannel.get(channel);
+    if (existingId !== void 0) {
+      throw new BinaryMapValidationError(channel, existingId, "duplicate_channel");
+    }
+    for (let id = 1; id <= 254; id++) {
+      if (!this.byId.has(id)) {
+        this.byChannel.set(channel, id);
+        this.byId.set(id, channel);
+        return this;
+      }
+    }
+    throw new BinaryMapExhaustedError();
+  }
+  build() {
+    return Object.freeze(Object.fromEntries(this.byChannel));
+  }
+};
+function validateBinaryMap(map) {
+  if (!map || Object.keys(map).length === 0) {
+    return;
+  }
+  const builder = new BinaryMapBuilder();
+  const sortedChannels = Object.keys(map).sort();
+  for (const ch of sortedChannels) {
+    builder.set(ch, map[ch]);
+  }
+}
+
+// src/presence.ts
+var PresenceManager = class {
+  states = /* @__PURE__ */ new Map();
+  autoInvalidateOnReliableGap;
+  constructor(config) {
+    this.autoInvalidateOnReliableGap = config?.autoInvalidateOnReliableGap ?? false;
+  }
+  get(room) {
+    return this.states.get(room);
+  }
+  init(room, members) {
+    const existing = this.states.get(room);
+    if (!existing) {
+      this.states.set(room, {
+        known: /* @__PURE__ */ new Set(),
+        serverCount: members,
+        invalidated: false,
+        invalidReason: ""
+      });
+    } else {
+      existing.serverCount = members;
+    }
+  }
+  remove(room) {
+    this.states.delete(room);
+  }
+  clear() {
+    this.states.clear();
+  }
+  invalidateAll() {
+    const rooms = [];
+    for (const [room, state] of this.states.entries()) {
+      state.invalidated = true;
+      state.invalidReason = "reconnected";
+      rooms.push(room);
+    }
+    return rooms;
+  }
+  knownMembers(room, selfLabel) {
+    const state = this.states.get(room);
+    if (!state) return [];
+    const list = Array.from(state.known).filter((m) => m !== selfLabel);
+    list.sort();
+    return list;
+  }
+  lastServerMemberCount(room) {
+    const state = this.states.get(room);
+    if (!state) return { count: 0, ok: false };
+    return { count: state.serverCount, ok: true };
+  }
+  presenceInvalidated(room) {
+    const state = this.states.get(room);
+    if (!state) return false;
+    return state.invalidated;
+  }
+  resetPresence(room) {
+    const state = this.states.get(room);
+    if (state) {
+      state.known.clear();
+      state.invalidated = false;
+      state.invalidReason = "";
+    }
+  }
+};
+
+// src/seq.ts
+var SeqTracker = class {
+  states = /* @__PURE__ */ new Map();
+  makeKey(room, channel) {
+    return `${room}:${channel}`;
+  }
+  lastSeq(room, channel) {
+    const key = this.makeKey(room, channel);
+    const state = this.states.get(key);
+    if (!state || !state.hasBase) {
+      return { seq: 0, ok: false };
+    }
+    return { seq: state.last, ok: true };
+  }
+  process(room, channel, seq, reliable) {
+    const key = this.makeKey(room, channel);
+    let state = this.states.get(key);
+    if (!state || !state.hasBase) {
+      state = { last: seq, hasBase: true };
+      this.states.set(key, state);
+      return {};
+    }
+    if (seq === 0) {
+      return {};
+    }
+    if (seq > state.last) {
+      let gap;
+      if (seq > state.last + 1) {
+        const missed = seq - state.last - 1;
+        gap = {
+          prev: state.last,
+          current: seq,
+          missed,
+          reliable
+        };
+      }
+      state.last = seq;
+      return { gap };
+    }
+    if (seq === state.last) {
+      return {};
+    }
+    state.last = seq;
+    return {};
+  }
+  rebaselineAll() {
+    for (const state of this.states.values()) {
+      state.hasBase = false;
+    }
+  }
+  clearRoom(room) {
+    const prefix = `${room}:`;
+    for (const key of this.states.keys()) {
+      if (key.startsWith(prefix)) {
+        this.states.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.states.clear();
+  }
+};
+
+// src/errors-policy.ts
+function classifyError(code, frame, overrides) {
+  if (overrides && overrides[code]) {
+    const custom = overrides[code];
+    return {
+      action: custom.action,
+      retryAfterMs: custom.retryAfterMs
+    };
+  }
+  switch (code) {
+    case "UNAUTHORIZED":
+    case "FORBIDDEN_SCOPE":
+      return { action: "fatal" };
+    case "NOT_ROOM_OWNER":
+    case "BAD_REQUEST":
+    case "ROOM_NOT_FOUND":
+      return { action: "drop_intent" };
+    case "ROOM_ALREADY_EXISTS":
+    case "INVALID_PASSCODE":
+      return { action: "app_prompt" };
+    case "ROOM_FULL":
+      return { action: "retry_backoff", retryAfterMs: 1e3 };
+    case "PASSCODE_RATE_LIMITED": {
+      const retry = frame?.retry_after_ms && frame.retry_after_ms > 0 ? frame.retry_after_ms : 6e4;
+      return { action: "retry_backoff", retryAfterMs: retry };
+    }
+    case "MAX_ROOMS_REACHED":
+      return { action: "retry_backoff", retryAfterMs: 5e3 };
+    case "BINARY_NOT_ALLOWED":
+    case "CHANNEL_NOT_RELIABLE":
+    case "CHANNEL_NOT_FOUND":
+    case "RESERVED_CHANNEL_NAME":
+    case "CHANNEL_READ_ONLY":
+      return { action: "ignore" };
+    case "RATE_LIMITED": {
+      const retry = frame?.retry_after_ms && frame.retry_after_ms > 0 ? frame.retry_after_ms : 250;
+      return { action: "retry_backoff", retryAfterMs: retry };
+    }
+    case "INTERNAL_ERROR":
+      return { action: "retry_backoff", retryAfterMs: 2e3 };
+    default:
+      return { action: "ignore" };
+  }
+}
+
+// src/rtt.ts
+var RttTracker = class {
+  stats;
+  getStats() {
+    return this.stats ? { ...this.stats } : void 0;
+  }
+  recordSample(sampleMs) {
+    if (!this.stats || this.stats.samples === 0) {
+      this.stats = {
+        last: sampleMs,
+        min: sampleMs,
+        max: sampleMs,
+        mean: sampleMs,
+        samples: 1
+      };
+    } else {
+      this.stats.last = sampleMs;
+      this.stats.samples += 1;
+      if (sampleMs < this.stats.min) {
+        this.stats.min = sampleMs;
+      }
+      if (sampleMs > this.stats.max) {
+        this.stats.max = sampleMs;
+      }
+      this.stats.mean = 0.8 * this.stats.mean + 0.2 * sampleMs;
+    }
+    return { ...this.stats };
+  }
+  reset() {
+    this.stats = void 0;
+  }
+};
+
+// src/client.ts
+function buildWsUrl(baseUrl, apiKey) {
+  const u = new URL(baseUrl);
+  u.searchParams.set("key", apiKey);
+  return u.toString();
+}
+var ROOM_NAME_REGEX = /room\s+"([^"]+)"/;
+function extractRoomFromMessage(message) {
+  const match = message.match(ROOM_NAME_REGEX);
+  return match ? match[1] : null;
+}
+var Client = class {
+  config;
+  clock;
+  emitter = new SyncEventEmitter();
+  logger;
+  transport;
+  _state = "idle";
+  _capabilities;
+  serverVersion;
+  firstConnectDone = false;
+  currentConnWelcomeReceived = false;
+  isRestoringSession = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  welcomeTimer = null;
+  intents = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  listRoomsLock = Promise.resolve();
+  heartbeatManager;
+  reliableQueue;
+  unreliableQueue;
+  coalesceManager;
+  backpressureManager;
+  rateLimiters;
+  writer;
+  policyOverrides = {};
+  appliedPolicies = /* @__PURE__ */ new Set();
+  _selfLabel = "";
+  binaryOwner = /* @__PURE__ */ new Map();
+  presenceManager;
+  seqTracker = new SeqTracker();
+  rttTracker = new RttTracker();
+  createdRooms = /* @__PURE__ */ new Set();
+  pingChain = Promise.resolve(0);
+  pendingConnectResolve = null;
+  pendingConnectReject = null;
+  constructor(config) {
+    if (!config.url) {
+      throw new SdkError("WebSocket URL is required");
+    }
+    if (!config.apiKey) {
+      throw new SdkError("API key is required");
+    }
+    this.config = config;
+    this.clock = config.clock ?? new RealClock();
+    this.transport = config.transport ?? new BrowserWebSocketTransport();
+    this.presenceManager = new PresenceManager(config.presence);
+    this.logger = new RedactingLogger(config.logger, () => [
+      this.config.apiKey,
+      ...Array.from(this.intents.values()).map((i) => i.passcode)
+    ]);
+    this.heartbeatManager = new HeartbeatManager(config.heartbeat, this.clock, {
+      sendPing: () => {
+        this.send({ type: "ping" });
+      },
+      onTimeout: (elapsedMs) => {
+        this.logger.warn("Heartbeat timeout; closing connection", { elapsedMs });
+        this.emitter.emit("heartbeatTimeout", { elapsedMs });
+        this.transport.close(1008, "heartbeat timeout");
+      },
+      onPong: (sample) => {
+        if (this.config.heartbeat?.trackRtt !== false) {
+          const stats = this.rttTracker.recordSample(sample);
+          this.emitter.emit("rtt", {
+            sample,
+            source: "heartbeat",
+            stats
+          });
+        }
+      }
+    });
+    const outboundCfg = config.outbound;
+    this.reliableQueue = new OutboundQueue(outboundCfg?.reliableQueueSize ?? 256);
+    this.unreliableQueue = new OutboundQueue(outboundCfg?.unreliableQueueSize ?? 16);
+    this.coalesceManager = new CoalesceManager(
+      this.clock,
+      () => {
+        this.writer.wake();
+      },
+      (ev) => {
+        this.emitter.emit("coalesced", ev);
+      }
+    );
+    this.backpressureManager = new BackpressureManager(
+      this.transport,
+      this.clock,
+      config.backpressure,
+      (ev) => {
+        this.emitter.emit("backpressure", ev);
+      },
+      () => {
+        this.writer.wake();
+      }
+    );
+    this.rateLimiters = new RateLimiterRegistry(this.clock);
+    this.writer = new WriterLoop({
+      transport: this.transport,
+      reliableQueue: this.reliableQueue,
+      unreliableQueue: this.unreliableQueue,
+      coalesceManager: this.coalesceManager,
+      backpressure: this.backpressureManager,
+      reliableBurst: outboundCfg?.reliableBurst ?? 32,
+      unreliableBurst: outboundCfg?.unreliableBurst ?? 8,
+      canWrite: () => (this._state === "ready" || this.isRestoringSession) && this.transport.readyState === 1,
+      onError: (err) => {
+        this.emitter.emit("error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          phase: "runtime"
+        });
+      }
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  get capabilities() {
+    return this._capabilities;
+  }
+  get selfLabel() {
+    return this._selfLabel;
+  }
+  knownMembers(room) {
+    return this.presenceManager.knownMembers(room, this._selfLabel);
+  }
+  lastServerMemberCount(room) {
+    return this.presenceManager.lastServerMemberCount(room);
+  }
+  presenceInvalidated(room) {
+    return this.presenceManager.presenceInvalidated(room);
+  }
+  resetPresence(room) {
+    if (!this.intents.has(room)) {
+      throw new NotReadyError(`Room "${room}" has no live intent`);
+    }
+    this.presenceManager.resetPresence(room);
+  }
+  lastSeq(room, channel) {
+    return this.seqTracker.lastSeq(room, channel);
+  }
+  rttStats() {
+    return this.rttTracker.getStats();
+  }
+  ping(timeoutMs) {
+    if (this._state !== "ready") {
+      return Promise.reject(new NotReadyError());
+    }
+    const runPing = () => {
+      if (this._state !== "ready") {
+        return Promise.reject(new NotReadyError());
+      }
+      const key = "pong:";
+      if (this.waiters.has(key)) {
+        return Promise.reject(
+          new ConcurrentRequestError("Concurrent ping request is not permitted")
+        );
+      }
+      const start = this.clock.now();
+      const timeout = timeoutMs ?? this.config.heartbeat?.timeoutMs ?? 1e4;
+      return new Promise((resolve, reject) => {
+        const timer = this.clock.setTimeout(() => {
+          this.waiters.delete(key);
+          reject(new RequestTimeoutError("Timed out waiting for pong frame"));
+        }, timeout);
+        this.waiters.set(key, {
+          resolve: () => {
+            const sample = Math.max(0, this.clock.now() - start);
+            const stats = this.rttTracker.recordSample(sample);
+            this.emitter.emit("rtt", {
+              sample,
+              source: "on_demand",
+              stats
+            });
+            resolve(sample);
+          },
+          reject,
+          timer,
+          room: "",
+          responseType: "pong"
+        });
+        try {
+          this.send({ type: "ping" });
+        } catch (err) {
+          this.clock.clearTimeout(timer);
+          this.waiters.delete(key);
+          reject(err);
+        }
+      });
+    };
+    const next = this.pingChain.then(runPing, runPing);
+    this.pingChain = next.then(
+      () => 0,
+      () => 0
+    );
+    return next;
+  }
+  clearRoomState(room) {
+    for (const [id, owner] of Array.from(this.binaryOwner.entries())) {
+      if (owner.room === room) {
+        this.binaryOwner.delete(id);
+      }
+    }
+    this.presenceManager.remove(room);
+    this.seqTracker.clearRoom(room);
+    this.rateLimiters.clearRoom(room);
+    this.coalesceManager.clearRoom(room);
+    const prefix = `${room}:`;
+    for (const key of Array.from(this.appliedPolicies)) {
+      if (key.startsWith(prefix)) {
+        this.appliedPolicies.delete(key);
+      }
+    }
+  }
+  isClosed() {
+    return this._state === "closed";
+  }
+  on(event, handler) {
+    return this.emitter.on(event, handler);
+  }
+  connect() {
+    if (this._state === "connecting" || this._state === "awaiting_welcome" || this._state === "ready" || this._state === "reconnecting") {
+      return Promise.reject(
+        new SdkError(`Client is already in state: ${this._state}`)
+      );
+    }
+    if (this._state === "closed") {
+      this.firstConnectDone = false;
+      this.reconnectAttempts = 0;
+      this.intents.clear();
+      this._capabilities = void 0;
+      this.serverVersion = void 0;
+      this._selfLabel = "";
+      this.appliedPolicies.clear();
+      this.rateLimiters.clearAll();
+      this.coalesceManager.clear();
+      this.discardOutboundQueues();
+      this.binaryOwner.clear();
+      this.presenceManager.clear();
+      this.seqTracker.clear();
+      this.rttTracker.reset();
+      this.createdRooms.clear();
+      this._state = "idle";
+    }
+    return new Promise((resolve, reject) => {
+      this.pendingConnectResolve = resolve;
+      this.pendingConnectReject = reject;
+      this.initiateConnect(false);
+    });
+  }
+  async close() {
+    if (this._state === "closed") {
+      return;
+    }
+    this.transitionState("closed");
+    this.clearTimers();
+    this.heartbeatManager.stop();
+    this.backpressureManager.stop();
+    this.writer.stop();
+    this.rateLimiters.clearAll();
+    this.coalesceManager.clear();
+    this.discardOutboundQueues();
+    this.appliedPolicies.clear();
+    this.intents.clear();
+    this.binaryOwner.clear();
+    this.presenceManager.clear();
+    this.seqTracker.clear();
+    this.rttTracker.reset();
+    this.createdRooms.clear();
+    try {
+      this.transport.close(1e3, "client closed");
+    } catch {
+    }
+    this.emitter.emit("disconnected", {
+      code: 1e3,
+      reason: "client closed",
+      wasClean: true
+    });
+    this.failPendingWaiters(new ConnectError("Client closed"));
+    if (this.pendingConnectReject) {
+      const reject = this.pendingConnectReject;
+      this.pendingConnectResolve = null;
+      this.pendingConnectReject = null;
+      reject(new ConnectError("Client closed"));
+    }
+  }
+  createRoom(req) {
+    try {
+      validateRoomName(req.room, this.config.validation);
+      checkCapabilityPreflight(this._capabilities, req, this.createdRooms.size);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    return this.sendWithCorrelation("room_created", req.room, {
+      ...req,
+      type: "create_room"
+    }).then((res) => {
+      this.createdRooms.add(req.room);
+      return res;
+    });
+  }
+  joinRoomWithBinary(roomOrReq, passcodeOrNothing, binaryChannelsOrNothing) {
+    let room;
+    let passcode;
+    let binaryChannels;
+    if (typeof roomOrReq === "string") {
+      room = roomOrReq;
+      passcode = passcodeOrNothing ?? "";
+      binaryChannels = binaryChannelsOrNothing ?? {};
+    } else {
+      room = roomOrReq.room;
+      passcode = roomOrReq.passcode ?? "";
+      binaryChannels = roomOrReq.binaryChannels ?? roomOrReq.binary_channels ?? {};
+    }
+    try {
+      validateRoomName(room, this.config.validation);
+      validateBinaryMap(binaryChannels);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    if (this._state !== "ready" && !this.isRestoringSession) {
+      return Promise.reject(new SdkError(`Client not ready (state: ${this._state})`));
+    }
+    const sorted = Object.entries(binaryChannels).map(([ch, id]) => ({ ch, id })).sort((a, b) => a.id - b.id);
+    let hasCollision = false;
+    let collidingId = 0;
+    const existingList = [];
+    const rejectedList = [];
+    for (const item of sorted) {
+      const owner = this.binaryOwner.get(item.id);
+      if (owner && owner.room !== room) {
+        if (!hasCollision) {
+          hasCollision = true;
+          collidingId = item.id;
+        }
+        existingList.push(`${owner.room}/${owner.channel}`);
+        rejectedList.push(`${room}/${item.ch}`);
+      }
+    }
+    if (hasCollision) {
+      this.emitter.emit("binaryIdCollision", {
+        id: collidingId,
+        existing: existingList,
+        rejected: rejectedList
+      });
+      return Promise.reject(
+        new BinaryIdCollisionError(collidingId, existingList, rejectedList)
+      );
+    }
+    const prevOwners = /* @__PURE__ */ new Map();
+    for (const [id, owner] of Array.from(this.binaryOwner.entries())) {
+      if (owner.room === room) {
+        prevOwners.set(id, owner);
+        this.binaryOwner.delete(id);
+      }
+    }
+    for (const item of sorted) {
+      this.binaryOwner.set(item.id, { room, channel: item.ch });
+    }
+    const req = {
+      type: "join_room",
+      room,
+      passcode: passcode || void 0,
+      binary_channels: Object.keys(binaryChannels).length > 0 ? { ...binaryChannels } : void 0
+    };
+    return this.sendWithCorrelation("room_joined", room, req).then((res) => {
+      let effectivePasscode = passcode;
+      if (!effectivePasscode && this.intents.has(room)) {
+        effectivePasscode = this.intents.get(room).passcode;
+      }
+      this.intents.set(room, {
+        room,
+        passcode: effectivePasscode,
+        binaryChannels: Object.keys(binaryChannels).length > 0 ? { ...binaryChannels } : void 0
+      });
+      this.presenceManager.init(room, res.members);
+      for (const item of sorted) {
+        this.rateLimiters.recordPublish(room, item.ch);
+      }
+      if (Object.keys(binaryChannels).length > 0 || prevOwners.size > 0) {
+        this.emitter.emit("binaryMappingChanged", {
+          room,
+          map: { ...binaryChannels }
+        });
+      }
+      return res;
+    }).catch((err) => {
+      for (const item of sorted) {
+        const owner = this.binaryOwner.get(item.id);
+        if (owner && owner.room === room) {
+          this.binaryOwner.delete(item.id);
+        }
+      }
+      for (const [id, owner] of prevOwners.entries()) {
+        this.binaryOwner.set(id, owner);
+      }
+      throw err;
+    });
+  }
+  joinRoom(req) {
+    return this.joinRoomWithBinary({
+      ...req,
+      binaryChannels: req.binary_channels
+    });
+  }
+  leaveRoom(room) {
+    return this.sendWithCorrelation("room_left", room, {
+      type: "leave_room",
+      room
+    }).then((res) => {
+      this.intents.delete(room);
+      this.clearRoomState(room);
+      return res;
+    });
+  }
+  deleteRoom(room) {
+    try {
+      validateRoomName(room, this.config.validation);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    const key = `delete_room:${room}`;
+    if (this.waiters.has(key)) {
+      return Promise.reject(
+        new ConcurrentRequestError(
+          `Concurrent delete_room request for room "${room}" is not permitted`
+        )
+      );
+    }
+    if (this._state !== "ready") {
+      return Promise.reject(new SdkError(`Client not ready (state: ${this._state})`));
+    }
+    const timeoutMs = this.config.requestTimeoutMs ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = this.clock.setTimeout(() => {
+        this.waiters.delete(key);
+        reject(
+          new RequestTimeoutError(
+            `Timed out waiting for room_deleted presence event on "${room}"`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.set(key, {
+        resolve: () => {
+          this.createdRooms.delete(room);
+          resolve();
+        },
+        reject: (err) => {
+          reject(err);
+        },
+        timer,
+        room,
+        responseType: "delete_room"
+      });
+      try {
+        const frame = { type: "delete_room", room };
+        this.send(frame);
+      } catch (err) {
+        this.clock.clearTimeout(timer);
+        this.waiters.delete(key);
+        reject(err);
+      }
+    });
+  }
+  listRooms() {
+    const execute = () => {
+      const frame = { type: "list_rooms" };
+      return this.sendWithCorrelation("room_list", "", frame);
+    };
+    const next = this.listRoomsLock.then(execute, execute);
+    this.listRoomsLock = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return next;
+  }
+  send(frame) {
+    if (this._state === "closed") {
+      throw new SdkError("Cannot send frame on closed client");
+    }
+    const room = frame.room ?? "";
+    const channel = frame.channel ?? "default";
+    const wire = JSON.stringify(frame);
+    if (this.reliableQueue.size >= this.reliableQueue.capacity) {
+      const action = this.config.outbound?.reliableOverflow ?? "drop";
+      if (action === "close") {
+        this.emitter.emit("reliableOverflow", {
+          room,
+          channel,
+          depth: this.reliableQueue.capacity,
+          action: "closed"
+        });
+        this.transport.close(1008, "reliable queue overflow");
+        return;
+      } else {
+        this.emitter.emit("reliableOverflow", {
+          room,
+          channel,
+          depth: this.reliableQueue.capacity,
+          action: "dropped"
+        });
+        return;
+      }
+    }
+    this.reliableQueue.enqueue({
+      room,
+      channel,
+      reliable: true,
+      wire
+    });
+    this.writer.wake();
+  }
+  publish(req) {
+    const channel = req.channel ?? "default";
+    try {
+      validateRoomName(req.room, this.config.validation);
+      validateChannelName(channel, this.config.validation);
+      const marshaled = JSON.stringify(req.payload);
+      const payloadBytes = new TextEncoder().encode(marshaled).length;
+      validateTextPayloadSize(payloadBytes, this.config.validation);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    if (this._state !== "ready") {
+      return Promise.reject(new NotReadyError());
+    }
+    const policy = this.getPolicy(req.room, channel);
+    const appliedKey = `${req.room}:${channel}`;
+    if (!this.appliedPolicies.has(appliedKey)) {
+      this.appliedPolicies.add(appliedKey);
+      this.emitter.emit("policyApplied", {
+        room: req.room,
+        channel,
+        policy
+      });
+    }
+    const reliable = req.reliable ?? policy.reliable;
+    if (reliable === true && policy.reliable === false) {
+      return Promise.reject(new ChannelNotReliableError(channel));
+    }
+    const paused = this.rateLimiters.isPaused(req.room, channel, this.clock.now());
+    if (paused.paused) {
+      const err = new RateLimitedError(paused.retryAfterMs, channel, "local");
+      this.emitter.emit("rateLimited", {
+        source: "local",
+        room: req.room,
+        channel,
+        retryAfterMs: paused.retryAfterMs
+      });
+      return Promise.reject(err);
+    }
+    if (policy.maxRate > 0 && this.config.outbound?.enableClientRateLimit !== false) {
+      const bucket = this.rateLimiters.get(req.room, channel, policy.maxRate);
+      if (!bucket.tryConsume()) {
+        const retryAfterMs = bucket.retryAfterMs(this.clock.now());
+        const err = new RateLimitedError(retryAfterMs, channel, "local");
+        this.emitter.emit("rateLimited", {
+          source: "local",
+          room: req.room,
+          channel,
+          retryAfterMs
+        });
+        return Promise.reject(err);
+      }
+    }
+    this.rateLimiters.recordPublish(req.room, channel);
+    const frameObj = {
+      type: "publish",
+      room: req.room,
+      channel,
+      payload: req.payload,
+      reliable
+    };
+    if (req.includeSender !== void 0) {
+      frameObj.include_sender = req.includeSender;
+    }
+    const wire = JSON.stringify(frameObj);
+    if (reliable) {
+      if (this.reliableQueue.size >= this.reliableQueue.capacity) {
+        const action = this.config.outbound?.reliableOverflow ?? "drop";
+        if (action === "close") {
+          this.emitter.emit("reliableOverflow", {
+            room: req.room,
+            channel,
+            depth: this.reliableQueue.capacity,
+            action: "closed"
+          });
+          this.transport.close(1008, "reliable queue overflow");
+          return Promise.resolve();
+        } else {
+          this.emitter.emit("reliableOverflow", {
+            room: req.room,
+            channel,
+            depth: this.reliableQueue.capacity,
+            action: "dropped"
+          });
+          return Promise.resolve();
+        }
+      }
+      this.reliableQueue.enqueue({
+        room: req.room,
+        channel,
+        reliable: true,
+        wire
+      });
+    } else {
+      if (policy.coalesce) {
+        this.coalesceManager.update(
+          req.room,
+          channel,
+          "text",
+          req.payload,
+          wire,
+          policy,
+          req.includeSender
+        );
+      } else {
+        if (this.unreliableQueue.size >= this.unreliableQueue.capacity) {
+          this.unreliableQueue.dropOldest();
+          this.emitter.emit("unreliableDropped", {
+            room: req.room,
+            channel,
+            depth: this.unreliableQueue.capacity
+          });
+        }
+        this.unreliableQueue.enqueue({
+          room: req.room,
+          channel,
+          reliable: false,
+          wire
+        });
+      }
+    }
+    this.writer.wake();
+    return Promise.resolve();
+  }
+  publishBinary(roomOrReq, channelOrNothing, payloadOrNothing) {
+    let room;
+    let channel;
+    let payloadRaw;
+    let reqReliable;
+    if (typeof roomOrReq === "string") {
+      room = roomOrReq;
+      channel = channelOrNothing;
+      payloadRaw = payloadOrNothing;
+    } else {
+      room = roomOrReq.room;
+      channel = roomOrReq.channel;
+      payloadRaw = roomOrReq.payload;
+      reqReliable = roomOrReq.reliable;
+    }
+    const pBytes = payloadRaw instanceof Uint8Array ? payloadRaw : new Uint8Array(payloadRaw);
+    const maxBytes = this.config.validation?.maxBinaryPayloadBytes ?? this.config.maxBinaryPayloadBytes ?? 65535;
+    try {
+      validateRoomName(room, this.config.validation);
+      validateChannelName(channel, this.config.validation);
+      validateBinaryPayloadSize(pBytes.byteLength, {
+        enabled: this.config.validation?.enabled,
+        maxBinaryPayloadBytes: maxBytes
+      });
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    if (this._state !== "ready") {
+      return Promise.reject(new NotReadyError());
+    }
+    let mappedId;
+    for (const [id, owner] of this.binaryOwner.entries()) {
+      if (owner.room === room && owner.channel === channel) {
+        mappedId = id;
+        break;
+      }
+    }
+    if (mappedId === void 0) {
+      return Promise.reject(new BinaryChannelUnmappedError(room, channel));
+    }
+    const policy = this.getPolicy(room, channel);
+    const appliedKey = `${room}:${channel}`;
+    if (!this.appliedPolicies.has(appliedKey)) {
+      this.appliedPolicies.add(appliedKey);
+      this.emitter.emit("policyApplied", { room, channel, policy });
+    }
+    const reliable = reqReliable ?? policy.reliable;
+    if (reliable === true && policy.reliable === false) {
+      return Promise.reject(new ChannelNotReliableError(channel));
+    }
+    const paused = this.rateLimiters.isPaused(room, channel, this.clock.now());
+    if (paused.paused) {
+      const err = new RateLimitedError(paused.retryAfterMs, channel, "local");
+      this.emitter.emit("rateLimited", {
+        source: "local",
+        room,
+        channel,
+        retryAfterMs: paused.retryAfterMs
+      });
+      return Promise.reject(err);
+    }
+    if (policy.maxRate > 0 && this.config.outbound?.enableClientRateLimit !== false) {
+      const bucket = this.rateLimiters.get(room, channel, policy.maxRate);
+      if (!bucket.tryConsume()) {
+        const retryAfterMs = bucket.retryAfterMs(this.clock.now());
+        const err = new RateLimitedError(retryAfterMs, channel, "local");
+        this.emitter.emit("rateLimited", {
+          source: "local",
+          room,
+          channel,
+          retryAfterMs
+        });
+        return Promise.reject(err);
+      }
+    }
+    this.rateLimiters.recordPublish(room, channel);
+    const wire = new Uint8Array(1 + pBytes.byteLength);
+    wire[0] = mappedId;
+    wire.set(pBytes, 1);
+    if (reliable) {
+      if (this.reliableQueue.size >= this.reliableQueue.capacity) {
+        const action = this.config.outbound?.reliableOverflow ?? "drop";
+        if (action === "close") {
+          this.emitter.emit("reliableOverflow", {
+            room,
+            channel,
+            depth: this.reliableQueue.capacity,
+            action: "closed"
+          });
+          this.transport.close(1008, "reliable queue overflow");
+          return Promise.resolve();
+        } else {
+          this.emitter.emit("reliableOverflow", {
+            room,
+            channel,
+            depth: this.reliableQueue.capacity,
+            action: "dropped"
+          });
+          return Promise.resolve();
+        }
+      }
+      this.reliableQueue.enqueue({
+        room,
+        channel,
+        reliable: true,
+        wire,
+        frameType: "binary"
+      });
+    } else {
+      if (policy.coalesce) {
+        this.coalesceManager.update(
+          room,
+          channel,
+          "binary",
+          pBytes,
+          wire,
+          policy
+        );
+      } else {
+        if (this.unreliableQueue.size >= this.unreliableQueue.capacity) {
+          this.unreliableQueue.dropOldest();
+          this.emitter.emit("unreliableDropped", {
+            room,
+            channel,
+            depth: this.unreliableQueue.capacity
+          });
+        }
+        this.unreliableQueue.enqueue({
+          room,
+          channel,
+          reliable: false,
+          wire,
+          frameType: "binary"
+        });
+      }
+    }
+    this.writer.wake();
+    return Promise.resolve();
+  }
+  setChannelPolicy(room, channel, policy) {
+    const key = `${room}:${channel}`;
+    this.policyOverrides[key] = policy;
+    if (!policy.coalesce) {
+      this.coalesceManager.flushChannel(room, channel, (wire) => {
+        try {
+          this.transport.send(wire);
+        } catch (err) {
+          this.emitter.emit("error", {
+            error: err instanceof Error ? err : new Error(String(err)),
+            phase: "runtime"
+          });
+        }
+      });
+    }
+  }
+  queueDepth() {
+    return {
+      reliable: this.reliableQueue.size,
+      unreliable: this.unreliableQueue.size,
+      coalesced: this.coalesceManager.countPending()
+    };
+  }
+  bufferedAmount() {
+    return this.transport.bufferedAmount();
+  }
+  // @internal — test seam
+  async __flushNow() {
+    await this.writer.flushNow();
+  }
+  getPolicy(room, channel) {
+    return resolvePolicy(
+      room,
+      channel,
+      this.config.outbound?.policyProvider,
+      this.policyOverrides
+    );
+  }
+  discardOutboundQueues() {
+    const reliable = this.reliableQueue.clear();
+    const unreliable = this.unreliableQueue.clear();
+    const coalesced = this.coalesceManager.clear();
+    return { reliable, unreliable, coalesced };
+  }
+  getRoomIntents() {
+    return Array.from(this.intents.values()).map((intent) => ({
+      room: intent.room,
+      passcode: intent.passcode,
+      binaryChannels: intent.binaryChannels ? { ...intent.binaryChannels } : void 0
+    }));
+  }
+  forgetRoom(room) {
+    validateRoomName(room, this.config.validation);
+    this.intents.delete(room);
+    this.clearRoomState(room);
+  }
+  // --- Private lifecycle and state machine ---
+  transitionState(to) {
+    const from = this._state;
+    if (from === to) return;
+    this._state = to;
+    this.emitter.emit("stateChange", { from, to });
+  }
+  initiateConnect(isReconnect) {
+    if (this._state === "closed") return;
+    this.currentConnWelcomeReceived = false;
+    this.transitionState(isReconnect ? "reconnecting" : "connecting");
+    let url;
+    try {
+      url = buildWsUrl(this.config.url, this.config.apiKey);
+    } catch (err) {
+      const redacted = redactUrl(this.config.url);
+      const connErr = new ConnectError(
+        `Invalid URL: ${redacted}`,
+        err instanceof Error ? err : void 0
+      );
+      this.transitionState("closed");
+      this.rejectPendingConnect(connErr);
+      return;
+    }
+    this.setupTransportHandlers(isReconnect);
+    this.transport.connect(url).catch((err) => {
+      if (this._state === "closed") return;
+      this.handlePreOpenFailure(err, isReconnect);
+    });
+  }
+  setupTransportHandlers(isReconnect) {
+    this.transport.onopen = () => {
+      if (this._state === "closed") return;
+      if (this._state === "connecting" || this._state === "reconnecting") {
+        this.transitionState("awaiting_welcome");
+      }
+      if (!this.welcomeTimer) {
+        const welcomeTimeoutMs = this.config.welcomeTimeoutMs ?? 1e4;
+        this.welcomeTimer = this.clock.setTimeout(() => {
+          this.welcomeTimer = null;
+          this.handleWelcomeTimeout(isReconnect);
+        }, welcomeTimeoutMs);
+      }
+    };
+    this.transport.onmessage = (ev) => {
+      this.handleIncomingData(ev.data, isReconnect);
+    };
+    this.transport.onclose = (ev) => {
+      this.handleSocketClose(ev.code, ev.reason, ev.wasClean, isReconnect);
+    };
+    this.transport.onerror = (ev) => {
+      this.logger.debug("Transport onerror", { error: ev });
+    };
+  }
+  handleIncomingData(rawData, isReconnect) {
+    if (rawData instanceof ArrayBuffer || rawData instanceof Uint8Array) {
+      const bytes = rawData instanceof Uint8Array ? rawData : new Uint8Array(rawData);
+      if (bytes.length === 0) {
+        this.emitter.emit("protocolViolation", {
+          room: "",
+          reason: "empty binary frame"
+        });
+        return;
+      }
+      const id = bytes[0];
+      const owner = this.binaryOwner.get(id);
+      if (!owner) {
+        this.emitter.emit("binaryUnknownChannel", { id });
+        return;
+      }
+      if (owner.channel === "presence") {
+        this.emitter.emit("protocolViolation", {
+          room: owner.room,
+          reason: "binary frame on presence channel"
+        });
+        return;
+      }
+      const payload = bytes.slice(1);
+      this.emitter.emit("binaryMessage", {
+        room: owner.room,
+        channel: owner.channel,
+        payload
+      });
+      return;
+    }
+    let frame;
+    try {
+      const str = typeof rawData === "string" ? rawData : String(rawData);
+      frame = JSON.parse(str);
+    } catch (err) {
+      this.emitter.emit("error", {
+        error: err instanceof Error ? err : new SdkError(String(err)),
+        phase: "runtime"
+      });
+      return;
+    }
+    if (isWelcomeFrame(frame)) {
+      this.handleWelcome(frame, isReconnect);
+      return;
+    }
+    if (isMessageFrame(frame)) {
+      if (this.intents.has(frame.room)) {
+        const policy = this.getPolicy(frame.room, frame.channel);
+        const { gap } = this.seqTracker.process(
+          frame.room,
+          frame.channel,
+          frame.seq,
+          policy.reliable
+        );
+        if (gap) {
+          this.emitter.emit("sequenceGap", {
+            room: frame.room,
+            channel: frame.channel,
+            prev: gap.prev,
+            current: gap.current,
+            missed: gap.missed,
+            reliable: gap.reliable
+          });
+          if (frame.channel === "presence" && gap.reliable && this.presenceManager.autoInvalidateOnReliableGap) {
+            const ps = this.presenceManager.get(frame.room);
+            if (ps) {
+              ps.invalidated = true;
+              ps.invalidReason = "reliable presence gap";
+            }
+            this.emitter.emit("presenceInvalidated", {
+              room: frame.room,
+              reason: "reliable presence gap"
+            });
+          }
+        }
+      }
+      if (frame.channel === "presence" && frame.from === "server") {
+        this.handlePresenceMessage(frame);
+      } else {
+        this.emitter.emit("message", frame);
+      }
+      return;
+    }
+    if (frame.type === "pong") {
+      this.heartbeatManager.handlePong();
+      const key2 = "pong:";
+      const waiter2 = this.waiters.get(key2);
+      if (waiter2) {
+        this.clock.clearTimeout(waiter2.timer);
+        this.waiters.delete(key2);
+        waiter2.resolve(frame);
+      }
+      return;
+    }
+    if (isErrorFrame(frame)) {
+      this.handleErrorFrame(frame);
+      return;
+    }
+    const key = `${frame.type}:${frame.room ?? ""}`;
+    const waiter = this.waiters.get(key);
+    if (waiter) {
+      this.clock.clearTimeout(waiter.timer);
+      this.waiters.delete(key);
+      waiter.resolve(frame);
+    }
+  }
+  handlePresenceMessage(frame) {
+    const payload = frame.payload;
+    if (!payload || typeof payload !== "object" || !payload.event) {
+      this.emitter.emit("protocolViolation", {
+        room: frame.room,
+        reason: "malformed presence payload"
+      });
+      return;
+    }
+    const evt = payload.event;
+    if (evt !== "join" && evt !== "leave" && evt !== "room_deleted") {
+      this.emitter.emit("protocolViolation", {
+        room: frame.room,
+        reason: "unknown presence event"
+      });
+      return;
+    }
+    if (!payload.who || typeof payload.who !== "string" || payload.who === "") {
+      this.emitter.emit("protocolViolation", {
+        room: frame.room,
+        reason: "presence event missing who"
+      });
+      return;
+    }
+    if ((evt === "join" || evt === "leave") && payload.who === this._selfLabel) {
+      this.emitter.emit("protocolViolation", {
+        room: frame.room,
+        reason: "self presence event"
+      });
+      return;
+    }
+    const deleteKey = `delete_room:${frame.room}`;
+    const hasDeleteWaiter = this.waiters.has(deleteKey);
+    if (!this.intents.has(frame.room) && !hasDeleteWaiter) {
+      this.logger.debug("Dropping presence event for unjoined room", {
+        room: frame.room,
+        event: evt
+      });
+      return;
+    }
+    if (evt === "room_deleted") {
+      this.createdRooms.delete(frame.room);
+      this.intents.delete(frame.room);
+      this.clearRoomState(frame.room);
+      this.emitter.emit("roomDeleted", { room: frame.room, who: payload.who });
+      const waiter = this.waiters.get(deleteKey);
+      if (waiter) {
+        this.clock.clearTimeout(waiter.timer);
+        this.waiters.delete(deleteKey);
+        waiter.resolve(void 0);
+      }
+      return;
+    }
+    const ps = this.presenceManager.get(frame.room);
+    if (evt === "join") {
+      if (!ps) {
+        this.presenceManager.init(frame.room, 1);
+        const newPs = this.presenceManager.get(frame.room);
+        newPs.known.add(payload.who);
+        this.emitter.emit("presenceJoin", { room: frame.room, who: payload.who });
+      } else {
+        if (!ps.known.has(payload.who)) {
+          ps.known.add(payload.who);
+          ps.serverCount++;
+          this.emitter.emit("presenceJoin", { room: frame.room, who: payload.who });
+        }
+      }
+    } else if (evt === "leave") {
+      if (ps) {
+        if (ps.known.has(payload.who)) {
+          ps.known.delete(payload.who);
+          if (ps.serverCount > 0) {
+            ps.serverCount--;
+          }
+          this.emitter.emit("presenceLeave", { room: frame.room, who: payload.who });
+        }
+      }
+    }
+  }
+  handleWelcome(frame, isReconnect) {
+    this.currentConnWelcomeReceived = true;
+    if (this.welcomeTimer) {
+      this.clock.clearTimeout(this.welcomeTimer);
+      this.welcomeTimer = null;
+    }
+    const previousCapabilities = this._capabilities;
+    const previousVersion = this.serverVersion;
+    const capabilitiesChanged = this._capabilities !== void 0 && (this.serverVersion !== frame.server_version || JSON.stringify(this._capabilities) !== JSON.stringify(frame.capabilities));
+    this._selfLabel = frame.label;
+    this._capabilities = frame.capabilities;
+    this.serverVersion = frame.server_version;
+    this.reconnectAttempts = 0;
+    this.rttTracker.reset();
+    if (capabilitiesChanged) {
+      this.emitter.emit("capabilitiesChanged", {
+        previous: previousCapabilities,
+        current: frame.capabilities ?? {},
+        previousVersion,
+        currentVersion: frame.server_version
+      });
+    }
+    this.emitter.emit("connected", { welcome: frame });
+    this.writer.resume();
+    const proceedToReady = () => {
+      this.firstConnectDone = true;
+      this.transitionState("ready");
+      this.heartbeatManager.start();
+      this.backpressureManager.start();
+      if (this.pendingConnectResolve) {
+        const resolve = this.pendingConnectResolve;
+        this.pendingConnectResolve = null;
+        this.pendingConnectReject = null;
+        resolve(frame);
+      }
+    };
+    if (isReconnect || this.firstConnectDone) {
+      const discarded = this.discardOutboundQueues();
+      this.appliedPolicies.clear();
+      this.emitter.emit("queuesDiscarded", discarded);
+      for (const room of this.intents.keys()) {
+        if (!this.presenceManager.get(room)) {
+          this.presenceManager.init(room, 0);
+        }
+      }
+      const invalidatedRooms = this.presenceManager.invalidateAll();
+      for (const room of invalidatedRooms) {
+        this.emitter.emit("presenceInvalidated", { room, reason: "reconnected" });
+      }
+      this.seqTracker.rebaselineAll();
+      this.isRestoringSession = true;
+      this.restoreSession().finally(() => {
+        this.isRestoringSession = false;
+        if (this._state === "closed") return;
+        proceedToReady();
+      });
+    } else {
+      proceedToReady();
+    }
+  }
+  handleWelcomeTimeout(isReconnect) {
+    this.logger.warn("Welcome timeout exceeded");
+    const timeoutErr = new RequestTimeoutError(
+      `Timed out waiting for welcome frame (${this.config.welcomeTimeoutMs ?? 1e4}ms)`
+    );
+    if (!isReconnect && !this.firstConnectDone) {
+      this.transitionState("closed");
+      this.rejectPendingConnect(timeoutErr);
+      try {
+        this.transport.close(1e3, "welcome timeout");
+      } catch {
+      }
+    } else {
+      this.emitter.emit("error", { error: timeoutErr, phase: "connect" });
+      try {
+        this.transport.close(1008, "welcome timeout");
+      } catch {
+      }
+      this.triggerReconnect();
+    }
+  }
+  handlePreOpenFailure(err, isReconnect) {
+    if (this._state === "closed" || this._state === "reconnecting") return;
+    const connErr = err instanceof ConnectError ? err : new ConnectError("Failed to establish connection", err);
+    const closeCode = connErr.closeCode ?? 1006;
+    const reason = connErr.reason ?? "";
+    this.classifyAndDispatch(closeCode, reason, connErr, isReconnect);
+  }
+  handleSocketClose(closeCode, reason, _wasClean, isReconnect) {
+    if (this._state === "closed") return;
+    if (this.welcomeTimer) {
+      this.clock.clearTimeout(this.welcomeTimer);
+      this.welcomeTimer = null;
+    }
+    this.heartbeatManager.stop();
+    this.backpressureManager.stop();
+    this.writer.stop();
+    this.failPendingWaiters(
+      new ConnectError(
+        `Socket closed (code: ${closeCode}, reason: ${reason || "none"})`,
+        { closeCode, reason }
+      )
+    );
+    const connErr = new ConnectError(
+      `WebSocket closed before welcome (code: ${closeCode}, reason: ${reason || "none"})`,
+      { closeCode, reason }
+    );
+    if (!this.currentConnWelcomeReceived && !this.firstConnectDone) {
+      this.classifyAndDispatch(closeCode, reason, connErr, isReconnect);
+      return;
+    }
+    if (closeCode === 1008 && reason !== "heartbeat timeout" && reason !== "welcome timeout") {
+      this.transitionState("closed");
+      this.emitter.emit("fatal", {
+        code: "POLICY_VIOLATION",
+        message: reason || "Policy violation"
+      });
+      if (this.pendingConnectReject) {
+        this.rejectPendingConnect(
+          new PolicyViolationError(reason || "Policy violation", closeCode, reason)
+        );
+      }
+      return;
+    }
+    if (this.config.reconnect?.shouldReconnect) {
+      const allow = this.config.reconnect.shouldReconnect({
+        closeCode,
+        firstConnect: false
+      });
+      if (!allow) {
+        this.transitionState("closed");
+        this.emitter.emit("fatal", {
+          code: "CLOSED",
+          message: reason || "Reconnect denied by shouldReconnect"
+        });
+        if (this.pendingConnectReject) {
+          this.rejectPendingConnect(
+            new ConnectError(reason || "Reconnect denied by shouldReconnect", {
+              closeCode,
+              reason
+            })
+          );
+        }
+        return;
+      }
+    }
+    this.emitter.emit("disconnected", {
+      code: closeCode,
+      reason,
+      wasClean: closeCode === 1e3
+    });
+    this.triggerReconnect();
+  }
+  classifyAndDispatch(closeCode, reason, err, isReconnect) {
+    let isFatal = false;
+    let fatalCode = "AUTH_FAILED";
+    if (closeCode === 1008) {
+      isFatal = true;
+      fatalCode = "POLICY_VIOLATION";
+    } else if (this.config.onAmbiguousAuth) {
+      const decision = this.config.onAmbiguousAuth(closeCode, reason);
+      isFatal = decision === "fatal";
+    } else {
+      const mode = this.config.authFailureMode ?? "heuristic";
+      if (mode === "always-fatal") {
+        isFatal = true;
+      } else if (mode === "never-fatal") {
+        isFatal = false;
+      } else {
+        isFatal = closeCode === 1006;
+      }
+    }
+    if (this.config.reconnect?.shouldReconnect) {
+      const allow = this.config.reconnect.shouldReconnect({
+        closeCode,
+        firstConnect: !this.firstConnectDone
+      });
+      if (!allow) {
+        isFatal = true;
+        fatalCode = "CLOSED";
+      }
+    }
+    if (isFatal) {
+      if (fatalCode === "AUTH_FAILED") {
+        this.emitter.emit("errorClassified", {
+          code: "UNAUTHORIZED",
+          message: "browser auth heuristic classified pre-welcome 1006 as auth failure",
+          action: "fatal",
+          rawFrame: void 0
+        });
+      }
+      this.transitionState("closed");
+      this.emitter.emit("fatal", {
+        code: fatalCode,
+        message: fatalCode === "AUTH_FAILED" ? "Authentication failed (pre-upgrade rejection)" : reason || "Connection halted"
+      });
+      const outErr = fatalCode === "AUTH_FAILED" ? new AuthError("Authentication failed (pre-upgrade rejection)") : fatalCode === "POLICY_VIOLATION" ? new PolicyViolationError(reason || "Policy violation", closeCode, reason) : new ConnectError(reason || "Connection rejected", { closeCode, reason });
+      this.rejectPendingConnect(outErr);
+      return;
+    }
+    this.emitter.emit("error", { error: err, phase: isReconnect ? "runtime" : "connect" });
+    this.triggerReconnect();
+  }
+  triggerReconnect() {
+    if (this._state === "closed") return;
+    this.transitionState("reconnecting");
+    const maxAttempts = this.config.reconnect?.maxAttempts ?? Infinity;
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.transitionState("closed");
+      const msg = `Exceeded maximum reconnect attempts (${maxAttempts})`;
+      this.emitter.emit("fatal", { code: "CLOSED", message: msg });
+      this.rejectPendingConnect(new ConnectError(msg));
+      return;
+    }
+    const attemptNumber = this.reconnectAttempts + 1;
+    const delayMs = computeReconnectDelay(
+      this.reconnectAttempts,
+      this.config.reconnect
+    );
+    this.emitter.emit("reconnecting", { attempt: attemptNumber, delayMs });
+    this.reconnectTimer = this.clock.setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this._state === "closed") return;
+      this.emitter.emit("reconnecting", { attempt: attemptNumber, delayMs: 0 });
+      this.reconnectAttempts++;
+      this.initiateConnect(true);
+    }, delayMs);
+  }
+  async restoreSession() {
+    const intentsList = Array.from(this.intents.values()).sort(
+      (a, b) => a.room.localeCompare(b.room)
+    );
+    const restored = [];
+    const failed = [];
+    const roomFullPolicy = this.config.restore?.roomFullPolicy ?? "drop";
+    const perRoomTimeout = this.config.restore?.restorePerRoomTimeoutMs ?? 5e3;
+    for (const intent of intentsList) {
+      if (this.isClosed()) break;
+      const maxAttempts = roomFullPolicy === "retry" ? 3 : 1;
+      let outcome = "drop";
+      let outcomeCode = "INTERNAL_ERROR";
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (this.isClosed()) break;
+        if (attempt > 0) {
+          const backoff = 50 * Math.pow(2, attempt);
+          await new Promise((res) => {
+            const t = this.clock.setTimeout(res, backoff);
+            if (this.isClosed()) {
+              this.clock.clearTimeout(t);
+              res();
+            }
+          });
+        }
+        const joinReq = {
+          type: "join_room",
+          room: intent.room,
+          passcode: intent.passcode,
+          binary_channels: intent.binaryChannels
+        };
+        try {
+          const res = await this.sendWithCorrelation(
+            "room_joined",
+            intent.room,
+            joinReq,
+            perRoomTimeout
+          );
+          outcome = "joined";
+          this.presenceManager.init(intent.room, res.members);
+          if (intent.binaryChannels) {
+            for (const [ch, id] of Object.entries(intent.binaryChannels)) {
+              this.binaryOwner.set(id, { room: intent.room, channel: ch });
+            }
+          }
+          break;
+        } catch (err) {
+          if (err instanceof ServerError) {
+            outcomeCode = err.code;
+            if (err.code === "ROOM_NOT_FOUND" || err.code === "FORBIDDEN_SCOPE") {
+              outcome = "drop";
+              break;
+            }
+            if (err.code === "INVALID_PASSCODE" || err.code === "PASSCODE_RATE_LIMITED") {
+              outcome = "keep";
+              break;
+            }
+            if (err.code === "ROOM_FULL") {
+              if (roomFullPolicy === "retry" && attempt < maxAttempts - 1) {
+                continue;
+              }
+              outcome = roomFullPolicy === "drop" ? "drop" : "keep";
+              break;
+            }
+            outcome = "keep";
+            break;
+          } else {
+            outcome = "keep";
+            outcomeCode = "INTERNAL_ERROR";
+            break;
+          }
+        }
+      }
+      if (outcome === "joined") {
+        restored.push(intent.room);
+      } else {
+        if (outcome === "drop") {
+          this.intents.delete(intent.room);
+          this.clearRoomState(intent.room);
+        }
+        failed.push({ room: intent.room, code: outcomeCode });
+        this.emitter.emit("intentFailed", { room: intent.room, code: outcomeCode });
+      }
+    }
+    this.emitter.emit("sessionRestored", { restored, failed });
+  }
+  sendWithCorrelation(responseType, room, frame, customTimeoutMs) {
+    const key = `${responseType}:${room}`;
+    if (this.waiters.has(key)) {
+      return Promise.reject(
+        new ConcurrentRequestError(
+          `Concurrent request for ${responseType} on room "${room}" is not permitted`
+        )
+      );
+    }
+    if (this._state !== "ready" && !this.isRestoringSession) {
+      return Promise.reject(new SdkError(`Client not ready (state: ${this._state})`));
+    }
+    const timeoutMs = customTimeoutMs ?? this.config.requestTimeoutMs ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = this.clock.setTimeout(() => {
+        this.waiters.delete(key);
+        reject(
+          new RequestTimeoutError(
+            `Timed out waiting for ${responseType} on "${room}"`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.set(key, {
+        resolve: (val) => resolve(val),
+        reject,
+        timer,
+        room,
+        responseType
+      });
+      try {
+        this.send(frame);
+      } catch (err) {
+        this.clock.clearTimeout(timer);
+        this.waiters.delete(key);
+        reject(err);
+      }
+    });
+  }
+  handleErrorFrame(frame) {
+    const classification = classifyError(
+      frame.code,
+      frame,
+      this.config.errorPolicy?.overrides
+    );
+    this.emitter.emit("errorClassified", {
+      code: frame.code,
+      message: frame.message,
+      room: frame.room,
+      channel: frame.channel,
+      action: classification.action,
+      retryAfterMs: classification.retryAfterMs,
+      rawFrame: frame
+    });
+    if (frame.code === "RATE_LIMITED" && frame.channel) {
+      const channel = frame.channel;
+      const retryAfterMs = frame.retry_after_ms ?? 250;
+      let room = frame.room;
+      if (!room) {
+        room = this.rateLimiters.getRecentRoom(channel) ?? "";
+      }
+      const untilMs = this.clock.now() + retryAfterMs;
+      this.rateLimiters.pause(room, channel, untilMs);
+      this.emitter.emit("rateLimited", {
+        source: "server",
+        room,
+        channel,
+        retryAfterMs
+      });
+    }
+    const serverErr = new ServerError(
+      frame.code,
+      frame.message,
+      frame.channel,
+      frame.retry_after_ms
+    );
+    this.emitter.emit("error", { error: serverErr, phase: "runtime" });
+    let matchedKey = null;
+    if (frame.room) {
+      for (const [key, waiter] of this.waiters.entries()) {
+        if (waiter.room === frame.room) {
+          matchedKey = key;
+          break;
+        }
+      }
+    }
+    if (!matchedKey) {
+      const extractedRoom = extractRoomFromMessage(frame.message);
+      if (extractedRoom) {
+        for (const [key, waiter] of this.waiters.entries()) {
+          if (waiter.room === extractedRoom) {
+            matchedKey = key;
+            break;
+          }
+        }
+      }
+    }
+    if (!matchedKey && this.waiters.size === 1) {
+      matchedKey = Array.from(this.waiters.keys())[0];
+    }
+    if (matchedKey) {
+      const waiter = this.waiters.get(matchedKey);
+      this.clock.clearTimeout(waiter.timer);
+      this.waiters.delete(matchedKey);
+      waiter.reject(serverErr);
+    }
+  }
+  failPendingWaiters(err) {
+    for (const [key, waiter] of this.waiters.entries()) {
+      this.clock.clearTimeout(waiter.timer);
+      this.waiters.delete(key);
+      waiter.reject(err);
+    }
+  }
+  clearTimers() {
+    if (this.reconnectTimer) {
+      this.clock.clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.welcomeTimer) {
+      this.clock.clearTimeout(this.welcomeTimer);
+      this.welcomeTimer = null;
+    }
+  }
+  rejectPendingConnect(err) {
+    if (this.pendingConnectReject) {
+      const reject = this.pendingConnectReject;
+      this.pendingConnectResolve = null;
+      this.pendingConnectReject = null;
+      reject(err);
+    }
+  }
+};
+
+export { AuthError, BackpressureManager, BinaryChannelUnmappedError, BinaryIdCollisionError, BinaryMapBuilder, BinaryMapExhaustedError, BinaryMapValidationError, BinaryPayloadTooLargeError, BrowserWebSocketTransport, CHANNEL_NAME_RE, CapabilityLimitError, ChannelNotReliableError, Client, ConcurrentRequestError, ConnectError, NotReadyError, OutboundQueue, PolicyViolationError, PresenceManager, ROOM_NAME_RE, RateLimitedError, RateLimiterRegistry, RealClock, RequestTimeoutError, RttTracker, SdkError, SeqTracker, ServerError, TokenBucket, ValidationError, buildWsUrl, checkCapabilityPreflight, classifyError, computeReconnectDelay, isErrorFrame, isMessageFrame, isWelcomeFrame, presetsFor, redactString, redactUrl, redactValue, resolvePolicy, validateBinaryMap, validateBinaryPayloadSize, validateChannelName, validateRoomName, validateTextPayloadSize };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map