@strevokit/meeting-sdk 0.0.0-stage → 0.6.0

package/dist/index.js

@@ -0,0 +1,2817 @@
+// src/internal/env.ts
+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()
+  };
+}
+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;
+
+// ../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.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;
+}
+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.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 (unplugged, revoked, "Stop sharing") turns that kind off and is announced. */
+  #watchEnded(kind, stream) {
+    const onEnded = () => {
+      if (this.#streams[kind] !== stream) return;
+      if (!this.#state[kind]) {
+        if (kind === "microphone") {
+          this.#streams.microphone = null;
+          this.#devices.microphone = null;
+        }
+        return;
+      }
+      this.#log.info(kind === "screen" ? "screen share ended by the browser" : "capture ended", { kind });
+      this.set(kind, false).catch(() => void 0);
+    };
+    for (const track of stream.getTracks()) track.addEventListener("ended", onEnded, { once: true });
+  }
+};
+
+// src/internal/log.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "state",
+  "code",
+  "reason",
+  "kind",
+  "participantId",
+  "meetingId",
+  "closeCode",
+  "messageType",
+  "durationMs",
+  "attempt",
+  "path",
+  "localPath",
+  "remotePath"
+]);
+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/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;
+  }
+};
+
+// 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.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/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;
+  #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;
+  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.#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
+    );
+  }
+  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;
+    this.#token = void 0;
+    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);
+    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();
+    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 "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.#emitter.clear();
+    const end = this.#endMeeting;
+    this.#endMeeting = void 0;
+    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") return;
+        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;
+      }
+      case "session.welcome": {
+        if (state !== "joining") return;
+        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;
+      }
+      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);
+        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") 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;
+        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.#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 deferred2 = 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";
+          deferred2.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 (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");
+        this.#finish(reason, error);
+        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.#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();
+  }
+  #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
+async function selectedPair(pc) {
+  const reports = await statsOf(pc);
+  if (!reports) return null;
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  const selectedId = reports.find((r) => r.type === "transport" && r.selectedCandidatePairId)?.selectedCandidatePairId;
+  const pair = (selectedId ? byId.get(selectedId) : void 0) ?? reports.find((r) => r.type === "candidate-pair" && r.state === "succeeded" && r.nominated === true);
+  if (!pair?.localCandidateId || !pair.remoteCandidateId) return null;
+  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/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 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;
+  #lastReport = null;
+  #recheckTimer;
+  /** 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();
+      await this.#pc.setLocalDescription(offer);
+      if (this.#closed) return;
+      const sdp2 = this.#pc.localDescription?.sdp ?? offer.sdp ?? "";
+      this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+    });
+  }
+  /**
+   * 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.#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();
+    });
+  }
+  /** 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();
+        return;
+      }
+      await this.#flushCandidates();
+    });
+  }
+  /** 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;
+    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 });
+        await this.#pc.setLocalDescription(offer);
+        if (this.#closed) return;
+        const sdp2 = this.#pc.localDescription?.sdp ?? offer.sdp ?? "";
+        this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+      } catch {
+        this.#restarting = false;
+        this.#restartFailed();
+      }
+    });
+  }
+  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.#clearRecheck();
+    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.#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;
+  }
+  #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" });
+    }
+  }
+  #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;
+    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();
+        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");
+        return;
+      case "failed":
+        this.#fail("connection_failed");
+        return;
+      default:
+        return;
+    }
+  }
+  /** True when the status changed. */
+  #setStatus(status, reason) {
+    if (this.#status === status) return false;
+    this.#status = status;
+    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;
+  }
+};
+
+// 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;
+  #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;
+  }
+  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") });
+    }
+  }
+  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;
+    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;
+    }
+    const link = this.#link ?? this.#createLink(from);
+    link?.acceptOffer(sdp2);
+  }
+  #createLink(peerId) {
+    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 }),
+          switchResult: (outcome) => {
+            if (this.#link === link && this.#serverSupportsRestart) {
+              context.send("webrtc.ice_restart_result", { peerParticipantId: peerId, outcome });
+            }
+          }
+        }
+      });
+    } catch {
+      this.#log.debug("negotiation step failed", { participantId: peerId, reason: "create" });
+      this.#reportFailure(peerId, "negotiation_failed");
+      return null;
+    }
+    this.#link = link;
+    this.#setStatus(peerId, "connecting");
+    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.#setStatus(peerParticipantId, "connected");
+        this.#refreshRemote(peerParticipantId);
+        return;
+      case "interrupted":
+        this.#context?.send("webrtc.disconnected", { peerParticipantId });
+        this.#setStatus(peerParticipantId, "interrupted");
+        return;
+      case "failed":
+        this.#link = null;
+        link.close();
+        this.#reportFailure(peerParticipantId, reason ?? "connection_failed");
+        return;
+      default:
+        return;
+    }
+  }
+  /** Reports a failed link. The pair stays as it is; nothing is retried 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;
+    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/internal/token.ts
+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 decodeAddressing(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");
+  }
+  const { meeting_id: meetingId, participant_id: participantId } = claims;
+  if (!isCanonicalUlid(meetingId) || !isCanonicalUlid(participantId)) {
+    throw new MeetingError("join_token_invalid");
+  }
+  return { meetingId, participantId };
+}
+
+// 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);
+  return new MeetingEngineImpl({
+    token,
+    realtimeUrl,
+    joinTimeoutMs,
+    logger: options.logger,
+    addressing,
+    env,
+    createMediaDelivery: (mediaMode, deps) => mediaMode === "p2p" ? new PeerMediaDelivery(deps) : new SignalingOnlyMediaDelivery()
+  });
+}
+export {
+  MeetingError,
+  createMeetingEngine
+};
+//# sourceMappingURL=index.js.map