@kossabos/patchwork-image-boardgameio 0.1.0

package/dist/index.js

@@ -0,0 +1,903 @@
+// src/context.ts
+var getReact = () => {
+  const win = window;
+  if (!win.React) {
+    throw new Error(
+      "[boardgameio] React not found on window. Ensure React is preloaded."
+    );
+  }
+  return win.React;
+};
+var SettingsContext = null;
+function getSettingsContext() {
+  if (!SettingsContext) {
+    SettingsContext = getReact().createContext({});
+  }
+  return SettingsContext;
+}
+function SettingsProvider({
+  settings,
+  children
+}) {
+  const React = getReact();
+  const Context = getSettingsContext();
+  return React.createElement(
+    Context.Provider,
+    { value: settings },
+    children
+  );
+}
+function useSettings() {
+  const React = getReact();
+  const Context = getSettingsContext();
+  return React.useContext(Context);
+}
+
+// src/p2p/authentication.ts
+function generateCredentials() {
+  const bytes = new Uint8Array(64);
+  crypto.getRandomValues(bytes);
+  return btoa(String.fromCharCode(...bytes));
+}
+function generateKeyPair() {
+  const privateKey = new Uint8Array(64);
+  crypto.getRandomValues(privateKey);
+  const publicKey = privateKey.slice(0, 32);
+  return {
+    publicKey: btoa(String.fromCharCode(...publicKey)),
+    privateKey: btoa(String.fromCharCode(...privateKey))
+  };
+}
+function signMessage(message, privateKey) {
+  const msgBytes = new TextEncoder().encode(message);
+  const keyBytes = Uint8Array.from(atob(privateKey), (c) => c.charCodeAt(0));
+  const signature = new Uint8Array(msgBytes.length + 64);
+  signature.set(msgBytes);
+  signature.set(keyBytes.slice(0, 64), msgBytes.length);
+  return btoa(String.fromCharCode(...signature));
+}
+function verifyMessage(signedMessage, publicKey, playerID) {
+  try {
+    const sigBytes = Uint8Array.from(
+      atob(signedMessage),
+      (c) => c.charCodeAt(0)
+    );
+    const keyBytes = Uint8Array.from(atob(publicKey), (c) => c.charCodeAt(0));
+    if (sigBytes.length < 64 || keyBytes.length < 32) return false;
+    const msgBytes = sigBytes.slice(0, -64);
+    const decoded = new TextDecoder().decode(msgBytes);
+    return decoded === playerID;
+  } catch {
+    return false;
+  }
+}
+function authenticate(matchID, clientMetadata, db) {
+  const { playerID, credentials, message } = clientMetadata;
+  const { metadata } = db.fetch(matchID);
+  if (!metadata) return false;
+  if (playerID === null || playerID === void 0 || !(+playerID in metadata.players)) {
+    return true;
+  }
+  const existingCredentials = metadata.players[+playerID]?.credentials;
+  const isMessageValid = credentials ? !!message && verifyMessage(message, credentials, playerID) : false;
+  if (!existingCredentials && isMessageValid) {
+    db.setMetadata(matchID, {
+      ...metadata,
+      players: {
+        ...metadata.players,
+        [+playerID]: { ...metadata.players[+playerID], credentials }
+      }
+    });
+    return true;
+  }
+  if (!existingCredentials && !credentials) return true;
+  if (existingCredentials === credentials && isMessageValid) return true;
+  return false;
+}
+
+// src/p2p/db.ts
+var P2PDB = class {
+  constructor() {
+    this.initialState = /* @__PURE__ */ new Map();
+    this.state = /* @__PURE__ */ new Map();
+    this.log = /* @__PURE__ */ new Map();
+    this.metadata = /* @__PURE__ */ new Map();
+  }
+  connect() {
+  }
+  createMatch(matchID, opts) {
+    this.initialState.set(matchID, opts.initialState);
+    this.state.set(matchID, opts.initialState);
+    this.log.set(matchID, opts.initialState._stateID === 0 ? [] : []);
+    this.metadata.set(matchID, opts.metadata);
+  }
+  setState(matchID, state, deltalog) {
+    this.state.set(matchID, state);
+    if (deltalog) {
+      const existing = this.log.get(matchID) ?? [];
+      this.log.set(matchID, [...existing, ...deltalog]);
+    }
+  }
+  setMetadata(matchID, metadata) {
+    this.metadata.set(matchID, metadata);
+  }
+  fetch(matchID) {
+    return {
+      state: this.state.get(matchID),
+      initialState: this.initialState.get(matchID),
+      log: this.log.get(matchID),
+      metadata: this.metadata.get(matchID)
+    };
+  }
+  wipe(matchID) {
+    this.initialState.delete(matchID);
+    this.state.delete(matchID);
+    this.log.delete(matchID);
+    this.metadata.delete(matchID);
+  }
+  listMatches() {
+    return [...this.metadata.keys()];
+  }
+};
+
+// src/p2p/host.ts
+var P2PHost = class {
+  constructor({
+    game,
+    numPlayers = 2,
+    matchID
+  }) {
+    this.clients = /* @__PURE__ */ new Map();
+    this.hostClient = null;
+    this.matchID = matchID;
+    this.game = game;
+    this.numPlayers = numPlayers;
+    this.db = new P2PDB();
+    const initialState = this.createInitialState();
+    this.state = initialState;
+    const players = {};
+    for (let i = 0; i < numPlayers; i++) {
+      players[i] = { id: i };
+    }
+    this.db.createMatch(matchID, {
+      initialState,
+      metadata: {
+        gameName: game.name ?? "unknown",
+        players,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      }
+    });
+  }
+  createInitialState() {
+    const activePlayers = {};
+    for (let i = 0; i < this.numPlayers; i++) {
+      activePlayers[String(i)] = "";
+    }
+    const ctx = {
+      numPlayers: this.numPlayers,
+      turn: 1,
+      currentPlayer: "0",
+      playOrder: Array.from({ length: this.numPlayers }, (_, i) => String(i)),
+      playOrderPos: 0,
+      phase: "",
+      activePlayers
+    };
+    const G = this.game.setup?.({ ctx, ...ctx }) ?? {};
+    return {
+      G,
+      ctx,
+      plugins: {},
+      _stateID: 0,
+      _undo: [],
+      _redo: []
+    };
+  }
+  registerClient(client) {
+    if (!authenticate(this.matchID, client.metadata, this.db)) {
+      console.log(
+        "[P2PHost] Client auth failed for playerID:",
+        client.metadata.playerID
+      );
+      return;
+    }
+    console.log(
+      "[P2PHost] Registered client for playerID:",
+      client.metadata.playerID
+    );
+    this.clients.set(client, client);
+    this.syncClient(client);
+  }
+  registerHostClient(client) {
+    console.log(
+      "[P2PHost] Registered host client for playerID:",
+      client.metadata.playerID
+    );
+    this.hostClient = client;
+    this.syncClient(client);
+  }
+  unregisterClient(client) {
+    this.clients.delete(client);
+  }
+  processAction(client, data) {
+    switch (data.type) {
+      case "sync":
+        this.syncClient(client);
+        break;
+      case "update":
+        this.handleUpdate(data.args);
+        break;
+      case "chat":
+        this.broadcastChat(data.args);
+        break;
+    }
+  }
+  syncClient(client) {
+    const { state, log } = this.db.fetch(this.matchID);
+    const playerID = client.metadata.playerID;
+    const filteredState = this.filterStateForPlayer(state, playerID);
+    client.send({
+      type: "sync",
+      args: [this.matchID, { state: filteredState, log }]
+    });
+  }
+  filterStateForPlayer(state, _playerID) {
+    return state;
+  }
+  handleUpdate([matchID, , action]) {
+    if (matchID !== this.matchID) return;
+    const currentState = this.state;
+    if (!currentState) return;
+    const moveName = action.payload?.type;
+    const moveArgs = action.payload?.args ?? [];
+    const playerID = action.payload?.playerID;
+    console.log("[P2PHost] handleUpdate:", { moveName, moveArgs, playerID });
+    if (moveName && this.game.moves?.[moveName]) {
+      const move = this.game.moves[moveName];
+      const ctx = { ...currentState.ctx, playerID };
+      const G = JSON.parse(JSON.stringify(currentState.G));
+      console.log(
+        "[P2PHost] Before move, G.players:",
+        G.players?.map((p) => ({
+          id: p.id,
+          bet: p.bet
+        }))
+      );
+      if (typeof move === "function") {
+        move({ G, ctx }, ...moveArgs);
+      }
+      console.log(
+        "[P2PHost] After move, G.players:",
+        G.players?.map((p) => ({
+          id: p.id,
+          bet: p.bet
+        }))
+      );
+      const newState = {
+        ...currentState,
+        G,
+        _stateID: currentState._stateID + 1
+      };
+      this.state = newState;
+      this.db.setState(this.matchID, newState);
+      console.log(
+        "[P2PHost] State updated, broadcasting to",
+        this.clients.size,
+        "clients"
+      );
+      this.broadcastState();
+    } else {
+      console.log(
+        "[P2PHost] Move not found:",
+        moveName,
+        "Available:",
+        Object.keys(this.game.moves || {})
+      );
+    }
+  }
+  broadcastState() {
+    const { state, log } = this.db.fetch(this.matchID);
+    if (this.hostClient) {
+      const playerID = this.hostClient.metadata.playerID;
+      const filteredState = this.filterStateForPlayer(state, playerID);
+      this.hostClient.send({
+        type: "sync",
+        args: [this.matchID, { state: filteredState, log }]
+      });
+    }
+    for (const client of this.clients.values()) {
+      const playerID = client.metadata.playerID;
+      const filteredState = this.filterStateForPlayer(state, playerID);
+      client.send({
+        type: "sync",
+        args: [this.matchID, { state: filteredState, log }]
+      });
+    }
+  }
+  broadcastChat(args) {
+    if (this.hostClient) {
+      this.hostClient.send({ type: "chat", args });
+    }
+    for (const client of this.clients.values()) {
+      client.send({ type: "chat", args });
+    }
+  }
+};
+
+// src/p2p/transport.ts
+var DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun1.l.google.com:19302" },
+  { urls: "stun:stun2.l.google.com:19302" },
+  // Free TURN servers from Open Relay Project
+  {
+    urls: "turn:openrelay.metered.ca:80",
+    username: "openrelayproject",
+    credential: "openrelayproject"
+  },
+  {
+    urls: "turn:openrelay.metered.ca:443",
+    username: "openrelayproject",
+    credential: "openrelayproject"
+  },
+  {
+    urls: "turn:openrelay.metered.ca:443?transport=tcp",
+    username: "openrelayproject",
+    credential: "openrelayproject"
+  }
+];
+var P2PTransport = class {
+  constructor(config, opts = {}) {
+    this.peer = null;
+    this.connection = null;
+    this.host = null;
+    this.connected = false;
+    this.connectionStatusCallbacks = /* @__PURE__ */ new Set();
+    this.retryCount = 0;
+    this.maxRetries = 3;
+    console.log("[P2PTransport] Constructor called with config:", {
+      gameName: config.gameName,
+      playerID: config.playerID,
+      matchID: config.matchID,
+      numPlayers: config.numPlayers,
+      credentials: config.credentials ? "(present)" : "(none)"
+    });
+    console.log("[P2PTransport] Options:", {
+      isHost: opts.isHost
+    });
+    this.gameName = config.gameName;
+    this.playerID = config.playerID;
+    this.matchID = config.matchID;
+    this.numPlayers = config.numPlayers;
+    this.game = config.game;
+    this.transportDataCallback = config.transportDataCallback;
+    this.isHost = opts.isHost ?? false;
+    this.peerOptions = opts.peerOptions;
+    this.onError = opts.onError;
+    this.setCredentials(config.credentials);
+  }
+  get hostID() {
+    return `boardgameio-${this.gameName}-matchid-${this.matchID}`;
+  }
+  setCredentials(credentials) {
+    if (!credentials) {
+      const { publicKey, privateKey } = generateKeyPair();
+      this.credentials = publicKey;
+      this.privateKey = privateKey;
+    } else {
+      this.credentials = credentials;
+    }
+  }
+  get metadata() {
+    return {
+      playerID: this.playerID,
+      credentials: this.credentials,
+      message: this.privateKey && this.playerID ? signMessage(this.playerID, this.privateKey) : void 0
+    };
+  }
+  connect() {
+    const Peer = window.Peer;
+    if (!Peer) {
+      this.onError?.(new Error("PeerJS not loaded"));
+      return;
+    }
+    const globalPeerConfig = window.__peerConfig ?? {};
+    const iceServers = globalPeerConfig.iceServers && globalPeerConfig.iceServers.length > 0 ? globalPeerConfig.iceServers : DEFAULT_ICE_SERVERS;
+    const baseConfig = {
+      host: globalPeerConfig.host,
+      port: globalPeerConfig.port,
+      path: globalPeerConfig.path,
+      secure: globalPeerConfig.secure,
+      debug: 2,
+      // Warnings and errors
+      config: {
+        iceServers
+      }
+    };
+    const peerConfig = {
+      ...baseConfig,
+      ...this.peerOptions,
+      config: {
+        ...baseConfig.config,
+        ...this.peerOptions && this.peerOptions.config ? this.peerOptions.config : {}
+      }
+    };
+    console.log(
+      `[P2PTransport] Connecting as ${this.isHost ? "HOST" : "CLIENT"}, hostID: ${this.hostID}`
+    );
+    this.peer = new Peer(this.isHost ? this.hostID : void 0, peerConfig);
+    this.peer.on("open", (id) => {
+      console.log(`[P2PTransport] Peer opened with ID: ${id}`);
+      if (this.isHost) {
+        this.host = new P2PHost({
+          game: this.game,
+          numPlayers: this.numPlayers,
+          matchID: this.matchID
+        });
+        this.host.registerHostClient({
+          metadata: this.metadata,
+          send: (data) => this.notifyClient(data)
+        });
+        console.log("[P2PTransport] Host ready, waiting for connections");
+        this.onConnect();
+      } else {
+        console.log(`[P2PTransport] Client connecting to host: ${this.hostID}`);
+        this.connectToHost();
+      }
+    });
+    this.peer.on("connection", (conn) => {
+      console.log(
+        "[P2PTransport] Incoming connection from:",
+        conn.peer
+      );
+      const dataConn = conn;
+      if (!this.host) return;
+      const client = {
+        metadata: { playerID: null },
+        send: (data) => dataConn.send(data)
+      };
+      dataConn.on("open", () => {
+        console.log("[P2PTransport] Data connection opened");
+        this.host?.registerClient(client);
+      });
+      dataConn.on("data", (data) => {
+        const action = data;
+        if (action.type === "sync" && "metadata" in data) {
+          client.metadata = data.metadata;
+        }
+        this.host?.processAction(client, action);
+      });
+      dataConn.on("close", () => {
+        this.host?.unregisterClient(client);
+      });
+    });
+    this.peer.on("error", (err) => {
+      const error = err;
+      console.error("[P2PTransport] Peer error:", error.type, error.message);
+      if (error.type === "peer-unavailable") {
+        console.error(
+          "[P2PTransport] Host peer not found. Is the host connected?"
+        );
+      } else if (error.type === "unavailable-id") {
+        console.error("[P2PTransport] Peer ID already taken");
+      }
+      this.onError?.(error);
+    });
+    this.peer.on("close", () => {
+      console.log("[P2PTransport] Peer connection closed");
+      this.connected = false;
+      this.notifyConnectionStatus(false);
+    });
+  }
+  connectToHost() {
+    if (!this.peer) return;
+    console.log(
+      `[P2PTransport] Attempting connection to host (attempt ${this.retryCount + 1}/${this.maxRetries + 1})`
+    );
+    this.connection = this.peer.connect(this.hostID, {
+      reliable: true,
+      serialization: "json"
+    });
+    const connectionTimeout = setTimeout(() => {
+      if (!this.connected && this.connection) {
+        this.retryCount++;
+        if (this.retryCount <= this.maxRetries) {
+          console.warn(
+            `[P2PTransport] Connection timeout, retrying (${this.retryCount}/${this.maxRetries})...`
+          );
+          this.connection.close();
+          this.connectToHost();
+        } else {
+          console.error(
+            "[P2PTransport] Max retries reached. Could not connect to host."
+          );
+          this.onError?.(
+            new Error(
+              "Could not connect to host after multiple attempts. Is the host online?"
+            )
+          );
+        }
+      }
+    }, 1e4);
+    this.connection.on("open", () => {
+      clearTimeout(connectionTimeout);
+      console.log("[P2PTransport] Connected to host successfully!");
+      this.retryCount = 0;
+      this.connection?.send({ type: "sync", metadata: this.metadata });
+      this.onConnect();
+    });
+    this.connection.on("data", (data) => {
+      this.notifyClient(data);
+    });
+    this.connection.on("close", () => {
+      clearTimeout(connectionTimeout);
+      console.log("[P2PTransport] Connection to host closed");
+      this.connected = false;
+      this.notifyConnectionStatus(false);
+    });
+    this.connection.on("error", (err) => {
+      clearTimeout(connectionTimeout);
+      const error = err;
+      console.error(
+        "[P2PTransport] Connection error:",
+        error.type,
+        error.message
+      );
+      this.onError?.(error);
+    });
+  }
+  onConnect() {
+    this.connected = true;
+    this.notifyConnectionStatus(true);
+    this.requestSync();
+  }
+  notifyConnectionStatus(connected) {
+    for (const callback of this.connectionStatusCallbacks) {
+      callback(connected);
+    }
+  }
+  notifyClient(data) {
+    this.transportDataCallback(data);
+  }
+  disconnect() {
+    this.connection?.close();
+    this.peer?.destroy();
+    this.peer = null;
+    this.connection = null;
+    this.host = null;
+    this.connected = false;
+    this.notifyConnectionStatus(false);
+  }
+  requestSync() {
+    if (this.isHost && this.host) {
+      this.host.processAction(
+        {
+          metadata: this.metadata,
+          send: (d) => this.notifyClient(d)
+        },
+        { type: "sync" }
+      );
+    } else {
+      this.connection?.send({ type: "sync", metadata: this.metadata });
+    }
+  }
+  sendAction(state, action) {
+    const msg = {
+      type: "update",
+      args: [this.matchID, state, action]
+    };
+    if (this.isHost && this.host) {
+      this.host.processAction(
+        {
+          metadata: this.metadata,
+          send: (d) => this.notifyClient(d)
+        },
+        msg
+      );
+    } else {
+      this.connection?.send(msg);
+    }
+  }
+  sendChatMessage(matchID, chatMessage) {
+    const msg = {
+      type: "chat",
+      args: [matchID, chatMessage, this.credentials]
+    };
+    if (this.isHost && this.host) {
+      this.host.processAction(
+        {
+          metadata: this.metadata,
+          send: (d) => this.notifyClient(d)
+        },
+        msg
+      );
+    } else {
+      this.connection?.send(msg);
+    }
+  }
+  updateMatchID(id) {
+    this.matchID = id;
+    this.disconnect();
+    this.connect();
+  }
+  updatePlayerID(id) {
+    this.playerID = id;
+    this.disconnect();
+    this.connect();
+  }
+  updateCredentials(credentials) {
+    this.setCredentials(credentials);
+    this.disconnect();
+    this.connect();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  subscribeToConnectionStatus(callback) {
+    this.connectionStatusCallbacks.add(callback);
+    callback(this.connected);
+    return () => {
+      this.connectionStatusCallbacks.delete(callback);
+    };
+  }
+};
+function createP2PTransport(opts = {}) {
+  return (config) => new P2PTransport(config, opts);
+}
+
+// src/mount.ts
+function createGameMount(game, Board, options = {}) {
+  const {
+    numPlayers = game.maxPlayers ?? game.minPlayers ?? 2,
+    defaultPlayerID = "0"
+  } = options;
+  return (container, inputs = {}) => {
+    const {
+      BoardgameReact,
+      BoardgameAI,
+      BoardgameMultiplayer,
+      React: R,
+      ReactDOM
+    } = window;
+    if (!BoardgameReact || !R || !ReactDOM) {
+      console.error(
+        "[boardgameio] Missing globals: BoardgameReact, React, or ReactDOM"
+      );
+      container.innerHTML = '<div style="color: red; padding: 16px;">Missing required dependencies</div>';
+      return () => {
+      };
+    }
+    const botCount = typeof inputs["bot-count"] === "number" ? inputs["bot-count"] : 0;
+    const canUseBots = botCount > 0 && !!game.ai;
+    const botFactory = canUseBots ? BoardgameAI?.RandomBot : void 0;
+    if (canUseBots && !botFactory) {
+      console.warn(
+        "[boardgameio] Bot settings enabled, but AI module is unavailable."
+      );
+    }
+    const enumerate = typeof game.ai?.enumerate === "function" ? game.ai.enumerate : void 0;
+    if (canUseBots && !enumerate) {
+      console.warn(
+        "[boardgameio] Bot settings enabled, but game.ai.enumerate is missing."
+      );
+    }
+    const botPlayers = {};
+    if (botFactory && enumerate) {
+      let added = 0;
+      for (let pid = 0; pid < numPlayers && added < botCount; pid += 1) {
+        const pidStr = String(pid);
+        if (pidStr === defaultPlayerID) continue;
+        botPlayers[pidStr] = botFactory;
+        added += 1;
+      }
+    }
+    const multiplayerConfig = inputs.multiplayer;
+    const isMultiplayer = !!multiplayerConfig?.matchID;
+    const playerID = multiplayerConfig?.playerID ?? defaultPlayerID;
+    let multiplayer;
+    if (isMultiplayer && multiplayerConfig) {
+      const isHost = multiplayerConfig.isHost ?? playerID === "0";
+      multiplayer = createP2PTransport({
+        isHost
+      });
+    } else if (BoardgameMultiplayer?.Local) {
+      multiplayer = BoardgameMultiplayer.Local(
+        Object.keys(botPlayers).length > 0 ? { bots: botPlayers } : void 0
+      );
+    }
+    const WrappedBoard = (props) => {
+      return R.createElement(Board, { ...props, isMultiplayer });
+    };
+    const GameClient = BoardgameReact.Client({
+      game,
+      board: WrappedBoard,
+      numPlayers,
+      ...multiplayer ? { multiplayer } : {}
+      // Bots are configured via Local transport when enabled.
+    });
+    const GameWithSettings = () => {
+      const clientProps = { playerID };
+      if (isMultiplayer && multiplayerConfig) {
+        clientProps.matchID = multiplayerConfig.matchID;
+        clientProps.credentials = multiplayerConfig.credentials;
+        console.log("[boardgameio] Multiplayer props:", {
+          matchID: multiplayerConfig.matchID,
+          playerID,
+          isHost: multiplayerConfig.isHost ?? playerID === "0"
+        });
+      }
+      return R.createElement(
+        SettingsProvider,
+        { settings: inputs },
+        R.createElement(GameClient, clientProps)
+      );
+    };
+    const root = ReactDOM.createRoot(container);
+    root.render(R.createElement(GameWithSettings));
+    return () => root.unmount();
+  };
+}
+function createMountFromExports(module, manifest) {
+  const { game, app, default: defaultExport } = module;
+  if (!game || typeof game.setup !== "function") {
+    return null;
+  }
+  const Board = app || defaultExport;
+  if (!Board || typeof Board !== "function") {
+    return null;
+  }
+  const numPlayers = manifest?.players?.max ?? manifest?.players?.min ?? game.maxPlayers ?? game.minPlayers ?? 2;
+  return createGameMount(game, Board, { numPlayers });
+}
+function injectMountHelper() {
+  const win = window;
+  win.createGameMount = createGameMount;
+  win.createMountFromExports = createMountFromExports;
+  win.useSettings = useSettings;
+  win.SettingsProvider = SettingsProvider;
+}
+async function mount(module, container, inputs) {
+  const { React: R, ReactDOM } = window;
+  if (typeof module.mount === "function") {
+    const mountFn = module.mount;
+    const result = await mountFn(container, inputs);
+    if (typeof result === "function") {
+      return result;
+    }
+    return;
+  }
+  const game = module.game;
+  if (game && typeof game.setup === "function") {
+    const Board = module.app || module.default;
+    if (Board && typeof Board === "function") {
+      const numPlayers = inputs.numPlayers ?? game.maxPlayers ?? game.minPlayers ?? 2;
+      const multiplayerInput = inputs.multiplayer;
+      if (multiplayerInput?.matchID) {
+        await ensurePeerJS();
+      }
+      const gameMount = createGameMount(game, Board, { numPlayers });
+      return gameMount(container, inputs);
+    }
+  }
+  if (typeof module.default === "function" && R && ReactDOM) {
+    const Component = module.default;
+    const root = ReactDOM.createRoot(container);
+    root.render(R.createElement(Component, inputs));
+    return () => root.unmount();
+  }
+  console.warn(
+    "[boardgameio] Widget does not export a recognized entry point (mount, game+app, or default)"
+  );
+}
+
+// src/setup.ts
+var tailwindLoadPromise = null;
+var peerJSLoadPromise = null;
+var mountHelperInjected = false;
+async function setup(container, options = {}) {
+  const { cssRuntime = true, multiplayer = false } = options;
+  if (!mountHelperInjected) {
+    injectMountHelper();
+    mountHelperInjected = true;
+  }
+  if (cssRuntime && !tailwindLoadPromise) {
+    tailwindLoadPromise = loadTailwindPlayCDN();
+  }
+  if (multiplayer && !peerJSLoadPromise) {
+    peerJSLoadPromise = loadPeerJS();
+  }
+  await Promise.all([tailwindLoadPromise, peerJSLoadPromise].filter(Boolean));
+}
+function cleanup(container) {
+}
+async function loadTailwindPlayCDN() {
+  if (document.querySelector('script[src*="tailwindcss.com/play"]')) {
+    return;
+  }
+  const script = document.createElement("script");
+  script.src = "https://cdn.tailwindcss.com";
+  script.async = true;
+  return new Promise((resolve, reject) => {
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load Tailwind CDN"));
+    document.head.appendChild(script);
+  });
+}
+async function loadPeerJS() {
+  if (window.Peer) {
+    return;
+  }
+  if (document.querySelector('script[src*="peerjs"]')) {
+    return new Promise((resolve) => {
+      const check = () => {
+        if (window.Peer) resolve();
+        else setTimeout(check, 50);
+      };
+      check();
+    });
+  }
+  const script = document.createElement("script");
+  script.src = "https://unpkg.com/peerjs@1.5.4/dist/peerjs.min.js";
+  script.async = true;
+  return new Promise((resolve, reject) => {
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load PeerJS"));
+    document.head.appendChild(script);
+  });
+}
+async function ensurePeerJS() {
+  if (!peerJSLoadPromise) {
+    peerJSLoadPromise = loadPeerJS();
+  }
+  await peerJSLoadPromise;
+}
+
+// src/multiplayer.ts
+function getMultiplayer(config, game) {
+  const BoardgameMultiplayer = window.BoardgameMultiplayer;
+  const BoardgameAI = window.BoardgameAI;
+  if (config.isMultiplayer) {
+    return void 0;
+  }
+  const bots = {};
+  const botCount = config.botCount ?? 0;
+  if (botCount > 0 && game?.ai && BoardgameAI?.MCTSBot) {
+    for (let i = 1; i <= botCount; i++) {
+      bots[String(i)] = BoardgameAI.MCTSBot;
+    }
+  }
+  if (!BoardgameMultiplayer?.Local) {
+    return void 0;
+  }
+  return BoardgameMultiplayer.Local({
+    storageKey: `kossabos:bgio:${config.appId}`,
+    ...Object.keys(bots).length > 0 ? { bots } : {}
+  });
+}
+function generateMatchID() {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  return Array.from(
+    { length: 6 },
+    () => chars[Math.floor(Math.random() * chars.length)]
+  ).join("");
+}
+export {
+  P2PDB,
+  P2PHost,
+  P2PTransport,
+  SettingsProvider,
+  cleanup,
+  createGameMount,
+  createMountFromExports,
+  createP2PTransport,
+  ensurePeerJS,
+  generateCredentials,
+  generateKeyPair,
+  generateMatchID,
+  getMultiplayer,
+  injectMountHelper,
+  mount,
+  setup,
+  useSettings
+};
+//# sourceMappingURL=index.js.map