@rpgjs/vite 5.0.0-alpha.33 → 5.0.0-alpha.36

package/dist/server-plugin.d.ts

@@ -28,10 +28,8 @@ declare class PartyConnection {
     private messageQueue;
     private isProcessingQueue;
     private sequenceCounter;
-    private lastSendTime;
-    private outgoingFlushTimeout;
     private incomingQueue;
-    private incomingFlushTimeout;
+    private isProcessingIncomingQueue;
     static packetLossRate: number;
     static packetLossEnabled: boolean;
     static packetLossFilter: string;
@@ -60,16 +58,18 @@ declare class PartyConnection {
      */
     send(data: any): Promise<void>;
     /**
-     * Processes the outgoing queue with TCP-like batching.
+     * Processes the outgoing queue in order.
      *
-     * - If latency is enabled, schedule a single flush after latencyMs to batch messages.
-     * - At flush, send all queued messages in order, applying bandwidth delays per message.
+     * Each message receives its own fixed latency (if enabled), while preserving
+     * original spacing and order.
      */
     private processMessageQueue;
     /**
      * Flushes the send queue sequentially, respecting bandwidth constraints.
      */
     private flushSendQueue;
+    private shouldApplyLatency;
+    private waitUntil;
     /**
      * Closes the WebSocket connection
      */
@@ -89,8 +89,8 @@ declare class PartyConnection {
     /**
      * Buffers incoming messages to simulate TCP latency on reception.
      *
-     * All messages that arrive within the latency window are flushed together,
-     * preserving order. The provided processor is called with the ordered batch.
+     * Messages are processed in strict order. Each message keeps its own fixed
+     * latency delay relative to the moment it arrived.
      *
      * @param {string} message - Raw incoming message
      * @param {(messages: string[]) => Promise<void>} processor - Async batch processor
@@ -101,6 +101,7 @@ declare class PartyConnection {
      * })
      */
     bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void;
+    private processIncomingQueue;
     /**
      * Configures packet loss simulation settings
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/vite",
-  "version": "5.0.0-alpha.33",
+  "version": "5.0.0-alpha.36",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [],
@@ -12,17 +12,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.50",
-    "@hono/vite-dev-server": "^0.24.0",
-    "@rpgjs/server": "5.0.0-alpha.33",
-    "@types/node": "^25.0.3",
+    "@canvasengine/compiler": "2.0.0-beta.53",
+    "@hono/vite-dev-server": "^0.25.0",
+    "@rpgjs/server": "5.0.0-alpha.36",
+    "@types/node": "^25.2.3",
     "acorn": "^8.15.0",
     "acorn-walk": "^8.3.4",
     "magic-string": "^0.30.21",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.16",
+    "vitest": "^4.0.18",
     "ws": "^8.19.0"
   },
   "devDependencies": {

package/src/server-plugin.ts

@@ -42,10 +42,12 @@ class PartyConnection {
   private messageQueue: Array<{ message: string; timestamp: number; sequence: number }> = [];
   private isProcessingQueue: boolean = false;
   private sequenceCounter: number = 0;
-  private lastSendTime: number = 0;
-  private outgoingFlushTimeout: any = null;
-  private incomingQueue: string[] = [];
-  private incomingFlushTimeout: any = null;
+  private incomingQueue: Array<{
+    message: string;
+    timestamp: number;
+    processor: (messages: string[]) => Promise<void>;
+  }> = [];
+  private isProcessingIncomingQueue: boolean = false;
   public static packetLossRate: number = parseFloat(process.env.RPGJS_PACKET_LOSS_RATE || '0.1');
   public static packetLossEnabled: boolean = process.env.RPGJS_ENABLE_PACKET_LOSS === 'true';
   public static packetLossFilter: string = process.env.RPGJS_PACKET_LOSS_FILTER || '';
@@ -100,25 +102,12 @@ class PartyConnection {
   }
 
   /**
-   * Processes the outgoing queue with TCP-like batching.
-   * 
-   * - If latency is enabled, schedule a single flush after latencyMs to batch messages.
-   * - At flush, send all queued messages in order, applying bandwidth delays per message.
+   * Processes the outgoing queue in order.
+   *
+   * Each message receives its own fixed latency (if enabled), while preserving
+   * original spacing and order.
    */
   private async processMessageQueue(): Promise<void> {
-    if (this.messageQueue.length === 0) return;
-
-    const shouldBatchWithLatency = PartyConnection.latencyEnabled && PartyConnection.latencyMs > 0;
-
-    if (shouldBatchWithLatency) {
-      if (this.outgoingFlushTimeout) return; // Already scheduled
-      this.outgoingFlushTimeout = setTimeout(async () => {
-        this.outgoingFlushTimeout = null;
-        await this.flushSendQueue();
-      }, PartyConnection.latencyMs);
-      return;
-    }
-
     await this.flushSendQueue();
   }
 
@@ -132,6 +121,11 @@ class PartyConnection {
     while (this.messageQueue.length > 0) {
       const queueItem = this.messageQueue.shift()!;
 
+      // Apply fixed one-way latency per message (not batched bursts).
+      if (this.shouldApplyLatency(queueItem.message)) {
+        await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+      }
+
       // Bandwidth simulation per message
       if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
         if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
@@ -150,6 +144,24 @@ class PartyConnection {
     this.isProcessingQueue = false;
   }
 
+  private shouldApplyLatency(message: string): boolean {
+    if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) {
+      return false;
+    }
+    if (!PartyConnection.latencyFilter) {
+      return true;
+    }
+    return message.includes(PartyConnection.latencyFilter);
+  }
+
+  private async waitUntil(targetTimestamp: number): Promise<void> {
+    const delayMs = targetTimestamp - Date.now();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+
   /**
    * Closes the WebSocket connection
    */
@@ -180,9 +192,9 @@ class PartyConnection {
 
   /**
    * Buffers incoming messages to simulate TCP latency on reception.
-   * 
-   * All messages that arrive within the latency window are flushed together,
-   * preserving order. The provided processor is called with the ordered batch.
+   *
+   * Messages are processed in strict order. Each message keeps its own fixed
+   * latency delay relative to the moment it arrived.
    *
    * @param {string} message - Raw incoming message
    * @param {(messages: string[]) => Promise<void>} processor - Async batch processor
@@ -193,19 +205,33 @@ class PartyConnection {
    * })
    */
   bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void {
-    this.incomingQueue.push(message);
-    const latencyMs = PartyConnection.latencyEnabled && PartyConnection.latencyMs > 0 ? PartyConnection.latencyMs : 0;
-    if (this.incomingFlushTimeout) return;
-    this.incomingFlushTimeout = setTimeout(async () => {
-      const batch = this.incomingQueue;
-      this.incomingQueue = [];
-      this.incomingFlushTimeout = null;
+    this.incomingQueue.push({
+      message,
+      timestamp: Date.now(),
+      processor,
+    });
+    if (!this.isProcessingIncomingQueue) {
+      void this.processIncomingQueue();
+    }
+  }
+
+  private async processIncomingQueue(): Promise<void> {
+    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 processor(batch);
+        await item.processor([item.message]);
       } catch (err) {
-        console.error('Error processing incoming batch:', err);
+        console.error('Error processing incoming message:', err);
       }
-    }, latencyMs);
+    }
+    this.isProcessingIncomingQueue = false;
   }
 
   /**
@@ -481,12 +507,16 @@ async function importWebSocketServer(): Promise<any> {
 }
 
 async function updateMap(roomId: string, rpgServer: RpgServerEngine) {
+  if (!roomId.startsWith('map-')) {
+    return;
+  }
+
   try {
     const mapId = roomId.startsWith('map-') ? roomId.slice(4) : roomId;
     const defaultMapPayload = {
       id: mapId,
-      width: 1000,
-      height: 1000,
+      width: 0,
+      height: 0,
       events: [] as any[],
     };
 
@@ -684,27 +714,82 @@ export function serverPlugin(
       // HTTP request interception for /parties/* routes
       server.middlewares.use("/parties", async (req, res, next) => {
         try {
-          // For now, pass to the next middleware
-          // The RPG-JS server handles its own routes via @signe/room
-          console.log(`RPG-JS HTTP request: ${req.method} ${req.url}`);
+          const host = req.headers.host || "localhost";
+          const incomingUrl = req.url || "/";
+          const parsedUrl = new URL(incomingUrl, `http://${host}`);
+          const normalizedPath = parsedUrl.pathname.startsWith("/parties")
+            ? parsedUrl.pathname
+            : `/parties${parsedUrl.pathname.startsWith("/") ? parsedUrl.pathname : `/${parsedUrl.pathname}`}`;
+          const pathParts = normalizedPath.split("/").filter(Boolean);
+
+          if (pathParts[0] !== "parties" || pathParts[1] !== "main" || pathParts.length < 4) {
+            next();
+            return;
+          }
+
+          const roomId = pathParts[2];
+          const requestPath = `/${pathParts.slice(3).join("/")}`;
+          const { room, rpgServer } = await ensureRoomAndServer(roomId);
+          room.context.parties = buildPartiesContext();
+
+          const bodyText = await new Promise<string>((resolve, reject) => {
+            const chunks: Buffer[] = [];
+            req.on("data", (chunk: Buffer | string) => {
+              chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+            });
+            req.on("end", () => {
+              resolve(Buffer.concat(chunks).toString("utf8"));
+            });
+            req.on("error", reject);
+          });
+
+          const requestHeaders = new Headers();
+          Object.entries(req.headers).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+              if (value[0] !== undefined) requestHeaders.set(key, value[0]);
+              return;
+            }
+            if (typeof value === "string") {
+              requestHeaders.set(key, value);
+            }
+          });
+
+          const requestLike = {
+            url: `http://${host}/parties/main/${roomId}${requestPath}${parsedUrl.search}`,
+            method: (req.method || "GET").toUpperCase(),
+            headers: requestHeaders,
+            json: async () => {
+              if (!bodyText) return undefined as any;
+              return JSON.parse(bodyText);
+            },
+            text: async () => bodyText,
+          } as any;
+
+          const result = await (rpgServer as any).onRequest(requestLike);
+
+          if (result instanceof Response) {
+            res.statusCode = result.status;
+            result.headers.forEach((value, key) => {
+              res.setHeader(key, value);
+            });
+            res.end(await result.text());
+            return;
+          }
 
-          // Create a basic response for test routes
-          if (req.url?.includes("/test")) {
+          if (typeof result === "string") {
             res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(
-              JSON.stringify({
-                message: "RPG-JS server is running",
-                timestamp: new Date().toISOString(),
-              })
-            );
+            res.setHeader("Content-Type", "text/plain");
+            res.end(result);
             return;
           }
 
-          next();
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(result ?? {}));
         } 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" }));
         }
       });