@vgai/sdk 0.5.14 → 0.5.16

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/sdk",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.5.14",
+  "version": "0.5.16",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@vgai/engine": "0.5.14",
+    "@vgai/engine": "0.5.16",
     "playwright": "^1.58.2",
     "zod": "^4.3.6"
   }

package/src/editor/open-operations.ts

@@ -68,7 +68,6 @@ const AssetKindSchema = z.enum([
   'json',
   'scene',
   'prefab',
-  'material',
 ]);
 
 const EditorAssetOpenInput = z.object({

package/src/mcp/mcp-stdio-server.ts

@@ -1,8 +1,5 @@
 /**
- * Real-SDK stdio transport for the MCP projection (roadmap A1, bespoke-audit
- * F1) — the exact follow-up `mcp-projection.ts`'s header reserved: "If the
- * official SDK is later added, only a transport wrapper around `handle`
- * changes; the derivation below does not."
+ * Official-SDK stdio transport for the MCP projection.
  *
  * This module is that transport wrapper and NOTHING more: it binds
  * `@modelcontextprotocol/sdk`'s `Server` + `StdioServerTransport` around the

package/src/render/render-cinematic.ts

@@ -245,7 +245,7 @@ function keepFramesOverride(signal: AbortSignal | undefined): boolean | undefine
 }
 
 const DEFAULT_SEED = 0x5eed_c0de;
-/** Only actually used when `entry` is an http(s) URL (no dev server spawn — see {@link resolveEffectivePort}) or as this pure function's own documented default before that override applies. */
+/** Only actually used when `entry` is an http(s) URL (no preview server spawn — see {@link resolveEffectivePort}) or as this pure function's own documented default before that override applies. */
 const DEFAULT_PORT = 5799;
 
 /**
@@ -282,7 +282,7 @@ export function findFreeRenderPort(): Promise<number> {
 
 /**
  * I7 fold-in (#9b): when the caller didn't pin an explicit `port`, resolve a
- * genuinely free one right before spawning the dev server, overriding the
+ * genuinely free one right before spawning the preview server, overriding the
  * resolved request's `DEFAULT_PORT` placeholder. Checked against the
  * ORIGINAL (unresolved) `request.port`, not `resolved.port` — the latter
  * already has `DEFAULT_PORT` filled in by {@link resolveRenderCinematicRequest}
@@ -471,7 +471,7 @@ export function resolveRenderCinematicRequest(
     keepFrames: req.keepFrames ?? false,
     // I7 fold-in #9b: this DEFAULT_PORT fallback is only actually used when
     // `resolveEffectivePort` (below) doesn't override it — i.e. `entry` is
-    // an already-serving http(s) URL (no dev server is ever spawned, so no
+    // an already-serving http(s) URL (no preview server is ever spawned, so no
     // port collision is possible). Every Vite-config `entry` gets a REAL
     // free port at launch time instead — see `resolveEffectivePort`.
     port: req.port ?? DEFAULT_PORT,
@@ -607,23 +607,23 @@ async function waitForHttpOk(url: string, timeoutMs: number, signal?: AbortSigna
   const deadline = Date.now() + timeoutMs;
   let lastErr: unknown;
   while (Date.now() < deadline) {
-    // I7 fold-in (#9a): don't keep polling a dev server that's booting for a
+    // I7 fold-in (#9a): don't keep polling a preview server that's booting for a
     // render that was already cancelled — return promptly so the caller's
     // own catch path (`launchEntryServer`) can group-kill the half-started
     // vite process right away instead of waiting out the full 30s timeout.
     if (signal?.aborted) {
-      throw new Error('Render cancelled while waiting for the dev server to become ready.');
+      throw new Error('Render cancelled while waiting for the preview server to become ready.');
     }
     try {
       const res = await fetch(url);
-      if (res.ok || res.status === 404) return; // dev server answering is enough; 404 still proves it's up
+      if (res.ok || res.status === 404) return; // a preview response is enough; 404 still proves it's up
     } catch (err) {
       lastErr = err;
     }
     await new Promise((r) => setTimeout(r, 200));
   }
   throw new Error(
-    `Dev server at ${url} did not become ready within ${timeoutMs}ms` +
+    `Preview server at ${url} did not become ready within ${timeoutMs}ms` +
       (lastErr instanceof Error ? ` (last error: ${lastErr.message})` : ''),
   );
 }
@@ -633,16 +633,56 @@ export interface LaunchedServer {
   stop(): Promise<void>;
 }
 
-/** Resolve `entry` into a running dev server: reuse a URL as-is, or spawn `npx vite --config <entry>` (mirrors `run-doctor.ts`/`runConformance`'s `npx tsx <runner>` spawn idiom, `packages/vgai-cli/src/index.ts`). */
+/** Build one Vite config as an exported artifact. A dev-served standalone game
+ * is intentionally trapped by `unexported-game-trap.ts`; render tooling must
+ * exercise either the editor or the export, never invent a bypass query. */
+async function buildExportedEntry(
+  configPath: string,
+  cwd: string,
+  outDir: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const child = spawn('npx', ['vite', 'build', '--config', configPath, '--outDir', outDir], {
+    cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  });
+  let output = '';
+  child.stdout?.on('data', (data) => {
+    output += String(data);
+  });
+  child.stderr?.on('data', (data) => {
+    output += String(data);
+  });
+
+  const abort = () => void stopServerProcess(child);
+  signal?.addEventListener('abort', abort, { once: true });
+  try {
+    const code = await new Promise<number>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', (exitCode) => resolve(exitCode ?? 1));
+    });
+    if (signal?.aborted) throw new Error('Render cancelled while building the exported game.');
+    if (code !== 0) {
+      throw new Error(`Vite production build failed (exit ${code}).\nOutput:\n${output}`);
+    }
+    return output;
+  } finally {
+    signal?.removeEventListener('abort', abort);
+  }
+}
+
+/** Resolve `entry` into a running exported page: reuse a URL as-is, or build
+ * the Vite config and spawn `vite preview`. */
 export async function launchEntryServer(
   entry: string,
   port: number,
-  engineRoot: string,
+  _engineRoot: string,
   onProgress: ((e: RenderCinematicProgress) => void) | undefined,
   signal?: AbortSignal,
   options?: {
     /**
-     * Extra args appended to the `npx vite` spawn (G3 fold-in). Motivating
+     * Extra args appended to the `npx vite preview` spawn (G3 fold-in). Motivating
      * case: the render-mode e2e fixtures all pin `server.host: '127.0.0.1'`
      * in their own vite configs, but a real project's config (an
      * `examples/<id>/vite.config.ts`) typically leaves `host` at Vite's
@@ -668,6 +708,15 @@ export async function launchEntryServer(
   }
   const baseUrl = `http://127.0.0.1:${port}`;
   onProgress?.({ phase: 'server-launch', url: baseUrl });
+  const projectDir = dirname(configPath);
+  const exportDir = await mkdtemp(join(tmpdir(), 'vgai-render-export-'));
+  let buildOutput: string;
+  try {
+    buildOutput = await buildExportedEntry(configPath, projectDir, exportDir, signal);
+  } catch (error) {
+    await rm(exportDir, { recursive: true, force: true });
+    throw error;
+  }
 
   // `detached: true` makes this child the leader of its OWN process group —
   // required for `stopServerProcess`'s `process.kill(-pid, sig)` group-kill
@@ -682,14 +731,17 @@ export async function launchEntryServer(
     'npx',
     [
       'vite',
+      'preview',
       '--config',
       configPath,
+      '--outDir',
+      exportDir,
       '--port',
       String(port),
       '--strictPort',
       ...(options?.extraViteArgs ?? []),
     ],
-    { cwd: engineRoot, stdio: ['ignore', 'pipe', 'pipe'], detached: true },
+    { cwd: projectDir, stdio: ['ignore', 'pipe', 'pipe'], detached: true },
   );
   let serverOutput = '';
   child.stdout?.on('data', (d) => {
@@ -708,10 +760,14 @@ export async function launchEntryServer(
     await waitForHttpOk(`${baseUrl}/`, 30_000, signal);
   } catch (err) {
     await stopServerProcess(child);
-    throw new Error(`${(err as Error).message}\nVite dev server output:\n${serverOutput}`);
+    await rm(exportDir, { recursive: true, force: true });
+    throw new Error(
+      `${(err as Error).message}\nVite build output:\n${buildOutput}\nVite preview output:\n${serverOutput}`,
+    );
   }
   if (exited) {
-    throw new Error(`Vite dev server exited before becoming ready.\nOutput:\n${serverOutput}`);
+    await rm(exportDir, { recursive: true, force: true });
+    throw new Error(`Vite preview exited before becoming ready.\nOutput:\n${serverOutput}`);
   }
 
   onProgress?.({ phase: 'server-ready', url: baseUrl });
@@ -719,8 +775,8 @@ export async function launchEntryServer(
   return {
     baseUrl,
     async stop() {
-      if (exited) return;
-      await stopServerProcess(child);
+      if (!exited) await stopServerProcess(child);
+      await rm(exportDir, { recursive: true, force: true });
     },
   };
 }
@@ -729,7 +785,7 @@ export async function launchEntryServer(
  * Terminate `proc` AND its whole process group (see the `detached: true`
  * comment at its call site above) — a plain `proc.kill()` leaves the real
  * `vite` node process (an `npx` grandchild) running, which both leaks a
- * port-bound dev server across renders and keeps THIS process's event loop
+ * port-bound preview server across renders and keeps THIS process's event loop
  * alive via the still-open stdout/stderr pipes, hanging `renderCinematic`'s
  * caller indefinitely after the render itself has already finished. Mirrors
  * `packages/editor/e2e/helpers/server.ts`'s `stopProcess` (POSIX process-
@@ -757,7 +813,7 @@ function stopServerProcess(proc: ChildProcess): Promise<void> {
       return;
     }
     const timer = setTimeout(() => {
-      signalGroup('SIGKILL'); // belt and braces — don't hang the render on a stuck dev server
+      signalGroup('SIGKILL'); // belt and braces — don't hang the render on a stuck preview server
       resolvePromise();
     }, 5_000);
     proc.on('exit', () => {
@@ -1450,12 +1506,12 @@ async function openRenderPage(
 export interface RenderCinematicPageSession {
   readonly page: Page;
   readonly resolved: ResolvedRenderCinematicRequest;
-  /** Closes the page/context, the browser, and stops the spawned dev server (if any). */
+  /** Closes the page/context, the browser, and stops the spawned preview server (if any). */
   close(): Promise<void>;
 }
 
 /**
- * Open a live render-mode page — preflight, dev-server launch, headless
+ * Open a live render-mode page — preflight, production build/preview launch, headless
  * Chromium launch, DOM/CSS-animation freeze, navigate, and wait for
  * `__vgaiRender.ready()` — WITHOUT running {@link renderCinematic}'s own
  * frame-capture/encode loop. This exposes the raw Playwright `Page` for a
@@ -1723,13 +1779,13 @@ export async function renderCinematic(
     // I7 fold-in (#9a — cancellation race): this is the EARLIEST possible
     // cancellation point — `preparePipelineOutputs` (immediately above)
     // already created `framesDir` on disk, so throwing here without cleanup
-    // leaked it (reproduced by a real abort landing before the dev server
+    // leaked it (reproduced by a real abort landing before the preview server
     // even starts, not merely a hypothetical). `cleanupAfterFailure` is a
     // no-op on everything else at this point (no `outAbs` output could
     // possibly exist yet), so this is just the framesDir removal, done
     // explicitly rather than pulled into a broader try/catch this early.
     const err = new RenderCinematicCancelledError(
-      'Render cancelled before the dev server launched.',
+      'Render cancelled before the preview server launched.',
       keepFramesOverride(signal),
     );
     await cleanupAfterFailure(err, resolved, outAbs, framesDir, signal);
@@ -1742,7 +1798,7 @@ export async function renderCinematic(
   // cancellation-driven failure — `waitForHttpOk`'s own `signal?.aborted`
   // check inside `launchEntryServer` throws a plain `Error` (wrapped again
   // by `launchEntryServer`'s own catch, losing any `RenderCinematicCancelledError`-
-  // ness entirely) if `signal` aborts while still waiting for the dev server
+  // ness entirely) if `signal` aborts while still waiting for the preview server
   // to come up. Without this try/catch, THAT throw skipped
   // `cleanupAfterFailure` completely (it's outside the main try block) and
   // leaked the temp frames dir `preparePipelineOutputs` already created
@@ -1765,7 +1821,7 @@ export async function renderCinematic(
   let browser: Browser | undefined;
   const warnings: string[] = [];
   // I7 fold-in (#9a — cancellation/orphan): tear down the browser AND the
-  // vite dev server's WHOLE PROCESS GROUP the INSTANT `signal` aborts,
+  // Vite preview server's WHOLE PROCESS GROUP the INSTANT `signal` aborts,
   // rather than waiting for the next cooperative per-frame check
   // (`captureFrames`'s `signal?.aborted` guard) to be reached. This is what
   // makes a slow/hung in-flight `page.evaluate`/`page.screenshot` call, or a