@playdrop/playdrop-cli 0.17.5 → 0.17.15

package/README.md

@@ -123,6 +123,18 @@ playdrop project dev my-app
 playdrop project publish --env dev .
 ```
 
+## Game server SDK
+
+For a game with a `server` declaration, `project build`, `project check`, `project dev`, and upload preflight select the SDK reported by the environment's rooms runtime. The CLI verifies and downloads `playdrop-server-<version>.tgz` from the SDK CDN, installs its matching dependencies, and records them in `package.json`, `package-lock.json`, and `vendor/playdrop/`. Keep these files with the project. There is no npm registry release of `@playdrop/server` to install manually.
+
+SDK selection is fixed for one CLI invocation. Start a new invocation to pick up a platform SDK release. Missing runtime metadata, unavailable artifacts, or integrity mismatches fail explicitly. Production uses the SDK included in the deployed rooms runtime; the SDK release lane publishes the matching client and server artifacts before promoting them.
+
+Use Node.js 22 or later. Mixed client/server TypeScript projects should include both `src` and `server`, use `lib: ["ES2022", "DOM", "DOM.Iterable"]`, and retain `strict: true`. Set `skipLibCheck: true` for the Colyseus browser SDK's upstream declaration errors; game code remains checked. The CLI does not rewrite your TypeScript configuration.
+
+Cloud and direct first-party uploads run the same checks against the staged files before publishing. Declared playtest tapes run too. Server games run the exact prepared server bundle on a private temporary port, with isolated matchmaking and the publishing job's database settings. Auth-required unpublished games use the creator's test-player account, not a token for a version that does not exist yet. A failed check stops publication with its error.
+
+For direct first-party server uploads from this checkout, start `npm run dev:agent-platform` and load `infra/.env.dev` in the publishing process. Its `PLAYDROP_WORKER_GAME_SERVER_REDIS_ADMIN_URL` and `PLAYDROP_DEV_MONGO_URL` let the CLI create and clean up a temporary database lease for that upload. Cloud publishing receives the existing task lease directly and does not delete it until the task ends.
+
 ## Documentation
 
 ```bash

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.17.5",
+  "version": "0.17.15",
   "build": 1,
-  "runtimeSdkVersion": "0.17.5",
+  "runtimeSdkVersion": "0.17.15",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/apps/build.d.ts

@@ -1,5 +1,6 @@
 import type { AppPlaytestTapes, AppSurface, AppType } from "@playdrop/types";
 import type { AppTask } from "../catalogue";
+import { type ServerSdkOptions } from "./serverSdk";
 export type AppBuildMetadata = {
     displayName?: string;
     subtitle?: string;
@@ -24,7 +25,7 @@ export type AppBuildArtifacts = {
     sourceHash?: string;
     metadata: AppBuildMetadata;
 };
-export type BuildAppOptions = {
+export type BuildAppOptions = ServerSdkOptions & {
     includeSourceArchive?: boolean;
 };
 export declare function runNpmScript(projectDir: string, script: string): Promise<void>;

package/dist/apps/build.js

@@ -9,6 +9,8 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_zlib_1 = require("node:zlib");
+const runtimeSyntax_1 = require("./runtimeSyntax");
+const serverSdk_1 = require("./serverSdk");
 const BASE_SOURCE_IGNORE_PATTERNS = [
     "node_modules/",
     "dist/",
@@ -75,10 +77,11 @@ function readPackageJson(packageJsonPath) {
     const raw = (0, node_fs_1.readFileSync)(packageJsonPath, "utf8");
     return JSON.parse(raw);
 }
-async function ensureProjectBuild(task) {
+async function ensureProjectBuild(task, options) {
     if (!task.isTypescriptProject || !task.packageJsonPath) {
         return;
     }
+    await (0, serverSdk_1.ensureGameServerSdk)(task, options);
     if (!projectBuildCache.has(task.projectDir)) {
         const promise = (async () => {
             const pkg = readPackageJson(task.packageJsonPath);
@@ -614,7 +617,7 @@ function createSourceArchive(task) {
     return { buffer, hash };
 }
 async function buildApp(task, options = {}) {
-    await ensureProjectBuild(task);
+    await ensureProjectBuild(task, options);
     if (!(0, node_fs_1.existsSync)(task.filePath) || !(0, node_fs_1.statSync)(task.filePath).isFile()) {
         const locationHint = task.cataloguePath || "catalogue.json";
         const bundlePath = task.relativeFile || (0, node_path_1.basename)(task.filePath);
@@ -628,6 +631,7 @@ async function buildApp(task, options = {}) {
         ].join(" "));
     }
     const runtime = collectBundleFiles(task);
+    await (0, runtimeSyntax_1.validateRuntimeSyntax)(runtime.entries);
     const runtimeHash = (0, node_crypto_1.createHash)("sha256");
     const runtimeFiles = runtime.entries.map((entry) => {
         const content = (0, node_fs_1.readFileSync)(entry.absolutePath);

package/dist/apps/index.d.ts

@@ -2,6 +2,7 @@ import type { ApiClient } from "@playdrop/api-client";
 import type { AgentTaskPlaytestProof, UserResponse } from "@playdrop/types";
 import type { AppTask } from "../catalogue";
 import type { TaskCaptureSession } from "../appUrls";
+import type { GameServerDevServices } from "../commands/devGameServer";
 import { collectAppValidationWarnings, validateAppTask, runFormatScript } from "./validate";
 import { buildApp, type AppBuildArtifacts } from "./build";
 import { prepareAppUploadFiles, uploadApp, type AppUploadResult, type AppUploadOptions } from "./upload";
@@ -18,14 +19,12 @@ export type AppPipelineOptions = {
     webBase?: string | null;
     token?: string | null;
     user?: UserResponse | null;
-    runLocalLoadCheck?: boolean;
     devRouterPort?: number;
-    runStagedUploadLoadCheck?: boolean;
+    gameServerDev?: GameServerDevServices;
     loadCheckTimeoutMs?: number;
     ensureRegisteredAppShell?: boolean;
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
-    playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
     artifacts?: AppBuildArtifacts;
     prepareGitTransition?: AppUploadOptions["prepareGitTransition"];

package/dist/apps/index.js

@@ -12,67 +12,35 @@ const upload_1 = require("./upload");
 Object.defineProperty(exports, "prepareAppUploadFiles", { enumerable: true, get: function () { return upload_1.prepareAppUploadFiles; } });
 Object.defineProperty(exports, "uploadApp", { enumerable: true, get: function () { return upload_1.uploadApp; } });
 const registration_1 = require("./registration");
-const loadCheck_1 = require("./loadCheck");
 async function runAppPipeline(client, task, options) {
-    await (0, validate_1.validateAppTask)(task);
-    // External apps don't need to be built - they're hosted elsewhere
-    const isExternal = task.hostingMode === "EXTERNAL" || !!task.externalUrl;
-    const shouldEnsureRegisteredShell = !isExternal && options?.ensureRegisteredAppShell;
-    if (shouldEnsureRegisteredShell) {
-        const creatorUsername = typeof options.creatorUsername === "string" ? options.creatorUsername.trim() : "";
-        if (!creatorUsername) {
-            throw new Error(`Missing creator username for required hosted app registration of "${task.name}".`);
-        }
-        await (0, registration_1.ensureRegisteredHostedAppShell)({
-            client,
-            creatorUsername,
-            task,
-            agentTaskId: options.agentTaskId,
-        });
+    await (0, validate_1.validateAppTask)(task, { apiBase: options?.apiBase });
+    const isExternal = task.hostingMode === "EXTERNAL" || Boolean(task.externalUrl);
+    if (!isExternal && options?.ensureRegisteredAppShell) {
+        const creatorUsername = options.creatorUsername?.trim();
+        if (!creatorUsername)
+            throw new Error(`Missing creator username for app "${task.name}" registration.`);
+        await (0, registration_1.ensureRegisteredHostedAppShell)({ client, creatorUsername, task, agentTaskId: options.agentTaskId });
     }
-    const artifacts = isExternal
-        ? null
-        : (options?.artifacts ?? (await (0, build_1.buildApp)(task, { includeSourceArchive: options?.agentTaskId === undefined })));
+    const artifacts = isExternal ? null : options?.artifacts ?? await (0, build_1.buildApp)(task, {
+        includeSourceArchive: options?.agentTaskId === undefined,
+        apiBase: options?.apiBase,
+    });
     const warnings = (0, validate_1.collectAppValidationWarnings)(task, isExternal ? "source" : "bundle");
-    if (!isExternal && options?.runLocalLoadCheck) {
-        const creatorUsername = typeof options.creatorUsername === "string" ? options.creatorUsername.trim() : "";
-        if (!creatorUsername) {
-            throw new Error(`Missing creator username for local hosted load-check of "${task.name}".`);
-        }
-        const apiBase = typeof options.apiBase === "string" ? options.apiBase.trim() : "";
-        if (!apiBase) {
-            throw new Error(`Missing API base URL for local hosted load-check of "${task.name}".`);
-        }
-        const loadCheck = await (0, loadCheck_1.runLocalHostedLoadCheck)({
-            client,
-            apiBase,
-            webBase: options.webBase,
-            creatorUsername,
-            task,
-            devRouterPort: options.devRouterPort,
-            timeoutMs: options.loadCheckTimeoutMs,
-            token: options.token ?? null,
-            currentUser: options.user ?? null,
-            captureSession: options.captureSession,
-        });
-        if (loadCheck.status !== "PASSED") {
-            throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, "local"));
-        }
-    }
-    const uploadOptions = {
+    // Cloud and direct publishing use the same uploaded-game checks. A separate
+    // local browser pass cannot validate the uploaded bytes or their server.
+    const upload = await (0, upload_1.uploadApp)(client, task, artifacts, {
+        apiBase: options?.apiBase,
         skipReview: options?.skipReview,
         clearTags: options?.clearTags,
         creatorUsername: options?.creatorUsername,
         token: options?.token,
         user: options?.user ?? null,
-        runStagedUploadLoadCheck: options?.runStagedUploadLoadCheck,
+        gameServerDev: options?.gameServerDev,
         loadCheckTimeoutMs: options?.loadCheckTimeoutMs,
         agentTaskId: options?.agentTaskId,
         playtestProof: options?.playtestProof,
-        playtestSmokeCheckRequired: options?.playtestSmokeCheckRequired,
         captureSession: options?.captureSession,
         prepareGitTransition: options?.prepareGitTransition,
-    };
-    const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);
+    });
     return { artifacts, upload, warnings };
 }

package/dist/apps/loadCheck.d.ts

@@ -72,13 +72,14 @@ export declare function runLocalHostedLoadCheck(input: {
     postReadyWaitMs?: number;
     gameServerCredential?: DevGameServerCredentialResponse | null;
 }): Promise<HostedLoadCheckResult>;
-export declare function buildUploadedHostedLoadCheckUrl(rawUrl: string, phase?: "play" | "editor"): string;
+export declare function buildUploadedHostedLoadCheckUrl(rawUrl: string, phase?: "play" | "editor", localDevPort?: number): string;
 export declare function buildUploadedHostedLoadCheckScreenshotPath(task: Pick<AppTask, "name" | "projectDir">, sessionId: string, phase?: "play" | "editor"): string | null;
 export declare function runUploadedHostedLoadCheck(input: {
     client: ApiClient;
     creatorUsername: string;
     task: AppTask;
     sessionId: string;
+    localDevPort?: number;
     timeoutMs?: number;
     token?: string | null;
     currentUser?: UserResponse | null;
@@ -100,6 +101,7 @@ export declare function runUploadedHostedPlaytestSmokeCheck(input: {
     creatorUsername: string;
     task: AppTask;
     sessionId: string;
+    localDevPort?: number;
     timeoutMs?: number;
     token?: string | null;
     currentUser?: UserResponse | null;

package/dist/apps/loadCheck.js

@@ -292,14 +292,13 @@ function formatLoadCheckErrors(errors) {
         return "";
     }
     const normalized = errors
-        .map((entry) => entry.replace(/\s+/g, " ").trim())
+        .map((entry) => entry.trim())
         .filter(Boolean)
-        .slice(0, 3)
-        .map((entry) => (entry.length > 240 ? `${entry.slice(0, 237)}...` : entry));
+        .slice(0, 3);
     if (normalized.length === 0) {
         return "";
     }
-    return ` First error${normalized.length === 1 ? "" : "s"}: ${normalized.join(" | ")}`;
+    return `\nFirst error${normalized.length === 1 ? "" : "s"}:\n${normalized.join("\n\n")}`;
 }
 function isSoftwareWebGlRenderer(renderer) {
     const normalized = typeof renderer === "string" ? renderer.trim() : "";
@@ -549,13 +548,17 @@ async function readWebGlRenderer(frame) {
     }
     return normalized;
 }
-async function saveScreenshot(page, screenshotPath) {
+async function saveScreenshot(page, screenshotPath, timeoutMs = 30000) {
     const normalizedPath = typeof screenshotPath === "string" ? screenshotPath.trim() : "";
     if (!normalizedPath) {
         return null;
     }
     await (0, promises_1.mkdir)((0, node_path_1.dirname)(normalizedPath), { recursive: true });
-    await page.screenshot({ path: normalizedPath, fullPage: true });
+    await page.screenshot({
+        path: normalizedPath,
+        fullPage: true,
+        timeout: timeoutMs,
+    });
     return normalizedPath;
 }
 async function saveGameFrameScreenshot(page, screenshotPath) {
@@ -632,11 +635,22 @@ async function runHostedLoadCheck(options) {
             const withTapeAction = (line) => (currentTapeAction ? `${line} after ${currentTapeAction}` : line);
             let hostedLaunchWaiterSettled = false;
             let lastHostedLaunchState = null;
+            let fatalRuntimeError = null;
+            let rejectFatalRuntimeFailure;
+            const fatalRuntimeFailure = new Promise((_resolve, reject) => {
+                rejectFatalRuntimeFailure = reject;
+            });
+            // Browser events can arrive before navigation starts awaiting this signal.
+            void fatalRuntimeFailure.catch(() => { });
             let resolveHostedLaunchWaiter = null;
             const hostedLaunchWaiter = new Promise((resolve) => {
                 resolveHostedLaunchWaiter = resolve;
             });
             const settleHostedLaunchWaiter = (state) => {
+                if (state.state === "error" && !fatalRuntimeError) {
+                    fatalRuntimeError = new Error(formatHostedLaunchError(state));
+                    rejectFatalRuntimeFailure(fatalRuntimeError);
+                }
                 lastHostedLaunchState = state;
                 if (hostedLaunchWaiterSettled) {
                     return;
@@ -760,9 +774,14 @@ async function runHostedLoadCheck(options) {
                 pendingConsoleMessages.add(pending);
             });
             page.on("pageerror", (error) => {
-                const text = redactReportText(error?.message ?? String(error));
+                const text = redactReportText(error.stack?.trim() || `${error.name}: ${error.message}`);
                 const line = withTapeAction(`[check][pageerror] ${text}`);
                 errors.push(line);
+                settleHostedLaunchWaiter({
+                    state: "error",
+                    errorCode: "hosted_app_javascript_error",
+                    message: line,
+                });
             });
             page.on("crash", () => {
                 const line = withTapeAction("[check][pagecrash] Hosted validator page crashed.");
@@ -811,7 +830,7 @@ async function runHostedLoadCheck(options) {
             });
             const captureFailureScreenshot = async () => {
                 try {
-                    screenshotPath = await saveScreenshot(page, options.failureScreenshotPath ?? options.screenshotPath);
+                    screenshotPath = await saveScreenshot(page, options.failureScreenshotPath ?? options.screenshotPath, HOSTED_LAUNCH_DIAGNOSTIC_TIMEOUT_MS);
                 }
                 catch (screenshotError) {
                     const detail = redactReportText(screenshotError instanceof Error ? screenshotError.message : String(screenshotError));
@@ -826,57 +845,81 @@ async function runHostedLoadCheck(options) {
                 screenshotPath = await saveScreenshot(page, options.screenshotPath);
             };
             try {
-                const readinessTimeoutMs = Math.min(Math.max(timeoutMs, 1000), 30000);
-                let response;
-                let launchState;
-                try {
-                    [response, launchState] = await waitForHostedLaunchDeadline(async () => await Promise.all([
-                        page.goto(options.targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 }),
-                        hostedLaunchWaiter,
-                    ]), expectedHostedLaunchState, timeoutMs);
-                }
-                catch (error) {
-                    const timeoutContext = await describeHostedLaunchTimeout(page, lastHostedLaunchState);
-                    const detail = error instanceof Error ? error.message : String(error);
-                    throw new Error(`${detail} ${timeoutContext}`);
-                }
-                if (response && !response.ok()) {
-                    errors.push(`[check][navigation] ${response.status()} ${response.statusText()} ${reportTargetUrl}`);
-                }
-                if (launchState.state === "error") {
-                    throw new Error(formatHostedLaunchError(launchState));
-                }
-                finalUrl = (0, appUrls_1.redactTaskCaptureSession)(page.url());
-                if (expectedHostedLaunchState !== "ready") {
+                const check = async () => {
+                    const readinessTimeoutMs = Math.min(Math.max(timeoutMs, 1000), 30000);
+                    let response;
+                    let launchState;
+                    try {
+                        [response, launchState] = await waitForHostedLaunchDeadline(async () => await Promise.race([
+                            Promise.all([
+                                page.goto(options.targetUrl, {
+                                    waitUntil: "domcontentloaded",
+                                    timeout: 30000,
+                                }),
+                                hostedLaunchWaiter,
+                            ]),
+                            fatalRuntimeFailure,
+                        ]), expectedHostedLaunchState, timeoutMs);
+                    }
+                    catch (error) {
+                        const detail = error instanceof Error ? error.message : String(error);
+                        if (!/^hosted_app_(?:missing_ready|gate_missing):/.test(detail))
+                            throw error;
+                        const timeoutContext = await describeHostedLaunchTimeout(page, lastHostedLaunchState);
+                        throw new Error(`${detail} ${timeoutContext}`);
+                    }
+                    if (response && !response.ok()) {
+                        errors.push(`[check][navigation] ${response.status()} ${response.statusText()} ${reportTargetUrl}`);
+                    }
+                    if (launchState.state === "error") {
+                        throw new Error(formatHostedLaunchError(launchState));
+                    }
+                    finalUrl = (0, appUrls_1.redactTaskCaptureSession)(page.url());
+                    if (expectedHostedLaunchState !== "ready") {
+                        if (expectedHostedLaunchState === "login_required") {
+                            try {
+                                // Trial checks visibility and hit testing without opening the sign-in flow.
+                                await page.locator('[data-hosted-play-gate="login_required"] button').click({
+                                    trial: true,
+                                    timeout: readinessTimeoutMs,
+                                });
+                            }
+                            catch (error) {
+                                throw new Error("hosted_app_gate_not_visible: PlayDrop reported that sign-in is required, but the game's sign-in panel could not be seen or used. " +
+                                    (error instanceof Error ? error.message : String(error)));
+                            }
+                        }
+                        await drainConsoleMessages();
+                        await captureCompletionScreenshot();
+                        return;
+                    }
+                    const frame = await findGameFrame(page, readinessTimeoutMs);
+                    webglRenderer = await readWebGlRenderer(frame);
+                    if (isSoftwareWebGlRenderer(webglRenderer)) {
+                        throw new Error(`project_check_webgl_renderer_software: WebGL renderer is "${webglRenderer}". Real hardware acceleration is required.`);
+                    }
+                    if (options.verifyEditorPhaseRoundTrip) {
+                        await verifyHostedEditorPhaseRoundTrip(page, frame, readinessTimeoutMs);
+                    }
+                    await saveGameFrameScreenshot(page, options.readyGameFrameScreenshotPath);
+                    if (options.playtestTape) {
+                        if (!options.playtestSurface) {
+                            throw new Error("project_check_playtest_surface_required");
+                        }
+                        await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape, {
+                            onBeforeEvent: (eventIndex, event) => {
+                                currentTapeAction = `action ${eventIndex + 1} of ${options.playtestTape.events.length} (${event.type} at ${event.atMs} ms)`;
+                            },
+                        });
+                    }
+                    else if (options.postReadyWaitMs && options.postReadyWaitMs > 0) {
+                        await page.waitForTimeout(options.postReadyWaitMs);
+                    }
+                    await saveGameFrameScreenshot(page, options.gameFrameScreenshotPath);
                     await drainConsoleMessages();
                     await captureCompletionScreenshot();
-                    return;
-                }
-                const frame = await findGameFrame(page, readinessTimeoutMs);
-                webglRenderer = await readWebGlRenderer(frame);
-                if (isSoftwareWebGlRenderer(webglRenderer)) {
-                    throw new Error(`project_check_webgl_renderer_software: WebGL renderer is "${webglRenderer}". Real hardware acceleration is required.`);
-                }
-                if (options.verifyEditorPhaseRoundTrip) {
-                    await verifyHostedEditorPhaseRoundTrip(page, frame, readinessTimeoutMs);
-                }
-                await saveGameFrameScreenshot(page, options.readyGameFrameScreenshotPath);
-                if (options.playtestTape) {
-                    if (!options.playtestSurface) {
-                        throw new Error("project_check_playtest_surface_required");
-                    }
-                    await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape, {
-                        onBeforeEvent: (eventIndex, event) => {
-                            currentTapeAction = `action ${eventIndex + 1} of ${options.playtestTape.events.length} (${event.type} at ${event.atMs} ms)`;
-                        },
-                    });
-                }
-                else if (options.postReadyWaitMs && options.postReadyWaitMs > 0) {
-                    await page.waitForTimeout(options.postReadyWaitMs);
-                }
-                await saveGameFrameScreenshot(page, options.gameFrameScreenshotPath);
-                await drainConsoleMessages();
-                await captureCompletionScreenshot();
+                };
+                await Promise.race([check(), fatalRuntimeFailure]);
             }
             catch (error) {
                 await drainConsoleMessages();
@@ -887,7 +930,7 @@ async function runHostedLoadCheck(options) {
                     // Keep the last known URL when the renderer is unavailable.
                 }
                 await captureFailureScreenshot();
-                throw error;
+                throw fatalRuntimeError ?? error;
             }
         }, {
             ...options.contextOptions,
@@ -907,7 +950,9 @@ async function runHostedLoadCheck(options) {
             targetUrl: finalUrl,
             errors: errors.length > 0 ? errors : normalized.errors,
             warnings,
-            message: normalized.message ? `${normalized.message}${formatLoadCheckErrors(errors)}` : normalized.message,
+            message: normalized.message
+                ? `${normalized.message}${formatLoadCheckErrors(errors.filter((entry) => !normalized.message.includes(entry)))}`
+                : normalized.message,
         };
     }
     if (errors.length > 0) {
@@ -1028,6 +1073,8 @@ async function runLocalHostedLoadCheck(input) {
                     creatorUsername: input.creatorUsername,
                     appName: input.task.name,
                     appType: input.task.type ?? "GAME",
+                    devAuth: "player",
+                    player: "1",
                     launchCheck: true,
                     localDevPort,
                     captureSession: input.captureSession,
@@ -1068,7 +1115,8 @@ async function runLocalHostedLoadCheck(input) {
                     creatorUsername: input.creatorUsername,
                     appName: input.task.name,
                     appType: input.task.type ?? "GAME",
-                    devAuth: "viewer",
+                    devAuth: "player",
+                    player: "1",
                     launchCheck: true,
                     localDevPort,
                 }),
@@ -1114,9 +1162,11 @@ function appendLoadCheckParams(targetUrl, devAuth) {
         player: null,
     });
 }
-function buildUploadedHostedLoadCheckUrl(rawUrl, phase) {
+function buildUploadedHostedLoadCheckUrl(rawUrl, phase, localDevPort) {
     const url = new URL(rawUrl);
     url.searchParams.set("launchCheck", "1");
+    if (localDevPort !== undefined)
+        url.searchParams.set("localDevPort", String(localDevPort));
     if (phase === "editor") {
         url.searchParams.set("hostPhase", "editor");
     }
@@ -1132,7 +1182,10 @@ function buildUploadedHostedLoadCheckScreenshotPath(task, sessionId, phase) {
 }
 async function runUploadedHostedLoadCheck(input) {
     const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
-    const withRequestedPhase = (rawUrl) => buildUploadedHostedLoadCheckUrl(rawUrl, input.phase);
+    if (input.task.server && (!Number.isInteger(input.localDevPort) || input.localDevPort <= 0 || input.localDevPort > 65535)) {
+        throw new Error("publishing_game_server_port_missing: The uploaded game cannot be checked without its running game server.");
+    }
+    const withRequestedPhase = (rawUrl) => buildUploadedHostedLoadCheckUrl(rawUrl, input.phase, input.localDevPort);
     const failureScreenshotPath = input.screenshotPath ?? buildUploadedHostedLoadCheckScreenshotPath(input.task, input.sessionId, input.phase);
     const captureSurface = resolveLoadCheckSurface(preview.localAppMetadata.surfaceTargets, input.task.primarySurface);
     const contextOptions = cloneLoadCheckContextOptions(captureSurface);
@@ -1142,7 +1195,10 @@ async function runUploadedHostedLoadCheck(input) {
     });
     let result;
     if (input.captureSession) {
-        const targetUrl = new URL(withRequestedPhase(preview.launchUrl));
+        const targetUrl = new URL((0, devAuth_1.applyHostedDevAuthSelectionToUrl)(withRequestedPhase(preview.launchUrl), {
+            devAuth: "player",
+            player: 1,
+        }));
         (0, appUrls_1.appendTaskCaptureSession)(targetUrl, input.captureSession);
         result = await runHostedLoadCheck({
             targetUrl: targetUrl.toString(),
@@ -1179,7 +1235,9 @@ async function runUploadedHostedLoadCheck(input) {
             }
             else {
                 result = await runHostedLoadCheck({
-                    targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, "viewer")),
+                    targetUrl: (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(withRequestedPhase(preview.launchUrl), {
+                        devAuth: "player", player: 1,
+                    }),
                     artifactFingerprint: preview.session.manifestHash,
                     timeoutMs: input.timeoutMs,
                     expectedHostedLaunchState: resolvePostAuthHostedLaunchState(preview.localAppMetadata.controllerMode),
@@ -1285,6 +1343,7 @@ async function runUploadedHostedPlaytestSmokeCheck(input) {
             creatorUsername: input.creatorUsername,
             task: input.task,
             sessionId: input.sessionId,
+            localDevPort: input.localDevPort,
             timeoutMs: input.timeoutMs,
             token: input.token,
             currentUser: input.currentUser,

package/dist/apps/publishingRuntime.d.ts

@@ -0,0 +1,18 @@
+import type { ApiClient } from "@playdrop/api-client";
+import type { AppTask } from "../catalogue";
+import { type GameServerDevServices } from "../commands/devGameServer";
+import type { GameServerBuild } from "./serverBuild";
+export type PublishingRuntime = {
+    localDevPort: number;
+    close(): Promise<void>;
+};
+export declare function startPublishingRuntime(input: {
+    client: ApiClient;
+    task: AppTask;
+    creatorUsername: string;
+    appId: number;
+    sessionId: string;
+    apiBase?: string;
+    gameServerBuild: GameServerBuild;
+    gameServerDev?: GameServerDevServices;
+}): Promise<PublishingRuntime>;