@aethervtt/shard-net-webrtc 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-net-webrtc
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/connection.d.ts

@@ -0,0 +1,56 @@
+import { ShardError } from '@aethervtt/shard-core';
+import type { Channel, ConnectionStats, NetConnection, PeerId } from '@aethervtt/shard-net';
+import type { SignalData } from './protocol.js';
+/**
+ * One peer as a net connection (0091): two negotiated data channels, `reliable` (id 0, ordered)
+ * and `unreliable` (id 1, unordered, no retransmits). Negotiated ids mean both sides create the
+ * same channels and neither waits for `ondatachannel`.
+ */
+export declare class WebRtcConnection implements NetConnection {
+    readonly peer: PeerId;
+    readonly pc: RTCPeerConnection;
+    /** Resolves when both channels are open; rejects if the connection fails first. */
+    readonly opened: Promise<void>;
+    private readonly channels;
+    private readonly maxMessage;
+    private readonly messageFns;
+    private readonly closeFns;
+    private readonly counters;
+    private closed;
+    private closing;
+    private readonly cleanup;
+    constructor(pc: RTCPeerConnection, peer: PeerId, maxMessage: number);
+    /** Runs when the connection ends either way (closes the peer's lobby socket). */
+    onEnd(fn: () => void): void;
+    private fail;
+    send(channel: Channel, bytes: Uint8Array): void;
+    onMessage(fn: (channel: Channel, bytes: Uint8Array) => void): () => void;
+    onClose(fn: (reason: ShardError | undefined) => void): () => void;
+    /**
+     * Closes gracefully: no more sends, then the channels close once what's queued has gone out (a
+     * goodbye message arrives before the close), and the peer connection after them.
+     */
+    close(): void;
+    private shut;
+    stats(): ConnectionStats;
+}
+export declare function failed(message: string): ShardError;
+/**
+ * Runs one side of the offer/answer exchange. The joiner offers; the host answers. Candidates
+ * that arrive before the remote description wait for it.
+ */
+export declare class Negotiation {
+    private readonly pc;
+    private readonly send;
+    private readonly pending;
+    private remoteSet;
+    private chain;
+    error: ShardError | undefined;
+    constructor(pc: RTCPeerConnection, send: (data: SignalData) => void);
+    /** Joiner: make and send the offer. */
+    offer(): void;
+    /** Handles what the other side sent, in arrival order. */
+    receive(data: SignalData): void;
+    private sendDescription;
+    private queue;
+}

package/dist/connection.js

@@ -0,0 +1,193 @@
+import { ShardError } from "@aethervtt/shard-core";
+class WebRtcConnection {
+  peer;
+  pc;
+  /** Resolves when both channels are open; rejects if the connection fails first. */
+  opened;
+  channels;
+  maxMessage;
+  messageFns = [];
+  closeFns = [];
+  counters = { rtt: 0, sentBytes: 0, receivedBytes: 0, lost: 0 };
+  closed = false;
+  closing = false;
+  cleanup = [];
+  constructor(pc, peer, maxMessage) {
+    this.pc = pc;
+    this.peer = peer;
+    this.maxMessage = maxMessage;
+    const reliable = pc.createDataChannel("reliable", { negotiated: true, id: 0, ordered: true });
+    const unreliable = pc.createDataChannel("unreliable", {
+      negotiated: true,
+      id: 1,
+      ordered: false,
+      maxRetransmits: 0
+    });
+    this.channels = [reliable, unreliable];
+    let open = 0;
+    let settle;
+    this.opened = new Promise((resolve, reject) => {
+      settle = { resolve, reject };
+    });
+    this.opened.catch(() => {
+    });
+    const names = ["reliable", "unreliable"];
+    this.channels.forEach((dc, i) => {
+      dc.binaryType = "arraybuffer";
+      dc.onopen = () => {
+        if (++open === 2) settle?.resolve();
+      };
+      dc.onmessage = (event) => {
+        const data = event.data;
+        const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : void 0;
+        if (!bytes) return;
+        this.counters.receivedBytes += bytes.length;
+        for (const fn of this.messageFns) fn(names[i], bytes);
+      };
+      dc.onclose = () => this.fail("A data channel closed");
+    });
+    pc.onconnectionstatechange = () => {
+      const state = pc.connectionState;
+      if (state === "failed" || state === "closed") this.fail(`WebRTC connection ${state}`);
+    };
+    this.cleanup.push(() => settle?.reject(failed("The connection closed before it opened")));
+  }
+  /** Runs when the connection ends either way (closes the peer's lobby socket). */
+  onEnd(fn) {
+    this.cleanup.push(fn);
+  }
+  fail(message) {
+    this.shut(this.closing ? void 0 : failed(message));
+  }
+  send(channel, bytes) {
+    if (this.closed) return;
+    if (bytes.length > this.maxMessage) {
+      throw new ShardError(
+        "net/message-too-large",
+        `A ${bytes.length}-byte message is over ${this.maxMessage} bytes`,
+        {
+          hint: "Reliable messages are split automatically; keep unreliable ones under maxMessage."
+        }
+      );
+    }
+    const dc = this.channels[channel === "reliable" ? 0 : 1];
+    if (dc.readyState !== "open") return;
+    this.counters.sentBytes += bytes.length;
+    try {
+      dc.send(bytes.slice());
+    } catch {
+      this.fail("A data channel closed while sending");
+    }
+  }
+  onMessage(fn) {
+    this.messageFns.push(fn);
+    return () => remove(this.messageFns, fn);
+  }
+  onClose(fn) {
+    this.closeFns.push(fn);
+    return () => remove(this.closeFns, fn);
+  }
+  /**
+   * Closes gracefully: no more sends, then the channels close once what's queued has gone out (a
+   * goodbye message arrives before the close), and the peer connection after them.
+   */
+  close() {
+    if (this.closed) return;
+    this.closing = true;
+    this.shut(void 0, true);
+  }
+  shut(reason, graceful = false) {
+    if (this.closed) return;
+    this.closed = true;
+    const teardown = () => {
+      for (const dc of this.channels) dc.close();
+      setTimeout(() => this.pc.close(), graceful ? LINGER_MS : 0);
+    };
+    if (graceful) drain(this.channels, teardown);
+    else teardown();
+    for (const fn of this.cleanup.splice(0)) fn();
+    for (const fn of [...this.closeFns]) fn(reason);
+  }
+  stats() {
+    return { ...this.counters };
+  }
+}
+const LINGER_MS = 250;
+const DRAIN_LIMIT_MS = 1e3;
+function drain(channels, done) {
+  const start = Date.now();
+  const check = () => {
+    const queued = channels.some((dc) => dc.readyState === "open" && dc.bufferedAmount > 0);
+    if (!queued || Date.now() - start > DRAIN_LIMIT_MS) done();
+    else setTimeout(check, 10);
+  };
+  check();
+}
+function failed(message) {
+  return new ShardError("net/webrtc-failed", message, {
+    hint: "Peers on different networks need STUN (and TURN behind strict NATs) in iceServers."
+  });
+}
+function remove(list, item) {
+  const i = list.indexOf(item);
+  if (i !== -1) list.splice(i, 1);
+}
+class Negotiation {
+  pc;
+  send;
+  pending = [];
+  remoteSet = false;
+  chain = Promise.resolve();
+  error;
+  constructor(pc, send) {
+    this.pc = pc;
+    this.send = send;
+    pc.onicecandidate = (event) => {
+      const c = event.candidate;
+      if (!c?.candidate) return;
+      send({
+        candidate: { candidate: c.candidate, sdpMid: c.sdpMid, sdpMLineIndex: c.sdpMLineIndex }
+      });
+    };
+  }
+  /** Joiner: make and send the offer. */
+  offer() {
+    this.queue(async () => {
+      const offer = await this.pc.createOffer();
+      await this.pc.setLocalDescription(offer);
+      this.sendDescription();
+    });
+  }
+  /** Handles what the other side sent, in arrival order. */
+  receive(data) {
+    this.queue(async () => {
+      if ("sdp" in data) {
+        await this.pc.setRemoteDescription(data.sdp);
+        this.remoteSet = true;
+        for (const c of this.pending.splice(0)) await this.pc.addIceCandidate(c);
+        if (data.sdp.type === "offer") {
+          const answer = await this.pc.createAnswer();
+          await this.pc.setLocalDescription(answer);
+          this.sendDescription();
+        }
+      } else if (this.remoteSet) {
+        await this.pc.addIceCandidate(data.candidate);
+      } else this.pending.push(data.candidate);
+    });
+  }
+  sendDescription() {
+    const d = this.pc.localDescription;
+    if (d) this.send({ sdp: { type: d.type, sdp: d.sdp } });
+  }
+  queue(step) {
+    this.chain = this.chain.then(step).catch((err) => {
+      this.error = failed(err instanceof Error ? err.message : String(err));
+      this.pc.close();
+    });
+  }
+}
+export {
+  Negotiation,
+  WebRtcConnection,
+  failed
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { NetSessionProvider, TransportCaps } from '@aethervtt/shard-net';
+import { type LobbyWebSocketClass } from './lobby.js';
+export interface WebRtcLobbyOptions {
+    /** The lobby server, `ws://` or `wss://`. */
+    url: string;
+    /** STUN and TURN servers. Without them peers connect only on the same network. */
+    iceServers?: RTCIceServer[];
+    /** Default: the global one (browsers). Node passes one, e.g. from `node-datachannel/polyfill`. */
+    RTCPeerConnection?: typeof RTCPeerConnection;
+    /** Default: the global one (browsers, Node 22+). */
+    WebSocket?: LobbyWebSocketClass;
+    /** Largest data-channel message. Default 64 KiB. */
+    maxMessage?: number;
+    /** How long a join may take to open its channels, in ms. Default 15 s. */
+    connectTimeout?: number;
+}
+/**
+ * Peer-to-peer sessions over WebRTC, introduced by a lobby (0091). Hosting gets a room code;
+ * joining with it opens a direct connection to the host. Pass it as `netPlugin({ session })`.
+ */
+export declare function webRtcLobby(options: WebRtcLobbyOptions): NetSessionProvider & {
+    readonly caps: TransportCaps;
+};
+export { Negotiation, WebRtcConnection } from './connection.js';
+export type { LobbyWebSocket, LobbyWebSocketClass } from './lobby.js';
+export type { FromLobby, RoomInfo, SignalData, ToLobby } from './protocol.js';

package/dist/index.js

@@ -0,0 +1,135 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { failed, Negotiation, WebRtcConnection } from "./connection.js";
+import { LobbySocket } from "./lobby.js";
+function webRtcLobby(options) {
+  const maxMessage = options.maxMessage ?? 64 * 1024;
+  const timeout = options.connectTimeout ?? 15e3;
+  const config = { iceServers: options.iceServers ?? [] };
+  const Socket = options.WebSocket ?? globalThis.WebSocket;
+  const Peer = options.RTCPeerConnection ?? globalThis.RTCPeerConnection;
+  const open = () => {
+    if (!Socket) {
+      throw new ShardError("net/no-websocket", "This runtime has no global WebSocket", {
+        hint: "Pass one: webRtcLobby({ WebSocket })."
+      });
+    }
+    return LobbySocket.open(options.url, Socket);
+  };
+  const peer = () => {
+    if (!Peer) {
+      throw new ShardError("net/no-webrtc", "This runtime has no RTCPeerConnection", {
+        hint: "In Node, pass one: webRtcLobby({ RTCPeerConnection }) from node-datachannel/polyfill."
+      });
+    }
+    return new Peer(config);
+  };
+  return {
+    name: "webrtc-lobby",
+    caps: { unreliable: true, maxMessage },
+    async host(listen) {
+      const lobby = await open();
+      lobby.send({
+        t: "host",
+        ...listen.meta ? { meta: listen.meta } : {},
+        ...listen.maxPeers ? { maxPeers: listen.maxPeers } : {}
+      });
+      const { code } = await lobby.next("hosted");
+      const fns = [];
+      const joining = /* @__PURE__ */ new Map();
+      let nextPeer = 1;
+      lobby.on("joined", ({ id }) => {
+        const pc = peer();
+        const connection = new WebRtcConnection(pc, nextPeer++, maxMessage);
+        const negotiation = new Negotiation(pc, (data) => lobby.send({ t: "signal", to: id, data }));
+        joining.set(id, negotiation);
+        connection.opened.then(
+          () => {
+            joining.delete(id);
+            for (const fn of fns) fn(connection);
+          },
+          () => joining.delete(id)
+        );
+        setTimeout(() => {
+          if (joining.get(id) === negotiation) connection.close();
+        }, timeout);
+      });
+      lobby.on("signal", ({ from, data }) => joining.get(from)?.receive(data));
+      lobby.on("left", ({ id }) => joining.delete(id));
+      const listener = {
+        onConnection(fn) {
+          fns.push(fn);
+          return () => {
+            const i = fns.indexOf(fn);
+            if (i !== -1) fns.splice(i, 1);
+          };
+        },
+        async close() {
+          lobby.close();
+        }
+      };
+      return { code, listener };
+    },
+    async join(code) {
+      const lobby = await open();
+      lobby.send({ t: "join", code });
+      try {
+        await lobby.next("joining");
+      } catch (err) {
+        lobby.close();
+        throw err;
+      }
+      const pc = peer();
+      const connection = new WebRtcConnection(pc, 0, maxMessage);
+      const negotiation = new Negotiation(pc, (data) => lobby.send({ t: "signal", data }));
+      lobby.on("signal", ({ data }) => negotiation.receive(data));
+      connection.onEnd(() => lobby.close());
+      lobby.onClose(() => {
+        if (!opened) connection.close();
+      });
+      let opened = false;
+      negotiation.offer();
+      let timer;
+      try {
+        await Promise.race([
+          connection.opened,
+          new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(
+                negotiation.error ?? failed(`No connection to the host within ${timeout} ms`)
+              ),
+              timeout
+            );
+          })
+        ]);
+        opened = true;
+      } catch (err) {
+        connection.close();
+        throw negotiation.error ?? err;
+      } finally {
+        clearTimeout(timer);
+      }
+      return connection;
+    },
+    async list(filter) {
+      const lobby = await open();
+      try {
+        lobby.send({ t: "list" });
+        const { rooms } = await lobby.next("rooms");
+        return rooms.filter((r) => !filter || Object.entries(filter).every(([k, v]) => r.meta[k] === v)).map((r) => ({
+          code: r.code,
+          meta: r.meta,
+          peers: r.peers,
+          ...r.maxPeers === null ? {} : { maxPeers: r.maxPeers }
+        }));
+      } finally {
+        lobby.close();
+      }
+    }
+  };
+}
+import { Negotiation as Negotiation2, WebRtcConnection as WebRtcConnection2 } from "./connection.js";
+export {
+  Negotiation2 as Negotiation,
+  WebRtcConnection2 as WebRtcConnection,
+  webRtcLobby
+};

package/dist/lobby.d.ts

@@ -0,0 +1,34 @@
+import type { FromLobby, ToLobby } from './protocol.js';
+/** What a browser `WebSocket` (and Node 22's global one) offers. */
+export interface LobbyWebSocket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(): void;
+    addEventListener(type: 'open', fn: () => void): void;
+    addEventListener(type: 'message', fn: (event: {
+        data: unknown;
+    }) => void): void;
+    addEventListener(type: 'close', fn: () => void): void;
+    addEventListener(type: 'error', fn: () => void): void;
+}
+export type LobbyWebSocketClass = new (url: string) => LobbyWebSocket;
+/** A JSON connection to the lobby, with waiting for one reply by type. */
+export declare class LobbySocket {
+    private readonly socket;
+    private readonly handlers;
+    private readonly closeFns;
+    closed: boolean;
+    private constructor();
+    static open(url: string, Socket: LobbyWebSocketClass): Promise<LobbySocket>;
+    send(message: ToLobby): void;
+    on<T extends FromLobby['t']>(type: T, fn: (message: Extract<FromLobby, {
+        t: T;
+    }>) => void): void;
+    onClose(fn: () => void): void;
+    /** The next message of `type`; an `error` message or a close rejects. */
+    next<T extends FromLobby['t']>(type: T): Promise<Extract<FromLobby, {
+        t: T;
+    }>>;
+    private off;
+    close(): void;
+}

package/dist/lobby.js

@@ -0,0 +1,95 @@
+import { ShardError } from "@aethervtt/shard-core";
+class LobbySocket {
+  socket;
+  handlers = /* @__PURE__ */ new Map();
+  closeFns = [];
+  closed = false;
+  constructor(socket) {
+    this.socket = socket;
+    socket.addEventListener("message", (event) => {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      for (const fn of [...this.handlers.get(message.t) ?? []]) fn(message);
+      for (const fn of [...this.handlers.get("*") ?? []]) fn(message);
+    });
+    socket.addEventListener("close", () => {
+      this.closed = true;
+      for (const fn of this.closeFns.splice(0)) fn();
+    });
+  }
+  static open(url, Socket) {
+    return new Promise((resolve, reject) => {
+      const socket = new Socket(url);
+      let settled = false;
+      socket.addEventListener("open", () => {
+        settled = true;
+        resolve(new LobbySocket(socket));
+      });
+      const fail = () => {
+        if (settled) return;
+        settled = true;
+        reject(
+          new ShardError("net/connect-failed", `Couldn't reach the lobby at ${url}`, {
+            hint: "Check the lobby server is running and the URL (ws:// or wss://)."
+          })
+        );
+      };
+      socket.addEventListener("error", fail);
+      socket.addEventListener("close", fail);
+    });
+  }
+  send(message) {
+    if (!this.closed) this.socket.send(JSON.stringify(message));
+  }
+  on(type, fn) {
+    const list = this.handlers.get(type) ?? [];
+    list.push(fn);
+    this.handlers.set(type, list);
+  }
+  onClose(fn) {
+    if (this.closed) fn();
+    else this.closeFns.push(fn);
+  }
+  /** The next message of `type`; an `error` message or a close rejects. */
+  next(type) {
+    return new Promise((resolve, reject) => {
+      const done = () => {
+        this.off(type, onMessage);
+        this.off("error", onError);
+      };
+      const onMessage = (m) => {
+        done();
+        resolve(m);
+      };
+      const onError = (m) => {
+        done();
+        const e = m;
+        reject(new ShardError(e.code, e.message));
+      };
+      this.on(type, onMessage);
+      this.on("error", onError);
+      this.onClose(() => {
+        done();
+        reject(new ShardError("net/lobby-closed", "The lobby connection closed"));
+      });
+    });
+  }
+  off(type, fn) {
+    const list = this.handlers.get(type);
+    const i = list?.indexOf(fn) ?? -1;
+    if (i !== -1) list.splice(i, 1);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.socket.close();
+    for (const fn of this.closeFns.splice(0)) fn();
+  }
+}
+export {
+  LobbySocket
+};

package/dist/protocol.d.ts

@@ -0,0 +1,63 @@
+import type { JsonObject } from '@aethervtt/shard-core';
+export interface RoomInfo {
+    code: string;
+    meta: JsonObject;
+    /** Players connected through the lobby (each keeps its lobby socket while in the game). */
+    peers: number;
+    maxPeers: number | null;
+}
+/** Offers, answers and network candidates, passed between two peers through the lobby. */
+export type SignalData = {
+    sdp: {
+        type: string;
+        sdp: string;
+    };
+} | {
+    candidate: {
+        candidate: string;
+        sdpMid: string | null;
+        sdpMLineIndex: number | null;
+    };
+};
+export type ToLobby = {
+    t: 'host';
+    meta?: JsonObject;
+    maxPeers?: number;
+} | {
+    t: 'join';
+    code: string;
+}
+/** From a host: `to` is a joiner's id. From a joiner: always to its room's host. */
+ | {
+    t: 'signal';
+    to?: number;
+    data: SignalData;
+} | {
+    t: 'list';
+};
+export type FromLobby = {
+    t: 'hosted';
+    code: string;
+} | {
+    t: 'joined';
+    id: number;
+} | {
+    t: 'joining';
+    id: number;
+} | {
+    t: 'left';
+    id: number;
+} | {
+    t: 'signal';
+    from: number;
+    data: SignalData;
+} | {
+    t: 'rooms';
+    rooms: RoomInfo[];
+} | {
+    t: 'error';
+    code: string;
+    message: string;
+} | {
+    t: 'closed';
+};

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import type { RoomInfo } from './protocol.js';
+export interface LobbyServerOptions {
+    /** 0 picks a free port: read it from `port`. */
+    port?: number;
+    host?: string;
+    /** Rooms at most. Default 10,000. */
+    maxRooms?: number;
+}
+export interface LobbyServer {
+    readonly port: number;
+    rooms(): RoomInfo[];
+    close(): Promise<void>;
+}
+/**
+ * The lobby (0091): room codes, a room list, and signaling between a room's host and its joiners.
+ * Game traffic never passes through it.
+ */
+export declare function lobbyServer(options?: LobbyServerOptions): Promise<LobbyServer>;

package/dist/server.js

@@ -0,0 +1,113 @@
+import { randomInt } from "node:crypto";
+import { WebSocketServer } from "ws";
+const ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+async function lobbyServer(options = {}) {
+  const server = new WebSocketServer({
+    port: options.port ?? 0,
+    host: options.host ?? "127.0.0.1",
+    maxPayload: 64 * 1024
+  });
+  await new Promise((resolve, reject) => {
+    server.once("listening", resolve);
+    server.once("error", reject);
+  });
+  const rooms = /* @__PURE__ */ new Map();
+  const maxRooms = options.maxRooms ?? 1e4;
+  let nextId = 1;
+  const send = (client, message) => {
+    if (client.socket.readyState === 1) client.socket.send(JSON.stringify(message));
+  };
+  const error = (client, code, message) => send(client, { t: "error", code, message });
+  const info = (room) => ({
+    code: room.code,
+    meta: room.meta,
+    peers: room.joiners.size,
+    maxPeers: room.maxPeers
+  });
+  const newCode = () => {
+    for (; ; ) {
+      let code = "";
+      for (let i = 0; i < 6; i++) code += ALPHABET[randomInt(ALPHABET.length)];
+      if (!rooms.has(code)) return code;
+    }
+  };
+  server.on("connection", (socket) => {
+    const client = { id: nextId++, socket, room: void 0 };
+    socket.on("message", (raw) => {
+      let message;
+      try {
+        message = JSON.parse(String(raw));
+      } catch {
+        error(client, "net/bad-lobby-message", "Lobby messages are JSON");
+        return;
+      }
+      switch (message.t) {
+        case "host": {
+          if (client.room) return error(client, "net/bad-lobby-message", "Already in a room");
+          if (rooms.size >= maxRooms) return error(client, "net/room-full", "The lobby is full");
+          const room = {
+            code: newCode(),
+            host: client,
+            meta: message.meta ?? {},
+            maxPeers: message.maxPeers ?? null,
+            joiners: /* @__PURE__ */ new Map()
+          };
+          rooms.set(room.code, room);
+          client.room = room;
+          return send(client, { t: "hosted", code: room.code });
+        }
+        case "join": {
+          if (client.room) return error(client, "net/bad-lobby-message", "Already in a room");
+          const room = rooms.get(String(message.code).toUpperCase());
+          if (!room) return error(client, "net/room-not-found", `No room ${message.code}`);
+          if (room.maxPeers !== null && room.joiners.size >= room.maxPeers) {
+            return error(client, "net/room-full", `Room ${room.code} is full`);
+          }
+          room.joiners.set(client.id, client);
+          client.room = room;
+          send(room.host, { t: "joined", id: client.id });
+          return send(client, { t: "joining", id: client.id });
+        }
+        case "signal": {
+          const room = client.room;
+          if (!room) return error(client, "net/bad-lobby-message", "Join or host a room first");
+          if (room.host === client) {
+            const to = room.joiners.get(Number(message.to));
+            if (to) send(to, { t: "signal", from: client.id, data: message.data });
+          } else send(room.host, { t: "signal", from: client.id, data: message.data });
+          return;
+        }
+        case "list":
+          return send(client, { t: "rooms", rooms: [...rooms.values()].map(info) });
+        default:
+          return error(client, "net/bad-lobby-message", "Unknown lobby message");
+      }
+    });
+    socket.on("close", () => {
+      const room = client.room;
+      if (!room) return;
+      if (room.host === client) {
+        rooms.delete(room.code);
+        for (const joiner of room.joiners.values()) {
+          send(joiner, { t: "closed" });
+          joiner.room = void 0;
+        }
+      } else {
+        room.joiners.delete(client.id);
+        send(room.host, { t: "left", id: client.id });
+      }
+    });
+  });
+  const address = server.address();
+  return {
+    port: typeof address === "object" && address ? address.port : 0,
+    rooms: () => [...rooms.values()].map(info),
+    close: () => new Promise((resolve) => {
+      for (const socket of server.clients) socket.terminate();
+      server.close(() => resolve());
+    })
+  };
+}
+export {
+  lobbyServer
+};

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@aethervtt/shard-net-webrtc",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.3.0",
+    "@aethervtt/shard-net": "0.3.0",
+    "ws": "^8.21.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/net-webrtc"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "7c8c46fee30f86eff262af53b9249bdae6ce4927"
+  }
+}