@rpgjs/vite 5.0.0-alpha.42 → 5.0.0-alpha.44

package/dist/mmorpg-build-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+interface MmorpgBuildPluginOptions {
+    rpgType: string;
+    serverEntry: string;
+    adapterEntries?: Record<string, string>;
+}
+export declare function mmorpgBuildPlugin({ rpgType, serverEntry, adapterEntries, }: MmorpgBuildPluginOptions): Plugin;
+export {};

package/dist/rpgjs-plugin.d.ts

@@ -1,8 +1,13 @@
+type MmorpgEntryPoints = string | {
+    client?: string;
+    server?: string;
+    adapters?: Record<string, string>;
+};
 interface RpgjsPluginOptions {
     server: any;
     entryPoints?: {
-        rpg: string;
-        mmorpg: string;
+        rpg?: string;
+        mmorpg?: MmorpgEntryPoints;
     };
 }
 export declare function rpgjs({ server, entryPoints }: RpgjsPluginOptions): (import('vite').Plugin<any> | {

package/dist/server-plugin.d.ts

@@ -1,285 +1,8 @@
-import { RpgServerEngine } from '@rpgjs/server';
+import { RpgTransportServerConstructor } from '@rpgjs/server/node';
 import { ViteDevServer } from 'vite';
-interface WSConnection {
-    readyState: number;
-    send(data: string): void;
-    close(): void;
-    on(event: string, callback: (...args: any[]) => void): void;
-}
-/**
- * PartyConnection class compatible with PartyKit's Party.Connection interface
- *
- * This class implements the Connection interface expected by RPG-JS server,
- * providing WebSocket communication capabilities and connection state management.
- * Includes optional packet loss simulation for testing network conditions.
- *
- * @example
- * ```typescript
- * const connection = new PartyConnection(websocket, 'player123');
- * connection.send('Hello player!');
- * connection.setState({ username: 'Alice' });
- * ```
- */
-declare class PartyConnection {
-    private ws;
-    id: string;
-    uri: string;
-    private _state;
-    private messageQueue;
-    private isProcessingQueue;
-    private sequenceCounter;
-    private incomingQueue;
-    private isProcessingIncomingQueue;
-    static packetLossRate: number;
-    static packetLossEnabled: boolean;
-    static packetLossFilter: string;
-    static bandwidthEnabled: boolean;
-    static bandwidthKbps: number;
-    static bandwidthFilter: string;
-    static latencyEnabled: boolean;
-    static latencyMs: number;
-    static latencyFilter: string;
-    constructor(ws: WSConnection, id?: string, uri?: string);
-    /**
-     * Generates a unique identifier for the connection
-     *
-     * @returns {string} Unique identifier based on timestamp and random number
-     */
-    private generateId;
-    /**
-     * Sends data to the client via WebSocket with bandwidth and latency simulation
-     *
-     * Messages are queued and sent in the order they were called, with bandwidth limitations
-     * and network latency that simulate a slow, distant network connection. This ensures that
-     * if send(A) is called before send(B), A will always be sent before B, but both will be
-     * slowed down by bandwidth constraints and network latency.
-     *
-     * @param {any} data - Data to send (automatically serialized to JSON if not string)
-     */
-    send(data: any): Promise<void>;
-    /**
-     * Processes the outgoing queue in order.
-     *
-     * 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
-     */
-    close(): void;
-    /**
-     * Sets state data for this connection
-     *
-     * @param {any} value - State data to store (max 2KB as per PartyKit spec)
-     */
-    setState(value: any): void;
-    /**
-     * Gets the current state of this connection
-     *
-     * @returns {any} Current connection state
-     */
-    get state(): any;
-    /**
-     * Buffers incoming messages to simulate TCP latency on reception.
-     *
-     * 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
-     *
-     * @example
-     * await connection.bufferIncoming(raw, async (batch) => {
-     *   for (const msg of batch) await handle(msg)
-     * })
-     */
-    bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void;
-    private processIncomingQueue;
-    /**
-     * Configures packet loss simulation settings
-     *
-     * @param {boolean} enabled - Whether to enable packet loss simulation
-     * @param {number} rate - Packet loss rate (0.0 to 1.0, e.g., 0.1 = 10% loss)
-     * @param {string} filter - Optional filter string to only simulate loss for messages containing this string
-     *
-     * @example
-     * ```typescript
-     * PartyConnection.configurePacketLoss(true, 0.15); // 15% packet loss
-     * PartyConnection.configurePacketLoss(true, 0.2, 'sync'); // 20% loss only for sync messages
-     * ```
-     */
-    static configurePacketLoss(enabled: boolean, rate: number, filter?: string): void;
-    /**
-     * Gets current packet loss simulation status
-     *
-     * @returns {Object} Current configuration
-     */
-    static getPacketLossStatus(): {
-        enabled: boolean;
-        rate: number;
-        filter: string;
-    };
-    /**
-     * Configures bandwidth simulation settings
-     *
-     * @param {boolean} enabled - Whether to enable bandwidth simulation
-     * @param {number} kbps - Bandwidth in kilobits per second (e.g., 100 = 100 kbps)
-     * @param {string} filter - Optional filter string to only simulate bandwidth for messages containing this string
-     *
-     * @example
-     * ```typescript
-     * PartyConnection.configureBandwidth(true, 50); // 50 kbps (very slow connection)
-     * PartyConnection.configureBandwidth(true, 1000, 'sync'); // 1 Mbps only for sync messages
-     * ```
-     */
-    static configureBandwidth(enabled: boolean, kbps: number, filter?: string): void;
-    /**
-     * Gets current bandwidth simulation status
-     *
-     * @returns {Object} Current configuration
-     */
-    static getBandwidthStatus(): {
-        enabled: boolean;
-        kbps: number;
-        filter: string;
-    };
-    /**
-     * Configures latency simulation settings
-     *
-     * Latency simulates the ping time to a distant server. Each message gets the same fixed delay,
-     * regardless of when it was sent. This means if you send 3 messages rapidly, they will all
-     * have the same latency delay applied to them.
-     *
-     * @param {boolean} enabled - Whether to enable latency simulation
-     * @param {number} ms - Fixed latency in milliseconds (simulates ping to distant server)
-     * @param {string} filter - Optional filter string to only simulate latency for messages containing this string
-     *
-     * @example
-     * ```typescript
-     * PartyConnection.configureLatency(true, 100); // 100ms latency (distant server)
-     * PartyConnection.configureLatency(true, 200, 'sync'); // 200ms latency only for sync messages
-     * ```
-     */
-    static configureLatency(enabled: boolean, ms: number, filter?: string): void;
-    /**
-     * Gets current latency simulation status
-     *
-     * @returns {Object} Current configuration
-     */
-    static getLatencyStatus(): {
-        enabled: boolean;
-        ms: number;
-        filter: string;
-    };
-}
-/**
- * Room class compatible with PartyKit's Party.Room interface
- *
- * This class manages multiple WebSocket connections and provides broadcasting
- * capabilities, storage, and connection management as expected by RPG-JS server.
- *
- * @example
- * ```typescript
- * const room = new Room('lobby-1');
- * room.broadcast('Game started!');
- * const playerCount = [...room.getConnections()].length;
- * ```
- */
-declare class Room {
-    id: string;
-    internalID: string;
-    env: Record<string, any>;
-    context: any;
-    private connections;
-    private storageData;
-    constructor(id: string);
-    /**
-     * Broadcasts a message to all connected clients with bandwidth simulation
-     *
-     * Messages are sent to each connection in parallel, but each connection maintains
-     * its own ordered queue of messages with bandwidth limitations. This ensures that
-     * broadcast messages are queued in the correct order for each individual connection,
-     * while being slowed down by simulated bandwidth constraints.
-     *
-     * @param {any} message - Message to broadcast
-     * @param {string[]} except - Array of connection IDs to exclude from broadcast
-     */
-    broadcast(message: any, except?: string[]): Promise<void>;
-    /**
-     * Gets a connection by its ID
-     *
-     * @param {string} id - Connection ID
-     * @returns {PartyConnection | undefined} The connection or undefined if not found
-     */
-    getConnection(id: string): PartyConnection | undefined;
-    /**
-     * Gets all currently connected clients
-     *
-     * @param {string} tag - Optional tag to filter connections (not implemented yet)
-     * @returns {IterableIterator<PartyConnection>} Iterator of all connections
-     */
-    getConnections(tag?: string): IterableIterator<PartyConnection>;
-    /**
-     * Adds a connection to this room
-     *
-     * @param {PartyConnection} connection - Connection to add
-     */
-    addConnection(connection: PartyConnection): void;
-    /**
-     * Removes a connection from this room
-     *
-     * @param {string} connectionId - ID of connection to remove
-     */
-    removeConnection(connectionId: string): void;
-    /**
-     * Simple key-value storage for the room
-     */
-    get storage(): {
-        put: (key: string, value: any) => Promise<void>;
-        get: <T = any>(key: string) => Promise<T | undefined>;
-        delete: (key: string) => Promise<void>;
-        list: () => Promise<[string, any][]>;
-    };
-}
-/**
- * Creates a Vite plugin for integrating RPG-JS server functionality
- *
- * This plugin configures the development server to automatically start
- * an RPG-JS server instance when Vite's dev server starts. It handles
- * the instantiation and initialization of the server module, and sets up
- * HTTP request and WebSocket connection forwarding to the RPG-JS server.
- *
- * The plugin intercepts:
- * - HTTP requests to `/parties/*` paths and forwards them to the RPG-JS server
- * - WebSocket upgrade requests and establishes connections with the RPG-JS server
- *
- * @param {new () => RpgServerEngine} serverModule - A class constructor that extends RpgServerEngine
- * @returns {Object} Vite plugin configuration object
- *
- * @example
- * ```typescript
- * // In vite.config.ts
- * import { serverPlugin } from '@rpgjs/vite';
- * import startServer from './src/server';
- *
- * export default defineConfig({
- *   plugins: [
- *     serverPlugin(startServer)
- *   ]
- * });
- * ```
- */
-export declare function serverPlugin(serverModule: new (room: Room) => RpgServerEngine): {
+export declare function serverPlugin(serverModule: RpgTransportServerConstructor): {
     name: string;
     configureServer(server: ViteDevServer): Promise<void>;
     buildStart(): void;
     buildEnd(): void;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/vite",
-  "version": "5.0.0-alpha.42",
+  "version": "5.0.0-alpha.44",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [],
@@ -12,12 +12,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.53",
+    "@canvasengine/tiled": "2.0.0-beta.54",
+    "@canvasengine/compiler": "2.0.0-beta.54",
     "@hono/vite-dev-server": "^0.25.0",
-    "@rpgjs/server": "5.0.0-alpha.42",
-    "@types/node": "^25.2.3",
-    "acorn": "^8.15.0",
-    "acorn-walk": "^8.3.4",
+    "@rpgjs/server": "5.0.0-alpha.44",
+    "@types/node": "^25.3.5",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
     "magic-string": "^0.30.21",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",

package/src/mmorpg-build-plugin.ts

@@ -0,0 +1,123 @@
+import { existsSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { build as viteBuild, type Plugin, type ResolvedConfig } from "vite";
+
+interface MmorpgBuildPluginOptions {
+  rpgType: string;
+  serverEntry: string;
+  adapterEntries?: Record<string, string>;
+}
+
+function isBareImport(id: string): boolean {
+  return !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0");
+}
+
+function resolveEntry(root: string, entry: string): string {
+  return resolve(root, entry);
+}
+
+function collectServerEntries(
+  root: string,
+  serverEntry: string,
+  adapterEntries: Record<string, string>,
+): Record<string, string> {
+  const entries: Record<string, string> = {};
+  const resolvedServerEntry = resolveEntry(root, serverEntry);
+
+  if (!existsSync(resolvedServerEntry)) {
+    throw new Error(`[rpgjs:mmorpg-build] Missing server entry: ${serverEntry}`);
+  }
+
+  entries.server = resolvedServerEntry;
+
+  for (const [name, entry] of Object.entries(adapterEntries)) {
+    const resolvedAdapterEntry = resolveEntry(root, entry);
+    if (!existsSync(resolvedAdapterEntry)) {
+      throw new Error(`[rpgjs:mmorpg-build] Missing adapter entry "${name}": ${entry}`);
+    }
+    entries[name] = resolvedAdapterEntry;
+  }
+
+  return entries;
+}
+
+export function mmorpgBuildPlugin({
+  rpgType,
+  serverEntry,
+  adapterEntries = {},
+}: MmorpgBuildPluginOptions): Plugin {
+  let config: ResolvedConfig;
+  let didBuildServer = false;
+  let didCleanDist = false;
+
+  return {
+    name: "rpgjs:mmorpg-build",
+    apply: "build",
+    enforce: "post",
+    config(_, env) {
+      if (env.command !== "build" || rpgType !== "mmorpg") {
+        return;
+      }
+
+      return {
+        build: {
+          outDir: "dist/client",
+        },
+      };
+    },
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    buildStart() {
+      if (rpgType !== "mmorpg" || didCleanDist) {
+        return;
+      }
+      didCleanDist = true;
+      rmSync(resolve(config.root, "dist"), { recursive: true, force: true });
+    },
+    async closeBundle() {
+      if (rpgType !== "mmorpg" || didBuildServer) {
+        return;
+      }
+      didBuildServer = true;
+
+      const entries = collectServerEntries(config.root, serverEntry, adapterEntries);
+      console.log(
+        `[rpgjs:mmorpg-build] Building server bundle(s): ${Object.keys(entries).join(", ")}`,
+      );
+
+      await viteBuild({
+        configFile: false,
+        root: config.root,
+        define: config.define,
+        resolve: {
+          alias: config.resolve.alias,
+          dedupe: config.resolve.dedupe,
+          extensions: config.resolve.extensions,
+          mainFields: config.resolve.mainFields,
+          conditions: config.resolve.conditions,
+        },
+        publicDir: false,
+        build: {
+          emptyOutDir: true,
+          minify: false,
+          outDir: "dist/server",
+          sourcemap: config.build.sourcemap,
+          target: "node18",
+          lib: {
+            entry: entries,
+            formats: ["es"],
+          },
+          rollupOptions: {
+            external(id) {
+              return isBareImport(id);
+            },
+            output: {
+              entryFileNames: "[name].js",
+            },
+          },
+        },
+      });
+    },
+  };
+}

package/src/rpgjs-plugin.ts

@@ -2,12 +2,37 @@ import canvasengine from "@canvasengine/compiler";
 import { replaceConfigImport } from "./replace-config-import";
 import { serverPlugin } from "./server-plugin";
 import { entryPointPlugin } from "./entry-point-plugin";
+import { mmorpgBuildPlugin } from "./mmorpg-build-plugin";
+
+type MmorpgEntryPoints =
+  | string
+  | {
+      client?: string;
+      server?: string;
+      adapters?: Record<string, string>;
+    };
 
 interface RpgjsPluginOptions {
   server: any;
   entryPoints?: {
-    rpg: string;
-    mmorpg: string;
+    rpg?: string;
+    mmorpg?: MmorpgEntryPoints;
+  };
+}
+
+function normalizeMmorpgEntryPoints(entryPoints?: MmorpgEntryPoints) {
+  if (!entryPoints || typeof entryPoints === "string") {
+    return {
+      client: entryPoints ?? "./src/client.ts",
+      server: "./src/server.ts",
+      adapters: {},
+    };
+  }
+
+  return {
+    client: entryPoints.client ?? "./src/client.ts",
+    server: entryPoints.server ?? "./src/server.ts",
+    adapters: entryPoints.adapters ?? {},
   };
 }
 
@@ -15,15 +40,22 @@ export function rpgjs({
   server,
   entryPoints
 }: RpgjsPluginOptions) {
+  const mmorpgEntryPoints = normalizeMmorpgEntryPoints(entryPoints?.mmorpg);
+
   return [
     canvasengine(),
     replaceConfigImport(),
     serverPlugin(server),
+    mmorpgBuildPlugin({
+      rpgType: process.env.RPG_TYPE || "rpg",
+      serverEntry: mmorpgEntryPoints.server,
+      adapterEntries: mmorpgEntryPoints.adapters,
+    }),
     entryPointPlugin({
       entryPoints: {
         rpg: entryPoints?.rpg ?? './src/standalone.ts',
-        mmorpg: entryPoints?.mmorpg ?? './src/client.ts'
+        mmorpg: mmorpgEntryPoints.client,
       }
     })
   ]
-}
+}