@strevokit/meeting-sdk 0.0.0-stage → 0.8.0

package/dist/index.js

@@ -0,0 +1,3935 @@
+// src/internal/env.ts
+function subscribeNetworkChange(callback) {
+  const scope = globalThis;
+  const targets = [];
+  if (typeof scope.addEventListener === "function") {
+    targets.push({ target: globalThis, type: "online" });
+  }
+  const connection = scope.navigator?.connection;
+  if (connection && typeof connection.addEventListener === "function" && typeof connection.removeEventListener === "function") {
+    targets.push({ target: connection, type: "change" });
+  }
+  for (const { target, type } of targets) target.addEventListener(type, callback);
+  return () => {
+    for (const { target, type } of targets) target.removeEventListener(type, callback);
+  };
+}
+var override;
+function defaultEnvironment() {
+  const scope = globalThis;
+  return {
+    WebSocket: typeof scope.WebSocket === "function" ? scope.WebSocket : void 0,
+    mediaDevices: scope.navigator?.mediaDevices,
+    RTCPeerConnection: typeof scope.RTCPeerConnection === "function" ? scope.RTCPeerConnection : void 0,
+    MediaStream: typeof scope.MediaStream === "function" ? scope.MediaStream : void 0,
+    setTimeout: (callback, ms) => globalThis.setTimeout(callback, ms),
+    clearTimeout: (handle) => globalThis.clearTimeout(handle),
+    now: () => Date.now(),
+    onNetworkChange: subscribeNetworkChange
+  };
+}
+function currentEnvironment() {
+  return override ?? defaultEnvironment();
+}
+
+// ../signaling-protocol/dist/version.js
+var PROTOCOL_VERSION = 1;
+var SUPPORTED_PROTOCOL_VERSIONS = Object.freeze([1]);
+function isSupportedVersion(value) {
+  return typeof value === "number" && Number.isInteger(value) && SUPPORTED_PROTOCOL_VERSIONS.includes(value);
+}
+
+// ../signaling-protocol/dist/limits.js
+var MAX_MESSAGE_BYTES = 65536;
+var MAX_SDP_BYTES = 49152;
+var MAX_ICE_CANDIDATE_LENGTH = 1024;
+var MAX_DISPLAY_NAME_CODE_POINTS = 255;
+var MAX_REASON_LENGTH = 64;
+var MAX_SDP_MID_LENGTH = 64;
+var MAX_USERNAME_FRAGMENT_LENGTH = 256;
+var MAX_SDP_MLINE_INDEX = 1023;
+var MAX_ICE_SERVERS = 4;
+var MAX_ICE_SERVER_URLS = 4;
+var MAX_ICE_SERVER_URL_LENGTH = 256;
+var MAX_ICE_SERVER_USERNAME_LENGTH = 256;
+var MAX_ICE_SERVER_CREDENTIAL_LENGTH = 256;
+var MAX_QUALITY_CODEC_LENGTH = 64;
+var MAX_QUALITY_CANDIDATE_TYPE_LENGTH = 32;
+var MAX_QUALITY_FRAME_DIMENSION = 16384;
+
+// ../signaling-protocol/dist/rejection.js
+var REJECTION_CODES = Object.freeze([
+  "invalid_envelope",
+  "unsupported_version",
+  "unknown_type",
+  "direction_not_allowed",
+  "invalid_payload"
+]);
+var REJECTION_DETAILS = Object.freeze([
+  "message_too_large",
+  "not_text",
+  "invalid_json",
+  "not_an_object",
+  "invalid_ulid",
+  "payload_not_object",
+  "missing_field",
+  "wrong_type",
+  "too_long",
+  "out_of_range",
+  "invalid_format"
+]);
+var CODE_MESSAGES = {
+  invalid_envelope: "Message envelope is invalid.",
+  unsupported_version: "Protocol version is missing or not supported.",
+  unknown_type: "Message type is not part of the protocol.",
+  direction_not_allowed: "Message type is not allowed in this direction.",
+  invalid_payload: "Message payload is invalid."
+};
+var DETAIL_MESSAGES = {
+  message_too_large: "Message exceeds the maximum size.",
+  not_text: "Message frame must be UTF-8 text.",
+  invalid_json: "Message frame is not valid JSON.",
+  not_an_object: "Message must be a JSON object.",
+  invalid_ulid: "Identifier must be a canonical ULID.",
+  payload_not_object: "Payload must be a JSON object.",
+  missing_field: "A required field is missing.",
+  wrong_type: "A field has the wrong type.",
+  too_long: "A field is too long.",
+  out_of_range: "A field is out of range.",
+  invalid_format: "A field has an invalid format."
+};
+function reject(code, detail, field) {
+  const rejection = {
+    code,
+    message: detail ? DETAIL_MESSAGES[detail] : CODE_MESSAGES[code]
+  };
+  if (field !== void 0)
+    rejection.field = field;
+  if (detail !== void 0)
+    rejection.detail = detail;
+  return rejection;
+}
+var SignalingProtocolError = class extends Error {
+  rejection;
+  constructor(rejection) {
+    super(`${rejection.code}: ${rejection.message}`);
+    this.name = "SignalingProtocolError";
+    this.rejection = rejection;
+  }
+};
+
+// ../signaling-protocol/dist/primitives.js
+var ULID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+var REASON_CODE_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
+var TIMESTAMP_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+function isCanonicalUlid(value) {
+  return typeof value === "string" && ULID_PATTERN.test(value);
+}
+function utf8ByteLength(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit < 128) {
+      bytes += 1;
+    } else if (unit < 2048) {
+      bytes += 2;
+    } else if (unit >= 55296 && unit <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function codePointLength(value) {
+  let count = 0;
+  for (let i = 0; i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit >= 55296 && unit <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343)
+        i++;
+    }
+    count++;
+  }
+  return count;
+}
+function isReasonCode(value) {
+  return typeof value === "string" && REASON_CODE_PATTERN.test(value);
+}
+function isRfc3339UtcTimestamp(value) {
+  if (typeof value !== "string")
+    return false;
+  const match = TIMESTAMP_PATTERN.exec(value);
+  if (!match)
+    return false;
+  const [year, month, day, hour, minute, second] = match.slice(1, 7).map((part) => Number(part));
+  if (month < 1 || month > 12 || day < 1)
+    return false;
+  if (hour > 23 || minute > 59 || second > 59)
+    return false;
+  const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+  return day <= daysInMonth;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function readOwn(obj, key) {
+  return Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+function hasOwn(obj, key) {
+  return Object.hasOwn(obj, key);
+}
+
+// ../signaling-protocol/dist/catalog.js
+var CATALOG = {
+  "participant.join": { family: "participant", direction: "client_to_server" },
+  "participant.joined": { family: "participant", direction: "server_to_client" },
+  "participant.leave": { family: "participant", direction: "client_to_server" },
+  "participant.left": { family: "participant", direction: "server_to_client" },
+  "participant.reconnected": { family: "participant", direction: "server_to_client" },
+  "webrtc.offer": { family: "webrtc", direction: "both" },
+  "webrtc.answer": { family: "webrtc", direction: "both" },
+  "webrtc.ice_candidate": { family: "webrtc", direction: "both" },
+  "webrtc.connected": { family: "webrtc", direction: "client_to_server" },
+  "webrtc.disconnected": { family: "webrtc", direction: "client_to_server" },
+  "webrtc.failed": { family: "webrtc", direction: "client_to_server" },
+  "webrtc.quality_sample": { family: "webrtc", direction: "client_to_server" },
+  "webrtc.ice_restart": { family: "webrtc", direction: "both" },
+  "webrtc.ice_restart_result": { family: "webrtc", direction: "client_to_server" },
+  "media.camera.started": { family: "media", direction: "both" },
+  "media.camera.stopped": { family: "media", direction: "both" },
+  "media.microphone.started": { family: "media", direction: "both" },
+  "media.microphone.stopped": { family: "media", direction: "both" },
+  "media.screen.started": { family: "media", direction: "both" },
+  "media.screen.stopped": { family: "media", direction: "both" },
+  "meeting.started": { family: "meeting", direction: "server_to_client" },
+  "meeting.ended": { family: "meeting", direction: "server_to_client" },
+  "meeting.terminated": { family: "meeting", direction: "server_to_client" },
+  "meeting.end": { family: "meeting", direction: "client_to_server" },
+  "session.authenticated": { family: "session", direction: "server_to_client" },
+  "session.welcome": { family: "session", direction: "server_to_client" },
+  "session.rejected": { family: "session", direction: "server_to_client" },
+  "session.ice_servers": { family: "session", direction: "server_to_client" }
+};
+for (const entry of Object.values(CATALOG))
+  Object.freeze(entry);
+var MESSAGE_CATALOG = Object.freeze(CATALOG);
+var MESSAGE_TYPES = Object.freeze(Object.keys(CATALOG));
+function isMessageType(value) {
+  return typeof value === "string" && Object.hasOwn(CATALOG, value);
+}
+function isDirectionAllowed(type, direction) {
+  const allowed = MESSAGE_CATALOG[type].direction;
+  return allowed === "both" || allowed === direction;
+}
+
+// ../signaling-protocol/dist/rolePolicy.js
+var ALL_ROLES = Object.freeze(["host", "participant"]);
+var ROLE_POLICY = Object.freeze({
+  "media.screen.started": Object.freeze(["host"]),
+  "media.screen.stopped": Object.freeze(["host"]),
+  "meeting.end": Object.freeze(["host"])
+});
+function allowedRoles(type) {
+  return ROLE_POLICY[type] ?? ALL_ROLES;
+}
+function isRoleAllowed(type, role2) {
+  return allowedRoles(type).includes(role2);
+}
+
+// ../signaling-protocol/dist/payloads.js
+var PayloadFailure = class {
+  rejection;
+  constructor(rejection) {
+    this.rejection = rejection;
+  }
+};
+function fail(detail, path) {
+  throw new PayloadFailure(reject("invalid_payload", detail, path));
+}
+function required(obj, key, path) {
+  if (!hasOwn(obj, key))
+    fail("missing_field", path);
+  return obj[key];
+}
+function requiredString(obj, key, path) {
+  const value = required(obj, key, path);
+  if (typeof value !== "string")
+    fail("wrong_type", path);
+  return value;
+}
+function participantRef(obj, key, path, ctx, allowSelf) {
+  const value = requiredString(obj, key, path);
+  if (!isCanonicalUlid(value))
+    fail("invalid_ulid", path);
+  if (!allowSelf && value === ctx.participantId)
+    fail("invalid_format", path);
+  return value;
+}
+function reasonCode(obj, key, path) {
+  const value = requiredString(obj, key, path);
+  if (value.length > MAX_REASON_LENGTH)
+    fail("too_long", path);
+  if (!isReasonCode(value))
+    fail("invalid_format", path);
+  return value;
+}
+function timestamp(obj, key, path) {
+  const value = requiredString(obj, key, path);
+  if (!isRfc3339UtcTimestamp(value))
+    fail("invalid_format", path);
+  return value;
+}
+function sdp(obj) {
+  const path = "payload.sdp";
+  const value = requiredString(obj, "sdp", path);
+  if (value.length === 0)
+    fail("invalid_format", path);
+  if (value.length > MAX_SDP_BYTES)
+    fail("too_long", path);
+  if (value.length * 3 > MAX_SDP_BYTES && utf8ByteLength(value) > MAX_SDP_BYTES) {
+    fail("too_long", path);
+  }
+  return value;
+}
+function nullableString(obj, key, path, maxLength) {
+  const value = obj[key];
+  if (value === null)
+    return null;
+  if (typeof value !== "string")
+    fail("wrong_type", path);
+  if (value.length > maxLength)
+    fail("too_long", path);
+  return value;
+}
+function iceCandidate(obj) {
+  const base = "payload.candidate";
+  const raw = required(obj, "candidate", base);
+  if (!isPlainObject(raw))
+    fail("wrong_type", base);
+  const candidate = requiredString(raw, "candidate", `${base}.candidate`);
+  if (candidate.length > MAX_ICE_CANDIDATE_LENGTH)
+    fail("too_long", `${base}.candidate`);
+  required(raw, "sdpMid", `${base}.sdpMid`);
+  const sdpMid = nullableString(raw, "sdpMid", `${base}.sdpMid`, MAX_SDP_MID_LENGTH);
+  const indexPath = `${base}.sdpMLineIndex`;
+  const index = required(raw, "sdpMLineIndex", indexPath);
+  let sdpMLineIndex = null;
+  if (index !== null) {
+    if (typeof index !== "number")
+      fail("wrong_type", indexPath);
+    if (!Number.isInteger(index) || index < 0 || index > MAX_SDP_MLINE_INDEX) {
+      fail("out_of_range", indexPath);
+    }
+    sdpMLineIndex = index;
+  }
+  if (candidate.length > 0 && sdpMid === null && sdpMLineIndex === null) {
+    fail("invalid_format", base);
+  }
+  const value = { candidate, sdpMid, sdpMLineIndex };
+  if (hasOwn(raw, "usernameFragment")) {
+    value.usernameFragment = nullableString(raw, "usernameFragment", `${base}.usernameFragment`, MAX_USERNAME_FRAGMENT_LENGTH);
+  }
+  return value;
+}
+var empty = () => ({});
+var sessionDescription = (p, ctx) => ({
+  targetParticipantId: participantRef(p, "targetParticipantId", "payload.targetParticipantId", ctx, false),
+  sdp: sdp(p)
+});
+var peer = (p, ctx) => ({
+  peerParticipantId: participantRef(p, "peerParticipantId", "payload.peerParticipantId", ctx, false)
+});
+function role(obj) {
+  const value = requiredString(obj, "role", "payload.role");
+  if (value !== "host" && value !== "participant")
+    fail("invalid_format", "payload.role");
+  return value;
+}
+function optionalDisplayName(p, value) {
+  if (hasOwn(p, "displayName")) {
+    const path = "payload.displayName";
+    const displayName = p.displayName;
+    if (typeof displayName !== "string")
+      fail("wrong_type", path);
+    if (displayName.length === 0)
+      fail("invalid_format", path);
+    if (codePointLength(displayName) > MAX_DISPLAY_NAME_CODE_POINTS)
+      fail("too_long", path);
+    value.displayName = displayName;
+  }
+  return value;
+}
+var ICE_SERVER_URL_SCHEMES = ["stun:", "stuns:", "turn:", "turns:"];
+function optionalBoundedString(obj, key, path, maxLength, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "string")
+    fail("wrong_type", path);
+  if (raw.length > maxLength)
+    fail("too_long", path);
+  value[key] = raw;
+}
+function iceServer(raw, path) {
+  if (!isPlainObject(raw))
+    fail("wrong_type", path);
+  const urlsPath = `${path}.urls`;
+  const urls = required(raw, "urls", urlsPath);
+  if (!Array.isArray(urls))
+    fail("wrong_type", urlsPath);
+  if (urls.length === 0 || urls.length > MAX_ICE_SERVER_URLS)
+    fail("out_of_range", urlsPath);
+  const checked = urls.map((url, index) => {
+    const urlPath = `${urlsPath}.${index}`;
+    if (typeof url !== "string")
+      fail("wrong_type", urlPath);
+    if (url.length > MAX_ICE_SERVER_URL_LENGTH)
+      fail("too_long", urlPath);
+    if (!ICE_SERVER_URL_SCHEMES.some((scheme) => url.startsWith(scheme) && url.length > scheme.length)) {
+      fail("invalid_format", urlPath);
+    }
+    return url;
+  });
+  const value = { urls: checked };
+  optionalBoundedString(raw, "username", `${path}.username`, MAX_ICE_SERVER_USERNAME_LENGTH, value);
+  optionalBoundedString(raw, "credential", `${path}.credential`, MAX_ICE_SERVER_CREDENTIAL_LENGTH, value);
+  return value;
+}
+function iceServers(obj) {
+  const path = "payload.iceServers";
+  const servers = required(obj, "iceServers", path);
+  if (!Array.isArray(servers))
+    fail("wrong_type", path);
+  if (servers.length > MAX_ICE_SERVERS)
+    fail("too_long", path);
+  return servers.map((server, index) => iceServer(server, `${path}.${index}`));
+}
+function sessionWelcome(p) {
+  const value = optionalDisplayName(p, {
+    role: role(p),
+    joinedAt: timestamp(p, "joinedAt", "payload.joinedAt")
+  });
+  if (hasOwn(p, "mediaMode")) {
+    const path = "payload.mediaMode";
+    const mediaMode = p.mediaMode;
+    if (typeof mediaMode !== "string")
+      fail("wrong_type", path);
+    if (mediaMode !== "p2p" && mediaMode !== "sfu")
+      fail("invalid_format", path);
+    value.mediaMode = mediaMode;
+  }
+  if (hasOwn(p, "iceServers"))
+    value.iceServers = iceServers(p);
+  if (hasOwn(p, "iceServersExpireAt")) {
+    value.iceServersExpireAt = timestamp(p, "iceServersExpireAt", "payload.iceServersExpireAt");
+  }
+  return value;
+}
+function optionalNonNegativeNumber(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (raw < 0)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalUnitInterval(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (raw < 0 || raw > 1)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalNonNegativeInt(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (!Number.isInteger(raw) || raw < 0)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalPositiveInt(obj, key, path, max, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (!Number.isInteger(raw) || raw < 1 || raw > max)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function looksLikeSdpOrCandidateDump(value) {
+  if (value.includes("\r\n") || value.includes("\n"))
+    return true;
+  if (/^v=0/i.test(value))
+    return true;
+  if (/^candidate:/i.test(value))
+    return true;
+  if (/\bIN IP[46]\b/i.test(value))
+    return true;
+  return false;
+}
+function optionalShortToken(obj, key, path, maxLength, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "string")
+    fail("wrong_type", path);
+  if (raw.length === 0 || raw.length > maxLength)
+    fail(raw.length === 0 ? "invalid_format" : "too_long", path);
+  if (looksLikeSdpOrCandidateDump(raw))
+    fail("invalid_format", path);
+  if (!/^[a-zA-Z0-9._+/-]+$/.test(raw))
+    fail("invalid_format", path);
+  value[key] = raw;
+}
+var qualitySample = (p, ctx) => {
+  const value = {
+    ...peer(p, ctx),
+    connectionState: reasonCode(p, "connectionState", "payload.connectionState"),
+    sampledAt: timestamp(p, "sampledAt", "payload.sampledAt")
+  };
+  optionalNonNegativeNumber(p, "rttMs", "payload.rttMs", value);
+  optionalNonNegativeNumber(p, "jitterMs", "payload.jitterMs", value);
+  optionalUnitInterval(p, "packetLossRatio", "payload.packetLossRatio", value);
+  optionalNonNegativeNumber(p, "sendBitrateBps", "payload.sendBitrateBps", value);
+  optionalNonNegativeNumber(p, "receiveBitrateBps", "payload.receiveBitrateBps", value);
+  optionalShortToken(p, "iceLocalCandidateType", "payload.iceLocalCandidateType", MAX_QUALITY_CANDIDATE_TYPE_LENGTH, value);
+  optionalShortToken(p, "iceRemoteCandidateType", "payload.iceRemoteCandidateType", MAX_QUALITY_CANDIDATE_TYPE_LENGTH, value);
+  for (const key of ["path", "localPath", "remotePath"]) {
+    if (hasOwn(p, key))
+      value[key] = reasonCode(p, key, `payload.${key}`);
+  }
+  optionalNonNegativeInt(p, "framesDropped", "payload.framesDropped", value);
+  optionalPositiveInt(p, "frameWidth", "payload.frameWidth", MAX_QUALITY_FRAME_DIMENSION, value);
+  optionalPositiveInt(p, "frameHeight", "payload.frameHeight", MAX_QUALITY_FRAME_DIMENSION, value);
+  optionalShortToken(p, "codec", "payload.codec", MAX_QUALITY_CODEC_LENGTH, value);
+  if (hasOwn(p, "incomplete")) {
+    if (typeof p.incomplete !== "boolean")
+      fail("wrong_type", "payload.incomplete");
+    value.incomplete = p.incomplete;
+  }
+  return value;
+};
+var VALIDATORS = {
+  "participant.join": empty,
+  "participant.joined": (p) => optionalDisplayName(p, { role: role(p) }),
+  "participant.leave": empty,
+  "participant.left": (p) => ({ reason: reasonCode(p, "reason", "payload.reason") }),
+  "participant.reconnected": empty,
+  "webrtc.offer": sessionDescription,
+  "webrtc.answer": sessionDescription,
+  "webrtc.ice_candidate": (p, ctx) => ({
+    targetParticipantId: participantRef(p, "targetParticipantId", "payload.targetParticipantId", ctx, false),
+    candidate: iceCandidate(p)
+  }),
+  "webrtc.connected": (p, ctx) => {
+    const value = peer(p, ctx);
+    for (const key of ["path", "localPath", "remotePath"]) {
+      if (hasOwn(p, key))
+        value[key] = reasonCode(p, key, `payload.${key}`);
+    }
+    return value;
+  },
+  "webrtc.disconnected": peer,
+  "webrtc.failed": (p, ctx) => ({
+    ...peer(p, ctx),
+    reason: reasonCode(p, "reason", "payload.reason")
+  }),
+  "webrtc.quality_sample": qualitySample,
+  "webrtc.ice_restart": (p, ctx) => ({
+    targetParticipantId: participantRef(p, "targetParticipantId", "payload.targetParticipantId", ctx, false)
+  }),
+  "webrtc.ice_restart_result": (p, ctx) => ({
+    ...peer(p, ctx),
+    outcome: reasonCode(p, "outcome", "payload.outcome")
+  }),
+  "media.camera.started": empty,
+  "media.camera.stopped": empty,
+  "media.microphone.started": empty,
+  "media.microphone.stopped": empty,
+  "media.screen.started": empty,
+  "media.screen.stopped": empty,
+  "meeting.started": (p) => ({ startedAt: timestamp(p, "startedAt", "payload.startedAt") }),
+  "meeting.ended": (p, ctx) => {
+    const value = { endedAt: timestamp(p, "endedAt", "payload.endedAt") };
+    if (hasOwn(p, "endedByParticipantId")) {
+      value.endedByParticipantId = participantRef(p, "endedByParticipantId", "payload.endedByParticipantId", ctx, true);
+    }
+    return value;
+  },
+  "meeting.terminated": (p) => ({
+    terminatedAt: timestamp(p, "terminatedAt", "payload.terminatedAt"),
+    reason: reasonCode(p, "reason", "payload.reason")
+  }),
+  "meeting.end": empty,
+  "session.authenticated": (p) => ({ role: role(p) }),
+  "session.welcome": sessionWelcome,
+  "session.rejected": (p) => {
+    const value = { code: reasonCode(p, "code", "payload.code") };
+    if (hasOwn(p, "detail"))
+      value.detail = reasonCode(p, "detail", "payload.detail");
+    return value;
+  },
+  "session.ice_servers": (p) => ({
+    iceServers: iceServers(p),
+    expiresAt: timestamp(p, "expiresAt", "payload.expiresAt")
+  })
+};
+function validatePayload(type, payload, ctx) {
+  try {
+    return { ok: true, value: VALIDATORS[type](payload, ctx) };
+  } catch (error) {
+    if (error instanceof PayloadFailure)
+      return { ok: false, rejection: error.rejection };
+    throw error;
+  }
+}
+
+// ../signaling-protocol/dist/parse.js
+function failure(error) {
+  return { ok: false, error };
+}
+function resolveDirection(options) {
+  const direction = options?.direction;
+  return direction === "client_to_server" || direction === "server_to_client" ? direction : void 0;
+}
+function parseValue(input, direction) {
+  if (!isPlainObject(input))
+    return failure(reject("invalid_envelope", "not_an_object"));
+  if (!isSupportedVersion(readOwn(input, "version"))) {
+    return failure(reject("unsupported_version", void 0, "version"));
+  }
+  const type = readOwn(input, "type");
+  if (!isMessageType(type))
+    return failure(reject("unknown_type", void 0, "type"));
+  if (direction !== void 0 && !isDirectionAllowed(type, direction)) {
+    return failure(reject("direction_not_allowed", void 0, "type"));
+  }
+  const meetingId = readOwn(input, "meetingId");
+  if (!isCanonicalUlid(meetingId)) {
+    return failure(reject("invalid_envelope", "invalid_ulid", "meetingId"));
+  }
+  const participantId = readOwn(input, "participantId");
+  if (!isCanonicalUlid(participantId)) {
+    return failure(reject("invalid_envelope", "invalid_ulid", "participantId"));
+  }
+  const payload = readOwn(input, "payload");
+  if (!isPlainObject(payload)) {
+    return failure(reject("invalid_envelope", "payload_not_object", "payload"));
+  }
+  const result = validatePayload(type, payload, { participantId });
+  if (!result.ok)
+    return failure(result.rejection);
+  const message = {
+    version: PROTOCOL_VERSION,
+    type,
+    meetingId,
+    participantId,
+    payload: result.value
+  };
+  return { ok: true, message };
+}
+function parseSignalingMessage(input, options) {
+  try {
+    return parseValue(input, resolveDirection(options));
+  } catch {
+    return failure(reject("invalid_envelope"));
+  }
+}
+function exceedsMaxMessageBytes(frame) {
+  if (frame.length > MAX_MESSAGE_BYTES)
+    return true;
+  if (frame.length * 3 <= MAX_MESSAGE_BYTES)
+    return false;
+  return utf8ByteLength(frame) > MAX_MESSAGE_BYTES;
+}
+function decodeSignalingFrame(frame, options) {
+  try {
+    if (typeof frame !== "string")
+      return failure(reject("invalid_envelope", "not_text"));
+    if (exceedsMaxMessageBytes(frame)) {
+      return failure(reject("invalid_envelope", "message_too_large"));
+    }
+    let value;
+    try {
+      value = JSON.parse(frame);
+    } catch {
+      return failure(reject("invalid_envelope", "invalid_json"));
+    }
+    return parseValue(value, resolveDirection(options));
+  } catch {
+    return failure(reject("invalid_envelope"));
+  }
+}
+
+// ../signaling-protocol/dist/build.js
+function createSignalingMessage(type, fields) {
+  const result = parseSignalingMessage({
+    version: PROTOCOL_VERSION,
+    type,
+    meetingId: fields.meetingId,
+    participantId: fields.participantId,
+    payload: fields.payload
+  });
+  if (!result.ok)
+    throw new SignalingProtocolError(result.error);
+  return result.message;
+}
+function encodeSignalingMessage(message) {
+  const result = parseSignalingMessage(message);
+  if (!result.ok)
+    throw new SignalingProtocolError(result.error);
+  const frame = JSON.stringify(result.message);
+  if (utf8ByteLength(frame) > MAX_MESSAGE_BYTES) {
+    throw new SignalingProtocolError(reject("invalid_envelope", "message_too_large"));
+  }
+  return frame;
+}
+
+// src/public/errors.ts
+var ERROR_INFO = Object.freeze({
+  join_token_invalid: { message: "This meeting link is not valid. Ask for a new one.", retryable: false },
+  join_token_expired: { message: "This meeting link has expired. Ask for a new one.", retryable: true },
+  origin_not_allowed: { message: "This site is not allowed to join this meeting.", retryable: false },
+  connection_failed: {
+    message: "Could not connect to the meeting. Check your connection and try again.",
+    retryable: true
+  },
+  join_timeout: { message: "Joining the meeting took too long. Please try again.", retryable: true },
+  join_cancelled: { message: "Joining was cancelled.", retryable: false },
+  connection_lost: { message: "The connection to the meeting was lost.", retryable: true },
+  session_replaced: { message: "You joined this meeting from another tab or device.", retryable: false },
+  service_unavailable: {
+    message: "The meeting service is temporarily unavailable. Please try again shortly.",
+    retryable: true
+  },
+  rate_limited: { message: "Too many attempts. Please wait a moment and try again.", retryable: true },
+  meeting_ended: { message: "This meeting has ended.", retryable: false },
+  protocol_error: { message: "Something went wrong in the meeting connection.", retryable: false },
+  already_joined: { message: "This meeting is already joined or joining.", retryable: false },
+  engine_closed: {
+    message: "This meeting session has ended. Create a new one to join again.",
+    retryable: false
+  },
+  not_joined: { message: "Join the meeting first.", retryable: false },
+  not_permitted: { message: "You don't have permission to do that in this meeting.", retryable: false },
+  permission_denied: {
+    message: "Camera or microphone access was blocked. Allow access in your browser settings.",
+    retryable: false
+  },
+  device_not_found: { message: "No camera or microphone was found.", retryable: false },
+  device_unavailable: {
+    message: "Your camera or microphone is being used by another application.",
+    retryable: true
+  },
+  screen_share_cancelled: { message: "Screen sharing was cancelled.", retryable: false },
+  unsupported_environment: {
+    message: "This browser does not support meetings. Try a current version of Chrome, Edge, Firefox, or Safari.",
+    retryable: false
+  },
+  media_connection_failed: {
+    message: "Audio and video couldn't connect to the other participant. Check your network and try rejoining.",
+    retryable: true
+  },
+  media_participant_limit: {
+    message: "Audio and video are available with one other participant in this meeting.",
+    retryable: false
+  }
+});
+var MeetingError = class extends Error {
+  name = "MeetingError";
+  /** Stable machine-readable code. */
+  code;
+  /** True when retrying the same action later (with a fresh token for join errors) may succeed. */
+  retryable;
+  constructor(code) {
+    const info = ERROR_INFO[code];
+    super(info.message);
+    this.code = code;
+    this.retryable = info.retryable;
+  }
+};
+
+// src/internal/emitter.ts
+var Emitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  #log;
+  constructor(log) {
+    this.#log = log;
+  }
+  on(type, listener) {
+    let set = this.#listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(type, set);
+    }
+    const entry = listener;
+    set.add(entry);
+    return () => {
+      this.#listeners.get(type)?.delete(entry);
+    };
+  }
+  emit(type, event) {
+    const set = this.#listeners.get(type);
+    if (!set || set.size === 0) return;
+    for (const listener of [...set]) {
+      try {
+        listener(event);
+      } catch {
+        this.#log.warn("event listener threw", { messageType: String(type) });
+      }
+    }
+  }
+  clear() {
+    this.#listeners.clear();
+  }
+};
+
+// src/internal/errorMapping.ts
+var BEFORE_JOINED = {
+  1001: "service_unavailable",
+  4001: "join_token_invalid",
+  4002: "join_token_expired",
+  4003: "origin_not_allowed",
+  4004: "meeting_ended",
+  4008: "join_timeout",
+  4009: "session_replaced",
+  4011: "protocol_error",
+  4029: "rate_limited",
+  4503: "service_unavailable"
+};
+var AFTER_JOINED = {
+  1e3: ["left", void 0],
+  1001: ["error", "service_unavailable"],
+  4001: ["error", "join_token_invalid"],
+  4002: ["error", "join_token_expired"],
+  4003: ["error", "origin_not_allowed"],
+  4004: ["meeting_ended", void 0],
+  4009: ["session_replaced", "session_replaced"],
+  4011: ["error", "protocol_error"],
+  4029: ["error", "rate_limited"],
+  4503: ["error", "service_unavailable"]
+};
+function mapClose(code, phase) {
+  if (phase === "before_joined") {
+    return { reason: "join_failed", error: new MeetingError(BEFORE_JOINED[code] ?? "connection_failed") };
+  }
+  const [reason, errorCode] = AFTER_JOINED[code] ?? ["connection_lost", "connection_lost"];
+  return errorCode ? { reason, error: new MeetingError(errorCode) } : { reason };
+}
+var REJECTIONS = {
+  rate_limited: "rate_limited",
+  service_unavailable: "service_unavailable",
+  role_not_allowed: "not_permitted"
+};
+function mapRejection(code) {
+  return new MeetingError(Object.hasOwn(REJECTIONS, code) ? REJECTIONS[code] : "protocol_error");
+}
+var LEFT_REASONS = /* @__PURE__ */ new Set(["left", "disconnected", "removed", "meeting_ended"]);
+function mapLeftReason(reason) {
+  return LEFT_REASONS.has(reason) ? reason : "other";
+}
+var DEVICE_ERRORS = {
+  NotAllowedError: "permission_denied",
+  SecurityError: "permission_denied",
+  NotFoundError: "device_not_found",
+  OverconstrainedError: "device_not_found",
+  NotReadableError: "device_unavailable",
+  AbortError: "device_unavailable",
+  TypeError: "unsupported_environment"
+};
+var SCREEN_ERRORS = {
+  NotAllowedError: "screen_share_cancelled",
+  AbortError: "screen_share_cancelled",
+  SecurityError: "permission_denied",
+  TypeError: "unsupported_environment"
+};
+function errorName(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const name = error.name;
+  return typeof name === "string" ? name : void 0;
+}
+function mapMediaError(kind, error) {
+  if (error instanceof MeetingError) return error;
+  const name = errorName(error);
+  const table = kind === "screen" ? SCREEN_ERRORS : DEVICE_ERRORS;
+  const code = name !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
+  return new MeetingError(code ?? "device_unavailable");
+}
+
+// src/internal/localMedia.ts
+var KINDS = ["camera", "microphone", "screen"];
+function stopTracks(stream) {
+  for (const track of stream.getTracks()) {
+    try {
+      track.stop();
+    } catch {
+    }
+  }
+}
+function setTracksEnabled(stream, enabled) {
+  for (const track of stream.getTracks()) track.enabled = enabled;
+}
+function hasLiveTrack(stream) {
+  return stream.getTracks().some((track) => track.readyState === "live");
+}
+function deviceOf(stream, requested) {
+  const track = stream.getTracks()[0];
+  const reported = typeof track?.getSettings === "function" ? track.getSettings().deviceId : void 0;
+  return reported || requested || null;
+}
+var LocalMediaController = class {
+  #env;
+  #hooks;
+  #log;
+  #state = { camera: false, microphone: false, screen: false };
+  #streams = { camera: null, microphone: null, screen: null };
+  #devices = { camera: null, microphone: null, screen: null };
+  #tails = {
+    camera: Promise.resolve(),
+    microphone: Promise.resolve(),
+    screen: Promise.resolve()
+  };
+  #queued = { camera: [], microphone: [], screen: [] };
+  #released = false;
+  #generation = 0;
+  constructor(env, hooks, log) {
+    this.#env = env;
+    this.#hooks = hooks;
+    this.#log = log;
+  }
+  get state() {
+    return Object.freeze({ ...this.#state });
+  }
+  get streams() {
+    return Object.freeze({
+      camera: this.#state.camera ? this.#streams.camera : null,
+      microphone: this.#state.microphone ? this.#streams.microphone : null,
+      screen: this.#state.screen ? this.#streams.screen : null
+    });
+  }
+  /**
+   * Turns `kind` on or off. `deviceId` applies to turning the camera or microphone on: it captures that device, or
+   * switches to it in place when `kind` is already on with another device.
+   */
+  set(kind, enabled, deviceId) {
+    const wanted = enabled && kind !== "screen" ? deviceId : void 0;
+    const queue = this.#queued[kind];
+    const last = queue[queue.length - 1];
+    if (last) {
+      if (last.target === enabled && last.deviceId === wanted) return last.promise;
+    } else if (this.#state[kind] === enabled && !this.#released && !this.#needsSwitch(kind, wanted)) {
+      return Promise.resolve();
+    }
+    const promise = this.#tails[kind].then(() => this.#run(kind, enabled, wanted));
+    const operation = { target: enabled, deviceId: wanted, promise };
+    queue.push(operation);
+    const settle = () => {
+      const index = queue.indexOf(operation);
+      if (index >= 0) queue.splice(index, 1);
+    };
+    this.#tails[kind] = promise.then(settle, settle);
+    return promise;
+  }
+  /** Turns `kind` off locally without announcing it, because the meeting refused the change. */
+  rollback(kind) {
+    if (!this.#state[kind]) return;
+    this.#turnOff(kind, false);
+  }
+  /** Stops every capture. Pending and later changes reject with `not_joined`. Emits nothing. */
+  releaseAll() {
+    this.#released = true;
+    this.#generation += 1;
+    for (const kind of KINDS) {
+      const stream = this.#streams[kind];
+      if (stream) stopTracks(stream);
+      this.#streams[kind] = null;
+      this.#devices[kind] = null;
+      this.#state[kind] = false;
+    }
+  }
+  /** True when `kind` is on and a specific device other than the one in use was asked for. */
+  #needsSwitch(kind, deviceId) {
+    return this.#state[kind] && deviceId !== void 0 && deviceId !== this.#devices[kind];
+  }
+  async #run(kind, enabled, deviceId) {
+    if (this.#released) throw new MeetingError("not_joined");
+    if (enabled && this.#needsSwitch(kind, deviceId)) return this.#switchDevice(kind, deviceId);
+    if (this.#state[kind] === enabled) return;
+    if (enabled) await this.#turnOn(kind, deviceId);
+    else this.#turnOff(kind, true);
+  }
+  /**
+   * Replaces a running capture with one from another device. The new capture is handed on before the old one stops,
+   * so the meeting keeps receiving media; nothing is announced because the on/off state does not change. When the
+   * new device cannot be captured, the old capture keeps running.
+   */
+  async #switchDevice(kind, deviceId) {
+    const generation = this.#generation;
+    const stream = await this.#capture(kind, deviceId);
+    if (generation !== this.#generation || this.#released || !this.#state[kind]) {
+      stopTracks(stream);
+      throw new MeetingError("not_joined");
+    }
+    const previous = this.#streams[kind];
+    this.#streams[kind] = stream;
+    this.#devices[kind] = deviceOf(stream, deviceId);
+    this.#watchEnded(kind, stream);
+    this.#hooks.changed(kind, true, stream);
+    if (previous) stopTracks(previous);
+  }
+  async #turnOn(kind, deviceId) {
+    if (kind === "microphone") {
+      const kept = this.#streams.microphone;
+      const sameDevice = deviceId === void 0 || deviceId === this.#devices.microphone;
+      if (kept && hasLiveTrack(kept) && sameDevice) {
+        setTracksEnabled(kept, true);
+        if (!this.#hooks.announce(kind, true)) {
+          setTracksEnabled(kept, false);
+          throw new MeetingError("not_joined");
+        }
+        this.#state.microphone = true;
+        this.#hooks.changed(kind, true, kept);
+        return;
+      }
+      if (kept && !hasLiveTrack(kept)) {
+        stopTracks(kept);
+        this.#streams.microphone = null;
+        this.#devices.microphone = null;
+      }
+    }
+    const generation = this.#generation;
+    const stream = await this.#capture(kind, deviceId);
+    if (generation !== this.#generation || this.#released || !this.#hooks.announce(kind, true)) {
+      stopTracks(stream);
+      throw new MeetingError("not_joined");
+    }
+    const replaced = this.#streams[kind];
+    this.#streams[kind] = stream;
+    this.#devices[kind] = kind === "screen" ? null : deviceOf(stream, deviceId);
+    this.#state[kind] = true;
+    this.#watchEnded(kind, stream);
+    this.#hooks.changed(kind, true, stream);
+    if (replaced) stopTracks(replaced);
+  }
+  #turnOff(kind, announce) {
+    const stream = this.#streams[kind];
+    if (kind === "microphone") {
+      if (stream) setTracksEnabled(stream, false);
+    } else {
+      if (stream) stopTracks(stream);
+      this.#streams[kind] = null;
+      this.#devices[kind] = null;
+    }
+    this.#state[kind] = false;
+    const sent = !announce || this.#hooks.announce(kind, false);
+    this.#hooks.changed(kind, false, null);
+    if (!sent) throw new MeetingError("not_joined");
+  }
+  async #capture(kind, deviceId) {
+    const devices = this.#env.mediaDevices;
+    try {
+      if (kind === "screen") {
+        if (typeof devices?.getDisplayMedia !== "function") throw new MeetingError("unsupported_environment");
+        return await devices.getDisplayMedia({ video: true, audio: false });
+      }
+      if (typeof devices?.getUserMedia !== "function") throw new MeetingError("unsupported_environment");
+      const track = deviceId === void 0 ? true : { deviceId: { exact: deviceId } };
+      return await devices.getUserMedia(kind === "camera" ? { video: track, audio: false } : { audio: track, video: false });
+    } catch (error) {
+      const mapped = mapMediaError(kind, error);
+      this.#log.warn("capture failed", { kind, code: mapped.code });
+      throw mapped;
+    }
+  }
+  /**
+   * A capture the browser or device ended. A live camera or unmuted microphone continues on another listed
+   * device of that kind when one can be opened. Otherwise the kind turns off and is announced. Screen share
+   * always turns off. A muted microphone is dropped and is not replaced.
+   */
+  #watchEnded(kind, stream) {
+    const onEnded = () => {
+      if (this.#released || this.#streams[kind] !== stream) return;
+      if (!this.#state[kind]) {
+        if (kind === "microphone") {
+          this.#streams.microphone = null;
+          this.#devices.microphone = null;
+        }
+        return;
+      }
+      if (kind === "screen") {
+        this.#log.info("screen share ended by the browser", { kind });
+        this.set(kind, false).catch(() => void 0);
+        return;
+      }
+      const generation = this.#generation;
+      const scheduled = this.#tails[kind].then(() => this.#continueOnAnotherDevice(kind, stream, generation));
+      this.#tails[kind] = scheduled.then(
+        () => void 0,
+        () => void 0
+      );
+    };
+    for (const track of stream.getTracks()) track.addEventListener("ended", onEnded, { once: true });
+  }
+  /** The capture that just ended is still the one in use, and the meeting has not been released. */
+  #stillCurrent(kind, stream, generation) {
+    return !this.#released && this.#generation === generation && this.#state[kind] && this.#streams[kind] === stream;
+  }
+  /**
+   * Opens the first remaining device of `kind` and installs it the same way as a live switch. When none can be
+   * opened, turns `kind` off. A release or a newer capture during the attempt stops the new stream and emits nothing.
+   */
+  async #continueOnAnotherDevice(kind, endedStream, generation) {
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    const endedId = this.#devices[kind] ?? deviceOf(endedStream, void 0);
+    const candidates = await this.#otherDevices(kind, endedId);
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    for (const deviceId of candidates) {
+      if (!this.#stillCurrent(kind, endedStream, generation)) return;
+      let stream;
+      try {
+        stream = await this.#capture(kind, deviceId);
+      } catch {
+        continue;
+      }
+      if (!this.#stillCurrent(kind, endedStream, generation)) {
+        stopTracks(stream);
+        return;
+      }
+      this.#streams[kind] = stream;
+      this.#devices[kind] = deviceOf(stream, deviceId);
+      this.#watchEnded(kind, stream);
+      this.#hooks.changed(kind, true, stream);
+      stopTracks(endedStream);
+      this.#log.info("capture continued on another device", { kind, reason: "capture_fallback" });
+      return;
+    }
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    this.#log.info("capture ended", { kind });
+    try {
+      this.#turnOff(kind, true);
+    } catch {
+    }
+  }
+  /** Listed devices of `kind`, excluding the one that just ended and any empty id. */
+  async #otherDevices(kind, endedId) {
+    const devices = this.#env.mediaDevices;
+    if (typeof devices?.enumerateDevices !== "function") return [];
+    let listed;
+    try {
+      listed = await devices.enumerateDevices();
+    } catch {
+      return [];
+    }
+    const wanted = kind === "camera" ? "videoinput" : "audioinput";
+    const ids = [];
+    for (const device of listed) {
+      if (device.kind !== wanted || !device.deviceId || device.deviceId === endedId || ids.includes(device.deviceId)) continue;
+      ids.push(device.deviceId);
+    }
+    return ids;
+  }
+};
+
+// src/internal/log.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "state",
+  "code",
+  "reason",
+  "kind",
+  "participantId",
+  "meetingId",
+  "closeCode",
+  "messageType",
+  "durationMs",
+  "attempt",
+  "path",
+  "localPath",
+  "remotePath",
+  "trigger",
+  "elapsedMs",
+  "requestId",
+  "correlationId",
+  "rttMs",
+  "jitterMs",
+  "packetLossRatio",
+  "sendBitrateBps",
+  "receiveBitrateBps",
+  "incomplete"
+]);
+var JWT_SHAPE = /[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*/;
+var NEGOTIATION_CONTENT = /sdp|candidate/i;
+function isSafeString(value) {
+  return !JWT_SHAPE.test(value) && !NEGOTIATION_CONTENT.test(value);
+}
+function sanitize(fields) {
+  if (!fields) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (!ALLOWED_KEYS.has(key) || value === void 0) continue;
+    if (typeof value === "string" && !isSafeString(value)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+var Log = class {
+  #logger;
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  debug(message, fields) {
+    this.#write("debug", message, fields);
+  }
+  info(message, fields) {
+    this.#write("info", message, fields);
+  }
+  warn(message, fields) {
+    this.#write("warn", message, fields);
+  }
+  error(message, fields) {
+    this.#write("error", message, fields);
+  }
+  #write(level, message, fields) {
+    const logger = this.#logger;
+    if (!logger) return;
+    try {
+      const method = logger[level];
+      if (typeof method !== "function") return;
+      const safe = sanitize(fields);
+      if (safe) method.call(logger, message, safe);
+      else method.call(logger, message);
+    } catch {
+    }
+  }
+};
+
+// src/internal/mediaDelivery.ts
+var NO_REMOTE_MEDIA = Object.freeze({ camera: null, microphone: null, screen: null });
+var SignalingOnlyMediaDelivery = class {
+  attach() {
+  }
+  peersPresent() {
+  }
+  peerPresent() {
+  }
+  peerMediaChanged() {
+  }
+  peerLeft() {
+  }
+  peerReconnected() {
+  }
+  onPeerFrame() {
+  }
+  iceServersUpdated() {
+  }
+  localMediaChanged() {
+  }
+  supportsScreenShare() {
+    return false;
+  }
+  remoteMedia() {
+    return NO_REMOTE_MEDIA;
+  }
+  connectionStatus() {
+    return null;
+  }
+  close() {
+  }
+};
+
+// src/internal/reconnect/backoff.ts
+var RECONNECT_BACKOFF_BASE_MS = 500;
+var RECONNECT_BACKOFF_FACTOR = 2;
+var RECONNECT_BACKOFF_CAP_MS = 8e3;
+var RECONNECT_BACKOFF_JITTER = 0.2;
+function reconnectBackoffMs(attempt, clock = Math) {
+  const n = Math.max(1, Math.floor(attempt));
+  const raw = Math.min(RECONNECT_BACKOFF_CAP_MS, RECONNECT_BACKOFF_BASE_MS * RECONNECT_BACKOFF_FACTOR ** (n - 1));
+  const jitter = 1 + (clock.random() * 2 - 1) * RECONNECT_BACKOFF_JITTER;
+  return Math.max(0, Math.round(raw * jitter));
+}
+
+// src/internal/reconnect/recoveryWindow.ts
+var DEFAULT_RECONNECT_WINDOW_MS = 12e4;
+var MIN_RECONNECT_WINDOW_MS = 1e3;
+var MAX_RECONNECT_WINDOW_MS = 6e5;
+function clampReconnectWindowMs(value) {
+  if (value === void 0) return DEFAULT_RECONNECT_WINDOW_MS;
+  if (typeof value !== "number" || !Number.isInteger(value) || !Number.isFinite(value)) {
+    return DEFAULT_RECONNECT_WINDOW_MS;
+  }
+  if (value < MIN_RECONNECT_WINDOW_MS) return MIN_RECONNECT_WINDOW_MS;
+  if (value > MAX_RECONNECT_WINDOW_MS) return MAX_RECONNECT_WINDOW_MS;
+  return value;
+}
+function markRecoveryWindowStart(state, nowMs) {
+  if (state.windowStartedAtMs === void 0) state.windowStartedAtMs = nowMs;
+}
+function resetRecoveryWindow(state) {
+  state.windowStartedAtMs = void 0;
+}
+function isRecoveryWindowExhausted(state, nowMs) {
+  if (state.windowStartedAtMs === void 0) return false;
+  return nowMs - state.windowStartedAtMs >= state.windowMs;
+}
+
+// src/internal/reconnect/reasons.ts
+var REASON_CLASSES = /* @__PURE__ */ new Set([
+  "token_refresh_failed",
+  "admission_refused",
+  "recovery_window_exhausted",
+  "meeting_ended",
+  "session_replaced",
+  "left",
+  "hard_failure"
+]);
+var TRIGGERS = /* @__PURE__ */ new Set(["meeting_service", "media", "network", "visibility"]);
+var FORBIDDEN_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "joinToken",
+  "join_token",
+  "authorization",
+  "Authorization",
+  "password",
+  "credential",
+  "sdp",
+  "candidate",
+  "ice"
+]);
+function isReconnectReasonClass(value) {
+  return REASON_CLASSES.has(value);
+}
+function isReconnectTrigger(value) {
+  return TRIGGERS.has(value);
+}
+function reconnectLogFields(input) {
+  const out = {};
+  const attempt = Math.max(1, Math.floor(input.attempt));
+  out.attempt = attempt;
+  if (input.trigger !== void 0 && isReconnectTrigger(input.trigger)) out.trigger = input.trigger;
+  if (typeof input.elapsedMs === "number" && Number.isFinite(input.elapsedMs) && input.elapsedMs >= 0) {
+    out.elapsedMs = Math.floor(input.elapsedMs);
+  }
+  if (input.reason !== void 0 && isReconnectReasonClass(input.reason)) out.reason = input.reason;
+  for (const key of ["meetingId", "participantId", "requestId", "correlationId"]) {
+    const value = input[key];
+    if (typeof value === "string" && value.length > 0) out[key] = value;
+  }
+  for (const key of Object.keys(input)) {
+    if (FORBIDDEN_FIELD_KEYS.has(key)) {
+    }
+  }
+  return out;
+}
+
+// src/internal/reconnect/reconnectController.ts
+var ReconnectController = class {
+  #env;
+  #logger;
+  #open;
+  #onAbandoned;
+  #clock;
+  #window;
+  #active = false;
+  #attempt = 0;
+  #trigger = "meeting_service";
+  #timer;
+  #generation = 0;
+  #inFlight = false;
+  constructor(deps) {
+    this.#env = deps.env;
+    this.#logger = deps.logger;
+    this.#open = deps.open;
+    this.#onAbandoned = deps.onAbandoned;
+    this.#clock = { random: deps.random ?? (() => Math.random()) };
+    this.#window = { windowMs: deps.windowMs, windowStartedAtMs: void 0 };
+  }
+  get active() {
+    return this.#active;
+  }
+  get attempt() {
+    return this.#attempt;
+  }
+  /**
+   * Starts (or continues) a single active reconnect chain.
+   * Overlapping starts while already active are ignored.
+   */
+  start(trigger = "meeting_service") {
+    if (this.#active) return;
+    this.#active = true;
+    this.#trigger = trigger;
+    this.#attempt = 0;
+    markRecoveryWindowStart(this.#window, this.#env.now());
+    this.#scheduleNext(0);
+  }
+  /** Cancels further opens and clears timers. Safe to call when idle. */
+  cancel(reason = "left") {
+    if (!this.#active && this.#timer === void 0) return;
+    const attempt = Math.max(1, this.#attempt);
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    this.#clearTimer();
+    this.#generation += 1;
+    this.#active = false;
+    this.#inFlight = false;
+    resetRecoveryWindow(this.#window);
+    this.#log("info", "reconnect cancelled", {
+      attempt,
+      elapsedMs,
+      reason,
+      trigger: this.#trigger
+    });
+  }
+  #scheduleNext(delayMs) {
+    this.#clearTimer();
+    const generation = this.#generation;
+    const run = () => {
+      if (generation !== this.#generation) return;
+      void this.#runAttempt();
+    };
+    if (delayMs <= 0) {
+      queueMicrotask(run);
+      return;
+    }
+    this.#timer = this.#env.setTimeout(run, delayMs);
+  }
+  async #runAttempt() {
+    if (!this.#active || this.#inFlight) return;
+    const now = this.#env.now();
+    if (isRecoveryWindowExhausted(this.#window, now)) {
+      this.#abandon("recovery_window_exhausted");
+      return;
+    }
+    this.#attempt += 1;
+    const attempt = this.#attempt;
+    const generation = this.#generation;
+    this.#inFlight = true;
+    this.#log("info", "reconnect attempt started", { attempt, trigger: this.#trigger });
+    let result = "failed";
+    try {
+      result = await this.#open(attempt);
+    } catch {
+      result = "failed";
+    }
+    if (generation !== this.#generation) return;
+    this.#inFlight = false;
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    if (result === "recovered") {
+      this.#active = false;
+      resetRecoveryWindow(this.#window);
+      this.#log("info", "reconnect succeeded", { attempt, elapsedMs, trigger: this.#trigger });
+      return;
+    }
+    if (result === "cancelled") {
+      this.cancel("left");
+      return;
+    }
+    if (result === "failed") {
+      this.#abandon("hard_failure");
+      return;
+    }
+    if (isRecoveryWindowExhausted(this.#window, this.#env.now())) {
+      this.#abandon("recovery_window_exhausted");
+      return;
+    }
+    const delay = reconnectBackoffMs(attempt + 1, this.#clock);
+    this.#scheduleNext(delay);
+  }
+  #abandon(reason) {
+    const attempt = Math.max(1, this.#attempt);
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    this.#clearTimer();
+    this.#generation += 1;
+    this.#active = false;
+    this.#inFlight = false;
+    resetRecoveryWindow(this.#window);
+    this.#log("warn", "reconnect failed", { attempt, elapsedMs, reason, trigger: this.#trigger });
+    this.#onAbandoned?.(reason);
+  }
+  #clearTimer() {
+    if (this.#timer !== void 0) this.#env.clearTimeout(this.#timer);
+    this.#timer = void 0;
+  }
+  #log(level, message, fields) {
+    const logger = this.#logger;
+    if (!logger) return;
+    const method = logger[level];
+    if (typeof method !== "function") return;
+    try {
+      method.call(logger, message, reconnectLogFields(fields));
+    } catch {
+    }
+  }
+};
+
+// src/internal/roster.ts
+function snapshot(entry) {
+  const media = Object.freeze({ ...entry.media });
+  const participant = {
+    id: entry.id,
+    role: entry.role,
+    media
+  };
+  if (entry.displayName !== void 0) participant.displayName = entry.displayName;
+  return Object.freeze(participant);
+}
+var Roster = class {
+  #entries = /* @__PURE__ */ new Map();
+  #committed = false;
+  #cache;
+  get committed() {
+    return this.#committed;
+  }
+  upsertJoined(id, role2, displayName) {
+    const existing = this.#entries.get(id);
+    this.#cache = void 0;
+    if (existing) {
+      existing.role = role2;
+      if (displayName !== void 0) existing.displayName = displayName;
+      else delete existing.displayName;
+      return this.#committed ? "updated" : "buffered";
+    }
+    const entry = { id, role: role2, media: { camera: false, microphone: false, screen: false } };
+    if (displayName !== void 0) entry.displayName = displayName;
+    this.#entries.set(id, entry);
+    return this.#committed ? "added" : "buffered";
+  }
+  /** Returns true when the participant's state changed. Unknown participants are ignored after commit. */
+  setMedia(id, kind, enabled) {
+    let entry = this.#entries.get(id);
+    if (!entry) {
+      if (this.#committed) return false;
+      this.upsertJoined(id, "participant");
+      entry = this.#entries.get(id);
+      if (!entry) return false;
+    }
+    if (entry.media[kind] === enabled) return false;
+    entry.media[kind] = enabled;
+    this.#cache = void 0;
+    return true;
+  }
+  remove(id) {
+    const removed = this.#entries.delete(id);
+    if (removed) this.#cache = void 0;
+    return removed;
+  }
+  commit() {
+    this.#committed = true;
+    this.#cache = void 0;
+  }
+  get(id) {
+    const entry = this.#entries.get(id);
+    return entry ? snapshot(entry) : void 0;
+  }
+  /** Committed participants in arrival order; empty before commit. */
+  list() {
+    if (!this.#committed) return Object.freeze([]);
+    this.#cache ??= Object.freeze([...this.#entries.values()].map(snapshot));
+    return this.#cache;
+  }
+  clear() {
+    this.#entries.clear();
+    this.#cache = void 0;
+  }
+  /** Clears participants and returns to the uncommitted (joining) buffer state. */
+  reset() {
+    this.clear();
+    this.#committed = false;
+  }
+};
+
+// src/internal/signalingSession.ts
+var SIGNALING_SUBPROTOCOL = "strevokit.signaling.v1";
+var TOKEN_SUBPROTOCOL_PREFIX = "strevokit.join-token.";
+var ABNORMAL_CLOSE = 1006;
+var OUTBOUND_TYPES = Object.freeze([
+  "participant.join",
+  "participant.leave",
+  "meeting.end",
+  "media.camera.started",
+  "media.camera.stopped",
+  "media.microphone.started",
+  "media.microphone.stopped",
+  "media.screen.started",
+  "media.screen.stopped"
+]);
+var PEER_OUTBOUND_TYPES = Object.freeze([
+  "webrtc.offer",
+  "webrtc.answer",
+  "webrtc.ice_candidate",
+  "webrtc.connected",
+  "webrtc.disconnected",
+  "webrtc.failed",
+  "webrtc.quality_sample",
+  "webrtc.ice_restart",
+  "webrtc.ice_restart_result"
+]);
+var SignalingSession = class {
+  #env;
+  #url;
+  #addressing;
+  #log;
+  #token;
+  #callbacks;
+  #socket;
+  #opened = false;
+  constructor(options) {
+    this.#env = options.env;
+    this.#url = `${options.realtimeUrl}/v1/meetings/${options.addressing.meetingId}/signaling`;
+    this.#addressing = options.addressing;
+    this.#log = options.log;
+    this.#token = options.token;
+    this.#callbacks = options.callbacks;
+  }
+  open() {
+    const token = this.#token;
+    this.#token = void 0;
+    const Socket = this.#env.WebSocket;
+    if (!Socket || token === void 0) {
+      this.#fail();
+      return;
+    }
+    let socket;
+    try {
+      socket = new Socket(this.#url, [SIGNALING_SUBPROTOCOL, `${TOKEN_SUBPROTOCOL_PREFIX}${token}`]);
+    } catch {
+      this.#log.warn("connection could not be created");
+      this.#fail();
+      return;
+    }
+    this.#socket = socket;
+    socket.onopen = () => this.#handleOpen();
+    socket.onmessage = (event) => this.#handleFrame(event.data);
+    socket.onclose = (event) => this.#handleClose(event.code, event.reason);
+    socket.onerror = () => void 0;
+  }
+  /** Sends an empty-payload frame. Returns false when the connection is not open or the frame cannot be built. */
+  send(type) {
+    const socket = this.#socket;
+    if (!socket || !this.#opened || !this.#callbacks) return false;
+    try {
+      const message = createSignalingMessage(type, {
+        meetingId: this.#addressing.meetingId,
+        participantId: this.#addressing.participantId,
+        payload: {}
+      });
+      socket.send(encodeSignalingMessage(message));
+      return true;
+    } catch {
+      this.#log.warn("frame could not be sent", { messageType: type });
+      return false;
+    }
+  }
+  /**
+   * Sends a media frame. Returns false when the connection is not open or the frame fails validation. The payload
+   * is never logged.
+   */
+  sendPeer(type, payload) {
+    const socket = this.#socket;
+    if (!socket || !this.#opened || !this.#callbacks) return false;
+    try {
+      const message = createSignalingMessage(type, {
+        meetingId: this.#addressing.meetingId,
+        participantId: this.#addressing.participantId,
+        payload
+      });
+      socket.send(encodeSignalingMessage(message));
+      return true;
+    } catch {
+      this.#log.debug("frame could not be sent", { messageType: type });
+      return false;
+    }
+  }
+  /** Closes the connection. No further callbacks are made. */
+  close(code = 1e3) {
+    this.#callbacks = void 0;
+    const socket = this.#socket;
+    if (!socket) return;
+    try {
+      socket.close(code);
+    } catch {
+    }
+  }
+  #handleOpen() {
+    if (!this.#callbacks) return;
+    if (this.#socket?.protocol !== SIGNALING_SUBPROTOCOL) {
+      this.#log.warn("unexpected subprotocol negotiated");
+      const socket = this.#socket;
+      this.#fail();
+      try {
+        socket?.close(1e3);
+      } catch {
+      }
+      return;
+    }
+    this.#opened = true;
+  }
+  #handleFrame(data) {
+    const callbacks = this.#callbacks;
+    if (!callbacks) return;
+    const result = decodeSignalingFrame(data, { direction: "server_to_client" });
+    try {
+      if (result.ok) callbacks.onMessage(result.message);
+      else {
+        this.#log.debug("invalid frame received", { code: result.error.code });
+        callbacks.onProtocolError();
+      }
+    } catch {
+      this.#log.error("frame handling failed");
+    }
+  }
+  #handleClose(code, reason) {
+    const callbacks = this.#callbacks;
+    this.#callbacks = void 0;
+    if (!callbacks) return;
+    try {
+      callbacks.onClose(typeof code === "number" ? code : ABNORMAL_CLOSE, typeof reason === "string" ? reason : "", this.#opened);
+    } catch {
+      this.#log.error("close handling failed");
+    }
+  }
+  #fail() {
+    const callbacks = this.#callbacks;
+    this.#callbacks = void 0;
+    if (!callbacks) return;
+    try {
+      callbacks.onClose(ABNORMAL_CLOSE, "", false);
+    } catch {
+      this.#log.error("close handling failed");
+    }
+  }
+};
+
+// src/internal/token.ts
+var TOKEN_EXPIRY_SKEW_MS = 3e4;
+var BASE64URL = /^[A-Za-z0-9_-]+$/;
+function decodeSegment(segment) {
+  if (!BASE64URL.test(segment)) throw new MeetingError("join_token_invalid");
+  const padded = segment.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(segment.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function decodeClaims(token) {
+  const segments = token.split(".");
+  if (segments.length !== 3) throw new MeetingError("join_token_invalid");
+  let claims;
+  try {
+    claims = decodeSegment(segments[1] ?? "");
+  } catch {
+    throw new MeetingError("join_token_invalid");
+  }
+  if (typeof claims !== "object" || claims === null || Array.isArray(claims)) {
+    throw new MeetingError("join_token_invalid");
+  }
+  return claims;
+}
+function decodeAddressing(token) {
+  const claims = decodeClaims(token);
+  const { meeting_id: meetingId, participant_id: participantId } = claims;
+  if (!isCanonicalUlid(meetingId) || !isCanonicalUlid(participantId)) {
+    throw new MeetingError("join_token_invalid");
+  }
+  return { meetingId, participantId };
+}
+function isJoinTokenUsable(token, nowMs, skewMs = TOKEN_EXPIRY_SKEW_MS) {
+  try {
+    const claims = decodeClaims(token);
+    const exp = claims.exp;
+    if (typeof exp !== "number" || !Number.isFinite(exp)) return false;
+    return exp * 1e3 > nowMs + skewMs;
+  } catch {
+    return false;
+  }
+}
+
+// src/internal/engine.ts
+var LEAVE_FALLBACK_MS = 5e3;
+var RESTRICTED_PENDING_MS = 2e3;
+var END_MEETING_TIMEOUT_MS = 1e4;
+var MEDIA_KINDS = ["camera", "microphone", "screen"];
+function deferred() {
+  let resolve;
+  let reject2;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject2 = rej;
+  });
+  return { promise, resolve, reject: reject2 };
+}
+function mediaFrame(type) {
+  const match = /^media\.(camera|microphone|screen)\.(started|stopped)$/.exec(type);
+  if (!match) return void 0;
+  return { kind: match[1], enabled: match[2] === "started" };
+}
+var MeetingEngineImpl = class {
+  #realtimeUrl;
+  #joinTimeoutMs;
+  #addressing;
+  #env;
+  #createDelivery;
+  #getJoinToken;
+  #reconnectWindowMs;
+  #logger;
+  #delivery = new SignalingOnlyMediaDelivery();
+  #log;
+  #emitter;
+  #roster = new Roster();
+  #media;
+  #token;
+  #state = "idle";
+  #disposed = false;
+  #session;
+  #self = null;
+  #role;
+  #join;
+  #leave;
+  #joinTimer;
+  #leaveTimer;
+  #endMeeting;
+  #endMeetingTimer;
+  #pendingRestricted;
+  #reconnect;
+  #reconnectOpen;
+  #reconnectOutcome;
+  #preRecoveryParticipants;
+  #pendingAbandonReason;
+  #onVisibility;
+  constructor(config) {
+    this.#token = config.token;
+    this.#realtimeUrl = config.realtimeUrl;
+    this.#joinTimeoutMs = config.joinTimeoutMs;
+    this.#addressing = config.addressing;
+    this.#env = config.env;
+    this.#createDelivery = config.createMediaDelivery;
+    this.#getJoinToken = config.getJoinToken;
+    this.#reconnectWindowMs = config.reconnectWindowMs ?? 12e4;
+    this.#logger = config.logger;
+    this.#log = new Log(config.logger);
+    this.#emitter = new Emitter(this.#log);
+    this.#media = new LocalMediaController(
+      config.env,
+      {
+        announce: (kind, enabled) => this.#announce(kind, enabled),
+        changed: (kind, enabled, stream) => {
+          this.#emit("local_media_changed", { kind, enabled, stream });
+          this.#delivery.localMediaChanged(kind, stream);
+        }
+      },
+      this.#log
+    );
+    this.#installVisibilityListener();
+  }
+  get state() {
+    return this.#state;
+  }
+  get self() {
+    return this.#self;
+  }
+  get participants() {
+    return this.#roster.list();
+  }
+  get localMediaState() {
+    return this.#media.state;
+  }
+  get localMedia() {
+    return this.#media.streams;
+  }
+  remoteMedia(participantId) {
+    return this.#delivery.remoteMedia(participantId);
+  }
+  mediaConnectionStatus(participantId) {
+    return this.#delivery.connectionStatus(participantId);
+  }
+  join() {
+    if (this.#state === "closed") return Promise.reject(new MeetingError("engine_closed"));
+    if (this.#state !== "idle") return Promise.reject(new MeetingError("already_joined"));
+    const token = this.#token;
+    if (!this.#env.WebSocket || token === void 0) return Promise.reject(new MeetingError("unsupported_environment"));
+    const join = deferred();
+    this.#join = join;
+    this.#setState("connecting");
+    if (!this.#is("connecting")) return join.promise;
+    this.#joinTimer = this.#env.setTimeout(() => this.#failJoin(new MeetingError("join_timeout")), this.#joinTimeoutMs);
+    this.#openSession(token);
+    return join.promise;
+  }
+  leave() {
+    switch (this.#state) {
+      case "idle":
+      case "closed":
+        return Promise.resolve();
+      case "leaving":
+        return this.#leave?.promise ?? Promise.resolve();
+      case "connecting":
+      case "joining":
+        this.#failJoin(new MeetingError("join_cancelled"));
+        return Promise.resolve();
+      case "reconnecting":
+        this.#cancelReconnect("left");
+        this.#finish("left");
+        return Promise.resolve();
+      case "joined":
+        break;
+    }
+    const leave = deferred();
+    this.#leave = leave;
+    this.#media.releaseAll();
+    this.#releaseRemoteMedia();
+    this.#setState("leaving");
+    if (!this.#is("leaving")) return leave.promise;
+    if (!this.#session?.send("participant.leave")) {
+      this.#finish("left");
+      return leave.promise;
+    }
+    this.#leaveTimer = this.#env.setTimeout(() => this.#finish("left"), LEAVE_FALLBACK_MS);
+    return leave.promise;
+  }
+  endMeeting() {
+    if (this.#state !== "joined") return Promise.reject(new MeetingError("not_joined"));
+    if (this.#role !== "host") return Promise.reject(new MeetingError("not_permitted"));
+    if (this.#endMeeting) return this.#endMeeting.promise;
+    const pending = deferred();
+    this.#endMeeting = pending;
+    if (!this.#session?.send("meeting.end")) {
+      this.#endMeeting = void 0;
+      return Promise.reject(new MeetingError("service_unavailable"));
+    }
+    this.#endMeetingTimer = this.#env.setTimeout(() => {
+      const p = this.#endMeeting;
+      this.#endMeeting = void 0;
+      this.#endMeetingTimer = void 0;
+      p?.reject(new MeetingError("service_unavailable"));
+    }, END_MEETING_TIMEOUT_MS);
+    return pending.promise;
+  }
+  enableCamera(options) {
+    return this.#mediaCall("camera", true, options?.deviceId);
+  }
+  disableCamera() {
+    return this.#mediaCall("camera", false);
+  }
+  mute() {
+    return this.#mediaCall("microphone", false);
+  }
+  unmute(options) {
+    return this.#mediaCall("microphone", true, options?.deviceId);
+  }
+  startScreenShare() {
+    return this.#mediaCall("screen", true);
+  }
+  stopScreenShare() {
+    return this.#mediaCall("screen", false);
+  }
+  on(type, listener) {
+    if (this.#disposed) return () => void 0;
+    return this.#emitter.on(type, listener);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#removeVisibilityListener();
+    this.#emitter.clear();
+    const end = this.#endMeeting;
+    this.#endMeeting = void 0;
+    this.#cancelReconnect("hard_failure");
+    this.#teardown();
+    this.#state = "closed";
+    const join = this.#join;
+    this.#join = void 0;
+    if (join) {
+      join.promise.catch(() => void 0);
+      join.reject(new MeetingError("join_cancelled"));
+    }
+    this.#leave?.resolve();
+    end?.reject(new MeetingError("engine_closed"));
+  }
+  #mediaCall(kind, enabled, deviceId) {
+    if (this.#state !== "joined") return Promise.reject(new MeetingError("not_joined"));
+    if (kind === "screen") {
+      const type = enabled ? "media.screen.started" : "media.screen.stopped";
+      if (this.#role === void 0 || !isRoleAllowed(type, this.#role)) {
+        return Promise.reject(new MeetingError("not_permitted"));
+      }
+      if (enabled && !this.#delivery.supportsScreenShare()) {
+        return Promise.reject(new MeetingError("unsupported_environment"));
+      }
+    }
+    return this.#media.set(kind, enabled, typeof deviceId === "string" && deviceId !== "" ? deviceId : void 0);
+  }
+  #announce(kind, enabled) {
+    if (this.#state !== "joined") return false;
+    const type = `media.${kind}.${enabled ? "started" : "stopped"}`;
+    if (!this.#session?.send(type)) return false;
+    if (this.#pendingRestricted?.kind === kind) this.#clearPendingRestricted();
+    if (ROLE_POLICY[type]) {
+      this.#pendingRestricted = {
+        kind,
+        timer: this.#env.setTimeout(() => {
+          this.#pendingRestricted = void 0;
+        }, RESTRICTED_PENDING_MS)
+      };
+    }
+    return true;
+  }
+  #clearPendingRestricted() {
+    if (this.#pendingRestricted) this.#env.clearTimeout(this.#pendingRestricted.timer);
+    this.#pendingRestricted = void 0;
+  }
+  #onMessage(message) {
+    const state = this.#state;
+    if (state === "closed" || state === "idle") return;
+    const from = message.participantId;
+    const isSelf = from === this.#addressing.participantId;
+    switch (message.type) {
+      case "session.authenticated": {
+        if (state === "connecting") {
+          this.#role = message.payload.role;
+          this.#setState("joining");
+          if (!this.#is("joining")) return;
+          if (!this.#session?.send("participant.join")) this.#failJoin(new MeetingError("connection_failed"));
+          return;
+        }
+        if (state === "reconnecting") {
+          this.#role = message.payload.role;
+          if (!this.#session?.send("participant.join")) this.#failReconnectOpen(new MeetingError("connection_failed"));
+        }
+        return;
+      }
+      case "session.welcome": {
+        if (state === "joining") {
+          this.#clearTimer("join");
+          this.#roster.commit();
+          const payload = message.payload;
+          const self = {
+            id: this.#addressing.participantId,
+            role: payload.role,
+            joinedAt: payload.joinedAt
+          };
+          if (payload.displayName !== void 0) self.displayName = payload.displayName;
+          this.#self = Object.freeze(self);
+          this.#role = payload.role;
+          const join = this.#join;
+          this.#join = void 0;
+          this.#setState("joined");
+          this.#emit("joined", { self: this.#self, participants: this.#roster.list() });
+          join?.resolve();
+          if (this.#is("joined")) {
+            const expiresAt = payload.iceServersExpireAt !== void 0 ? Date.parse(payload.iceServersExpireAt) : NaN;
+            this.#startDelivery(payload.mediaMode, payload.iceServers ?? [], Number.isFinite(expiresAt) ? expiresAt : null);
+          }
+          return;
+        }
+        if (state === "reconnecting") {
+          this.#completeReconnectWelcome(message);
+        }
+        return;
+      }
+      case "session.ice_servers": {
+        if (!this.#is("joined")) {
+          this.#log.debug("frame ignored", { messageType: message.type, state });
+          return;
+        }
+        const expiresAt = Date.parse(message.payload.expiresAt);
+        if (Number.isFinite(expiresAt)) this.#delivery.iceServersUpdated(message.payload.iceServers, expiresAt);
+        return;
+      }
+      case "participant.joined": {
+        if (isSelf || state === "connecting") return;
+        const result = this.#roster.upsertJoined(from, message.payload.role, message.payload.displayName);
+        if (state === "reconnecting") return;
+        const participant = this.#roster.get(from);
+        if (result === "added" && participant) {
+          this.#emit("participant_joined", { participant });
+          const present = this.#roster.committed && this.#is("joined") ? this.#roster.get(from) : void 0;
+          if (present) this.#delivery.peerPresent(from, present.media);
+        }
+        return;
+      }
+      case "participant.left": {
+        if (isSelf || state === "connecting" || state === "reconnecting") return;
+        if (this.#roster.remove(from) && this.#roster.committed) {
+          this.#delivery.peerLeft(from);
+          this.#emit("participant_left", { participantId: from, reason: mapLeftReason(message.payload.reason) });
+        }
+        return;
+      }
+      case "participant.reconnected": {
+        if (isSelf || !this.#roster.committed) return;
+        if (!this.#roster.get(from)) {
+          this.#roster.upsertJoined(from, "participant");
+          const restored = this.#roster.get(from);
+          if (restored && this.#is("joined")) this.#delivery.peerPresent(from, restored.media);
+        }
+        this.#delivery.peerReconnected(from);
+        this.#emit("participant_reconnected", { participantId: from });
+        return;
+      }
+      case "media.camera.started":
+      case "media.camera.stopped":
+      case "media.microphone.started":
+      case "media.microphone.stopped":
+      case "media.screen.started":
+      case "media.screen.stopped": {
+        const change = mediaFrame(message.type);
+        if (isSelf || state === "connecting" || !change) return;
+        if (this.#roster.setMedia(from, change.kind, change.enabled) && this.#roster.committed) {
+          this.#emit("participant_media_changed", { participantId: from, kind: change.kind, enabled: change.enabled });
+          this.#delivery.peerMediaChanged(from, change.kind, change.enabled);
+        }
+        return;
+      }
+      case "meeting.ended":
+      case "meeting.terminated": {
+        this.#log.info("meeting ended", { messageType: message.type });
+        if (state === "connecting" || state === "joining") this.#failJoin(new MeetingError("meeting_ended"));
+        else {
+          this.#cancelReconnect("meeting_ended");
+          this.#finish("meeting_ended");
+        }
+        return;
+      }
+      case "session.rejected": {
+        const payload = message.payload;
+        const isEndMeetingRejection = payload.ref_type === "meeting.end" || payload.refType === "meeting.end" || this.#endMeeting !== void 0;
+        if (this.#endMeeting && isEndMeetingRejection) {
+          const pending = this.#endMeeting;
+          this.#clearEndMeetingTimer();
+          this.#endMeeting = void 0;
+          let mappedCode = "service_unavailable";
+          if (payload.code === "role_not_allowed") mappedCode = "not_permitted";
+          else if (payload.code === "rate_limited") mappedCode = "rate_limited";
+          pending.reject(new MeetingError(mappedCode));
+          return;
+        }
+        this.#onRejected(payload.code);
+        return;
+      }
+      case "webrtc.offer":
+      case "webrtc.answer":
+      case "webrtc.ice_candidate":
+      case "webrtc.ice_restart":
+        this.#delivery.onPeerFrame(message);
+        return;
+      default:
+        this.#log.debug("frame ignored", { messageType: message.type });
+    }
+  }
+  #startDelivery(mediaMode, iceServers2, iceServersExpireAt) {
+    const delivery = this.#createDelivery(mediaMode, { env: this.#env, log: this.#log });
+    this.#delivery = delivery;
+    delivery.attach({
+      participantId: this.#addressing.participantId,
+      iceServers: iceServers2,
+      iceServersExpireAt,
+      send: (type, payload) => this.#delivery === delivery && (this.#session?.sendPeer(type, payload) ?? false),
+      emit: (type, event) => {
+        if (this.#delivery === delivery) this.#emit(type, event);
+      }
+    });
+    const local = this.#media.streams;
+    for (const kind of MEDIA_KINDS) {
+      const stream = local[kind];
+      if (stream) delivery.localMediaChanged(kind, stream);
+    }
+    if (this.#delivery !== delivery || !this.#is("joined")) return;
+    delivery.peersPresent(this.#roster.list().map((participant) => ({ id: participant.id, media: participant.media })));
+  }
+  /** Reports every remote media and connection status as gone, then closes the delivery. */
+  #releaseRemoteMedia() {
+    const delivery = this.#delivery;
+    for (const participant of this.#roster.list()) {
+      const media = delivery.remoteMedia(participant.id);
+      for (const kind of MEDIA_KINDS) {
+        if (media[kind]) this.#emit("remote_media_changed", { participantId: participant.id, kind, stream: null });
+      }
+      if (delivery.connectionStatus(participant.id) !== null) {
+        this.#emit("media_connection_changed", { participantId: participant.id, status: null });
+      }
+    }
+    delivery.close();
+  }
+  #onRejected(code) {
+    const error = mapRejection(code);
+    if (this.#state === "connecting" || this.#state === "joining") {
+      this.#failJoin(error);
+      return;
+    }
+    if (this.#state === "reconnecting" && this.#reconnectOpen) {
+      const session = this.#session;
+      this.#session = void 0;
+      session?.close();
+      this.#failReconnectOpen(error, error.retryable);
+      return;
+    }
+    if (code === "role_not_allowed") {
+      const pending = this.#pendingRestricted;
+      this.#clearPendingRestricted();
+      if (pending) this.#media.rollback(pending.kind);
+    }
+    this.#log.warn("request rejected", { code: error.code });
+    this.#emit("error", { error });
+  }
+  #onProtocolError() {
+    if (this.#state === "closed") return;
+    this.#emit("error", { error: new MeetingError("protocol_error") });
+  }
+  #onClose(session, code) {
+    if (this.#session !== session) return;
+    this.#session = void 0;
+    this.#log.info("connection closed", { closeCode: code });
+    switch (this.#state) {
+      case "connecting":
+      case "joining": {
+        const { error } = mapClose(code, "before_joined");
+        this.#failJoin(error ?? new MeetingError("connection_failed"));
+        return;
+      }
+      case "joined": {
+        const { reason, error } = mapClose(code, "after_joined");
+        if (reason === "left" || reason === "meeting_ended" || reason === "session_replaced") {
+          this.#finish(reason, error);
+          return;
+        }
+        if (this.#isRecoverableClose(reason, error)) {
+          this.#beginRecovery("meeting_service");
+          return;
+        }
+        this.#finish(reason, error);
+        return;
+      }
+      case "reconnecting": {
+        const { reason, error } = mapClose(code, "after_joined");
+        if (reason === "meeting_ended" || reason === "session_replaced") {
+          this.#cancelReconnect(reason === "meeting_ended" ? "meeting_ended" : "session_replaced");
+          this.#finish(reason, error);
+          return;
+        }
+        if (reason === "left") {
+          this.#cancelReconnect("left");
+          this.#finish("left");
+          return;
+        }
+        const tokenFailure = error?.code === "join_token_expired" || error?.code === "join_token_invalid";
+        if (tokenFailure) this.#token = void 0;
+        const retry = tokenFailure || this.#isRecoverableClose(reason, error);
+        this.#failReconnectOpen(error ?? new MeetingError("connection_lost"), retry);
+        return;
+      }
+      case "leaving":
+        this.#finish("left");
+        return;
+      default:
+        return;
+    }
+  }
+  #failJoin(error) {
+    if (this.#state !== "connecting" && this.#state !== "joining") return;
+    const join = this.#join;
+    this.#join = void 0;
+    this.#teardown();
+    this.#log.warn("join failed", { code: error.code });
+    this.#setState("closed");
+    this.#emit("closed", { reason: "join_failed", error });
+    join?.reject(error);
+  }
+  #finish(reason, error) {
+    if (this.#state === "closed") return;
+    const end = this.#endMeeting;
+    this.#endMeeting = void 0;
+    this.#cancelReconnect(
+      reason === "meeting_ended" ? "meeting_ended" : reason === "session_replaced" ? "session_replaced" : reason === "left" ? "left" : "hard_failure"
+    );
+    this.#teardown();
+    this.#setState("closed");
+    this.#emit("closed", error ? { reason, error } : { reason });
+    this.#leave?.resolve();
+    if (end) {
+      if (reason === "meeting_ended") end.resolve();
+      else end.reject(error ?? new MeetingError("engine_closed"));
+    }
+  }
+  #teardown() {
+    this.#clearTimer("join");
+    this.#clearTimer("leave");
+    this.#clearEndMeetingTimer();
+    this.#clearPendingRestricted();
+    this.#media.releaseAll();
+    this.#delivery.close();
+    const session = this.#session;
+    this.#session = void 0;
+    session?.close();
+    this.#roster.clear();
+    this.#reconnectOpen = void 0;
+    this.#reconnectOutcome = void 0;
+    this.#preRecoveryParticipants = void 0;
+  }
+  #isRecoverableClose(reason, error) {
+    if (reason === "connection_lost") return true;
+    if (reason === "error" && error?.code === "service_unavailable") return true;
+    return false;
+  }
+  #beginRecovery(trigger) {
+    if (this.#state !== "joined" && this.#state !== "reconnecting") return;
+    if (this.#endMeeting) {
+      const end = this.#endMeeting;
+      this.#endMeeting = void 0;
+      this.#clearEndMeetingTimer();
+      end.reject(new MeetingError("connection_lost"));
+    }
+    if (this.#state === "joined") this.#preRecoveryParticipants = this.#roster.list();
+    this.#pauseDeliveryForRecovery();
+    this.#setState("reconnecting");
+    if (!this.#is("reconnecting")) return;
+    if (!this.#reconnect) {
+      this.#reconnect = new ReconnectController({
+        env: this.#env,
+        logger: this.#logger,
+        windowMs: this.#reconnectWindowMs,
+        open: () => this.#reconnectOpenAttempt(),
+        onAbandoned: (reason) => this.#onReconnectAbandoned(reason)
+      });
+    }
+    this.#reconnect.start(trigger);
+  }
+  #pauseDeliveryForRecovery() {
+    const delivery = this.#delivery;
+    for (const participant of this.#roster.list()) {
+      const media = delivery.remoteMedia(participant.id);
+      for (const kind of MEDIA_KINDS) {
+        if (media[kind]) this.#emit("remote_media_changed", { participantId: participant.id, kind, stream: null });
+      }
+      if (delivery.connectionStatus(participant.id) !== null) {
+        this.#emit("media_connection_changed", { participantId: participant.id, status: null });
+      }
+    }
+    delivery.close();
+    this.#delivery = new SignalingOnlyMediaDelivery();
+  }
+  async #reconnectOpenAttempt() {
+    if (this.#state !== "reconnecting" || this.#disposed) return "cancelled";
+    let token;
+    try {
+      token = await this.#resolveReconnectToken();
+    } catch (error) {
+      const meetingError = error instanceof MeetingError ? error : new MeetingError("join_token_invalid");
+      this.#log.warn("reconnect token refresh failed", { code: meetingError.code });
+      this.#pendingAbandonReason = "token_refresh_failed";
+      return "failed";
+    }
+    this.#roster.reset();
+    this.#reconnectOutcome = void 0;
+    const open = deferred();
+    this.#reconnectOpen = open;
+    const attemptTimer = this.#env.setTimeout(() => {
+      if (this.#reconnectOpen !== open) return;
+      const session = this.#session;
+      this.#session = void 0;
+      session?.close();
+      this.#failReconnectOpen(new MeetingError("join_timeout"), true);
+    }, this.#joinTimeoutMs);
+    this.#openSession(token);
+    try {
+      await open.promise;
+    } catch {
+    } finally {
+      this.#env.clearTimeout(attemptTimer);
+    }
+    if (this.#state !== "reconnecting" && this.#state !== "joined") {
+      return this.#reconnectOutcome ?? "cancelled";
+    }
+    return this.#reconnectOutcome ?? "failed";
+  }
+  async #resolveReconnectToken() {
+    const current = this.#token;
+    if (current !== void 0 && isJoinTokenUsable(current, this.#env.now())) return current;
+    const refresh = this.#getJoinToken;
+    if (!refresh) throw new MeetingError("join_token_expired");
+    const next = await refresh();
+    if (typeof next !== "string" || next.length === 0) throw new MeetingError("join_token_invalid");
+    const addressing = decodeAddressing(next);
+    if (addressing.meetingId !== this.#addressing.meetingId || addressing.participantId !== this.#addressing.participantId) {
+      throw new MeetingError("join_token_invalid");
+    }
+    this.#token = next;
+    return next;
+  }
+  #openSession(token) {
+    const session = new SignalingSession({
+      env: this.#env,
+      realtimeUrl: this.#realtimeUrl,
+      token,
+      addressing: this.#addressing,
+      log: this.#log,
+      callbacks: {
+        onMessage: (message) => this.#onMessage(message),
+        onProtocolError: () => this.#onProtocolError(),
+        onClose: (code) => this.#onClose(session, code)
+      }
+    });
+    this.#session = session;
+    session.open();
+  }
+  #completeReconnectWelcome(message) {
+    const payload = message.payload;
+    if (message.participantId !== this.#addressing.participantId) {
+      this.#failReconnectOpen(new MeetingError("protocol_error"));
+      return;
+    }
+    this.#roster.commit();
+    const self = {
+      id: this.#addressing.participantId,
+      role: payload.role,
+      joinedAt: payload.joinedAt
+    };
+    if (payload.displayName !== void 0) self.displayName = payload.displayName;
+    this.#self = Object.freeze(self);
+    this.#role = payload.role;
+    this.#reconnectOutcome = "recovered";
+    const open = this.#reconnectOpen;
+    this.#reconnectOpen = void 0;
+    this.#setState("joined");
+    open?.resolve();
+    if (!this.#is("joined")) {
+      this.#preRecoveryParticipants = void 0;
+      return;
+    }
+    this.#emitRecoveryRosterDiff();
+    if (!this.#is("joined")) return;
+    const expiresAt = payload.iceServersExpireAt !== void 0 ? Date.parse(payload.iceServersExpireAt) : NaN;
+    this.#startDelivery(payload.mediaMode, payload.iceServers ?? [], Number.isFinite(expiresAt) ? expiresAt : null);
+  }
+  /** Announce peers who joined or left during the outage; leave survivors quiet (no join/leave flash). */
+  #emitRecoveryRosterDiff() {
+    const previous = this.#preRecoveryParticipants ?? [];
+    this.#preRecoveryParticipants = void 0;
+    const previousIds = new Set(previous.map((participant) => participant.id));
+    const next = this.#roster.list();
+    const nextIds = new Set(next.map((participant) => participant.id));
+    for (const id of previousIds) {
+      if (!nextIds.has(id)) this.#emit("participant_left", { participantId: id, reason: "disconnected" });
+    }
+    for (const participant of next) {
+      if (!previousIds.has(participant.id)) this.#emit("participant_joined", { participant });
+    }
+  }
+  #failReconnectOpen(error, retry = false) {
+    const open = this.#reconnectOpen;
+    if (!open) return;
+    this.#reconnectOpen = void 0;
+    this.#reconnectOutcome = retry ? "retry" : "failed";
+    if (!retry) this.#log.warn("reconnect open failed", { code: error.code });
+    open.resolve();
+  }
+  #onReconnectAbandoned(reason) {
+    if (this.#state === "closed") return;
+    const actual = this.#pendingAbandonReason ?? reason;
+    this.#pendingAbandonReason = void 0;
+    this.#preRecoveryParticipants = void 0;
+    this.#reconnect = void 0;
+    if (actual === "meeting_ended") {
+      this.#finish("meeting_ended");
+      return;
+    }
+    if (actual === "session_replaced") {
+      this.#finish("session_replaced", new MeetingError("session_replaced"));
+      return;
+    }
+    if (actual === "left") {
+      this.#finish("left");
+      return;
+    }
+    const error = actual === "token_refresh_failed" ? new MeetingError("join_token_expired") : new MeetingError("connection_lost");
+    this.#finish("connection_lost", error);
+  }
+  #cancelReconnect(reason) {
+    const controller = this.#reconnect;
+    this.#reconnect = void 0;
+    this.#preRecoveryParticipants = void 0;
+    if (this.#reconnectOpen) {
+      this.#reconnectOutcome = "cancelled";
+      const open = this.#reconnectOpen;
+      this.#reconnectOpen = void 0;
+      open.resolve();
+    }
+    controller?.cancel(reason);
+  }
+  #installVisibilityListener() {
+    const doc = globalThis.document;
+    if (!doc || typeof doc.addEventListener !== "function") return;
+    this.#onVisibility = () => {
+      if (doc.visibilityState !== "visible" || this.#disposed) return;
+      if (this.#state === "reconnecting") {
+        if (this.#reconnect && !this.#reconnect.active) this.#reconnect.start("visibility");
+        return;
+      }
+      if (this.#state === "joined" && this.#session === void 0) {
+        this.#beginRecovery("visibility");
+      }
+    };
+    doc.addEventListener("visibilitychange", this.#onVisibility);
+  }
+  #removeVisibilityListener() {
+    const doc = globalThis.document;
+    const handler = this.#onVisibility;
+    this.#onVisibility = void 0;
+    if (doc && handler && typeof doc.removeEventListener === "function") {
+      doc.removeEventListener("visibilitychange", handler);
+    }
+  }
+  #clearEndMeetingTimer() {
+    if (this.#endMeetingTimer !== void 0) this.#env.clearTimeout(this.#endMeetingTimer);
+    this.#endMeetingTimer = void 0;
+  }
+  #clearTimer(which) {
+    const handle = which === "join" ? this.#joinTimer : this.#leaveTimer;
+    if (handle !== void 0) this.#env.clearTimeout(handle);
+    if (which === "join") this.#joinTimer = void 0;
+    else this.#leaveTimer = void 0;
+  }
+  /** Re-reads the state after emitting, since listeners may have changed it. */
+  #is(state) {
+    return this.#state === state;
+  }
+  #setState(next) {
+    const previous = this.#state;
+    if (previous === next) return;
+    this.#state = next;
+    this.#log.info("state changed", { state: next });
+    this.#emit("state_changed", { state: next, previous });
+  }
+  #emit(type, event) {
+    if (!this.#disposed) this.#emitter.emit(type, event);
+  }
+};
+
+// src/internal/selectedPair.ts
+function selectedCandidatePairReport(reports) {
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  const selectedId = reports.find((r) => r.type === "transport" && r.selectedCandidatePairId)?.selectedCandidatePairId;
+  return (selectedId ? byId.get(selectedId) : void 0) ?? reports.find((r) => r.type === "candidate-pair" && r.state === "succeeded" && r.nominated === true);
+}
+async function selectedPair(pc) {
+  const reports = await statsOf(pc);
+  if (!reports) return null;
+  const pair = selectedCandidatePairReport(reports);
+  if (!pair?.localCandidateId || !pair.remoteCandidateId) return null;
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  const localType = byId.get(pair.localCandidateId)?.candidateType;
+  const remoteType = byId.get(pair.remoteCandidateId)?.candidateType;
+  if (!localType || !remoteType) return null;
+  return { localId: pair.localCandidateId, localType, remoteType };
+}
+async function localCandidateIds(pc) {
+  const reports = await statsOf(pc);
+  if (!reports) return null;
+  return new Set(reports.filter((r) => r.type === "local-candidate").map((r) => r.id));
+}
+async function statsOf(pc) {
+  try {
+    const collection = await pc.getStats();
+    const reports = [];
+    collection.forEach((report) => reports.push(report));
+    return reports;
+  } catch {
+    return null;
+  }
+}
+function pathReport(pair) {
+  const localPath = kindOf(pair.localType);
+  const remotePath = kindOf(pair.remoteType);
+  return { path: localPath === "relayed" || remotePath === "relayed" ? "relayed" : "direct", localPath, remotePath };
+}
+function samePath(a, b) {
+  return a.path === b.path && a.localPath === b.localPath && a.remotePath === b.remotePath;
+}
+function kindOf(candidateType) {
+  return candidateType === "relay" ? "relayed" : "direct";
+}
+
+// src/internal/qualitySample.ts
+var QUALITY_SAMPLE_INTERVAL_MS = 5e3;
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function nonNegative(value) {
+  return value !== void 0 && value >= 0 ? value : void 0;
+}
+async function collectReports(pc) {
+  try {
+    const collection = await pc.getStats();
+    const reports = [];
+    collection.forEach((report) => reports.push(report));
+    return reports;
+  } catch {
+    return null;
+  }
+}
+function pickRttMs(reports) {
+  const pair = selectedCandidatePairReport(reports);
+  if (pair) {
+    const seconds = finiteNumber(pair.currentRoundTripTime);
+    if (seconds !== void 0) return nonNegative(seconds * 1e3);
+  }
+  for (const report of reports) {
+    if (report.type === "remote-inbound-rtp") {
+      const seconds = finiteNumber(report.roundTripTime);
+      if (seconds !== void 0) return nonNegative(seconds * 1e3);
+    }
+  }
+  return void 0;
+}
+function pickJitterMs(reports) {
+  for (const report of reports) {
+    if (report.type === "inbound-rtp") {
+      const seconds = finiteNumber(report.jitter);
+      if (seconds !== void 0) return nonNegative(seconds * 1e3);
+    }
+  }
+  return void 0;
+}
+function pickPacketLossRatio(reports) {
+  let lost = 0;
+  let received = 0;
+  let saw = false;
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp") continue;
+    const packetsLost = finiteNumber(report.packetsLost);
+    const packetsReceived = finiteNumber(report.packetsReceived);
+    if (packetsLost === void 0 && packetsReceived === void 0) continue;
+    saw = true;
+    lost += Math.max(0, packetsLost ?? 0);
+    received += Math.max(0, packetsReceived ?? 0);
+  }
+  if (!saw) return void 0;
+  const total = lost + received;
+  if (total <= 0) return 0;
+  return Math.min(1, lost / total);
+}
+function sumBytes(reports, type, key) {
+  let total = 0;
+  let saw = false;
+  for (const report of reports) {
+    if (report.type !== type) continue;
+    const value = finiteNumber(report[key]);
+    if (value === void 0) continue;
+    saw = true;
+    total += Math.max(0, value);
+  }
+  return saw ? total : void 0;
+}
+function bitrateBps(current, previous, elapsedMs) {
+  if (current === void 0 || previous === void 0 || elapsedMs <= 0) return void 0;
+  const delta = current - previous;
+  if (delta < 0) return void 0;
+  return delta * 8 * 1e3 / elapsedMs;
+}
+function pickFrames(reports) {
+  let framesDropped;
+  let frameWidth;
+  let frameHeight;
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp") continue;
+    const dropped = finiteNumber(report.framesDropped);
+    if (dropped !== void 0 && dropped >= 0) framesDropped = (framesDropped ?? 0) + dropped;
+    const width = finiteNumber(report.frameWidth);
+    const height = finiteNumber(report.frameHeight);
+    if (width !== void 0 && width > 0) frameWidth = width;
+    if (height !== void 0 && height > 0) frameHeight = height;
+  }
+  return {
+    ...framesDropped !== void 0 ? { framesDropped } : {},
+    ...frameWidth !== void 0 ? { frameWidth } : {},
+    ...frameHeight !== void 0 ? { frameHeight } : {}
+  };
+}
+function isQualityCodecToken(value) {
+  if (value.length === 0 || value.length > MAX_QUALITY_CODEC_LENGTH) return false;
+  if (value.includes("\r\n") || value.includes("\n")) return false;
+  if (/^v=0/i.test(value) || /^candidate:/i.test(value) || /\bIN IP[46]\b/i.test(value)) return false;
+  return /^[a-zA-Z0-9._+/-]+$/.test(value);
+}
+function pickCodec(reports) {
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp" && report.type !== "outbound-rtp") continue;
+    const codecId = report.codecId;
+    if (!codecId) continue;
+    const mime = byId.get(codecId)?.mimeType;
+    if (typeof mime === "string" && isQualityCodecToken(mime)) return mime;
+  }
+  for (const report of reports) {
+    if (report.type === "codec" && typeof report.mimeType === "string" && isQualityCodecToken(report.mimeType)) {
+      return report.mimeType;
+    }
+  }
+  return void 0;
+}
+async function buildQualitySample(pc, options) {
+  const sampledAt = new Date(options.nowMs).toISOString();
+  const base = {
+    connectionState: options.connectionState,
+    sampledAt
+  };
+  const reports = await collectReports(pc);
+  if (!reports) {
+    return { sample: { ...base, incomplete: true }, bytes: options.previous ?? null };
+  }
+  const rttMs = pickRttMs(reports);
+  const jitterMs = pickJitterMs(reports);
+  const packetLossRatio = pickPacketLossRatio(reports);
+  const bytesSent = sumBytes(reports, "outbound-rtp", "bytesSent");
+  const bytesReceived = sumBytes(reports, "inbound-rtp", "bytesReceived");
+  const elapsedMs = options.previous ? Math.max(0, options.nowMs - options.previous.atMs) : 0;
+  const sendBitrateBps = bitrateBps(bytesSent, options.previous?.sent, elapsedMs);
+  const receiveBitrateBps = bitrateBps(bytesReceived, options.previous?.received, elapsedMs);
+  const frames = pickFrames(reports);
+  const codec = pickCodec(reports);
+  let iceLocalCandidateType;
+  let iceRemoteCandidateType;
+  let pathFields = {};
+  try {
+    const pair = await selectedPair(pc);
+    if (pair) {
+      iceLocalCandidateType = pair.localType;
+      iceRemoteCandidateType = pair.remoteType;
+      pathFields = pathReport(pair);
+    }
+  } catch {
+  }
+  const hasCore = rttMs !== void 0 && jitterMs !== void 0 && packetLossRatio !== void 0 && sendBitrateBps !== void 0 && receiveBitrateBps !== void 0 && iceLocalCandidateType !== void 0;
+  const sample = {
+    ...base,
+    ...rttMs !== void 0 ? { rttMs } : {},
+    ...jitterMs !== void 0 ? { jitterMs } : {},
+    ...packetLossRatio !== void 0 ? { packetLossRatio } : {},
+    ...sendBitrateBps !== void 0 ? { sendBitrateBps } : {},
+    ...receiveBitrateBps !== void 0 ? { receiveBitrateBps } : {},
+    ...iceLocalCandidateType ? { iceLocalCandidateType } : {},
+    ...iceRemoteCandidateType ? { iceRemoteCandidateType } : {},
+    ...pathFields,
+    ...frames,
+    ...codec ? { codec } : {},
+    ...!hasCore ? { incomplete: true } : {}
+  };
+  const bytes = bytesSent !== void 0 || bytesReceived !== void 0 ? {
+    sent: bytesSent ?? options.previous?.sent ?? 0,
+    received: bytesReceived ?? options.previous?.received ?? 0,
+    atMs: options.nowMs
+  } : options.previous ?? null;
+  return { sample, bytes };
+}
+
+// src/internal/peerLink.ts
+var MAX_QUEUED_CANDIDATES = 64;
+var CONNECTION_TIMEOUT_MS = 3e4;
+var SWITCH_ATTEMPT_TIMEOUT_MS = 15e3;
+var SWITCH_RETRY_DELAYS_MS = [5e3, 1e4, 2e4];
+var SWITCH_DEADLINE_MARGIN_MS = 5e3;
+var SWITCH_POLL_MS = 1e3;
+var SWITCH_INTERRUPTION_HOLD_MS = 5e3;
+var INTERRUPTION_RESTART_HOLD_MS = 3e3;
+var PATH_RECHECK_DELAYS_MS = [2e3, 1e4];
+var PATH_RECHECK_INTERVAL_MS = 3e4;
+function copyServers(iceServers2) {
+  return iceServers2.map((server) => {
+    const copy = { urls: [...server.urls] };
+    if (server.username !== void 0) copy.username = server.username;
+    if (server.credential !== void 0) copy.credential = server.credential;
+    return copy;
+  });
+}
+function roleFor(selfId, peerId) {
+  return selfId < peerId ? "offerer" : "answerer";
+}
+function coarseState(pc) {
+  const state = typeof pc.connectionState === "string" ? pc.connectionState : pc.iceConnectionState;
+  switch (state) {
+    case "connected":
+    case "completed":
+      return "connected";
+    case "disconnected":
+      return "disconnected";
+    case "failed":
+      return "failed";
+    case "closed":
+      return "closed";
+    default:
+      return "connecting";
+  }
+}
+var PeerLink = class {
+  peerId;
+  role;
+  #status = "connecting";
+  #everConnected = false;
+  #closed = false;
+  #pc;
+  #env;
+  #log;
+  #callbacks;
+  #local;
+  #queued = [];
+  #remoteDescriptionSet = false;
+  #offerHandled = false;
+  #audio;
+  #video;
+  #screen;
+  #streams = { camera: null, microphone: null, screen: null };
+  #timer;
+  #chain = Promise.resolve();
+  #switch = null;
+  #restarting = false;
+  #interruptionHold;
+  #restartHold;
+  /** Local candidates gathered while an offer is being created; sent after it so the other side sees it first. */
+  #heldLocal = null;
+  #remoteOrigin;
+  #lastReport = null;
+  #recheckTimer;
+  #qualityTimer;
+  #qualityBytes = null;
+  #qualityRunning = false;
+  /** Throws when the connection cannot be created; the owner treats that as a negotiation failure. */
+  constructor(options) {
+    this.peerId = options.peerId;
+    this.role = roleFor(options.selfId, options.peerId);
+    this.#env = options.env;
+    this.#log = options.log;
+    this.#callbacks = options.callbacks;
+    const { local } = options;
+    this.#local = { ...local };
+    const PeerConnection = options.env.RTCPeerConnection;
+    if (!PeerConnection) throw new Error("peer connections unavailable");
+    this.#pc = new PeerConnection({ iceServers: copyServers(options.iceServers) });
+    this.#pc.onicecandidate = (event) => this.#onLocalCandidate(event.candidate);
+    this.#pc.onconnectionstatechange = () => this.#onStateChange();
+    this.#pc.oniceconnectionstatechange = () => {
+      if (typeof this.#pc.connectionState !== "string") this.#onStateChange();
+    };
+    this.#timer = this.#env.setTimeout(() => {
+      this.#timer = void 0;
+      if (!this.#everConnected) this.#fail("connection_timeout");
+    }, options.timeoutMs);
+    this.#log.debug("media connection created", { participantId: this.peerId });
+  }
+  get status() {
+    return this.#status;
+  }
+  get everConnected() {
+    return this.#everConnected;
+  }
+  /** Usable for rendering: connected at least once, and neither failed nor closed. */
+  get usable() {
+    return this.#everConnected && !this.#closed && this.#status !== "failed";
+  }
+  /** The stable stream holding the received track of `kind`, once the transceivers exist. */
+  remoteStream(kind) {
+    return this.#streams[kind];
+  }
+  /** Offerer: adds the transceivers (audio → camera → screen) and sends the offer. */
+  start() {
+    if (this.role !== "offerer" || this.#audio) return;
+    this.#run(async () => {
+      this.#audio = this.#pc.addTransceiver("audio", { direction: "sendrecv" });
+      this.#video = this.#pc.addTransceiver("video", { direction: "sendrecv" });
+      this.#screen = this.#pc.addTransceiver("video", { direction: "sendrecv" });
+      this.#bindStreams();
+      await this.#attachAll();
+      const offer = await this.#pc.createOffer();
+      this.#heldLocal = [];
+      await this.#pc.setLocalDescription(offer);
+      if (this.#closed) return;
+      this.#sendOffer(this.#pc.localDescription?.sdp ?? offer.sdp ?? "");
+    });
+  }
+  /**
+   * Answerer: applies the offer and sends the answer. A later offer (a restart) is answered when no other
+   * negotiation is in progress, keeping the transceivers and received streams; otherwise it is ignored.
+   */
+  acceptOffer(sdp2) {
+    if (this.role !== "answerer") {
+      this.#log.debug("frame ignored", { messageType: "webrtc.offer", reason: "offerer" });
+      return;
+    }
+    if (this.#offerHandled) {
+      this.#acceptReoffer(sdp2);
+      return;
+    }
+    this.#offerHandled = true;
+    this.#remoteOrigin = sessionOrigin(sdp2);
+    this.#run(async () => {
+      await this.#pc.setRemoteDescription({ type: "offer", sdp: sdp2 });
+      this.#remoteDescriptionSet = true;
+      const transceivers = this.#pc.getTransceivers();
+      this.#audio = transceivers[0];
+      this.#video = transceivers[1];
+      this.#screen = transceivers[2];
+      for (const transceiver of [this.#audio, this.#video, this.#screen]) {
+        if (transceiver) transceiver.direction = "sendrecv";
+      }
+      this.#bindStreams();
+      await this.#attachAll();
+      const answer = await this.#pc.createAnswer();
+      await this.#pc.setLocalDescription(answer);
+      if (this.#closed) return;
+      const answerSdp = this.#pc.localDescription?.sdp ?? answer.sdp ?? "";
+      this.#callbacks.sendAnswer({ targetParticipantId: this.peerId, sdp: answerSdp });
+      await this.#flushCandidates();
+    });
+  }
+  /**
+   * Answerer: whether `sdp` comes from a different connection than the one this link answered first, as when the
+   * other side replaced its connection. Such an offer needs a fresh link; a restart keeps the same origin.
+   */
+  startsNewSession(sdp2) {
+    const origin = sessionOrigin(sdp2);
+    return this.#offerHandled && this.#remoteOrigin !== void 0 && origin !== void 0 && origin !== this.#remoteOrigin;
+  }
+  /** Offerer: applies the answer while an offer is outstanding; otherwise ignored. */
+  acceptAnswer(sdp2) {
+    if (this.role !== "offerer") {
+      this.#log.debug("frame ignored", { messageType: "webrtc.answer", reason: "answerer" });
+      return;
+    }
+    this.#run(async () => {
+      if (this.#pc.signalingState !== "have-local-offer") {
+        this.#log.debug("frame ignored", { messageType: "webrtc.answer", state: this.#pc.signalingState });
+        return;
+      }
+      if (!this.#restarting) {
+        await this.#pc.setRemoteDescription({ type: "answer", sdp: sdp2 });
+        this.#remoteDescriptionSet = true;
+        await this.#flushCandidates();
+        return;
+      }
+      this.#restarting = false;
+      try {
+        await this.#pc.setRemoteDescription({ type: "answer", sdp: sdp2 });
+      } catch {
+        this.#restartFailed();
+        this.#rescheduleInterruptionRestartIfNeeded();
+        return;
+      }
+      await this.#flushCandidates();
+      this.#rescheduleInterruptionRestartIfNeeded();
+    });
+  }
+  /** Replaces the server list for future candidate gathering. The current connection is untouched. */
+  updateIceServers(iceServers2) {
+    if (this.#closed) return;
+    try {
+      this.#pc.setConfiguration({ ...this.#pc.getConfiguration(), iceServers: copyServers(iceServers2) });
+    } catch {
+      this.#log.debug("negotiation step failed", { participantId: this.peerId, reason: "configuration" });
+    }
+  }
+  /**
+   * Moves to fresh candidates before `deadlineMs` when this side sends through a relay, whose allocation is tied to
+   * the credentials about to expire. Direct paths and links that are not connected are left alone.
+   */
+  planSwitch(deadlineMs) {
+    if (this.#closed || this.#status !== "connected") return;
+    const active = this.#switch;
+    if (active) {
+      active.deadline = deadlineMs;
+      return;
+    }
+    void selectedPair(this.#pc).then((pair) => {
+      if (this.#closed || this.#switch || this.#status !== "connected" || pair?.localType !== "relay") return;
+      const started = {
+        deadline: deadlineMs,
+        attempt: 0,
+        known: /* @__PURE__ */ new Set(),
+        attemptTimer: void 0,
+        pollTimer: void 0,
+        retryTimer: void 0
+      };
+      this.#switch = started;
+      this.#log.debug("media path switch started", { participantId: this.peerId });
+      void this.#beginAttempt(started);
+    });
+  }
+  /**
+   * Offerer: renegotiates with fresh candidates. Joins a restart whose answer is still outstanding instead of starting
+   * another; a restart that already finished may predate the other side's fresh servers, so it does not count.
+   */
+  restart(reason) {
+    if (this.role !== "offerer" || this.#closed || this.#restarting) return false;
+    this.#restarting = true;
+    this.#log.debug("media connection restart", { participantId: this.peerId, reason });
+    this.#chain = this.#chain.then(async () => {
+      if (this.#closed) return;
+      try {
+        const offer = await this.#pc.createOffer({ iceRestart: true });
+        this.#heldLocal = [];
+        await this.#pc.setLocalDescription(offer);
+        if (this.#closed) return;
+        this.#sendOffer(this.#pc.localDescription?.sdp ?? offer.sdp ?? "");
+      } catch {
+        this.#heldLocal = null;
+        this.#restarting = false;
+        this.#restartFailed();
+        this.#rescheduleInterruptionRestartIfNeeded();
+      }
+    });
+    return true;
+  }
+  /** The browser regained connectivity or changed networks: an offerer restarts an interrupted connection now. */
+  networkChanged() {
+    if (this.#closed || this.#status !== "interrupted" || this.role !== "offerer") return;
+    this.#clearRestartHold();
+    if (this.restart("network")) this.#callbacks.recoveryStarted("network");
+    else this.#scheduleInterruptionRestart();
+  }
+  addRemoteCandidate(candidate) {
+    if (this.#closed) return;
+    const copy = {
+      candidate: candidate.candidate,
+      sdpMid: candidate.sdpMid,
+      sdpMLineIndex: candidate.sdpMLineIndex,
+      ...candidate.usernameFragment !== void 0 ? { usernameFragment: candidate.usernameFragment } : {}
+    };
+    if (!this.#remoteDescriptionSet) {
+      if (this.#queued.length >= MAX_QUEUED_CANDIDATES) {
+        this.#log.debug("late candidate dropped", { participantId: this.peerId, reason: "queue_full" });
+        return;
+      }
+      this.#queued.push(copy);
+      return;
+    }
+    void this.#applyCandidate(copy);
+  }
+  /** Sends `track` for `kind` (or nothing for `null`). Skipped when that track is already being sent. */
+  attachLocal(kind, track) {
+    this.#local[kind] = track;
+    if (this.#closed) return;
+    const sender = (kind === "camera" ? this.#video : kind === "screen" ? this.#screen : this.#audio)?.sender;
+    if (!sender || sender.track === track) return;
+    sender.replaceTrack(track).catch(() => {
+      this.#log.debug("negotiation step failed", { participantId: this.peerId, kind, reason: "replace_track" });
+    });
+  }
+  /** Closes the connection and stops received tracks. Reports nothing. Idempotent. */
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#clearTimer();
+    this.#endSwitch();
+    this.#clearInterruptionHold();
+    this.#clearRestartHold();
+    this.#clearRecheck();
+    this.#stopQualitySampler();
+    this.#pc.onicecandidate = null;
+    this.#pc.onconnectionstatechange = null;
+    this.#pc.oniceconnectionstatechange = null;
+    for (const stream of Object.values(this.#streams)) {
+      for (const track of stream?.getTracks() ?? []) {
+        try {
+          track.stop();
+        } catch {
+        }
+      }
+    }
+    try {
+      this.#pc.close();
+    } catch {
+    }
+  }
+  #run(step) {
+    this.#chain = this.#chain.then(async () => {
+      if (this.#closed) return;
+      try {
+        await step();
+      } catch {
+        if (this.#closed) return;
+        this.#log.debug("negotiation step failed", { participantId: this.peerId });
+        this.#fail("negotiation_failed");
+      }
+    });
+  }
+  #acceptReoffer(sdp2) {
+    this.#run(async () => {
+      if (this.#pc.signalingState !== "stable") {
+        this.#log.debug("frame ignored", { messageType: "webrtc.offer", reason: "busy" });
+        return;
+      }
+      try {
+        await this.#pc.setRemoteDescription({ type: "offer", sdp: sdp2 });
+        const answer = await this.#pc.createAnswer();
+        await this.#pc.setLocalDescription(answer);
+        if (this.#closed) return;
+        const answerSdp = this.#pc.localDescription?.sdp ?? answer.sdp ?? "";
+        this.#callbacks.sendAnswer({ targetParticipantId: this.peerId, sdp: answerSdp });
+      } catch {
+        this.#restartFailed();
+        return;
+      }
+      await this.#flushCandidates();
+    });
+  }
+  /** A restart negotiation step failed: the connection stays as it is and the current attempt, if any, fails. */
+  #restartFailed() {
+    if (this.#closed) return;
+    this.#log.debug("negotiation step failed", { participantId: this.peerId, reason: "restart" });
+    const current = this.#switch;
+    if (current?.attemptTimer !== void 0) this.#attemptFailed(current);
+  }
+  async #beginAttempt(current) {
+    current.attempt += 1;
+    const known = await localCandidateIds(this.#pc);
+    if (this.#switch !== current || this.#closed) return;
+    current.known = known ?? /* @__PURE__ */ new Set();
+    current.attemptTimer = this.#env.setTimeout(() => this.#attemptFailed(current), SWITCH_ATTEMPT_TIMEOUT_MS);
+    if (this.role === "offerer") {
+      this.restart("refresh");
+    } else if (!this.#callbacks.requestRestart()) {
+      this.#endSwitch();
+      return;
+    }
+    this.#schedulePoll(current);
+  }
+  #schedulePoll(current) {
+    current.pollTimer = this.#env.setTimeout(() => {
+      current.pollTimer = void 0;
+      void this.#checkSwitch(current);
+    }, SWITCH_POLL_MS);
+  }
+  async #checkSwitch(current) {
+    if (this.#switch !== current || current.attemptTimer === void 0) return;
+    const pair = coarseState(this.#pc) === "connected" ? await selectedPair(this.#pc) : null;
+    if (this.#switch !== current || current.attemptTimer === void 0) return;
+    if (!pair || current.known.has(pair.localId)) {
+      this.#schedulePoll(current);
+      return;
+    }
+    this.#endSwitch();
+    const report = pathReport(pair);
+    this.#log.debug("media path switch completed", { participantId: this.peerId, attempt: current.attempt, ...report });
+    this.#sendPath(report);
+    this.#callbacks.switchResult("completed");
+  }
+  #attemptFailed(current) {
+    if (this.#switch !== current || this.#closed) return;
+    this.#clearSwitchTimers(current);
+    this.#restarting = false;
+    this.#rescheduleInterruptionRestartIfNeeded();
+    this.#log.debug("media path switch attempt failed", { participantId: this.peerId, attempt: current.attempt });
+    this.#callbacks.switchResult("failed");
+    if (this.#switch !== current || this.#closed) return;
+    const delay = SWITCH_RETRY_DELAYS_MS[Math.min(current.attempt, SWITCH_RETRY_DELAYS_MS.length) - 1] ?? 0;
+    if (this.#env.now() + delay >= current.deadline - SWITCH_DEADLINE_MARGIN_MS) {
+      this.#endSwitch();
+      this.#log.debug("media path switch stopped", { participantId: this.peerId, attempt: current.attempt });
+      return;
+    }
+    current.retryTimer = this.#env.setTimeout(() => {
+      current.retryTimer = void 0;
+      if (this.#switch === current && !this.#closed) void this.#beginAttempt(current);
+    }, delay);
+  }
+  #endSwitch() {
+    const current = this.#switch;
+    if (!current) return;
+    this.#switch = null;
+    this.#clearSwitchTimers(current);
+  }
+  #clearSwitchTimers(current) {
+    for (const timer of [current.attemptTimer, current.pollTimer, current.retryTimer]) {
+      if (timer !== void 0) this.#env.clearTimeout(timer);
+    }
+    current.attemptTimer = void 0;
+    current.pollTimer = void 0;
+    current.retryTimer = void 0;
+  }
+  #clearInterruptionHold() {
+    if (this.#interruptionHold !== void 0) this.#env.clearTimeout(this.#interruptionHold);
+    this.#interruptionHold = void 0;
+  }
+  #clearRestartHold() {
+    if (this.#restartHold !== void 0) this.#env.clearTimeout(this.#restartHold);
+    this.#restartHold = void 0;
+  }
+  /** When a concurrent restart ends and the link is still interrupted, arm another recovery. */
+  #rescheduleInterruptionRestartIfNeeded() {
+    if (this.#closed || this.#status !== "interrupted") return;
+    this.#scheduleInterruptionRestart();
+  }
+  /** Offerer: restarts the connection when an interruption outlasts the hold, without waiting for it to fail. */
+  #scheduleInterruptionRestart() {
+    if (this.role !== "offerer" || this.#restartHold !== void 0) return;
+    this.#restartHold = this.#env.setTimeout(() => {
+      this.#restartHold = void 0;
+      if (this.#closed || this.#status !== "interrupted" || coarseState(this.#pc) === "connected") return;
+      if (this.restart("interruption")) this.#callbacks.recoveryStarted("media");
+      else this.#scheduleInterruptionRestart();
+    }, INTERRUPTION_RESTART_HOLD_MS);
+  }
+  #bindStreams() {
+    const Stream = this.#env.MediaStream;
+    if (!Stream) return;
+    if (this.#audio && !this.#streams.microphone) this.#streams.microphone = new Stream([this.#audio.receiver.track]);
+    if (this.#video && !this.#streams.camera) this.#streams.camera = new Stream([this.#video.receiver.track]);
+    if (this.#screen && !this.#streams.screen) this.#streams.screen = new Stream([this.#screen.receiver.track]);
+  }
+  async #attachAll() {
+    const pairs = [
+      [this.#audio, this.#local.microphone],
+      [this.#video, this.#local.camera],
+      [this.#screen, this.#local.screen]
+    ];
+    for (const [transceiver, track] of pairs) {
+      if (transceiver && track && transceiver.sender.track !== track) await transceiver.sender.replaceTrack(track);
+    }
+  }
+  async #flushCandidates() {
+    for (const candidate of this.#queued.splice(0)) await this.#applyCandidate(candidate);
+  }
+  async #applyCandidate(candidate) {
+    if (this.#closed) return;
+    try {
+      await this.#pc.addIceCandidate(candidate);
+    } catch {
+      this.#log.debug("late candidate dropped", { participantId: this.peerId, reason: "rejected" });
+    }
+  }
+  /** Sends the offer, then the candidates gathered while it was being created. */
+  #sendOffer(sdp2) {
+    this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+    const held = this.#heldLocal;
+    this.#heldLocal = null;
+    for (const candidate of held ?? []) this.#callbacks.sendCandidate({ targetParticipantId: this.peerId, candidate });
+  }
+  #onLocalCandidate(candidate) {
+    if (this.#closed || !candidate || candidate.candidate === "") return;
+    const payload = {
+      candidate: candidate.candidate,
+      sdpMid: candidate.sdpMid ?? null,
+      sdpMLineIndex: candidate.sdpMLineIndex ?? null
+    };
+    if (typeof candidate.usernameFragment === "string") payload.usernameFragment = candidate.usernameFragment;
+    if (this.#heldLocal) this.#heldLocal.push(payload);
+    else this.#callbacks.sendCandidate({ targetParticipantId: this.peerId, candidate: payload });
+  }
+  #onStateChange() {
+    if (this.#closed || this.#status === "failed") return;
+    const state = coarseState(this.#pc);
+    this.#log.debug("media connection state", { participantId: this.peerId, state });
+    switch (state) {
+      case "connected":
+        this.#everConnected = true;
+        this.#clearTimer();
+        this.#clearInterruptionHold();
+        if (this.#setStatus("connected")) void this.#reportPath();
+        this.#startQualitySampler();
+        return;
+      case "disconnected":
+        if (!this.#everConnected) return;
+        if (this.#switch && this.#status === "connected") {
+          this.#interruptionHold ??= this.#env.setTimeout(() => {
+            this.#interruptionHold = void 0;
+            if (!this.#closed && coarseState(this.#pc) !== "connected") this.#setStatus("interrupted");
+          }, SWITCH_INTERRUPTION_HOLD_MS);
+          return;
+        }
+        this.#setStatus("interrupted");
+        this.#startQualitySampler();
+        return;
+      case "failed":
+        this.#fail("connection_failed");
+        return;
+      default:
+        return;
+    }
+  }
+  #qualityConnectionState() {
+    if (this.#status === "interrupted") return "interrupted";
+    if (this.#status === "failed") return "failed";
+    if (this.#status === "connected") return "connected";
+    return "connecting";
+  }
+  #startQualitySampler() {
+    if (this.#closed || this.#qualityRunning) return;
+    this.#qualityRunning = true;
+    this.#scheduleQualitySample();
+  }
+  #stopQualitySampler() {
+    this.#qualityRunning = false;
+    if (this.#qualityTimer !== void 0) this.#env.clearTimeout(this.#qualityTimer);
+    this.#qualityTimer = void 0;
+    this.#qualityBytes = null;
+  }
+  #scheduleQualitySample() {
+    if (!this.#qualityRunning || this.#closed) return;
+    this.#qualityTimer = this.#env.setTimeout(() => {
+      this.#qualityTimer = void 0;
+      void this.#emitQualitySample();
+    }, QUALITY_SAMPLE_INTERVAL_MS);
+  }
+  async #emitQualitySample() {
+    if (!this.#qualityRunning || this.#closed) return;
+    try {
+      const result = await buildQualitySample(this.#pc, {
+        connectionState: this.#qualityConnectionState(),
+        nowMs: this.#env.now(),
+        previous: this.#qualityBytes
+      });
+      if (this.#closed || !this.#qualityRunning) return;
+      this.#qualityBytes = result.bytes;
+      this.#log.debug("webrtc quality sample", {
+        participantId: this.peerId,
+        state: result.sample.connectionState,
+        ...result.sample.rttMs !== void 0 ? { rttMs: result.sample.rttMs } : {},
+        ...result.sample.jitterMs !== void 0 ? { jitterMs: result.sample.jitterMs } : {},
+        ...result.sample.packetLossRatio !== void 0 ? { packetLossRatio: result.sample.packetLossRatio } : {},
+        ...result.sample.sendBitrateBps !== void 0 ? { sendBitrateBps: result.sample.sendBitrateBps } : {},
+        ...result.sample.receiveBitrateBps !== void 0 ? { receiveBitrateBps: result.sample.receiveBitrateBps } : {},
+        ...result.sample.path ? { path: result.sample.path } : {},
+        ...result.sample.incomplete ? { incomplete: true } : {}
+      });
+      this.#callbacks.qualitySample(result.sample);
+    } catch {
+    }
+    if (!this.#closed && this.#qualityRunning) this.#scheduleQualitySample();
+  }
+  /** True when the status changed. */
+  #setStatus(status, reason) {
+    if (this.#status === status) return false;
+    this.#status = status;
+    if (status === "interrupted") this.#scheduleInterruptionRestart();
+    else this.#clearRestartHold();
+    this.#callbacks.statusChanged(status, reason);
+    return true;
+  }
+  async #reportPath() {
+    const pair = await selectedPair(this.#pc);
+    if (this.#closed || this.#status !== "connected") return;
+    this.#sendPath(pair ? pathReport(pair) : null);
+  }
+  /** Reports the path and reads it again on the recheck schedule, starting over from the first delay. */
+  #sendPath(report) {
+    this.#lastReport = report;
+    this.#callbacks.connected(report);
+    this.#scheduleRecheck(0);
+  }
+  #scheduleRecheck(step) {
+    this.#clearRecheck();
+    const at = PATH_RECHECK_DELAYS_MS[step];
+    const delay = at === void 0 ? PATH_RECHECK_INTERVAL_MS : at - (PATH_RECHECK_DELAYS_MS[step - 1] ?? 0);
+    this.#recheckTimer = this.#env.setTimeout(() => {
+      this.#recheckTimer = void 0;
+      void this.#recheckPath(step);
+    }, delay);
+  }
+  /**
+   * The browser can settle on the path after the first report, for example when the other side's relay address was
+   * first seen as peer-reflexive. A changed path is reported again; an unchanged one sends nothing.
+   */
+  async #recheckPath(step) {
+    if (this.#closed) return;
+    const idle = () => this.#status !== "connected" || this.#switch !== null;
+    const pair = idle() ? null : await selectedPair(this.#pc);
+    if (this.#closed || this.#recheckTimer !== void 0) return;
+    const report = pair && !idle() ? pathReport(pair) : null;
+    if (report && !(this.#lastReport && samePath(report, this.#lastReport))) {
+      this.#log.debug("media path updated", { participantId: this.peerId, ...report });
+      this.#sendPath(report);
+      return;
+    }
+    this.#scheduleRecheck(step + 1);
+  }
+  #clearRecheck() {
+    if (this.#recheckTimer !== void 0) this.#env.clearTimeout(this.#recheckTimer);
+    this.#recheckTimer = void 0;
+  }
+  #fail(reason) {
+    if (this.#closed || this.#status === "failed") return;
+    this.#clearTimer();
+    this.#setStatus("failed", reason);
+    this.close();
+  }
+  #clearTimer() {
+    if (this.#timer !== void 0) this.#env.clearTimeout(this.#timer);
+    this.#timer = void 0;
+  }
+};
+function sessionOrigin(sdp2) {
+  for (const line of sdp2.split(/\r?\n/)) {
+    if (line.startsWith("o=")) return line.split(" ")[1];
+  }
+  return void 0;
+}
+
+// src/internal/remoteMedia.ts
+var KINDS2 = ["camera", "microphone", "screen"];
+function computeRemoteMedia(inputs) {
+  if (!inputs.active || !inputs.usable) return NO_REMOTE_MEDIA;
+  const camera = inputs.announced.camera ? inputs.streams.camera : null;
+  const microphone = inputs.announced.microphone ? inputs.streams.microphone : null;
+  const screen = inputs.announced.screen ? inputs.streams.screen : null;
+  if (camera === null && microphone === null && screen === null) return NO_REMOTE_MEDIA;
+  return Object.freeze({ camera, microphone, screen });
+}
+var RemoteMediaTracker = class {
+  #current = /* @__PURE__ */ new Map();
+  get(participantId) {
+    return this.#current.get(participantId) ?? NO_REMOTE_MEDIA;
+  }
+  update(participantId, next, emit) {
+    const previous = this.get(participantId);
+    if (next === NO_REMOTE_MEDIA) this.#current.delete(participantId);
+    else this.#current.set(participantId, next);
+    for (const kind of KINDS2) {
+      if (previous[kind] !== next[kind]) emit({ participantId, kind, stream: next[kind] });
+    }
+  }
+  /** Forgets everything without reporting. */
+  clear() {
+    this.#current.clear();
+  }
+};
+
+// src/internal/peerMediaDelivery.ts
+var EARLY_FRAME_HOLD_MS = 5e3;
+var MAX_EARLY_CANDIDATES = 64;
+var NOTHING_ANNOUNCED = Object.freeze({ camera: false, microphone: false, screen: false });
+var PeerMediaDelivery = class {
+  #env;
+  #log;
+  #timeoutMs;
+  #recoveryWindowMs;
+  #episode = null;
+  #unsubscribeNetwork;
+  #context;
+  /** The latest server list; links created later use it. */
+  #iceServers = [];
+  /** Whether the platform relays restart requests and results (it announces credential expiry). */
+  #serverSupportsRestart = false;
+  #inert = false;
+  #closed = false;
+  #present = /* @__PURE__ */ new Map();
+  #activeId = null;
+  #link = null;
+  #status = /* @__PURE__ */ new Map();
+  #remote = new RemoteMediaTracker();
+  #limitReported = /* @__PURE__ */ new Set();
+  #early = /* @__PURE__ */ new Map();
+  #heldOffer;
+  #local = { camera: null, microphone: null, screen: null };
+  constructor(options) {
+    this.#env = options.env;
+    this.#log = options.log;
+    this.#timeoutMs = options.connectionTimeoutMs ?? CONNECTION_TIMEOUT_MS;
+    this.#recoveryWindowMs = options.recoveryWindowMs ?? DEFAULT_RECONNECT_WINDOW_MS;
+  }
+  attach(context) {
+    if (this.#closed || this.#context) return;
+    this.#context = context;
+    this.#iceServers = context.iceServers;
+    this.#serverSupportsRestart = context.iceServersExpireAt !== null;
+    if (!this.#env.RTCPeerConnection || !this.#env.MediaStream) {
+      this.#inert = true;
+      this.#log.warn("media connections unsupported");
+      this.#emit("error", { error: new MeetingError("unsupported_environment") });
+      return;
+    }
+    this.#unsubscribeNetwork = this.#env.onNetworkChange?.(() => this.#link?.networkChanged());
+  }
+  peersPresent(entries) {
+    if (!this.#active()) return;
+    for (const { id, media } of entries) {
+      this.#present.set(id, { ...media });
+      this.#limitReported.delete(id);
+    }
+    this.#evaluate();
+    const held = this.#heldOffer;
+    if (held && entries.some((entry) => entry.id === held.from)) {
+      this.#dropHeldOffer();
+      if (held.from === this.#activeId) this.#handleOffer(held.from, held.sdp);
+    }
+  }
+  peerPresent(participantId, media) {
+    this.peersPresent([{ id: participantId, media }]);
+  }
+  peerMediaChanged(participantId, kind, enabled) {
+    const announced = this.#present.get(participantId);
+    if (!this.#active() || !announced) return;
+    this.#present.set(participantId, { ...announced, [kind]: enabled });
+    this.#refreshRemote(participantId);
+  }
+  peerLeft(participantId) {
+    if (!this.#active()) return;
+    this.#present.delete(participantId);
+    this.#limitReported.delete(participantId);
+    this.#dropEarly(participantId);
+    if (this.#heldOffer?.from === participantId) this.#dropHeldOffer();
+    if (participantId === this.#activeId) {
+      this.#closeLink();
+      this.#activeId = null;
+    }
+    this.#setStatus(participantId, null);
+    this.#evaluate();
+  }
+  peerReconnected(participantId) {
+    if (!this.#active() || participantId !== this.#activeId) return;
+    this.#dropEarly(participantId);
+    this.#closeLink();
+    this.#setStatus(participantId, null);
+    this.#startPairing();
+  }
+  onPeerFrame(message) {
+    if (!this.#active()) return;
+    const from = message.participantId;
+    if (!this.#present.has(from)) {
+      this.#holdEarly(message);
+      return;
+    }
+    if (from !== this.#activeId) {
+      this.#log.debug("frame ignored", { messageType: message.type, reason: "not_paired" });
+      return;
+    }
+    switch (message.type) {
+      case "webrtc.offer":
+        this.#handleOffer(from, message.payload.sdp);
+        return;
+      case "webrtc.answer":
+        if (this.#link) this.#link.acceptAnswer(message.payload.sdp);
+        else this.#log.debug("frame ignored", { messageType: message.type, reason: "no_connection" });
+        return;
+      case "webrtc.ice_candidate":
+        if (this.#link) this.#link.addRemoteCandidate(message.payload.candidate);
+        else this.#addEarlyCandidate(from, message.payload.candidate);
+        return;
+      case "webrtc.ice_restart":
+        if (this.#link?.role === "offerer") this.#link.restart("peer_request");
+        else this.#log.debug("frame ignored", { messageType: message.type, reason: this.#link ? "answerer" : "no_connection" });
+        return;
+      default:
+        return;
+    }
+  }
+  iceServersUpdated(iceServers2, expiresAt) {
+    if (!this.#active()) return;
+    this.#iceServers = iceServers2;
+    const link = this.#link;
+    if (!link) return;
+    link.updateIceServers(iceServers2);
+    link.planSwitch(expiresAt);
+  }
+  localMediaChanged(kind, stream) {
+    if (this.#closed) return;
+    if (kind === "screen") {
+      const track2 = stream?.getVideoTracks()[0] ?? null;
+      this.#local.screen = track2;
+      this.#link?.attachLocal("screen", track2);
+      return;
+    }
+    const track = (kind === "camera" ? stream?.getVideoTracks()[0] : stream?.getAudioTracks()[0]) ?? null;
+    if (kind === "microphone" && track === null) return;
+    this.#local[kind] = track;
+    this.#link?.attachLocal(kind, track);
+  }
+  supportsScreenShare() {
+    return this.#active();
+  }
+  remoteMedia(participantId) {
+    return this.#remote.get(participantId);
+  }
+  connectionStatus(participantId) {
+    return this.#status.get(participantId) ?? null;
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#unsubscribeNetwork?.();
+    this.#unsubscribeNetwork = void 0;
+    this.#episode = null;
+    const link = this.#link;
+    this.#link = null;
+    link?.close();
+    for (const participantId of [...this.#early.keys()]) this.#dropEarly(participantId);
+    this.#dropHeldOffer();
+    this.#present.clear();
+    this.#status.clear();
+    this.#remote.clear();
+    this.#activeId = null;
+  }
+  #active() {
+    return this.#context !== void 0 && !this.#inert && !this.#closed;
+  }
+  /** The single-peer rule, applied after every presence change. */
+  #evaluate() {
+    const others = this.#present.size;
+    if (this.#activeId !== null && others >= 2 && !this.#keepsPair()) {
+      const abandoned = this.#activeId;
+      this.#closeLink();
+      this.#activeId = null;
+      this.#setStatus(abandoned, null);
+      this.#log.debug("media connection abandoned", { participantId: abandoned });
+    }
+    if (this.#activeId === null && others === 1) {
+      const [only] = this.#present.keys();
+      if (only !== void 0) {
+        this.#activeId = only;
+        this.#startPairing();
+      }
+    }
+    if (others >= 2) {
+      for (const participantId of this.#present.keys()) {
+        if (participantId === this.#activeId && this.#keepsPair()) continue;
+        if (this.#limitReported.has(participantId)) continue;
+        this.#limitReported.add(participantId);
+        this.#log.info("media not carried", { participantId, code: "media_participant_limit" });
+        this.#emit("error", { error: new MeetingError("media_participant_limit") });
+      }
+    }
+  }
+  /** A pair is kept once its link has connected, until the peer leaves, reconnects, or the link fails. */
+  #keepsPair() {
+    return this.#link !== null && this.#link.everConnected && this.#link.status !== "failed";
+  }
+  #startPairing() {
+    const peerId = this.#activeId;
+    const self = this.#context?.participantId;
+    if (peerId === null || self === void 0) return;
+    if (roleFor(self, peerId) !== "offerer") return;
+    this.#createLink(peerId)?.start();
+  }
+  #handleOffer(from, sdp2) {
+    const self = this.#context?.participantId;
+    if (self === void 0) return;
+    if (roleFor(self, from) === "offerer") {
+      this.#log.debug("frame ignored", { messageType: "webrtc.offer", reason: "offerer" });
+      return;
+    }
+    let link = this.#link;
+    if (link?.startsNewSession(sdp2)) {
+      const interrupted = link.everConnected;
+      this.#link = null;
+      link.close();
+      if (interrupted) this.#openEpisode("media").replaced = true;
+      link = this.#createLink(from, interrupted ? "interrupted" : "connecting");
+      this.#refreshRemote(from);
+    }
+    link ??= this.#createLink(from);
+    link?.acceptOffer(sdp2);
+  }
+  #createLink(peerId, initialStatus = "connecting") {
+    const context = this.#context;
+    if (!context) return null;
+    let link;
+    try {
+      link = new PeerLink({
+        env: this.#env,
+        log: this.#log,
+        selfId: context.participantId,
+        peerId,
+        iceServers: this.#iceServers,
+        timeoutMs: this.#timeoutMs,
+        local: this.#local,
+        callbacks: {
+          sendOffer: (payload) => {
+            if (this.#link === link) context.send("webrtc.offer", payload);
+          },
+          sendAnswer: (payload) => {
+            if (this.#link === link) context.send("webrtc.answer", payload);
+          },
+          sendCandidate: (payload) => {
+            if (this.#link === link) context.send("webrtc.ice_candidate", payload);
+          },
+          statusChanged: (status, reason) => {
+            if (this.#link === link) this.#onLinkStatus(link, status, reason);
+          },
+          connected: (report) => {
+            if (this.#link === link) context.send("webrtc.connected", { peerParticipantId: peerId, ...report });
+          },
+          requestRestart: () => this.#link === link && this.#serverSupportsRestart && context.send("webrtc.ice_restart", { targetParticipantId: peerId }),
+          recoveryStarted: (trigger) => {
+            if (this.#link === link) this.#recoveryStarted(trigger);
+          },
+          switchResult: (outcome) => {
+            if (this.#link === link && this.#serverSupportsRestart) {
+              context.send("webrtc.ice_restart_result", { peerParticipantId: peerId, outcome });
+            }
+          },
+          qualitySample: (sample) => {
+            if (this.#link !== link) return;
+            try {
+              context.send("webrtc.quality_sample", { peerParticipantId: peerId, ...sample });
+            } catch {
+            }
+          }
+        }
+      });
+    } catch {
+      this.#log.debug("negotiation step failed", { participantId: peerId, reason: "create" });
+      this.#reportFailure(peerId, "negotiation_failed");
+      return null;
+    }
+    this.#link = link;
+    this.#setStatus(peerId, initialStatus);
+    const early = this.#early.get(peerId);
+    if (early) {
+      this.#dropEarly(peerId);
+      for (const candidate of early.candidates) link.addRemoteCandidate(candidate);
+    }
+    return link;
+  }
+  #onLinkStatus(link, status, reason) {
+    const peerParticipantId = link.peerId;
+    switch (status) {
+      case "connected":
+        this.#recovered(peerParticipantId);
+        this.#setStatus(peerParticipantId, "connected");
+        this.#refreshRemote(peerParticipantId);
+        return;
+      case "interrupted":
+        this.#openEpisode("media");
+        this.#context?.send("webrtc.disconnected", { peerParticipantId });
+        this.#setStatus(peerParticipantId, "interrupted");
+        return;
+      case "failed":
+        this.#link = null;
+        link.close();
+        if (this.#replaceFailedLink(link)) return;
+        this.#giveUp(peerParticipantId);
+        this.#reportFailure(peerParticipantId, reason ?? "connection_failed");
+        return;
+      default:
+        return;
+    }
+  }
+  #openEpisode(trigger) {
+    this.#episode ??= { startedAt: this.#env.now(), attempts: 0, trigger, replaced: false };
+    return this.#episode;
+  }
+  #recoveryStarted(trigger) {
+    const episode = this.#openEpisode(trigger);
+    episode.attempts += 1;
+    episode.trigger = trigger;
+    this.#log.info("reconnect attempt started", reconnectLogFields({ attempt: episode.attempts, trigger }));
+  }
+  /** The connection is carrying media again after a drop. */
+  #recovered(peerParticipantId) {
+    const episode = this.#episode;
+    if (!episode) return;
+    this.#episode = null;
+    this.#log.info(
+      "reconnect succeeded",
+      reconnectLogFields({
+        attempt: Math.max(1, episode.attempts),
+        trigger: episode.trigger,
+        elapsedMs: Math.max(0, this.#env.now() - episode.startedAt),
+        participantId: peerParticipantId
+      })
+    );
+  }
+  /** Recovery is over without media coming back. */
+  #giveUp(peerParticipantId) {
+    const episode = this.#episode;
+    if (!episode) return;
+    this.#episode = null;
+    const elapsedMs = Math.max(0, this.#env.now() - episode.startedAt);
+    this.#log.warn(
+      "reconnect failed",
+      reconnectLogFields({
+        attempt: Math.max(1, episode.attempts),
+        elapsedMs,
+        reason: elapsedMs >= this.#recoveryWindowMs ? "recovery_window_exhausted" : "hard_failure",
+        participantId: peerParticipantId
+      })
+    );
+  }
+  /**
+   * A connection that carried media and then failed is replaced once, within the recovery window, before media is
+   * given up. The meeting connection is untouched. False when no replacement is allowed or it could not be made.
+   */
+  #replaceFailedLink(failed) {
+    const peerId = failed.peerId;
+    if (!failed.everConnected || peerId !== this.#activeId || !this.#present.has(peerId)) return false;
+    const episode = this.#openEpisode("media");
+    if (episode.replaced || this.#env.now() - episode.startedAt >= this.#recoveryWindowMs) return false;
+    episode.replaced = true;
+    episode.attempts += 1;
+    this.#log.info("reconnect attempt started", reconnectLogFields({ attempt: episode.attempts, trigger: episode.trigger }));
+    const next = this.#createLink(peerId, "interrupted");
+    if (!next) {
+      this.#episode = null;
+      return true;
+    }
+    this.#refreshRemote(peerId);
+    next.start();
+    return true;
+  }
+  /** Reports a failed link. The pair stays as it is; nothing more is tried until the peer reconnects or rejoins. */
+  #reportFailure(peerParticipantId, reason) {
+    this.#log.warn("media connection failed", { participantId: peerParticipantId, reason });
+    this.#context?.send("webrtc.failed", { peerParticipantId, reason });
+    this.#setStatus(peerParticipantId, "failed");
+    this.#refreshRemote(peerParticipantId);
+    this.#emit("error", { error: new MeetingError("media_connection_failed") });
+  }
+  /** Closes the current link without reporting a failure, and reports its remote media as gone. */
+  #closeLink() {
+    const link = this.#link;
+    if (!link) return;
+    this.#link = null;
+    this.#episode = null;
+    link.close();
+    this.#refreshRemote(link.peerId);
+  }
+  #refreshRemote(participantId) {
+    const link = this.#link;
+    const active = participantId === this.#activeId && link !== null && link.peerId === participantId;
+    const next = computeRemoteMedia({
+      active,
+      usable: active && link.usable,
+      announced: this.#present.get(participantId) ?? NOTHING_ANNOUNCED,
+      streams: {
+        camera: link?.remoteStream("camera") ?? null,
+        microphone: link?.remoteStream("microphone") ?? null,
+        screen: link?.remoteStream("screen") ?? null
+      }
+    });
+    this.#remote.update(participantId, next, (event) => this.#emit("remote_media_changed", event));
+  }
+  #setStatus(participantId, status) {
+    const previous = this.#status.get(participantId) ?? null;
+    if (previous === status) return;
+    if (status === null) this.#status.delete(participantId);
+    else this.#status.set(participantId, status);
+    this.#emit("media_connection_changed", { participantId, status });
+  }
+  #holdEarly(message) {
+    switch (message.type) {
+      case "webrtc.offer": {
+        this.#dropHeldOffer();
+        const from = message.participantId;
+        this.#heldOffer = {
+          from,
+          sdp: message.payload.sdp,
+          timer: this.#env.setTimeout(() => {
+            if (this.#heldOffer?.from === from) this.#heldOffer = void 0;
+          }, EARLY_FRAME_HOLD_MS)
+        };
+        return;
+      }
+      case "webrtc.ice_candidate":
+        this.#addEarlyCandidate(message.participantId, message.payload.candidate);
+        return;
+      default:
+        this.#log.debug("frame ignored", { messageType: message.type, reason: "unknown_participant" });
+    }
+  }
+  #addEarlyCandidate(participantId, candidate) {
+    let early = this.#early.get(participantId);
+    if (!early) {
+      early = {
+        candidates: [],
+        timer: this.#env.setTimeout(() => this.#early.delete(participantId), EARLY_FRAME_HOLD_MS)
+      };
+      this.#early.set(participantId, early);
+    }
+    if (early.candidates.length >= MAX_EARLY_CANDIDATES) {
+      this.#log.debug("late candidate dropped", { participantId, reason: "queue_full" });
+      return;
+    }
+    early.candidates.push(candidate);
+  }
+  #dropEarly(participantId) {
+    const early = this.#early.get(participantId);
+    if (!early) return;
+    this.#env.clearTimeout(early.timer);
+    this.#early.delete(participantId);
+  }
+  #dropHeldOffer() {
+    if (this.#heldOffer) this.#env.clearTimeout(this.#heldOffer.timer);
+    this.#heldOffer = void 0;
+  }
+  #emit(type, event) {
+    if (!this.#closed) this.#context?.emit(type, event);
+  }
+};
+
+// src/createMeetingEngine.ts
+var DEFAULT_JOIN_TIMEOUT_MS = 15e3;
+var MIN_JOIN_TIMEOUT_MS = 1e3;
+var MAX_JOIN_TIMEOUT_MS = 6e4;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+function normalizeRealtimeUrl(value) {
+  const invalid = new TypeError(
+    "realtimeUrl must be wss://host[:port] (ws:// only for localhost) with no path, query, or fragment."
+  );
+  if (typeof value !== "string" || value.includes("?") || value.includes("#")) throw invalid;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw invalid;
+  }
+  const secure = url.protocol === "wss:";
+  const loopback = url.protocol === "ws:" && LOOPBACK_HOSTS.has(url.hostname);
+  if (!secure && !loopback) throw invalid;
+  if (url.username !== "" || url.password !== "" || url.pathname !== "" && url.pathname !== "/") throw invalid;
+  return `${url.protocol}//${url.host}`;
+}
+function normalizeJoinTimeout(value) {
+  if (value === void 0) return DEFAULT_JOIN_TIMEOUT_MS;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < MIN_JOIN_TIMEOUT_MS || value > MAX_JOIN_TIMEOUT_MS) {
+    throw new TypeError(`joinTimeoutMs must be an integer from ${MIN_JOIN_TIMEOUT_MS} to ${MAX_JOIN_TIMEOUT_MS}.`);
+  }
+  return value;
+}
+function createMeetingEngine(options) {
+  if (typeof options !== "object" || options === null) throw new TypeError("createMeetingEngine requires options.");
+  const realtimeUrl = normalizeRealtimeUrl(options.realtimeUrl);
+  const joinTimeoutMs = normalizeJoinTimeout(options.joinTimeoutMs);
+  const token = options.token;
+  if (typeof token !== "string" || token.length === 0) throw new MeetingError("join_token_invalid");
+  const env = currentEnvironment();
+  if (!env.WebSocket) throw new MeetingError("unsupported_environment");
+  const addressing = decodeAddressing(token);
+  const getJoinToken = options.getJoinToken;
+  if (getJoinToken !== void 0 && typeof getJoinToken !== "function") {
+    throw new TypeError("getJoinToken must be a function when provided.");
+  }
+  const reconnectWindowMs = clampReconnectWindowMs(options.reconnectWindowMs);
+  return new MeetingEngineImpl({
+    token,
+    realtimeUrl,
+    joinTimeoutMs,
+    logger: options.logger,
+    addressing,
+    env,
+    getJoinToken: typeof getJoinToken === "function" ? getJoinToken : void 0,
+    reconnectWindowMs,
+    createMediaDelivery: (mediaMode, deps) => mediaMode === "p2p" ? new PeerMediaDelivery({ ...deps, recoveryWindowMs: reconnectWindowMs }) : new SignalingOnlyMediaDelivery()
+  });
+}
+export {
+  MeetingError,
+  createMeetingEngine
+};
+//# sourceMappingURL=index.js.map