@rpgjs/server 5.0.0-alpha.42 → 5.0.0-alpha.43

package/dist/node/index.js

@@ -0,0 +1,693 @@
+import { r as resolveMapUpdateToken, u as updateMap, c as createMapUpdateHeaders } from '../map-D4T2_hc-.js';
+export { a as MAP_UPDATE_TOKEN_ENV, M as MAP_UPDATE_TOKEN_HEADER, i as isMapUpdateAuthorized, b as readMapUpdateToken } from '../map-D4T2_hc-.js';
+
+function readEnvVariable(name) {
+  const value = globalThis.process?.env?.[name];
+  return typeof value === "string" ? value : void 0;
+}
+class PartyConnection {
+  constructor(ws, id, uri) {
+    this.ws = ws;
+    this._state = {};
+    this.messageQueue = [];
+    this.isProcessingQueue = false;
+    this.sequenceCounter = 0;
+    this.incomingQueue = [];
+    this.isProcessingIncomingQueue = false;
+    this.id = id || this.generateId();
+    this.uri = uri || "";
+  }
+  static {
+    this.packetLossRate = parseFloat(readEnvVariable("RPGJS_PACKET_LOSS_RATE") || "0.1");
+  }
+  static {
+    this.packetLossEnabled = readEnvVariable("RPGJS_ENABLE_PACKET_LOSS") === "true";
+  }
+  static {
+    this.packetLossFilter = readEnvVariable("RPGJS_PACKET_LOSS_FILTER") || "";
+  }
+  static {
+    this.bandwidthEnabled = readEnvVariable("RPGJS_ENABLE_BANDWIDTH") === "true";
+  }
+  static {
+    this.bandwidthKbps = parseInt(readEnvVariable("RPGJS_BANDWIDTH_KBPS") || "100");
+  }
+  static {
+    this.bandwidthFilter = readEnvVariable("RPGJS_BANDWIDTH_FILTER") || "";
+  }
+  static {
+    this.latencyEnabled = readEnvVariable("RPGJS_ENABLE_LATENCY") === "true";
+  }
+  static {
+    this.latencyMs = parseInt(readEnvVariable("RPGJS_LATENCY_MS") || "50");
+  }
+  static {
+    this.latencyFilter = readEnvVariable("RPGJS_LATENCY_FILTER") || "";
+  }
+  generateId() {
+    return `conn_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  async send(data) {
+    if (this.ws.readyState !== 1) {
+      return;
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const timestamp = Date.now();
+    const sequence = ++this.sequenceCounter;
+    this.messageQueue.push({ message, timestamp, sequence });
+    if (!this.isProcessingQueue) {
+      void this.processMessageQueue();
+    }
+  }
+  async processMessageQueue() {
+    if (this.isProcessingQueue) {
+      return;
+    }
+    this.isProcessingQueue = true;
+    while (this.messageQueue.length > 0) {
+      const queueItem = this.messageQueue.shift();
+      if (this.shouldApplyLatency(queueItem.message)) {
+        await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+      }
+      if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
+        if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
+          const messageSizeBits = queueItem.message.length * 8;
+          const transmissionTimeMs = messageSizeBits / (PartyConnection.bandwidthKbps * 1e3) * 1e3;
+          const bandwidthDelayMs = Math.max(transmissionTimeMs, 10);
+          console.log(
+            `\x1B[34m[BANDWIDTH SIMULATION]\x1B[0m Connection ${this.id}: Message #${queueItem.sequence} transmission time: ${bandwidthDelayMs.toFixed(1)}ms`
+          );
+          await new Promise((resolve) => setTimeout(resolve, bandwidthDelayMs));
+        }
+      }
+      this.ws.send(queueItem.message);
+    }
+    this.isProcessingQueue = false;
+  }
+  shouldApplyLatency(message) {
+    if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) {
+      return false;
+    }
+    if (!PartyConnection.latencyFilter) {
+      return true;
+    }
+    return message.includes(PartyConnection.latencyFilter);
+  }
+  async waitUntil(targetTimestamp) {
+    const delayMs = targetTimestamp - Date.now();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  close() {
+    if (this.ws.readyState === 1) {
+      this.ws.close();
+    }
+  }
+  setState(value) {
+    this._state = value;
+  }
+  get state() {
+    return this._state;
+  }
+  bufferIncoming(message, processor) {
+    this.incomingQueue.push({
+      message,
+      timestamp: Date.now(),
+      processor
+    });
+    if (!this.isProcessingIncomingQueue) {
+      void this.processIncomingQueue();
+    }
+  }
+  async processIncomingQueue() {
+    if (this.isProcessingIncomingQueue) {
+      return;
+    }
+    this.isProcessingIncomingQueue = true;
+    while (this.incomingQueue.length > 0) {
+      const item = this.incomingQueue.shift();
+      if (this.shouldApplyLatency(item.message)) {
+        await this.waitUntil(item.timestamp + PartyConnection.latencyMs);
+      }
+      try {
+        await item.processor([item.message]);
+      } catch (err) {
+        console.error("Error processing incoming message:", err);
+      }
+    }
+    this.isProcessingIncomingQueue = false;
+  }
+  static configurePacketLoss(enabled, rate, filter) {
+    PartyConnection.packetLossEnabled = enabled;
+    PartyConnection.packetLossRate = Math.max(0, Math.min(1, rate));
+    PartyConnection.packetLossFilter = filter || "";
+    if (enabled && rate > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1B[35m[PACKET LOSS SIMULATION]\x1B[0m Enabled with ${(rate * 100).toFixed(1)}% loss rate${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1B[35m[PACKET LOSS SIMULATION]\x1B[0m Enabled but rate is 0% (no messages will be dropped)");
+    } else {
+      console.log("\x1B[35m[PACKET LOSS SIMULATION]\x1B[0m Disabled");
+    }
+  }
+  static getPacketLossStatus() {
+    return {
+      enabled: PartyConnection.packetLossEnabled,
+      rate: PartyConnection.packetLossRate,
+      filter: PartyConnection.packetLossFilter
+    };
+  }
+  static configureBandwidth(enabled, kbps, filter) {
+    PartyConnection.bandwidthEnabled = enabled;
+    PartyConnection.bandwidthKbps = Math.max(1, kbps);
+    PartyConnection.bandwidthFilter = filter || "";
+    if (enabled && kbps > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1B[35m[BANDWIDTH SIMULATION]\x1B[0m Enabled with ${kbps} kbps bandwidth${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1B[35m[BANDWIDTH SIMULATION]\x1B[0m Enabled but bandwidth is 0 kbps (no delay will be applied)");
+    } else {
+      console.log("\x1B[35m[BANDWIDTH SIMULATION]\x1B[0m Disabled");
+    }
+  }
+  static getBandwidthStatus() {
+    return {
+      enabled: PartyConnection.bandwidthEnabled,
+      kbps: PartyConnection.bandwidthKbps,
+      filter: PartyConnection.bandwidthFilter
+    };
+  }
+  static configureLatency(enabled, ms, filter) {
+    PartyConnection.latencyEnabled = enabled;
+    PartyConnection.latencyMs = Math.max(0, ms);
+    PartyConnection.latencyFilter = filter || "";
+    if (enabled && ms > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1B[35m[LATENCY SIMULATION]\x1B[0m Enabled with ${ms}ms fixed latency${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1B[35m[LATENCY SIMULATION]\x1B[0m Enabled but latency is 0ms (no delay will be applied)");
+    } else {
+      console.log("\x1B[35m[LATENCY SIMULATION]\x1B[0m Disabled");
+    }
+  }
+  static getLatencyStatus() {
+    return {
+      enabled: PartyConnection.latencyEnabled,
+      ms: PartyConnection.latencyMs,
+      filter: PartyConnection.latencyFilter
+    };
+  }
+}
+function logNetworkSimulationStatus() {
+  const packetLossStatus = PartyConnection.getPacketLossStatus();
+  const bandwidthStatus = PartyConnection.getBandwidthStatus();
+  const latencyStatus = PartyConnection.getLatencyStatus();
+  if (packetLossStatus.enabled) {
+    const filterInfo = packetLossStatus.filter ? ` (filter: "${packetLossStatus.filter}")` : "";
+    console.log(
+      `\x1B[36m[NETWORK SIMULATION]\x1B[0m Packet loss simulation: ${(packetLossStatus.rate * 100).toFixed(1)}% loss rate${filterInfo}`
+    );
+  } else {
+    console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Packet loss simulation: disabled");
+  }
+  if (bandwidthStatus.enabled) {
+    const filterInfo = bandwidthStatus.filter ? ` (filter: "${bandwidthStatus.filter}")` : "";
+    console.log(`\x1B[36m[NETWORK SIMULATION]\x1B[0m Bandwidth simulation: ${bandwidthStatus.kbps} kbps${filterInfo}`);
+  } else {
+    console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Bandwidth simulation: disabled");
+  }
+  if (latencyStatus.enabled) {
+    const filterInfo = latencyStatus.filter ? ` (filter: "${latencyStatus.filter}")` : "";
+    console.log(`\x1B[36m[NETWORK SIMULATION]\x1B[0m Latency simulation: ${latencyStatus.ms}ms ping${filterInfo}`);
+  } else {
+    console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Latency simulation: disabled");
+  }
+}
+
+class PartyRoom {
+  constructor(id) {
+    this.env = {};
+    this.context = {};
+    this.connections = /* @__PURE__ */ new Map();
+    this.storageData = /* @__PURE__ */ new Map();
+    this.id = id;
+    this.internalID = `internal_${id}_${Date.now()}`;
+  }
+  async broadcast(message, except = []) {
+    const data = typeof message === "string" ? message : JSON.stringify(message);
+    const sendPromises = [];
+    for (const [connectionId, connection] of this.connections) {
+      if (!except.includes(connectionId)) {
+        sendPromises.push(connection.send(data));
+      }
+    }
+    await Promise.all(sendPromises);
+  }
+  getConnection(id) {
+    return this.connections.get(id);
+  }
+  getConnections(tag) {
+    return this.connections.values();
+  }
+  addConnection(connection) {
+    this.connections.set(connection.id, connection);
+  }
+  removeConnection(connectionId) {
+    this.connections.delete(connectionId);
+  }
+  get storage() {
+    return {
+      put: async (key, value) => {
+        this.storageData.set(key, value);
+      },
+      get: async (key) => {
+        return this.storageData.get(key);
+      },
+      delete: async (key) => {
+        this.storageData.delete(key);
+      },
+      list: async () => {
+        return Array.from(this.storageData.entries());
+      }
+    };
+  }
+}
+
+function normalizePathPrefix(path, fallback) {
+  const trimmed = (path || fallback).trim();
+  if (!trimmed) {
+    return fallback;
+  }
+  const prefixed = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return prefixed !== "/" ? prefixed.replace(/\/+$/, "") : prefixed;
+}
+function hasPathPrefix(pathname, prefix) {
+  return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function prependMountedPath(pathname, mountedPath) {
+  if (!mountedPath) {
+    return pathname;
+  }
+  const normalizedMountedPath = normalizePathPrefix(mountedPath, "/");
+  if (hasPathPrefix(pathname, normalizedMountedPath)) {
+    return pathname;
+  }
+  if (pathname === "/") {
+    return normalizedMountedPath;
+  }
+  return `${normalizedMountedPath}${pathname.startsWith("/") ? pathname : `/${pathname}`}`.replace(/\/{2,}/g, "/");
+}
+function parseHttpRoute(pathname, partiesPath) {
+  if (!hasPathPrefix(pathname, partiesPath)) {
+    return null;
+  }
+  const remainder = pathname.slice(partiesPath.length);
+  const segments = remainder.split("/").filter(Boolean);
+  if (segments.length < 2) {
+    return null;
+  }
+  return {
+    roomId: segments[0],
+    requestPath: `/${segments.slice(1).join("/")}`
+  };
+}
+function parseSocketRoute(pathname, partiesPath) {
+  if (!hasPathPrefix(pathname, partiesPath)) {
+    return null;
+  }
+  const remainder = pathname.slice(partiesPath.length);
+  const segments = remainder.split("/").filter(Boolean);
+  if (segments.length < 1) {
+    return null;
+  }
+  return { roomId: segments[0] };
+}
+function toHeaders(input) {
+  if (!input) {
+    return new Headers();
+  }
+  if (input instanceof Headers) {
+    return new Headers(input);
+  }
+  if (Array.isArray(input)) {
+    return new Headers(input);
+  }
+  if (input instanceof Map) {
+    const headers2 = new Headers();
+    for (const [key, value] of input) {
+      if (typeof value !== "undefined") {
+        headers2.set(key, value);
+      }
+    }
+    return headers2;
+  }
+  const headers = new Headers();
+  Object.entries(input).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      if (typeof value[0] !== "undefined") {
+        headers.set(key, value[0]);
+      }
+      return;
+    }
+    if (typeof value !== "undefined") {
+      headers.set(key, String(value));
+    }
+  });
+  return headers;
+}
+function createRequestLike(url, method, headers, bodyText) {
+  return {
+    url,
+    method,
+    headers,
+    json: async () => {
+      if (!bodyText) {
+        return void 0;
+      }
+      return JSON.parse(bodyText);
+    },
+    text: async () => bodyText
+  };
+}
+async function normalizeEngineResponse(result) {
+  if (result instanceof Response) {
+    return result;
+  }
+  if (typeof result === "string") {
+    return new Response(result, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+  }
+  return new Response(JSON.stringify(result ?? {}), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+async function sendNodeResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  res.end(await response.text());
+}
+async function readNodeBody(req) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", reject);
+  });
+}
+function resolveUrlFromSocketRequest(request) {
+  const headers = toHeaders(request.headers);
+  const host = headers.get("host") || "localhost";
+  const rawUrl = request.url || "/";
+  const url = new URL(rawUrl, `http://${host}`);
+  return {
+    headers,
+    method: request.method,
+    rawUrl,
+    url
+  };
+}
+function createConnectionContext(url, headers, method) {
+  const normalizedHeaders = /* @__PURE__ */ new Map();
+  headers.forEach((value, key) => {
+    normalizedHeaders.set(key.toLowerCase(), value);
+  });
+  return {
+    request: {
+      headers: {
+        has: (name) => normalizedHeaders.has(name.toLowerCase()),
+        get: (name) => normalizedHeaders.get(name.toLowerCase()),
+        entries: () => normalizedHeaders.entries(),
+        keys: () => normalizedHeaders.keys(),
+        values: () => normalizedHeaders.values()
+      },
+      method,
+      url: url.toString()
+    },
+    url
+  };
+}
+class RpgServerTransport {
+  constructor(serverModule, options = {}) {
+    this.serverModule = serverModule;
+    this.rooms = /* @__PURE__ */ new Map();
+    this.servers = /* @__PURE__ */ new Map();
+    this.lastKnownHost = "";
+    this.initializeMaps = options.initializeMaps ?? true;
+    this.mapUpdateToken = resolveMapUpdateToken(options.mapUpdateToken);
+    this.partiesPath = normalizePathPrefix(options.partiesPath || "/parties/main", "/parties/main");
+    this.tiledBasePaths = options.tiledBasePaths;
+  }
+  getRoom(roomId) {
+    return this.rooms.get(roomId);
+  }
+  getServer(roomId) {
+    return this.servers.get(roomId);
+  }
+  async ensureRoomAndServer(roomId, host) {
+    if (host) {
+      this.lastKnownHost = host;
+    }
+    let room = this.rooms.get(roomId);
+    if (!room) {
+      room = new PartyRoom(roomId);
+      this.rooms.set(roomId, room);
+      console.log(`Created new room: ${roomId}`);
+    }
+    let rpgServer = this.servers.get(roomId);
+    if (!rpgServer) {
+      rpgServer = new this.serverModule(room);
+      this.servers.set(roomId, rpgServer);
+      console.log(`Created new server instance for room: ${roomId}`);
+      if (typeof rpgServer.onStart === "function") {
+        try {
+          await rpgServer.onStart();
+          console.log(`Server started for room: ${roomId}`);
+        } catch (error) {
+          console.error(`Error starting server for room ${roomId}:`, error);
+        }
+      }
+      if (this.initializeMaps) {
+        await updateMap(roomId, rpgServer, {
+          host: host || this.lastKnownHost,
+          mapUpdateToken: this.mapUpdateToken,
+          tiledBasePaths: this.tiledBasePaths
+        });
+      }
+    }
+    room.context.parties = this.buildPartiesContext();
+    return { room, rpgServer };
+  }
+  buildPartiesContext() {
+    return {
+      main: {
+        get: async (targetRoomId) => {
+          return {
+            fetch: async (path, init) => {
+              const method = (init?.method || "GET").toUpperCase();
+              const headers = toHeaders(init?.headers);
+              const requestPath = path.startsWith("/") ? path : `/${path}`;
+              let bodyText = "";
+              if (typeof init?.body === "string") {
+                bodyText = init.body;
+              } else if (typeof init?.body !== "undefined") {
+                bodyText = JSON.stringify(init.body);
+              }
+              return this.dispatchRoomRequest(
+                targetRoomId,
+                createRequestLike(
+                  `http://localhost${this.partiesPath}/${targetRoomId}${requestPath}`,
+                  method,
+                  headers,
+                  bodyText
+                ),
+                this.lastKnownHost
+              );
+            }
+          };
+        }
+      }
+    };
+  }
+  async dispatchRoomRequest(roomId, requestLike, host) {
+    const { room, rpgServer } = await this.ensureRoomAndServer(roomId, host);
+    room.context.parties = this.buildPartiesContext();
+    const result = await rpgServer.onRequest?.(requestLike);
+    return normalizeEngineResponse(result);
+  }
+  async fetch(request, init) {
+    const webRequest = request instanceof Request ? request : new Request(String(request), init);
+    const url = new URL(webRequest.url);
+    const route = parseHttpRoute(url.pathname, this.partiesPath);
+    if (!route) {
+      return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    }
+    const bodyText = await webRequest.text();
+    return this.dispatchRoomRequest(
+      route.roomId,
+      createRequestLike(webRequest.url, webRequest.method.toUpperCase(), toHeaders(webRequest.headers), bodyText),
+      url.host
+    );
+  }
+  async updateMap(mapId, payload, options = {}) {
+    const roomId = mapId.startsWith("map-") ? mapId : `map-${mapId}`;
+    const headers = createMapUpdateHeaders(this.mapUpdateToken, options.headers);
+    if (!headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    return this.dispatchRoomRequest(
+      roomId,
+      createRequestLike(
+        `http://localhost${this.partiesPath}/${roomId}/map/update`,
+        "POST",
+        headers,
+        JSON.stringify(payload)
+      ),
+      options.host ?? this.lastKnownHost
+    );
+  }
+  async handleNodeRequest(req, res, next, options = {}) {
+    try {
+      const headers = toHeaders(req.headers);
+      const host = headers.get("host") || "localhost";
+      const url = new URL(req.url || "/", `http://${host}`);
+      const normalizedPathname = prependMountedPath(url.pathname, options.mountedPath);
+      const normalizedUrl = new URL(url.toString());
+      normalizedUrl.pathname = normalizedPathname;
+      const route = parseHttpRoute(normalizedUrl.pathname, this.partiesPath);
+      if (!route) {
+        next?.();
+        return false;
+      }
+      const bodyText = await readNodeBody(req);
+      const response = await this.dispatchRoomRequest(
+        route.roomId,
+        createRequestLike(normalizedUrl.toString(), (req.method || "GET").toUpperCase(), headers, bodyText),
+        host
+      );
+      await sendNodeResponse(res, response);
+      return true;
+    } catch (error) {
+      console.error("Error handling RPG-JS request:", error);
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Internal server error" }));
+      return true;
+    }
+  }
+  async acceptWebSocket(ws, request) {
+    const normalizedRequest = resolveUrlFromSocketRequest(request);
+    const route = parseSocketRoute(normalizedRequest.url.pathname, this.partiesPath);
+    if (!route) {
+      return false;
+    }
+    try {
+      console.log(`WebSocket upgrade request: ${normalizedRequest.url.pathname}`);
+      const queryParams = Object.fromEntries(normalizedRequest.url.searchParams.entries());
+      console.log(`Room: ${route.roomId}, Query params:`, queryParams);
+      const { room, rpgServer } = await this.ensureRoomAndServer(route.roomId, normalizedRequest.url.host);
+      room.context.parties = this.buildPartiesContext();
+      const connection = new PartyConnection(ws, queryParams._pk, normalizedRequest.rawUrl);
+      room.addConnection(connection);
+      console.log(`WebSocket connection established: ${connection.id} in room: ${route.roomId}`);
+      let isClosed = false;
+      const cleanup = async (logMessage, error) => {
+        if (isClosed) {
+          return;
+        }
+        isClosed = true;
+        if (logMessage) {
+          console.log(logMessage);
+        }
+        if (error) {
+          console.error("WebSocket error:", error);
+        }
+        room.removeConnection(connection.id);
+        await rpgServer.onClose?.(connection);
+      };
+      ws.on("message", async (data) => {
+        try {
+          const rawMessage = typeof data === "string" ? data : data.toString();
+          if (PartyConnection.packetLossEnabled && PartyConnection.packetLossRate > 0) {
+            if (!PartyConnection.packetLossFilter || rawMessage.includes(PartyConnection.packetLossFilter)) {
+              const random = Math.random();
+              if (random < PartyConnection.packetLossRate) {
+                console.log(
+                  `\x1B[31m[PACKET LOSS]\x1B[0m Connection ${connection.id}: Server dropped an incoming packet (${(PartyConnection.packetLossRate * 100).toFixed(1)}% loss rate)`
+                );
+                console.log(`\x1B[33m[PACKET DATA]\x1B[0m ${rawMessage.slice(0, 100)}${rawMessage.length > 100 ? "..." : ""}`);
+                return;
+              }
+            }
+          }
+          connection.bufferIncoming(rawMessage, async (batch) => {
+            for (const message of batch) {
+              await rpgServer.onMessage?.(message, connection);
+            }
+          });
+        } catch (error) {
+          console.error("Error processing WebSocket message:", error);
+        }
+      });
+      ws.on("close", () => {
+        void cleanup(`WebSocket connection closed: ${connection.id} from room: ${route.roomId}`);
+      });
+      ws.on("error", (error) => {
+        void cleanup(void 0, error);
+      });
+      if (typeof rpgServer.onConnect === "function") {
+        await rpgServer.onConnect(
+          connection,
+          createConnectionContext(normalizedRequest.url, normalizedRequest.headers, normalizedRequest.method)
+        );
+      }
+      await connection.send({
+        type: "connected",
+        id: connection.id,
+        message: "Connected to RPG-JS server"
+      });
+      return true;
+    } catch (error) {
+      console.error("Error establishing WebSocket connection:", error);
+      ws.close();
+      return true;
+    }
+  }
+  async handleUpgrade(wsServer, request, socket, head) {
+    const headers = toHeaders(request.headers);
+    const host = headers.get("host") || "localhost";
+    const url = new URL(request.url || "/", `http://${host}`);
+    if (!parseSocketRoute(url.pathname, this.partiesPath)) {
+      return false;
+    }
+    wsServer.handleUpgrade(request, socket, head, (ws) => {
+      void this.acceptWebSocket(ws, request);
+    });
+    return true;
+  }
+}
+function createRpgServerTransport(serverModule, options) {
+  return new RpgServerTransport(serverModule, options);
+}
+
+export { PartyConnection, PartyRoom, RpgServerTransport, createMapUpdateHeaders, createRpgServerTransport, logNetworkSimulationStatus, resolveMapUpdateToken };
+//# sourceMappingURL=index.js.map