@aprovan/patchwork-image-boardgameio 0.1.0

package/dist/index.js

@@ -0,0 +1,1392 @@
+// 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/session-storage.ts
+var STORAGE_PREFIX = "p2p-session:";
+var SESSION_TTL_MS = 5 * 60 * 1e3;
+function getStorageKey(matchID) {
+  return `${STORAGE_PREFIX}${matchID}`;
+}
+function hasValidSession(matchID) {
+  const session = loadSession(matchID);
+  return session !== null;
+}
+function loadSession(matchID) {
+  try {
+    const key = getStorageKey(matchID);
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    const session = JSON.parse(raw);
+    const now = Date.now();
+    if (now - session.updatedAt > SESSION_TTL_MS) {
+      console.log("[P2PSessionStorage] Session expired, removing:", matchID);
+      removeSession(matchID);
+      return null;
+    }
+    console.log("[P2PSessionStorage] Loaded session:", {
+      matchID,
+      stateID: session.state._stateID,
+      age: Math.round((now - session.updatedAt) / 1e3) + "s"
+    });
+    return session;
+  } catch (err) {
+    console.error("[P2PSessionStorage] Failed to load session:", err);
+    return null;
+  }
+}
+function saveSession(session) {
+  try {
+    const key = getStorageKey(session.matchID);
+    session.updatedAt = Date.now();
+    const serialized = JSON.stringify(session);
+    localStorage.setItem(key, serialized);
+    console.log("[P2PSessionStorage] Saved session:", {
+      matchID: session.matchID,
+      stateID: session.state._stateID,
+      gameName: session.gameName,
+      sizeBytes: serialized.length
+    });
+  } catch (err) {
+    console.error("[P2PSessionStorage] Failed to save session:", err);
+    if (err instanceof DOMException && err.name === "QuotaExceededError") {
+      console.warn("[P2PSessionStorage] Storage quota exceeded, cleaning up old sessions");
+      cleanupExpiredSessions();
+    }
+  }
+}
+function updateSessionState(matchID, state, log) {
+  const session = loadSession(matchID);
+  if (!session) return;
+  session.state = state;
+  if (log) session.log = log;
+  saveSession(session);
+}
+function removeSession(matchID) {
+  try {
+    const key = getStorageKey(matchID);
+    localStorage.removeItem(key);
+    console.log("[P2PSessionStorage] Removed session:", matchID);
+  } catch (err) {
+    console.error("[P2PSessionStorage] Failed to remove session:", err);
+  }
+}
+function cleanupExpiredSessions() {
+  try {
+    const now = Date.now();
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (!key?.startsWith(STORAGE_PREFIX)) continue;
+      try {
+        const raw = localStorage.getItem(key);
+        if (!raw) continue;
+        const session = JSON.parse(raw);
+        if (now - session.updatedAt > SESSION_TTL_MS) {
+          keysToRemove.push(key);
+        }
+      } catch {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      localStorage.removeItem(key);
+      console.log("[P2PSessionStorage] Cleaned up expired session:", key);
+    }
+  } catch (err) {
+    console.error("[P2PSessionStorage] Cleanup failed:", err);
+  }
+}
+
+// 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 gameName = game.name ?? "unknown";
+    console.log("[P2PHost] Checking for existing session:", { matchID, gameName });
+    const existingSession = loadSession(matchID);
+    if (existingSession) {
+      console.log("[P2PHost] Found existing session:", {
+        matchID,
+        sessionGameName: existingSession.gameName,
+        expectedGameName: gameName,
+        stateID: existingSession.state._stateID
+      });
+      if (existingSession.gameName === gameName) {
+        console.log("[P2PHost] Restoring session from storage");
+        this.state = existingSession.state;
+        this.db.createMatch(matchID, {
+          initialState: existingSession.initialState,
+          metadata: existingSession.metadata
+        });
+        this.db.setState(matchID, existingSession.state, existingSession.log);
+        saveSession(existingSession);
+        return;
+      } else {
+        console.log("[P2PHost] Game name mismatch, creating new session");
+      }
+    } else {
+      console.log("[P2PHost] No existing session found, creating new");
+    }
+    const initialState = this.createInitialState();
+    this.state = initialState;
+    const players = {};
+    for (let i = 0; i < numPlayers; i++) {
+      players[i] = { id: i };
+    }
+    const metadata = {
+      gameName: game.name ?? "unknown",
+      players,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this.db.createMatch(matchID, {
+      initialState,
+      metadata
+    });
+    this.persistSession(initialState, [], metadata);
+  }
+  persistSession(state, log, metadata) {
+    const existingSession = loadSession(this.matchID);
+    const session = {
+      matchID: this.matchID,
+      gameName: this.game.name ?? "unknown",
+      numPlayers: this.numPlayers,
+      state,
+      initialState: existingSession?.initialState ?? state,
+      log,
+      metadata: metadata ?? existingSession?.metadata ?? {
+        gameName: this.game.name ?? "unknown",
+        players: {},
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      },
+      createdAt: existingSession?.createdAt ?? Date.now(),
+      updatedAt: Date.now()
+    };
+    saveSession(session);
+  }
+  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;
+    const ctxCurrentPlayer = currentState.ctx.currentPlayer;
+    const gCurrent = currentState.G?.current;
+    const currentPlayer = gCurrent !== void 0 ? String(gCurrent) : ctxCurrentPlayer;
+    console.log("[P2PHost] handleUpdate:", { moveName, moveArgs, playerID, currentPlayer });
+    if (playerID !== currentPlayer) {
+      console.log("[P2PHost] Rejected move: wrong player", { playerID, currentPlayer });
+      return;
+    }
+    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);
+      const { log } = this.db.fetch(this.matchID);
+      updateSessionState(this.matchID, newState, log);
+      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.hostRetryCount = 0;
+    this.maxHostRetries = 3;
+    this.lastPeerConfig = null;
+    this.retryCount = 0;
+    this.maxRetries = 6;
+    // Increased from 3 to handle host reconnection
+    this.retryDelayMs = 3e3;
+    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() {
+    cleanupExpiredSessions();
+    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 : {}
+      }
+    };
+    const isReconnection = this.isHost && hasValidSession(this.matchID);
+    console.log(
+      `[P2PTransport] Connecting as ${this.isHost ? "HOST" : "CLIENT"}, hostID: ${this.hostID}${isReconnection ? " (reconnecting)" : ""}`
+    );
+    if (isReconnection) {
+      console.log("[P2PTransport] Host reconnecting, waiting for PeerJS ID to clear...");
+      setTimeout(() => this.createPeer(Peer, peerConfig), 2e3);
+    } else {
+      this.createPeer(Peer, peerConfig);
+    }
+  }
+  createPeer(Peer, peerConfig) {
+    this.lastPeerConfig = peerConfig;
+    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?"
+        );
+        this.onError?.(error);
+      } else if (error.type === "unavailable-id") {
+        if (this.isHost && this.hostRetryCount < this.maxHostRetries) {
+          this.hostRetryCount++;
+          const delay = 2e3 * this.hostRetryCount;
+          console.log(
+            `[P2PTransport] Peer ID unavailable, retrying in ${delay}ms (${this.hostRetryCount}/${this.maxHostRetries})...`
+          );
+          this.peer?.destroy();
+          this.peer = null;
+          setTimeout(() => {
+            const Peer2 = window.Peer;
+            if (Peer2 && this.lastPeerConfig) {
+              this.createPeer(Peer2, this.lastPeerConfig);
+            }
+          }, delay);
+        } else {
+          console.error("[P2PTransport] Peer ID already taken, max retries reached");
+          this.onError?.(error);
+        }
+      } else {
+        this.onError?.(error);
+      }
+    });
+    this.peer.on("close", () => {
+      console.log("[P2PTransport] Peer connection closed");
+      this.connected = false;
+      this.notifyConnectionStatus(false);
+    });
+  }
+  // Delay between retries
+  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 in ${this.retryDelayMs}ms (${this.retryCount}/${this.maxRetries})...`
+          );
+          this.connection.close();
+          setTimeout(() => this.connectToHost(), this.retryDelayMs);
+        } 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/bot-manager.ts
+var DIFFICULTY_PRESETS = {
+  easy: {
+    strategy: "random",
+    mctsIterations: 0,
+    delay: 400,
+    minDelay: 200,
+    mistakeRate: 0.3
+  },
+  medium: {
+    strategy: "mcts",
+    mctsIterations: 500,
+    delay: 800,
+    minDelay: 400,
+    mistakeRate: 0.1
+  },
+  hard: {
+    strategy: "mcts",
+    mctsIterations: 2e3,
+    delay: 1200,
+    minDelay: 600,
+    mistakeRate: 0
+  },
+  custom: {
+    strategy: "mcts",
+    mctsIterations: 1e3,
+    delay: 800,
+    minDelay: 0,
+    mistakeRate: 0
+  }
+};
+function resolveBotConfig(inputs, gameAiDifficulty) {
+  const difficulty = inputs.botDifficulty ?? "medium";
+  const globalPreset = DIFFICULTY_PRESETS[difficulty];
+  const gamePreset = gameAiDifficulty?.[difficulty] ?? {};
+  return {
+    strategy: inputs.botStrategy ?? gamePreset.strategy ?? globalPreset.strategy,
+    mctsIterations: inputs.mctsIterations ?? gamePreset.mctsIterations ?? globalPreset.mctsIterations,
+    delay: inputs.botDelay ?? gamePreset.delay ?? globalPreset.delay,
+    minDelay: inputs.botMinDelay ?? gamePreset.minDelay ?? globalPreset.minDelay,
+    mistakeRate: inputs.botMistakeRate ?? gamePreset.mistakeRate ?? globalPreset.mistakeRate,
+    customBot: inputs.customBot
+  };
+}
+function computeBotPlayerIDs(numPlayers, botCount, humanPlayerID) {
+  const botIDs = [];
+  for (let i = 0; i < numPlayers && botIDs.length < botCount; i++) {
+    const id = String(i);
+    if (id !== humanPlayerID) {
+      botIDs.push(id);
+    }
+  }
+  return botIDs;
+}
+var BotManager = class {
+  constructor(game, config) {
+    this.game = game;
+    this.bot = null;
+    this.pendingMove = null;
+    this.stateListeners = /* @__PURE__ */ new Set();
+    this.currentState = { isThinking: false, thinkingPlayer: null };
+    this.moveInProgress = false;
+    this.config = config;
+    this.initializeBot();
+  }
+  initializeBot() {
+    const { BoardgameAI } = window;
+    const enumerate = this.game.ai?.enumerate;
+    if (!enumerate) {
+      console.warn(
+        "[BotManager] game.ai.enumerate is required for bot support"
+      );
+      return;
+    }
+    switch (this.config.strategy) {
+      case "mcts":
+        if (BoardgameAI?.MCTSBot) {
+          this.bot = new BoardgameAI.MCTSBot({
+            game: this.game,
+            enumerate,
+            iterations: this.config.mctsIterations
+          });
+        } else {
+          console.warn(
+            "[BotManager] MCTSBot not available, falling back to RandomBot"
+          );
+          if (BoardgameAI?.RandomBot) {
+            this.bot = new BoardgameAI.RandomBot({
+              game: this.game,
+              enumerate
+            });
+          }
+        }
+        break;
+      case "random":
+        if (BoardgameAI?.RandomBot) {
+          this.bot = new BoardgameAI.RandomBot({
+            game: this.game,
+            enumerate
+          });
+        }
+        break;
+      case "custom":
+        if (this.config.customBot) {
+          this.bot = this.config.customBot();
+        } else {
+          console.error(
+            "[BotManager] Custom strategy requires customBot factory"
+          );
+        }
+        break;
+    }
+    if (!this.bot) {
+      console.warn(
+        "[BotManager] Could not initialize bot. AI module may not be loaded."
+      );
+    }
+  }
+  /**
+   * Select a move, potentially with mistakes for easier difficulties.
+   */
+  async selectMove(state, playerID) {
+    const enumerate = this.game.ai?.enumerate;
+    if (!enumerate) {
+      console.log("[BotManager] No enumerate function");
+      return null;
+    }
+    const legalMoves = enumerate(state.G, state.ctx);
+    console.log("[BotManager] Legal moves:", legalMoves);
+    if (legalMoves.length === 0) {
+      console.log("[BotManager] No legal moves available");
+      return null;
+    }
+    if (this.config.mistakeRate > 0 && Math.random() < this.config.mistakeRate) {
+      const randomIndex = Math.floor(Math.random() * legalMoves.length);
+      const randomMove = legalMoves[randomIndex];
+      return {
+        action: {
+          payload: {
+            type: randomMove.move,
+            args: randomMove.args
+          }
+        }
+      };
+    }
+    if (!this.bot) {
+      const randomIndex = Math.floor(Math.random() * legalMoves.length);
+      const randomMove = legalMoves[randomIndex];
+      return {
+        action: {
+          payload: {
+            type: randomMove.move,
+            args: randomMove.args
+          }
+        }
+      };
+    }
+    const result = await this.bot.play(state, playerID);
+    if (!result?.action && legalMoves.length > 0) {
+      console.log("[BotManager] Bot returned null action, falling back to random selection");
+      const randomIndex = Math.floor(Math.random() * legalMoves.length);
+      const randomMove = legalMoves[randomIndex];
+      return {
+        action: {
+          payload: {
+            type: randomMove.move,
+            args: randomMove.args
+          }
+        }
+      };
+    }
+    return result;
+  }
+  /**
+   * Check if it's a bot's turn and schedule a move if so.
+   * Call this after every state update.
+   */
+  async maybePlayBot(state, botPlayerIDs, makeMove) {
+    const { ctx } = state;
+    console.log("[BotManager] maybePlayBot called:", {
+      currentPlayer: ctx.currentPlayer,
+      botPlayerIDs,
+      moveInProgress: this.moveInProgress,
+      gameover: ctx.gameover
+    });
+    if (this.moveInProgress) {
+      console.log("[BotManager] Skipping - move already in progress");
+      return;
+    }
+    const isBotTurn = botPlayerIDs.includes(ctx.currentPlayer);
+    if (!isBotTurn || ctx.gameover) {
+      console.log("[BotManager] Not bot turn or gameover:", { isBotTurn, gameover: ctx.gameover });
+      this.cancelPendingMove();
+      this.notifyState({ isThinking: false, thinkingPlayer: null });
+      return;
+    }
+    this.moveInProgress = true;
+    this.notifyState({ isThinking: true, thinkingPlayer: ctx.currentPlayer });
+    const delay = this.config.minDelay > 0 ? this.config.minDelay + Math.random() * (this.config.delay - this.config.minDelay) : this.config.delay;
+    try {
+      console.log("[BotManager] Selecting move for player:", ctx.currentPlayer);
+      const action = await this.selectMove(state, ctx.currentPlayer);
+      console.log("[BotManager] Selected action:", action);
+      if (!action?.action) {
+        console.log("[BotManager] No action returned, skipping");
+        this.notifyState({ isThinking: false, thinkingPlayer: null });
+        this.moveInProgress = false;
+        return;
+      }
+      console.log("[BotManager] Scheduling move after delay:", delay);
+      this.pendingMove = setTimeout(() => {
+        const { type, args } = action.action.payload;
+        console.log("[BotManager] Executing move:", { type, args });
+        makeMove(type, ...args);
+        this.notifyState({ isThinking: false, thinkingPlayer: null });
+        this.moveInProgress = false;
+      }, delay);
+    } catch (error) {
+      console.error("[BotManager] Error computing move:", error);
+      this.notifyState({ isThinking: false, thinkingPlayer: null });
+      this.moveInProgress = false;
+    }
+  }
+  /** Subscribe to bot state changes */
+  subscribe(listener) {
+    this.stateListeners.add(listener);
+    listener(this.currentState);
+    return () => this.stateListeners.delete(listener);
+  }
+  /** Get current bot state */
+  getState() {
+    return this.currentState;
+  }
+  notifyState(state) {
+    this.currentState = state;
+    this.stateListeners.forEach((fn) => fn(state));
+  }
+  cancelPendingMove() {
+    if (this.pendingMove) {
+      clearTimeout(this.pendingMove);
+      this.pendingMove = null;
+    }
+    this.moveInProgress = false;
+  }
+  dispose() {
+    this.cancelPendingMove();
+    this.stateListeners.clear();
+  }
+};
+
+// src/mount.ts
+function createGameMount(game, Board, options = {}) {
+  const {
+    numPlayers: defaultNumPlayers = game.maxPlayers ?? game.minPlayers ?? 2,
+    defaultPlayerID = "0"
+  } = options;
+  return (container, inputs = {}) => {
+    const { BoardgameReact, 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 numPlayers = inputs.numPlayers ?? defaultNumPlayers;
+    const multiplayerConfig = inputs.multiplayer;
+    const isMultiplayer = !!multiplayerConfig?.matchID;
+    const botCountInput = inputs["bot-count"] ?? inputs.botCount;
+    const botCount = typeof botCountInput === "number" ? botCountInput : isMultiplayer ? 0 : numPlayers - 1;
+    const playerID = inputs.playerID ?? multiplayerConfig?.playerID ?? defaultPlayerID;
+    const botPlayerIDs = computeBotPlayerIDs(numPlayers, botCount, playerID);
+    console.log("[boardgameio] Bot configuration:", {
+      numPlayers,
+      botCount,
+      botCountInput,
+      isMultiplayer,
+      playerID,
+      botPlayerIDs,
+      hasBotEnumerate: !!game.ai?.enumerate,
+      inputsBotCount: inputs["bot-count"],
+      hasMultiplayerConfig: !!multiplayerConfig
+    });
+    const botDifficulty = inputs.botDifficulty ?? "medium";
+    const botConfig = resolveBotConfig(inputs, game.ai?.difficulty);
+    const hasBots = botCount > 0 && game.ai?.enumerate;
+    let botManager = null;
+    if (hasBots) {
+      botManager = new BotManager(game, botConfig);
+    }
+    let multiplayer;
+    if (isMultiplayer && multiplayerConfig) {
+      const isHost = multiplayerConfig.isHost ?? playerID === "0";
+      multiplayer = createP2PTransport({
+        isHost
+      });
+    }
+    const WrappedBoard = (props) => {
+      const [botState, setBotState] = R.useState({
+        isThinking: false,
+        thinkingPlayer: null
+      });
+      R.useEffect(() => {
+        if (!botManager) return;
+        return botManager.subscribe(setBotState);
+      }, []);
+      R.useEffect(() => {
+        if (isMultiplayer) {
+          return;
+        }
+        if (!botManager || !props.G) {
+          console.log("[boardgameio] Bot effect skipped:", {
+            hasBotManager: !!botManager,
+            hasG: !!props.G
+          });
+          return;
+        }
+        const gState = props.G;
+        const ctxState = props.ctx;
+        const currentPlayer = gState.current !== void 0 ? String(gState.current) : ctxState.currentPlayer;
+        const gameover = gState.winner !== void 0 ? gState.winner !== null : ctxState.gameover;
+        const isBotTurn = botPlayerIDs.includes(currentPlayer);
+        console.log("[boardgameio] Bot effect running:", {
+          currentPlayer,
+          botPlayerIDs,
+          isBotTurn,
+          gameover
+        });
+        const state = {
+          G: props.G,
+          ctx: {
+            ...ctxState,
+            currentPlayer,
+            gameover
+          }
+        };
+        botManager.maybePlayBot(state, botPlayerIDs, (type, ...args) => {
+          console.log("[boardgameio] Bot making move:", { type, args });
+          const moves = props.moves;
+          moves[type]?.(...args);
+        });
+      }, [
+        props.G,
+        props.ctx?.currentPlayer,
+        props.ctx?.turn,
+        props.G?.current
+      ]);
+      return R.createElement(Board, {
+        ...props,
+        isMultiplayer,
+        botState,
+        botPlayerIDs,
+        botCount,
+        botDifficulty
+      });
+    };
+    const GameClient = BoardgameReact.Client({
+      game,
+      board: WrappedBoard,
+      numPlayers,
+      ...multiplayer ? { multiplayer } : {}
+    });
+    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 () => {
+      botManager?.dispose();
+      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: `zolvery: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 {
+  BotManager,
+  DIFFICULTY_PRESETS,
+  P2PDB,
+  P2PHost,
+  P2PTransport,
+  SettingsProvider,
+  cleanup,
+  computeBotPlayerIDs,
+  createGameMount,
+  createMountFromExports,
+  createP2PTransport,
+  ensurePeerJS,
+  generateCredentials,
+  generateKeyPair,
+  generateMatchID,
+  getMultiplayer,
+  injectMountHelper,
+  mount,
+  resolveBotConfig,
+  setup,
+  useSettings
+};
+//# sourceMappingURL=index.js.map