@bloopjs/web 0.0.44 → 0.0.46

package/dist/mod.js

@@ -2578,7 +2578,787 @@ var TIME_CTX_OFFSET2 = 0;
 var INPUT_CTX_OFFSET2 = TIME_CTX_OFFSET2 + 4;
 var EVENTS_OFFSET2 = INPUT_CTX_OFFSET2 + 4;
 
+// ../../node_modules/partysocket/dist/chunk-V6LO7DXK.mjs
+if (!globalThis.EventTarget || !globalThis.Event) {
+  console.error(`
+  PartySocket requires a global 'EventTarget' class to be available!
+  You can polyfill this global by adding this to your code before any partysocket imports: 
+  
+  \`\`\`
+  import 'partysocket/event-target-polyfill';
+  \`\`\`
+  Please file an issue at https://github.com/partykit/partykit if you're still having trouble.
+`);
+}
+var ErrorEvent = class extends Event {
+  message;
+  error;
+  constructor(error, target) {
+    super("error", target);
+    this.message = error.message;
+    this.error = error;
+  }
+};
+var CloseEvent = class extends Event {
+  code;
+  reason;
+  wasClean = true;
+  constructor(code = 1000, reason = "", target) {
+    super("close", target);
+    this.code = code;
+    this.reason = reason;
+  }
+};
+var Events = {
+  Event,
+  ErrorEvent,
+  CloseEvent
+};
+function assert2(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+function cloneEventBrowser(e) {
+  return new e.constructor(e.type, e);
+}
+function cloneEventNode(e) {
+  if ("data" in e) {
+    const evt2 = new MessageEvent(e.type, e);
+    return evt2;
+  }
+  if ("code" in e || "reason" in e) {
+    const evt2 = new CloseEvent(e.code || 1999, e.reason || "unknown reason", e);
+    return evt2;
+  }
+  if ("error" in e) {
+    const evt2 = new ErrorEvent(e.error, e);
+    return evt2;
+  }
+  const evt = new Event(e.type, e);
+  return evt;
+}
+var _a;
+var isNode = typeof process !== "undefined" && typeof ((_a = process.versions) == null ? undefined : _a.node) !== "undefined" && typeof document === "undefined";
+var cloneEvent = isNode ? cloneEventNode : cloneEventBrowser;
+var DEFAULT = {
+  maxReconnectionDelay: 1e4,
+  minReconnectionDelay: 1000 + Math.random() * 4000,
+  minUptime: 5000,
+  reconnectionDelayGrowFactor: 1.3,
+  connectionTimeout: 4000,
+  maxRetries: Number.POSITIVE_INFINITY,
+  maxEnqueuedMessages: Number.POSITIVE_INFINITY,
+  startClosed: false,
+  debug: false
+};
+var didWarnAboutMissingWebSocket = false;
+var ReconnectingWebSocket = class _ReconnectingWebSocket extends EventTarget {
+  _ws;
+  _retryCount = -1;
+  _uptimeTimeout;
+  _connectTimeout;
+  _shouldReconnect = true;
+  _connectLock = false;
+  _binaryType = "blob";
+  _closeCalled = false;
+  _messageQueue = [];
+  _debugLogger = console.log.bind(console);
+  _url;
+  _protocols;
+  _options;
+  constructor(url, protocols, options = {}) {
+    super();
+    this._url = url;
+    this._protocols = protocols;
+    this._options = options;
+    if (this._options.startClosed) {
+      this._shouldReconnect = false;
+    }
+    if (this._options.debugLogger) {
+      this._debugLogger = this._options.debugLogger;
+    }
+    this._connect();
+  }
+  static get CONNECTING() {
+    return 0;
+  }
+  static get OPEN() {
+    return 1;
+  }
+  static get CLOSING() {
+    return 2;
+  }
+  static get CLOSED() {
+    return 3;
+  }
+  get CONNECTING() {
+    return _ReconnectingWebSocket.CONNECTING;
+  }
+  get OPEN() {
+    return _ReconnectingWebSocket.OPEN;
+  }
+  get CLOSING() {
+    return _ReconnectingWebSocket.CLOSING;
+  }
+  get CLOSED() {
+    return _ReconnectingWebSocket.CLOSED;
+  }
+  get binaryType() {
+    return this._ws ? this._ws.binaryType : this._binaryType;
+  }
+  set binaryType(value) {
+    this._binaryType = value;
+    if (this._ws) {
+      this._ws.binaryType = value;
+    }
+  }
+  get retryCount() {
+    return Math.max(this._retryCount, 0);
+  }
+  get bufferedAmount() {
+    const bytes = this._messageQueue.reduce((acc, message) => {
+      if (typeof message === "string") {
+        acc += message.length;
+      } else if (message instanceof Blob) {
+        acc += message.size;
+      } else {
+        acc += message.byteLength;
+      }
+      return acc;
+    }, 0);
+    return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+  }
+  get extensions() {
+    return this._ws ? this._ws.extensions : "";
+  }
+  get protocol() {
+    return this._ws ? this._ws.protocol : "";
+  }
+  get readyState() {
+    if (this._ws) {
+      return this._ws.readyState;
+    }
+    return this._options.startClosed ? _ReconnectingWebSocket.CLOSED : _ReconnectingWebSocket.CONNECTING;
+  }
+  get url() {
+    return this._ws ? this._ws.url : "";
+  }
+  get shouldReconnect() {
+    return this._shouldReconnect;
+  }
+  onclose = null;
+  onerror = null;
+  onmessage = null;
+  onopen = null;
+  close(code = 1000, reason) {
+    this._closeCalled = true;
+    this._shouldReconnect = false;
+    this._clearTimeouts();
+    if (!this._ws) {
+      this._debug("close enqueued: no ws instance");
+      return;
+    }
+    if (this._ws.readyState === this.CLOSED) {
+      this._debug("close: already closed");
+      return;
+    }
+    this._ws.close(code, reason);
+  }
+  reconnect(code, reason) {
+    this._shouldReconnect = true;
+    this._closeCalled = false;
+    this._retryCount = -1;
+    if (!this._ws || this._ws.readyState === this.CLOSED) {
+      this._connect();
+    } else {
+      this._disconnect(code, reason);
+      this._connect();
+    }
+  }
+  send(data) {
+    if (this._ws && this._ws.readyState === this.OPEN) {
+      this._debug("send", data);
+      this._ws.send(data);
+    } else {
+      const { maxEnqueuedMessages = DEFAULT.maxEnqueuedMessages } = this._options;
+      if (this._messageQueue.length < maxEnqueuedMessages) {
+        this._debug("enqueue", data);
+        this._messageQueue.push(data);
+      }
+    }
+  }
+  _debug(...args) {
+    if (this._options.debug) {
+      this._debugLogger("RWS>", ...args);
+    }
+  }
+  _getNextDelay() {
+    const {
+      reconnectionDelayGrowFactor = DEFAULT.reconnectionDelayGrowFactor,
+      minReconnectionDelay = DEFAULT.minReconnectionDelay,
+      maxReconnectionDelay = DEFAULT.maxReconnectionDelay
+    } = this._options;
+    let delay = 0;
+    if (this._retryCount > 0) {
+      delay = minReconnectionDelay * reconnectionDelayGrowFactor ** (this._retryCount - 1);
+      if (delay > maxReconnectionDelay) {
+        delay = maxReconnectionDelay;
+      }
+    }
+    this._debug("next delay", delay);
+    return delay;
+  }
+  _wait() {
+    return new Promise((resolve) => {
+      setTimeout(resolve, this._getNextDelay());
+    });
+  }
+  _getNextProtocols(protocolsProvider) {
+    if (!protocolsProvider)
+      return Promise.resolve(null);
+    if (typeof protocolsProvider === "string" || Array.isArray(protocolsProvider)) {
+      return Promise.resolve(protocolsProvider);
+    }
+    if (typeof protocolsProvider === "function") {
+      const protocols = protocolsProvider();
+      if (!protocols)
+        return Promise.resolve(null);
+      if (typeof protocols === "string" || Array.isArray(protocols)) {
+        return Promise.resolve(protocols);
+      }
+      if (protocols.then) {
+        return protocols;
+      }
+    }
+    throw Error("Invalid protocols");
+  }
+  _getNextUrl(urlProvider) {
+    if (typeof urlProvider === "string") {
+      return Promise.resolve(urlProvider);
+    }
+    if (typeof urlProvider === "function") {
+      const url = urlProvider();
+      if (typeof url === "string") {
+        return Promise.resolve(url);
+      }
+      if (url.then) {
+        return url;
+      }
+    }
+    throw Error("Invalid URL");
+  }
+  _connect() {
+    if (this._connectLock || !this._shouldReconnect) {
+      return;
+    }
+    this._connectLock = true;
+    const {
+      maxRetries = DEFAULT.maxRetries,
+      connectionTimeout = DEFAULT.connectionTimeout
+    } = this._options;
+    if (this._retryCount >= maxRetries) {
+      this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+      return;
+    }
+    this._retryCount++;
+    this._debug("connect", this._retryCount);
+    this._removeListeners();
+    this._wait().then(() => Promise.all([
+      this._getNextUrl(this._url),
+      this._getNextProtocols(this._protocols || null)
+    ])).then(([url, protocols]) => {
+      if (this._closeCalled) {
+        this._connectLock = false;
+        return;
+      }
+      if (!this._options.WebSocket && typeof WebSocket === "undefined" && !didWarnAboutMissingWebSocket) {
+        console.error(`‼️ No WebSocket implementation available. You should define options.WebSocket. 
+
+For example, if you're using node.js, run \`npm install ws\`, and then in your code:
+
+import PartySocket from 'partysocket';
+import WS from 'ws';
+
+const partysocket = new PartySocket({
+  host: "127.0.0.1:1999",
+  room: "test-room",
+  WebSocket: WS
+});
+
+`);
+        didWarnAboutMissingWebSocket = true;
+      }
+      const WS = this._options.WebSocket || WebSocket;
+      this._debug("connect", { url, protocols });
+      this._ws = protocols ? new WS(url, protocols) : new WS(url);
+      this._ws.binaryType = this._binaryType;
+      this._connectLock = false;
+      this._addListeners();
+      this._connectTimeout = setTimeout(() => this._handleTimeout(), connectionTimeout);
+    }).catch((err) => {
+      this._connectLock = false;
+      this._handleError(new Events.ErrorEvent(Error(err.message), this));
+    });
+  }
+  _handleTimeout() {
+    this._debug("timeout event");
+    this._handleError(new Events.ErrorEvent(Error("TIMEOUT"), this));
+  }
+  _disconnect(code = 1000, reason) {
+    this._clearTimeouts();
+    if (!this._ws) {
+      return;
+    }
+    this._removeListeners();
+    try {
+      if (this._ws.readyState === this.OPEN || this._ws.readyState === this.CONNECTING) {
+        this._ws.close(code, reason);
+      }
+      this._handleClose(new Events.CloseEvent(code, reason, this));
+    } catch (_error) {}
+  }
+  _acceptOpen() {
+    this._debug("accept open");
+    this._retryCount = 0;
+  }
+  _handleOpen = (event) => {
+    this._debug("open event");
+    const { minUptime = DEFAULT.minUptime } = this._options;
+    clearTimeout(this._connectTimeout);
+    this._uptimeTimeout = setTimeout(() => this._acceptOpen(), minUptime);
+    assert2(this._ws, "WebSocket is not defined");
+    this._ws.binaryType = this._binaryType;
+    this._messageQueue.forEach((message) => {
+      var _a2;
+      (_a2 = this._ws) == null || _a2.send(message);
+    });
+    this._messageQueue = [];
+    if (this.onopen) {
+      this.onopen(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
+  };
+  _handleMessage = (event) => {
+    this._debug("message event");
+    if (this.onmessage) {
+      this.onmessage(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
+  };
+  _handleError = (event) => {
+    this._debug("error event", event.message);
+    this._disconnect(undefined, event.message === "TIMEOUT" ? "timeout" : undefined);
+    if (this.onerror) {
+      this.onerror(event);
+    }
+    this._debug("exec error listeners");
+    this.dispatchEvent(cloneEvent(event));
+    this._connect();
+  };
+  _handleClose = (event) => {
+    this._debug("close event");
+    this._clearTimeouts();
+    if (this._shouldReconnect) {
+      this._connect();
+    }
+    if (this.onclose) {
+      this.onclose(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
+  };
+  _removeListeners() {
+    if (!this._ws) {
+      return;
+    }
+    this._debug("removeListeners");
+    this._ws.removeEventListener("open", this._handleOpen);
+    this._ws.removeEventListener("close", this._handleClose);
+    this._ws.removeEventListener("message", this._handleMessage);
+    this._ws.removeEventListener("error", this._handleError);
+  }
+  _addListeners() {
+    if (!this._ws) {
+      return;
+    }
+    this._debug("addListeners");
+    this._ws.addEventListener("open", this._handleOpen);
+    this._ws.addEventListener("close", this._handleClose);
+    this._ws.addEventListener("message", this._handleMessage);
+    this._ws.addEventListener("error", this._handleError);
+  }
+  _clearTimeouts() {
+    clearTimeout(this._connectTimeout);
+    clearTimeout(this._uptimeTimeout);
+  }
+};
+/*!
+ * Reconnecting WebSocket
+ * by Pedro Ladaria <pedro.ladaria@gmail.com>
+ * https://github.com/pladaria/reconnecting-websocket
+ * License MIT
+ */
+
+// src/netcode/logs.ts
+var logger = {
+  onLog: null,
+  matchFrame: -1,
+  frameNumber: -1,
+  log(opts) {
+    this.onLog?.({
+      ...opts,
+      frame_number: this.frameNumber,
+      match_frame: this.matchFrame >= 0 ? this.matchFrame : null,
+      timestamp: Date.now(),
+      severity: "log"
+    });
+  },
+  warn(opts) {
+    this.onLog?.({
+      ...opts,
+      frame_number: this.frameNumber,
+      match_frame: this.matchFrame >= 0 ? this.matchFrame : null,
+      timestamp: Date.now(),
+      severity: "warn"
+    });
+  },
+  error(opts) {
+    this.onLog?.({
+      ...opts,
+      frame_number: this.frameNumber,
+      match_frame: this.matchFrame >= 0 ? this.matchFrame : null,
+      timestamp: Date.now(),
+      severity: "error"
+    });
+  }
+};
+
+// src/netcode/transport.ts
+var cachedIceServers = null;
+var cacheExpiry = 0;
+var TURN_CREDENTIALS_URL = "https://webrtc-divine-glade-8064.fly.dev/turn-credentials";
+var DEFAULT_ICE_TIMEOUT = 60000;
+async function getIceServers() {
+  const now = Date.now();
+  if (cachedIceServers && now < cacheExpiry) {
+    return cachedIceServers;
+  }
+  const res = await fetch(TURN_CREDENTIALS_URL);
+  if (!res.ok) {
+    throw new Error(`TURN credentials fetch failed: ${res.status}`);
+  }
+  const data = await res.json();
+  if (!data.iceServers) {
+    throw new Error("No iceServers in TURN response");
+  }
+  cachedIceServers = data.iceServers.map((server) => {
+    if (Array.isArray(server.urls)) {
+      return {
+        ...server,
+        urls: server.urls.filter((url) => !url.includes(":53"))
+      };
+    }
+    return server;
+  });
+  assert(cachedIceServers && cachedIceServers.length > 0, "No valid iceServers after filtering");
+  cacheExpiry = now + 60 * 60 * 1000;
+  logger.log({
+    source: "webrtc",
+    label: `Got TURN credentials`,
+    json: {
+      iceServers: cachedIceServers
+    }
+  });
+  return cachedIceServers;
+}
+async function connect(ws, peerId, timeoutMs = DEFAULT_ICE_TIMEOUT) {
+  const iceServers = await getIceServers();
+  const pc = new RTCPeerConnection({ iceServers });
+  const reliable = pc.createDataChannel("reliable", {});
+  const unreliable = pc.createDataChannel("unreliable", {
+    ordered: false,
+    maxRetransmits: 0
+  });
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  logger.log({ source: "webrtc", label: "set offer", json: offer });
+  await gatherIce(pc, timeoutMs);
+  logger.log({ source: "webrtc", label: "gathered ICE candidates" });
+  logger.log({
+    source: "ws",
+    label: "sending local description",
+    json: pc.localDescription,
+    to: peerId
+  });
+  send(ws, {
+    type: "offer",
+    payload: btoa(JSON.stringify(pc.localDescription)),
+    target: peerId
+  });
+  await waitForAnswer(ws, pc, timeoutMs);
+  return {
+    peerConnection: pc,
+    reliable,
+    unreliable,
+    peerId
+  };
+}
+async function logErrors(dc) {
+  dc.onerror = (event) => {
+    logger.error({
+      source: "webrtc",
+      label: `error on ${dc.label} channel`,
+      json: event.error
+    });
+  };
+  dc.onclosing = (_event) => {
+    logger.log({
+      source: "webrtc",
+      label: `closing ${dc.label} channel`
+    });
+  };
+  dc.onopen = (_event) => {
+    logger.log({
+      source: "webrtc",
+      label: `opened ${dc.label} channel`
+    });
+  };
+  dc.onclose = (_event) => {
+    logger.log({
+      source: "webrtc",
+      label: `closed ${dc.label} channel`
+    });
+  };
+}
+async function logPeerConnection(pc, peerId) {
+  pc.onconnectionstatechange = () => {
+    logger.log({
+      source: "webrtc",
+      label: `[${peerId.substring(0, 6)}] connectionState = ${pc.connectionState}`
+    });
+  };
+  pc.onsignalingstatechange = () => {
+    logger.log({
+      source: "webrtc",
+      label: `[${peerId.substring(0, 6)}] signalingState = ${pc.signalingState}`
+    });
+  };
+}
+async function gatherIce(pc, timeoutMs) {
+  return new Promise((yes, no) => {
+    setTimeout(() => no(new Error("Ice Gathering Timeout")), timeoutMs);
+    pc.onicegatheringstatechange = () => {
+      logger.log({
+        source: "webrtc",
+        label: `icegatheringstatechange: ${pc.iceGatheringState}`
+      });
+      if (pc.iceGatheringState === "complete") {
+        yes(true);
+      }
+    };
+  });
+}
+async function waitForAnswer(ws, pc, timeoutMs) {
+  return new Promise((yes, no) => {
+    const timeoutId = setTimeout(no, timeoutMs);
+    const messageListener = async (event) => {
+      const serverMsg = JSON.parse(event.data);
+      if (serverMsg.type !== "message:json") {
+        return;
+      }
+      const peerMsg = serverMsg.message;
+      if (peerMsg.type !== "answer") {
+        return;
+      }
+      const answerDesc = JSON.parse(atob(peerMsg.payload));
+      logger.log({
+        source: "webrtc",
+        label: "received answer",
+        json: answerDesc
+      });
+      await pc.setRemoteDescription(new RTCSessionDescription(answerDesc));
+      logger.log({
+        source: "webrtc",
+        label: "set remote description with answer"
+      });
+      clearTimeout(timeoutId);
+      yes();
+    };
+    ws.addEventListener("message", messageListener);
+  });
+}
+function listenForOffers(ws, cb) {
+  const messageListener = async (event) => {
+    const envelope = JSON.parse(event.data);
+    if (envelope.type !== "message:json") {
+      return;
+    }
+    const msg = envelope.message;
+    if (msg.type !== "offer") {
+      return;
+    }
+    logger.log({ source: "webrtc", label: "received offer" });
+    const offer = JSON.parse(atob(msg.payload));
+    const iceServers = await getIceServers();
+    const pc = new RTCPeerConnection({ iceServers });
+    await pc.setRemoteDescription(offer);
+    logger.log({
+      source: "webrtc",
+      label: "set remote description",
+      json: { offer, remoteDescription: pc.remoteDescription }
+    });
+    const answer = await pc.createAnswer();
+    await pc.setLocalDescription(answer);
+    logger.log({
+      source: "webrtc",
+      label: "set local description",
+      json: pc.localDescription
+    });
+    await gatherIce(pc, DEFAULT_ICE_TIMEOUT);
+    const channels = {
+      reliable: null,
+      unreliable: null
+    };
+    pc.ondatachannel = (event2) => {
+      logger.log({
+        source: "webrtc",
+        label: `received datachannel ${event2.channel.label}`
+      });
+      switch (event2.channel.label) {
+        case "reliable":
+          channels.reliable = event2.channel;
+          break;
+        case "unreliable":
+          channels.unreliable = event2.channel;
+          break;
+      }
+      if (channels.reliable && channels.unreliable) {
+        pc.ondatachannel = null;
+        cb({
+          peerConnection: pc,
+          reliable: channels.reliable,
+          unreliable: channels.unreliable,
+          peerId: envelope.peerId
+        });
+      }
+    };
+    logger.log({
+      source: "webrtc",
+      label: "sending answer",
+      json: pc.localDescription
+    });
+    send(ws, {
+      type: "answer",
+      payload: btoa(JSON.stringify(pc.localDescription)),
+      target: envelope.peerId
+    });
+  };
+  ws.addEventListener("message", messageListener);
+}
+function send(ws, msg) {
+  ws.send(JSON.stringify(msg));
+  logger.log({ source: "ws", direction: "outbound", json: msg });
+}
+
+// src/netcode/broker.ts
+function joinRoom(brokerUrl, _roomId, cbs) {
+  const broker = new ReconnectingWebSocket(brokerUrl);
+  broker.addEventListener("open", () => {
+    logger.log({
+      source: "ws",
+      label: "Connection opened"
+    });
+  });
+  broker.addEventListener("close", (event) => {
+    logger.warn({
+      source: "ws",
+      label: "Connection closed",
+      json: event
+    });
+  });
+  broker.addEventListener("error", (event) => {
+    logger.error({
+      source: "ws",
+      label: "Connection error",
+      json: event
+    });
+  });
+  const pipes = new Map;
+  let ourId = "";
+  broker.addEventListener("message", async (event) => {
+    try {
+      const envelope = JSON.parse(event.data);
+      logger.log({
+        source: "ws",
+        direction: "inbound",
+        json: envelope
+      });
+      switch (envelope.type) {
+        case "welcome":
+          ourId = envelope.yourId;
+          cbs.onPeerIdAssign(envelope.yourId);
+          for (const peerId of envelope.peerIds) {
+            if (peerId === ourId)
+              continue;
+            cbs.onPeerConnected(peerId);
+          }
+          break;
+        case "message:json":
+          break;
+        case "peer:connect": {
+          const pipe = await connect(broker, envelope.peerId);
+          registerPipe(pipe, cbs);
+          cbs.onPeerConnected(envelope.peerId);
+          break;
+        }
+        case "peer:disconnect":
+          cbs.onPeerDisconnected(envelope.peerId);
+          break;
+        default:
+          logger.warn({
+            source: "ws",
+            label: `Unknown message type: ${envelope.type}`,
+            json: envelope
+          });
+      }
+    } catch (e) {
+      logger.error({
+        source: "ws",
+        label: "Failure in message handler",
+        json: {
+          data: event.data,
+          error: e
+        }
+      });
+    }
+  });
+  listenForOffers(broker, (pipe) => {
+    registerPipe(pipe, cbs);
+  });
+  function registerPipe(pipe, cbs2) {
+    logErrors(pipe.reliable);
+    logErrors(pipe.unreliable);
+    logPeerConnection(pipe.peerConnection, ourId);
+    cbs2.onDataChannelOpen(pipe.peerId, true, pipe.reliable);
+    cbs2.onDataChannelOpen(pipe.peerId, false, pipe.unreliable);
+    pipe.reliable.onmessage = (event) => {
+      cbs2.onMessage(pipe.peerId, event.data, true);
+    };
+    pipe.reliable.onclose = () => {
+      cbs2.onDataChannelClose(pipe.peerId, true);
+    };
+    pipe.unreliable.onmessage = (event) => {
+      cbs2.onMessage(pipe.peerId, event.data, false);
+    };
+    pipe.unreliable.onclose = () => {
+      cbs2.onDataChannelClose(pipe.peerId, false);
+    };
+    pipes.set(pipe.peerId, pipe);
+  }
+}
+
 // src/App.ts
+var DEFAULT_BROKER_URL = "wss://webrtc-divine-glade-8064.fly.dev/ws";
 async function start(opts) {
   if (!opts.sim) {
     const { sim } = await mount({
@@ -2588,20 +3368,24 @@ async function start(opts) {
     });
     opts.sim = sim;
   }
-  const app = new App(opts.sim, opts.game);
+  const app = new App(opts.sim, opts.game, opts.brokerUrl ?? DEFAULT_BROKER_URL);
   return app;
 }
 
 class App {
   #sim;
   game;
+  brokerUrl;
   #rafHandle = null;
   #unsubscribe = null;
   #now = performance.now();
-  constructor(sim, game) {
+  constructor(sim, game, brokerUrl) {
     this.#sim = sim;
     this.game = game;
+    this.brokerUrl = brokerUrl;
     this.game.hooks.beforeFrame = (frame) => {
+      logger.frameNumber = this.#sim.time.frame;
+      logger.matchFrame = this.#sim.wasm.get_match_frame();
       this.beforeFrame.notify(frame);
     };
     this.subscribe();
@@ -2612,6 +3396,9 @@ class App {
   set sim(sim) {
     this.#sim = sim;
   }
+  joinRoom(roomId, callbacks) {
+    joinRoom(this.brokerUrl, roomId, callbacks);
+  }
   beforeFrame = createListener();
   afterFrame = createListener();
   subscribe() {
@@ -2748,10 +3535,18 @@ function createListener() {
     unsubscribeAll: () => listeners.clear()
   };
 }
+// src/netcode/protocol.ts
+var PacketType;
+((PacketType2) => {
+  PacketType2[PacketType2["None"] = 0] = "None";
+  PacketType2[PacketType2["Inputs"] = 1] = "Inputs";
+})(PacketType ||= {});
 export {
   start,
+  logger,
+  PacketType,
   App
 };
 
-//# debugId=59867E7246609DC264756E2164756E21
+//# debugId=9F8E122AB076111B64756E2164756E21
 //# sourceMappingURL=mod.js.map