@playcademy/vite-plugin 0.0.1-beta.18 → 0.0.1-beta.19

package/dist/index.js

@@ -109287,7 +109287,8 @@ function setupAuth() {
   };
 }
 var isBrowser = () => {
-  return typeof window !== "undefined" && typeof document !== "undefined";
+  const g5 = globalThis;
+  return typeof g5.window !== "undefined" && typeof g5.document !== "undefined";
 };
 var colors = {
   reset: "\x1B[0m",
@@ -111020,8 +111021,8 @@ async function startRealtimeServer(realtimeOptions, betterAuthSecret) {
         betterAuthSecret,
         quiet: true
       });
-    } catch (err2) {
-      console.warn("[sandbox] Bun runtime not detected - fallback realtime server failed to start.", err2);
+    } catch (error2) {
+      console.error("Failed to start realtime server:", error2);
       return null;
     }
   }
@@ -121164,37 +121165,54 @@ async function startServer(options) {
 var version3 = package_default.version;
 
 // src/lib/sandbox.ts
-function printSandboxInfo(viteConfig, availablePort, projectInfo) {
+function printSandboxInfo(viteConfig, apiPort, realtimePort, projectInfo) {
   viteConfig.logger.info("");
   viteConfig.logger.info(`  ${import_picocolors2.default.green(import_picocolors2.default.bold("PLAYCADEMY"))} ${import_picocolors2.default.green(`v${version3}`)}`);
   viteConfig.logger.info("");
   viteConfig.logger.info(`  ${import_picocolors2.default.green("➜")}  ${import_picocolors2.default.bold("Game:")}    ${import_picocolors2.default.cyan(projectInfo.slug)}`);
-  viteConfig.logger.info(`  ${import_picocolors2.default.green("➜")}  ${import_picocolors2.default.bold("Sandbox:")} ${import_picocolors2.default.cyan(`http://localhost:${import_picocolors2.default.bold(availablePort.toString())}/api`)}`);
+  viteConfig.logger.info(`  ${import_picocolors2.default.green("➜")}  ${import_picocolors2.default.bold("Sandbox:")} ${import_picocolors2.default.cyan(`http://localhost:${import_picocolors2.default.bold(apiPort.toString())}/api`)}`);
+  viteConfig.logger.info(`  ${import_picocolors2.default.green("➜")}  ${import_picocolors2.default.bold("Realtime:")} ${import_picocolors2.default.cyan(`ws://localhost:${import_picocolors2.default.bold(realtimePort.toString())}`)}`);
   viteConfig.logger.info("");
 }
 async function startSandbox(viteConfig, autoStart = true, verbose = false, customUrl) {
   if (!autoStart || viteConfig.command !== "serve") {
+    const baseUrl = customUrl ?? "http://localhost:4321/api";
+    const deriveRealtimeUrl = (url) => {
+      try {
+        const u3 = new URL(url);
+        const port = Number(u3.port || (u3.protocol === "https:" ? 443 : 80));
+        const wsProto = u3.protocol === "https:" ? "wss:" : "ws:";
+        return `${wsProto}//${u3.hostname}:${port + 1}`;
+      } catch {
+        return "ws://localhost:4322";
+      }
+    };
     return {
-      url: customUrl ?? "http://localhost:4321/api",
+      baseUrl,
+      realtimeUrl: deriveRealtimeUrl(baseUrl),
       project: null,
       cleanup: () => {}
     };
   }
   try {
-    const availablePort = await findAvailablePort(4321);
-    const sandboxUrl = `http://localhost:${availablePort}/api`;
+    const sandboxPort = await findAvailablePort(4321);
+    const baseUrl = `http://localhost:${sandboxPort}/api`;
+    const realtimePort = await findAvailablePort(sandboxPort + 1);
+    const realtimeUrl = `ws://localhost:${realtimePort}`;
     const projectInfo = extractProjectInfo(viteConfig);
     const server = await startServer({
-      port: availablePort,
+      port: sandboxPort,
       verbose,
       seed: true,
-      project: projectInfo
+      project: projectInfo,
+      realtime: { enabled: true, port: realtimePort }
     });
     setTimeout(() => {
-      printSandboxInfo(viteConfig, availablePort, projectInfo);
+      printSandboxInfo(viteConfig, sandboxPort, realtimePort, projectInfo);
     }, 100);
     return {
-      url: sandboxUrl,
+      baseUrl,
+      realtimeUrl,
       project: projectInfo,
       cleanup: () => {
         if (server && typeof server.stop === "function") {
@@ -121206,7 +121224,8 @@ async function startSandbox(viteConfig, autoStart = true, verbose = false, custo
   } catch (error2) {
     viteConfig.logger.error(import_picocolors2.default.red(`[Playcademy] Failed to start sandbox: ${error2}`));
     return {
-      url: "http://localhost:4321/api",
+      baseUrl: "http://localhost:4321/api",
+      realtimeUrl: "ws://localhost:4322",
       project: null,
       cleanup: () => {}
     };
@@ -121395,6 +121414,7 @@ var shell_default = `<!doctype html>
                             baseUrl: '{{SANDBOX_URL}}',
                             token: 'sandbox-demo-token',
                             gameId: '{{GAME_ID}}',
+                            realtimeUrl: '{{REALTIME_URL}}',
                         },
                         {
                             target: gameFrame.contentWindow,
@@ -121437,15 +121457,15 @@ var shell_default = `<!doctype html>
 `;
 
 // src/lib/server.ts
-function generateLoaderHTML(sandboxUrl, gameId) {
-  return shell_default.replace(/{{SANDBOX_URL}}/g, sandboxUrl).replace(/{{GAME_ID}}/g, gameId);
+function generateLoaderHTML(sandboxUrl, gameId, realtimeUrl) {
+  return shell_default.replace(/{{SANDBOX_URL}}/g, sandboxUrl).replace(/{{GAME_ID}}/g, gameId).replace(/{{REALTIME_URL}}/g, realtimeUrl);
 }
-function devServerMiddleware(server, sandboxUrl, project) {
+function devServerMiddleware(server, sandbox) {
   server.middlewares.use("/", (req, res, next) => {
     if (req.url === "/" && req.method === "GET") {
       res.setHeader("Content-Type", "text/html");
-      const gameId = project.slug;
-      res.end(generateLoaderHTML(sandboxUrl, gameId));
+      const gameId = sandbox.project?.slug;
+      res.end(generateLoaderHTML(sandbox.baseUrl, gameId ?? "", sandbox.realtimeUrl));
       return;
     }
     if (req.url === "/game" && req.method === "GET") {
@@ -121461,7 +121481,6 @@ function devServerMiddleware(server, sandboxUrl, project) {
 function playcademy(options = {}) {
   let viteConfig;
   let currentBuildOutputs = {};
-  let sandboxCleanup = null;
   const exportOptions = options.export ?? {};
   const sandboxOptions = options.sandbox ?? {};
   const _options = {
@@ -121485,12 +121504,11 @@ function playcademy(options = {}) {
     },
     async configureServer(server) {
       const sandbox = await startSandbox(viteConfig, _options.startSandbox, _options.verbose, _options.sandboxUrl);
-      sandboxCleanup = sandbox.cleanup;
       if (sandbox.project) {
-        devServerMiddleware(server, sandbox.url, sandbox.project);
+        devServerMiddleware(server, sandbox);
       }
       server.httpServer?.on("close", () => {
-        sandboxCleanup?.();
+        sandbox.cleanup();
       });
     },
     async writeBundle() {

package/dist/lib/server.d.ts

@@ -1,3 +1,3 @@
 import type { ViteDevServer } from 'vite';
-import type { ProjectInfo } from '../types';
-export declare function devServerMiddleware(server: ViteDevServer, sandboxUrl: string, project: ProjectInfo): void;
+import type { SandboxManager } from '../types';
+export declare function devServerMiddleware(server: ViteDevServer, sandbox: SandboxManager): void;

package/dist/types.d.ts

@@ -58,7 +58,8 @@ export interface ManifestOptions {
  * Sandbox manager interface for controlling sandbox lifecycle
  */
 export interface SandboxManager {
-    url: string;
+    baseUrl: string;
+    realtimeUrl: string;
     project: ProjectInfo | null;
     cleanup: () => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.0.1-beta.18",
+    "version": "0.0.1-beta.19",
     "type": "module",
     "exports": {
         ".": {