@dobuki/hello-worker 1.0.84 → 1.0.86

package/dist/webrtc-peer-collector.js

@@ -1,4 +1,634 @@
-class v{sendToServerFunctions=[];icePromiseResolve;icePromise;receiveIce(V,W){this.icePromiseResolve?.({url:V,expiration:W}),this.icePromiseResolve=void 0,this.icePromise=void 0}addRequester(V){return this.sendToServerFunctions.push(V),()=>{this.removeRequester(V)}}removeRequester(V){this.sendToServerFunctions.splice(this.sendToServerFunctions.indexOf(V),1)}sendToServer(V){this.sendToServerFunctions[Math.floor(this.sendToServerFunctions.length*Math.random())](V)}async requestIce(){if(!this.icePromise)this.icePromise=new Promise((V)=>{this.icePromiseResolve=V,this.sendToServer("request-ice")});return await this.icePromise}}function U(V){let{userId:W,worldId:K,room:S,host:M,autoRejoin:z=!0,logLine:H}=V,x=!1,O=0,D,j,_=!0,A=new Map,C=`wss://${M}/room/${K}/${S}?userId=${encodeURIComponent(W)}`,T=[],k=0;function E(Z,F,X){if(!D)return H?.("\uD83D\uDC64 ➡️ ❌","no ws available"),!1;let Q={type:Z,to:F,payload:X};if(T.push(Q),H?.("\uD83D\uDC64 ➡️ \uD83D\uDDA5️",Q),clearTimeout(k),x||D.readyState!==WebSocket.OPEN)return H?.("\uD83D\uDC64 ➡️ ❌","Not in opened state: "+D.readyState),!1;return k=setTimeout(()=>{D.send(JSON.stringify(T)),T.length=0}),!0}function P(){if(x)return;D=new WebSocket(C),D.onopen=()=>{if(_)V.onOpen?.(),_=!1;O=0},D.onmessage=(Z)=>{try{let F=JSON.parse(Z.data);(Array.isArray(F)?F:[F]).forEach((Q)=>{if(H?.("\uD83D\uDDA5️ ➡️ \uD83D\uDC64",Q),Q.type==="peer-joined"||Q.type==="peer-left")Y(Q.users,Q);else if(Q.type==="ice-server")V.onIceUrl?.(Q.url,Q.expiration);else if(Q.userId)V.onMessage(Q.type,Q.payload,Q.userId)})}catch{H?.("⚠️ ERROR",{error:"invalid-json"})}},D.onclose=(Z)=>{let X=[1001,1006,1011,1012,1013].includes(Z.code);if(z&&!x&&X){let Q=Math.min(Math.pow(2,O)*1000,15000),N=Math.random()*1000,J=Q+N;H?.("\uD83D\uDD04 RECONNECTING",{attempt:O+1,delayMs:Math.round(J)}),O++,j=setTimeout(P,J)}else V.onClose?.({code:Z.code,reason:Z.reason,wasClean:Z.wasClean})},D.onerror=(Z)=>{console.error("WS Error",Z),V.onError?.()}}function Y(Z,F){let X=[],Q=[],N=new Set,J=Z.filter((B)=>B.userId===W)[0];if(!J){H?.("⚠️","Cannot find self in updated users");return}let f=J.joined;Z.forEach(({userId:B,joined:w})=>{if(B===W)return;if(!A.has(B)||F.type==="peer-joined"&&B===F.userId){let R={userId:B,joined:w};A.set(B,R),X.push(R)}N.add(B)});for(let B of A.keys())if(!N.has(B)||F.type==="peer-left"&&B===F.userId)A.delete(B),Q.push({userId:B});if(X.length)V.onPeerJoined(X,f);if(Q.length)V.onPeerLeft(Q)}return P(),{send(Z,F,X){E(Z,F,X)},exitRoom:()=>{x=!0,clearTimeout(j),D.close()}}}function c({userId:V,worldId:W,room:K,host:S,autoRejoin:M=!0,onOpen:z,onClose:H,onError:x,onPeerJoined:O,onPeerLeft:D,onIceUrl:j,onMessage:_,logLine:A,workerUrl:C}){if(!C)return console.warn("Warning: enterRoom called without workerUrl; this may cause issues in some environments. You should pass workerUrl explicitly. Use:","https://cdn.jsdelivr.net/npm/@dobuki/hello-worker/dist/signal-room.worker.min.js"),U({userId:V,worldId:W,room:K,host:S,autoRejoin:M,onOpen:z,onClose:H,onError:x,onPeerJoined:O,onPeerLeft:D,onIceUrl:j,onMessage:_});let T=new Worker(C,{type:"module"}),k=!1,E=(P)=>{let Y=P.data;if(Y.kind==="open")z?.();else if(Y.kind==="close")T.terminate(),H?.(Y.ev);else if(Y.kind==="error")x?.();else if(Y.kind==="peer-joined")O(Y.users.map((Z)=>({userId:Z.userId,joined:Z.joined})),Y.joined);else if(Y.kind==="peer-left")D(Y.users);else if(Y.kind==="ice-server")j?.(Y.url,Y.expiration);else if(Y.kind==="message")_(Y.type,Y.payload,Y.fromUserId);else if(Y.kind==="log")A?.(Y.direction,Y.obj)};return T.addEventListener("message",E),T.postMessage({cmd:"enter",userId:V,worldId:W,room:K,host:S,autoRejoin:M}),{exitRoom:()=>{k=!0,T.removeEventListener("message",E),T.postMessage({cmd:"exit"})},send:(P,Y,Z)=>{T.postMessage({cmd:"send",toUserId:Y,host:S,room:K,type:P,payload:Z})}}}var y={iceServers:[{urls:"stun:stun.l.google.com:19302"}]};class i{iceUrlProvider;constructor(V){this.iceUrlProvider=V}rtcConfig={...y,timestamp:Date.now()};rtcConfigPromise;async getRtcConfig(){if(Date.now()-(this.rtcConfig?.timestamp??0)<1e4)return this.rtcConfig;if(!this.rtcConfigPromise)this.rtcConfigPromise=new Promise(async(W)=>{let K=3;for(let S=0;S<K;S++)try{let M=(await this.iceUrlProvider.requestIce()).url,z=await fetch(M);if(!z.ok)throw Error(`ICE endpoint failed: ${z.status}`);let H=await z.json();W(H);return}catch(M){console.warn("Failed fetching iceUrl")}}),this.rtcConfig=await this.rtcConfigPromise,this.rtcConfigPromise=void 0;return this.rtcConfig}}var g=c;function s({userId:V,worldId:W,receivePeerConnection:K,peerlessUserExpiration:S=5000,enterRoomFunction:M=g,logLine:z,onLeaveUser:H,workerUrl:x,onRoomReady:O,onRoomClose:D,onBroadcastMessage:j}){let _=V??`user-${crypto.randomUUID()}`,A=new Map,C=new Map;function T(F){H?.(F);let X=A.get(F);if(!X)return;A.delete(F);try{X.close()}catch{}}async function k(F){if(!F.connection?.pc?.remoteDescription)return;let X=F.connection.pendingRemoteIce;F.connection.pendingRemoteIce=[];for(let Q of X)try{await F.connection.pc.addIceCandidate(Q)}catch(N){z?.("⚠️ ERROR",{error:"add-ice-failed",userId:F.peer,detail:String(N)})}}let E=new v,P=new i(E);function Y({room:F,host:X}){let Q=`${X}/room/${F}`,N=C.get(Q);if(N)N.exitRoom(),C.delete(Q)}function Z({room:F,host:X}){return new Promise(async(Q,N)=>{async function J(q){if(q.connectionPromise)return q.connectionPromise;let $=new Promise(async(b)=>{q.connection={id:`conn-${crypto.randomUUID()}`,pc:new RTCPeerConnection(await P.getRtcConfig()),pendingRemoteIce:[]},q.connection.pc.onicecandidate=(h)=>{if(!h.candidate)return;R("ice",q.peer,{connectionId:q.connection?.id,ice:h.candidate.toJSON()})},q.connection.pc.onconnectionstatechange=async()=>{if(z?.("\uD83D\uDCAC",{event:"pc-state",userId:q.peer,state:q.connection?.pc?.connectionState}),q.connection?.pc?.connectionState==="failed"){q.close();let h=await f(q.peer,!0);if(h.connection?.pc)K({pc:h.connection?.pc,userId:h.peer,restart:()=>h.close()});else z?.("\uD83D\uDC64ℹ️","no pc: "+h.peer);return}},b(q.connection)});return q.connectionPromise=$,await $,q.connectionPromise=void 0,$}async function f(q,$){let b=A.get(q);if(!b||$){let h={peer:q,close(){if(this.connection)this.connection.pc.close(),this.connection=void 0;A.delete(q)},async reset(){h.close(),setTimeout(async()=>{let G=await f(q,!0);if(!G.connection?.pc){z?.("⚠️","no pc");return}K({pc:G.connection?.pc,userId:G.peer,restart:()=>G.close()}),await B(G.peer)},500)}};b=h,await J(h),A.set(b.peer,b)}else if(b){if(clearTimeout(b.expirationTimeout),b.expirationTimeout=0,!b.connection?.pc||b.connection?.pc.signalingState==="closed")await J(b)}return b.peer=q,b}async function B(q){let $=await f(q),b=$.connection?.pc,h=await b?.createOffer();await b?.setLocalDescription(h),R("offer",q,{connectionId:$.connection?.id,offer:b?.localDescription?.toJSON()})}let{exitRoom:w,send:R}=M({userId:_,worldId:W,room:F,host:X,logLine:z,workerUrl:x,autoRejoin:!0,onOpen(){O?.({room:F,host:X}),Q()},onError(){console.error("onError"),N()},onClose(q){D?.({room:F,host:X,ev:q})},onPeerJoined(q,$){q.forEach(async(b)=>{let h=await f(b.userId,!0);h.joined=b.joined;let G=h.connection?.pc;if(!G){z?.("\uD83D\uDC64ℹ️","no pc: "+b.userId);return}if(K({pc:G,userId:b.userId,restart:()=>h.close()}),b.joined>$||b.joined===$&&b.userId.localeCompare(_)>0)await B(b.userId)})},onPeerLeft(q){q.forEach(({userId:$})=>{let b=A.get($);if(!b)return;b.expirationTimeout=setTimeout(()=>T($),S??0)})},onIceUrl(q,$){E.receiveIce(q,$)},async onMessage(q,$,b){if(q==="offer"&&$.offer){let h=await f(b,!1),G=!h.connection||h.connection.pc.signalingState==="stable"?await J(h):h.connection;z?.("\uD83D\uDCAC",{type:q,signalingState:G.pc.signalingState}),G.peerConnectionId=$.connectionId,K({pc:G.pc,userId:b,restart:()=>h.close()}),await G.pc.setRemoteDescription($.offer);let L=await G.pc.createAnswer();await G.pc.setLocalDescription(L),R("answer",b,{connectionId:G.id,answer:G.pc.localDescription?.toJSON()}),await k(h);return}if(q==="answer"&&$.answer){let h=await f(b,!1),G=h.connection&&h.connection.pc.signalingState!=="closed"?h.connection:await J(h);z?.("\uD83D\uDCAC",{type:q,signalingState:G.pc.signalingState}),await G.pc.setRemoteDescription($.answer),G.peerConnectionId=$.connectionId,await k(h);return}if(q==="ice"&&$.ice){let h=await f(b,!1),G=h.connection??await h.connectionPromise;if(!G){z?.("⚠️","No connection");return}if(z?.("\uD83D\uDCAC",{type:q,signalingState:G.pc.signalingState}),G.peerConnectionId&&$.connectionId!==G.peerConnectionId){z?.("⚠️","Mismatch peerConnectionID"+$.connectionId+"vs"+G.peerConnectionId);return}if(!G.pc.remoteDescription||!G.peerConnectionId){G.peerConnectionId=$.connectionId,G.pendingRemoteIce.push($.ice);return}try{await G.pc.addIceCandidate($.ice)}catch(L){z?.("⚠️ ERROR",{error:"add-ice-failed",userId:h.peer,detail:String(L)})}return}if(q==="broadcast")j?.($,b)}}),I=E.addRequester((q)=>R(q,"server"));C.set(`${X}/room/${F}`,{exitRoom:()=>{w(),I()},room:F,host:X,broadcast:(q)=>R("broadcast","server",q)})})}return{userId:_,enterRoom:Z,exitRoom:Y,leaveUser:T,async reset(F){A.get(F)?.reset()},broadcast(F){C.forEach((X)=>X.broadcast(F))},end(){C.forEach(({exitRoom:F})=>F()),C.clear(),A.forEach(({peer:F})=>T(F)),A.clear()}}}export{s as collectPeerConnections};
+// src/browser/utils/ice-url-provider.ts
+class IceUrlProvider {
+  sendToServerFunctions = new Array;
+  icePromiseResolve;
+  icePromise;
+  receiveIce(url, expiration) {
+    this.icePromiseResolve?.({ url, expiration });
+    this.icePromiseResolve = undefined;
+    this.icePromise = undefined;
+  }
+  addRequester(requester) {
+    this.sendToServerFunctions.push(requester);
+    return () => {
+      this.removeRequester(requester);
+    };
+  }
+  removeRequester(requester) {
+    this.sendToServerFunctions.splice(this.sendToServerFunctions.indexOf(requester), 1);
+  }
+  sendToServer(command) {
+    this.sendToServerFunctions[Math.floor(this.sendToServerFunctions.length * Math.random())](command);
+  }
+  async requestIce() {
+    if (!this.icePromise) {
+      this.icePromise = new Promise((resolve) => {
+        this.icePromiseResolve = resolve;
+        this.sendToServer("request-ice");
+      });
+    }
+    return await this.icePromise;
+  }
+}
 
-//# debugId=676E5AB7574F379664756E2164756E21
+// src/browser/signal/impl/signal-room.ts
+function enterRoom(params) {
+  const {
+    userId,
+    worldId,
+    room,
+    host,
+    protocol,
+    autoRejoin = true,
+    logLine
+  } = params;
+  let exited = false;
+  let retryCount = 0;
+  let ws;
+  let timeoutId;
+  let initialConnection = true;
+  const peers = new Map;
+  const wsUrl = `${protocol ?? "wss"}://${host}/room/${worldId}/${room}?userId=${encodeURIComponent(userId)}`;
+  const accumulatedMessages = [];
+  let timeout = 0;
+  function send(type, to, payload) {
+    if (!ws) {
+      logLine?.("\uD83D\uDC64 ➡️ ❌", "no ws available");
+      return false;
+    }
+    const obj = { type, to, payload };
+    accumulatedMessages.push(obj);
+    logLine?.("\uD83D\uDC64 ➡️ \uD83D\uDDA5️", obj);
+    clearTimeout(timeout);
+    if (exited || ws.readyState !== WebSocket.OPEN) {
+      logLine?.("\uD83D\uDC64 ➡️ ❌", "Not in opened state: " + ws.readyState);
+      return false;
+    }
+    timeout = setTimeout(() => {
+      ws.send(JSON.stringify(accumulatedMessages));
+      accumulatedMessages.length = 0;
+    });
+    return true;
+  }
+  function connect() {
+    if (exited)
+      return;
+    ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      if (initialConnection) {
+        params.onOpen?.();
+        initialConnection = false;
+      }
+      retryCount = 0;
+    };
+    ws.onmessage = (e) => {
+      try {
+        const result = JSON.parse(e.data);
+        const msgs = Array.isArray(result) ? result : [result];
+        msgs.forEach((msg) => {
+          logLine?.("\uD83D\uDDA5️ ➡️ \uD83D\uDC64", msg);
+          if (msg.type === "peer-joined" || msg.type === "peer-left") {
+            updatePeers(msg.users, msg);
+          } else if (msg.type === "ice-server") {
+            params.onIceUrl?.(msg.url, msg.expiration);
+          } else if (msg.userId) {
+            params.onMessage(msg.type, msg.payload, msg.userId);
+          }
+        });
+      } catch {
+        logLine?.("⚠️ ERROR", { error: "invalid-json" });
+      }
+    };
+    ws.onclose = (ev) => {
+      const recoverableCodes = [1001, 1006, 1011, 1012, 1013];
+      const isRecoverable = recoverableCodes.includes(ev.code);
+      if (autoRejoin && !exited && isRecoverable) {
+        const backoff = Math.min(Math.pow(2, retryCount) * 1000, 15000);
+        const jitter = Math.random() * 1000;
+        const delay = backoff + jitter;
+        logLine?.("\uD83D\uDD04 RECONNECTING", {
+          attempt: retryCount + 1,
+          delayMs: Math.round(delay)
+        });
+        retryCount++;
+        timeoutId = setTimeout(connect, delay);
+      } else {
+        params.onClose?.({
+          code: ev.code,
+          reason: ev.reason,
+          wasClean: ev.wasClean
+        });
+      }
+    };
+    ws.onerror = (ev) => {
+      console.error("WS Error", ev);
+      params.onError?.();
+    };
+  }
+  function updatePeers(updatedUsers, msg) {
+    const joined = [];
+    const left = [];
+    const updatedPeerSet = new Set;
+    const selfPeer = updatedUsers.filter((peer) => peer.userId === userId)[0];
+    if (!selfPeer) {
+      logLine?.("⚠️", "Cannot find self in updated users");
+      return;
+    }
+    const selfJoined = selfPeer.joined;
+    updatedUsers.forEach(({ userId: pUserId, joined: joinedTime }) => {
+      if (pUserId === userId)
+        return;
+      if (!peers.has(pUserId) || msg.type === "peer-joined" && pUserId === msg.userId) {
+        const newPeer = {
+          userId: pUserId,
+          joined: joinedTime
+        };
+        peers.set(pUserId, newPeer);
+        joined.push(newPeer);
+      }
+      updatedPeerSet.add(pUserId);
+    });
+    for (const pUserId of peers.keys()) {
+      if (!updatedPeerSet.has(pUserId) || msg.type === "peer-left" && pUserId === msg.userId) {
+        peers.delete(pUserId);
+        left.push({ userId: pUserId });
+      }
+    }
+    if (joined.length)
+      params.onPeerJoined(joined, selfJoined);
+    if (left.length)
+      params.onPeerLeft(left);
+  }
+  connect();
+  return {
+    send(type, userId2, payload) {
+      send(type, userId2, payload);
+    },
+    exitRoom: () => {
+      exited = true;
+      clearTimeout(timeoutId);
+      ws.close();
+    }
+  };
+}
+
+// src/browser/signal/signal-room.ts
+function enterRoom2({
+  userId,
+  worldId,
+  room,
+  protocol = "wss",
+  host,
+  autoRejoin = true,
+  onOpen,
+  onClose,
+  onError,
+  onPeerJoined,
+  onPeerLeft,
+  onIceUrl,
+  onMessage,
+  logLine,
+  workerUrl
+}) {
+  if (!workerUrl) {
+    const CDN_WORKER_URL = `https://cdn.jsdelivr.net/npm/@dobuki/hello-worker/dist/signal-room.worker.min.js`;
+    console.warn("Warning: enterRoom called without workerUrl; this may cause issues in some environments. You should pass workerUrl explicitly. Use:", CDN_WORKER_URL);
+    return enterRoom({
+      userId,
+      worldId,
+      room,
+      protocol,
+      host,
+      autoRejoin,
+      onOpen,
+      onClose,
+      onError,
+      onPeerJoined,
+      onPeerLeft,
+      onIceUrl,
+      onMessage
+    });
+  }
+  let worker;
+  const res = fetch(workerUrl).then(async (res2) => {
+    if (!res2.ok) {
+      throw new Error(`Failed to load worker script: ${res2.status}`);
+    }
+    const source = await res2.text();
+    const blob = new Blob([source], { type: "text/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    worker = new Worker(blobUrl, { type: "module" });
+    worker.addEventListener("message", onWorkerMessage);
+    worker.postMessage({
+      cmd: "enter",
+      userId,
+      worldId,
+      room,
+      protocol,
+      host,
+      autoRejoin
+    });
+  });
+  let exited = false;
+  const onWorkerMessage = (e) => {
+    const ev = e.data;
+    if (ev.kind === "open")
+      onOpen?.();
+    else if (ev.kind === "close") {
+      worker?.terminate();
+      onClose?.(ev.ev);
+    } else if (ev.kind === "error")
+      onError?.();
+    else if (ev.kind === "peer-joined")
+      onPeerJoined(ev.users.map((ev2) => ({ userId: ev2.userId, joined: ev2.joined })), ev.joined);
+    else if (ev.kind === "peer-left")
+      onPeerLeft(ev.users);
+    else if (ev.kind === "ice-server")
+      onIceUrl?.(ev.url, ev.expiration);
+    else if (ev.kind === "message")
+      onMessage(ev.type, ev.payload, ev.fromUserId);
+    else if (ev.kind === "log")
+      logLine?.(ev.direction, ev.obj);
+  };
+  return {
+    exitRoom: () => {
+      exited = true;
+      worker?.removeEventListener("message", onWorkerMessage);
+      worker?.postMessage({ cmd: "exit" });
+    },
+    send: (type, toUserId, payload) => {
+      worker?.postMessage({
+        cmd: "send",
+        toUserId,
+        host,
+        room,
+        type,
+        payload
+      });
+    }
+  };
+}
+
+// src/browser/utils/rtc-config.ts
+var FALLBACK_RTC_CONFIG = {
+  iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+};
+
+class RTCConfigProvider {
+  iceUrlProvider;
+  constructor(iceUrlProvider) {
+    this.iceUrlProvider = iceUrlProvider;
+  }
+  rtcConfig = {
+    ...FALLBACK_RTC_CONFIG,
+    timestamp: Date.now()
+  };
+  rtcConfigPromise;
+  async getRtcConfig() {
+    const now = Date.now();
+    if (now - (this.rtcConfig?.timestamp ?? 0) < 1e4) {
+      return this.rtcConfig;
+    }
+    if (!this.rtcConfigPromise) {
+      this.rtcConfigPromise = new Promise(async (resolve) => {
+        let retries = 3;
+        for (let r = 0;r < retries; r++) {
+          try {
+            const iceUrl = (await this.iceUrlProvider.requestIce()).url;
+            const r2 = await fetch(iceUrl);
+            if (!r2.ok)
+              throw new Error(`ICE endpoint failed: ${r2.status}`);
+            const rtcConfig = await r2.json();
+            resolve(rtcConfig);
+            return;
+          } catch (e) {
+            console.warn("Failed fetching iceUrl");
+          }
+        }
+      });
+      this.rtcConfig = await this.rtcConfigPromise;
+      this.rtcConfigPromise = undefined;
+    }
+    return this.rtcConfig;
+  }
+}
+
+// src/browser/webrtc-peer-collector.ts
+var DEFAULT_ENTER_ROOM = enterRoom2;
+function collectPeerConnections({
+  userId: passedUserId,
+  worldId,
+  receivePeerConnection,
+  peerlessUserExpiration = 5000,
+  enterRoomFunction: enterRoom3 = DEFAULT_ENTER_ROOM,
+  logLine,
+  onLeaveUser,
+  workerUrl,
+  onRoomReady,
+  onRoomClose,
+  onBroadcastMessage
+}) {
+  const userId = passedUserId ?? `user-${crypto.randomUUID()}`;
+  const users = new Map;
+  const roomsEntered = new Map;
+  function leaveUser(userId2) {
+    onLeaveUser?.(userId2);
+    const p = users.get(userId2);
+    if (!p)
+      return;
+    users.delete(userId2);
+    try {
+      p.close();
+    } catch {}
+  }
+  async function flushRemoteIce(state) {
+    if (!state.connection?.pc?.remoteDescription)
+      return;
+    const queued = state.connection.pendingRemoteIce;
+    state.connection.pendingRemoteIce = [];
+    for (const ice of queued) {
+      try {
+        await state.connection.pc.addIceCandidate(ice);
+      } catch (e) {
+        logLine?.("⚠️ ERROR", {
+          error: "add-ice-failed",
+          userId: state.peer,
+          detail: String(e)
+        });
+      }
+    }
+  }
+  const iceUrlProvider = new IceUrlProvider;
+  const rtcConfigProvider = new RTCConfigProvider(iceUrlProvider);
+  function exit({ room, host }) {
+    const key = `${host}/room/${room}`;
+    const session = roomsEntered.get(key);
+    if (session) {
+      session.exitRoom();
+      roomsEntered.delete(key);
+    }
+  }
+  function enter({
+    room,
+    host,
+    protocol
+  }) {
+    return new Promise(async (resolve, reject) => {
+      async function setupConnection(state) {
+        if (state.connectionPromise) {
+          return state.connectionPromise;
+        }
+        const promise = new Promise(async (resolve2) => {
+          state.connection = {
+            id: `conn-${crypto.randomUUID()}`,
+            pc: new RTCPeerConnection(await rtcConfigProvider.getRtcConfig()),
+            pendingRemoteIce: []
+          };
+          state.connection.pc.onicecandidate = (ev) => {
+            if (!ev.candidate)
+              return;
+            send("ice", state.peer, {
+              connectionId: state.connection?.id,
+              ice: ev.candidate.toJSON()
+            });
+          };
+          state.connection.pc.onconnectionstatechange = async () => {
+            logLine?.("\uD83D\uDCAC", {
+              event: "pc-state",
+              userId: state.peer,
+              state: state.connection?.pc?.connectionState
+            });
+            if (state.connection?.pc?.connectionState === "failed") {
+              state.close();
+              const userState = await getPeer(state.peer, true);
+              if (userState.connection?.pc) {
+                receivePeerConnection({
+                  pc: userState.connection?.pc,
+                  userId: userState.peer,
+                  restart: () => userState.close()
+                });
+              } else {
+                logLine?.("\uD83D\uDC64ℹ️", "no pc: " + userState.peer);
+              }
+              return;
+            }
+          };
+          resolve2(state.connection);
+        });
+        state.connectionPromise = promise;
+        await promise;
+        state.connectionPromise = undefined;
+        return promise;
+      }
+      async function getPeer(peer, forceReset) {
+        let state = users.get(peer);
+        if (!state || forceReset) {
+          const newState = {
+            peer,
+            close() {
+              if (this.connection) {
+                this.connection.pc.close();
+                this.connection = undefined;
+              }
+              users.delete(peer);
+            },
+            async reset() {
+              newState.close();
+              setTimeout(async () => {
+                const userState = await getPeer(peer, true);
+                if (!userState.connection?.pc) {
+                  logLine?.("⚠️", "no pc");
+                  return;
+                }
+                receivePeerConnection({
+                  pc: userState.connection?.pc,
+                  userId: userState.peer,
+                  restart: () => userState.close()
+                });
+                await makeOffer(userState.peer);
+              }, 500);
+            }
+          };
+          state = newState;
+          await setupConnection(newState);
+          users.set(state.peer, state);
+        } else if (state) {
+          clearTimeout(state.expirationTimeout);
+          state.expirationTimeout = 0;
+          if (!state.connection?.pc || state.connection?.pc.signalingState === "closed") {
+            await setupConnection(state);
+          }
+        }
+        state.peer = peer;
+        return state;
+      }
+      async function makeOffer(userId2) {
+        const state = await getPeer(userId2);
+        const pc = state.connection?.pc;
+        const offer = await pc?.createOffer();
+        await pc?.setLocalDescription(offer);
+        send("offer", userId2, {
+          connectionId: state.connection?.id,
+          offer: pc?.localDescription?.toJSON()
+        });
+      }
+      const { exitRoom, send } = enterRoom3({
+        userId,
+        worldId,
+        room,
+        protocol,
+        host,
+        logLine,
+        workerUrl,
+        autoRejoin: true,
+        onOpen() {
+          onRoomReady?.({ room, host });
+          resolve();
+        },
+        onError() {
+          console.error("onError");
+          reject();
+        },
+        onClose(ev) {
+          onRoomClose?.({ room, host, ev });
+        },
+        onPeerJoined(joiningUsers, selfJoined) {
+          joiningUsers.forEach(async (user) => {
+            const state = await getPeer(user.userId, true);
+            state.joined = user.joined;
+            const pc = state.connection?.pc;
+            if (!pc) {
+              logLine?.("\uD83D\uDC64ℹ️", "no pc: " + user.userId);
+              return;
+            }
+            receivePeerConnection({
+              pc,
+              userId: user.userId,
+              restart: () => state.close()
+            });
+            if (user.joined > selfJoined || user.joined === selfJoined && user.userId.localeCompare(userId) > 0) {
+              await makeOffer(user.userId);
+            }
+          });
+        },
+        onPeerLeft(leavingUsers) {
+          leavingUsers.forEach(({ userId: userId2 }) => {
+            const state = users.get(userId2);
+            if (!state)
+              return;
+            state.expirationTimeout = setTimeout(() => leaveUser(userId2), peerlessUserExpiration ?? 0);
+          });
+        },
+        onIceUrl(url, expiration) {
+          iceUrlProvider.receiveIce(url, expiration);
+        },
+        async onMessage(type, payload, from) {
+          if (type === "offer" && payload.offer) {
+            const state = await getPeer(from, false);
+            const connection = !state.connection || state.connection.pc.signalingState === "stable" ? await setupConnection(state) : state.connection;
+            logLine?.("\uD83D\uDCAC", {
+              type,
+              signalingState: connection.pc.signalingState
+            });
+            connection.peerConnectionId = payload.connectionId;
+            receivePeerConnection({
+              pc: connection.pc,
+              userId: from,
+              restart: () => state.close()
+            });
+            await connection.pc.setRemoteDescription(payload.offer);
+            const answer = await connection.pc.createAnswer();
+            await connection.pc.setLocalDescription(answer);
+            send("answer", from, {
+              connectionId: connection.id,
+              answer: connection.pc.localDescription?.toJSON()
+            });
+            await flushRemoteIce(state);
+            return;
+          }
+          if (type === "answer" && payload.answer) {
+            const state = await getPeer(from, false);
+            const connection = state.connection && state.connection.pc.signalingState !== "closed" ? state.connection : await setupConnection(state);
+            logLine?.("\uD83D\uDCAC", {
+              type,
+              signalingState: connection.pc.signalingState
+            });
+            await connection.pc.setRemoteDescription(payload.answer);
+            connection.peerConnectionId = payload.connectionId;
+            await flushRemoteIce(state);
+            return;
+          }
+          if (type === "ice" && payload.ice) {
+            const state = await getPeer(from, false);
+            const connection = state.connection ?? await state.connectionPromise;
+            if (!connection) {
+              logLine?.("⚠️", "No connection");
+              return;
+            }
+            logLine?.("\uD83D\uDCAC", {
+              type,
+              signalingState: connection.pc.signalingState
+            });
+            if (connection.peerConnectionId && payload.connectionId !== connection.peerConnectionId) {
+              logLine?.("⚠️", "Mismatch peerConnectionID" + payload.connectionId + "vs" + connection.peerConnectionId);
+              return;
+            }
+            if (!connection.pc.remoteDescription || !connection.peerConnectionId) {
+              connection.peerConnectionId = payload.connectionId;
+              connection.pendingRemoteIce.push(payload.ice);
+              return;
+            }
+            try {
+              await connection.pc.addIceCandidate(payload.ice);
+            } catch (e) {
+              logLine?.("⚠️ ERROR", {
+                error: "add-ice-failed",
+                userId: state.peer,
+                detail: String(e)
+              });
+            }
+            return;
+          }
+          if (type === "broadcast") {
+            onBroadcastMessage?.(payload, from);
+          }
+        }
+      });
+      const removeRequester = iceUrlProvider.addRequester((command) => send(command, "server"));
+      roomsEntered.set(`${host}/room/${room}`, {
+        exitRoom: () => {
+          exitRoom();
+          removeRequester();
+        },
+        room,
+        host,
+        broadcast: (payload) => send("broadcast", "server", payload)
+      });
+    });
+  }
+  return {
+    userId,
+    enterRoom: enter,
+    exitRoom: exit,
+    leaveUser,
+    async reset(userId2) {
+      const userState = users.get(userId2);
+      userState?.reset();
+    },
+    broadcast(payload) {
+      roomsEntered.forEach((room) => room.broadcast(payload));
+    },
+    end() {
+      roomsEntered.forEach(({ exitRoom }) => exitRoom());
+      roomsEntered.clear();
+      users.forEach(({ peer }) => leaveUser(peer));
+      users.clear();
+    }
+  };
+}
+export {
+  collectPeerConnections
+};
+
+//# debugId=FD438A7CC3C2722364756E2164756E21
 //# sourceMappingURL=webrtc-peer-collector.js.map