@playdrop/playdrop-cli 0.15.6 → 0.15.11

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.15.6",
+  "version": "0.15.11",
   "build": 1,
-  "runtimeSdkVersion": "0.15.6",
+  "runtimeSdkVersion": "0.15.11",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/apps/index.d.ts

@@ -4,7 +4,7 @@ import type { AppTask } from '../catalogue';
 import type { TaskCaptureSession } from '../appUrls';
 import { collectAppValidationWarnings, validateAppTask, runFormatScript } from './validate';
 import { buildApp, type AppBuildArtifacts } from './build';
-import { uploadApp, type AppUploadResult } from './upload';
+import { prepareAppUploadFiles, uploadApp, type AppUploadResult } from './upload';
 export type AppPipelineResult = {
     artifacts: AppBuildArtifacts | null;
     upload: AppUploadResult;
@@ -25,10 +25,9 @@ export type AppPipelineOptions = {
     ensureRegisteredAppShell?: boolean;
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
-    mediaCaptureRequired?: boolean;
     playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
     artifacts?: AppBuildArtifacts;
 };
 export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;
-export { collectAppValidationWarnings, validateAppTask, buildApp, uploadApp, runFormatScript };
+export { collectAppValidationWarnings, validateAppTask, buildApp, prepareAppUploadFiles, uploadApp, runFormatScript };

package/dist/apps/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runFormatScript = exports.uploadApp = exports.buildApp = exports.validateAppTask = exports.collectAppValidationWarnings = void 0;
+exports.runFormatScript = exports.uploadApp = exports.prepareAppUploadFiles = exports.buildApp = exports.validateAppTask = exports.collectAppValidationWarnings = void 0;
 exports.runAppPipeline = runAppPipeline;
 const validate_1 = require("./validate");
 Object.defineProperty(exports, "collectAppValidationWarnings", { enumerable: true, get: function () { return validate_1.collectAppValidationWarnings; } });
@@ -9,6 +9,7 @@ Object.defineProperty(exports, "runFormatScript", { enumerable: true, get: funct
 const build_1 = require("./build");
 Object.defineProperty(exports, "buildApp", { enumerable: true, get: function () { return build_1.buildApp; } });
 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");
@@ -66,7 +67,6 @@ async function runAppPipeline(client, task, options) {
         loadCheckTimeoutMs: options?.loadCheckTimeoutMs,
         agentTaskId: options?.agentTaskId,
         playtestProof: options?.playtestProof,
-        mediaCaptureRequired: options?.mediaCaptureRequired,
         playtestSmokeCheckRequired: options?.playtestSmokeCheckRequired,
         captureSession: options?.captureSession,
     };

package/dist/apps/loadCheck.d.ts

@@ -38,7 +38,8 @@ export declare function isSoftwareWebGlRenderer(renderer: string | null | undefi
 export declare function dispatchPlaytestTapeToFrame(page: Page, frame: Frame, surface: AppSurface, tape: AppPlaytestTape, hooks?: {
     onBeforeEvent?: (eventIndex: number, event: AppPlaytestTapeEvent) => void;
 }): Promise<void>;
-export declare function formatHostedLoadCheckFailure(taskName: string, result: HostedLoadCheckResult, scope?: 'local' | 'staged' | 'final'): string;
+export declare function verifyHostedEditorPhaseRoundTrip(page: Pick<Page, 'evaluate'>, frame: Pick<Frame, 'evaluate' | 'waitForFunction'>, timeoutMs: number): Promise<void>;
+export declare function formatHostedLoadCheckFailure(taskName: string, result: HostedLoadCheckResult, scope?: 'local' | 'staged' | 'editor' | 'final'): string;
 export declare function redactHostedLoadCheckSecrets(text: string, sourceUrl: string): string;
 export declare function runLocalHostedLoadCheck(input: {
     client: ApiClient;
@@ -71,6 +72,8 @@ export declare function runUploadedHostedLoadCheck(input: {
     gameFrameScreenshotPath?: string | null;
     playtestTape?: AppPlaytestTape;
     postReadyWaitMs?: number;
+    phase?: 'play' | 'editor';
+    verifyEditorPhaseRoundTrip?: boolean;
 }): Promise<HostedLoadCheckResult>;
 export declare function comparePlaytestFrames(firstPath: string, secondPath: string, thresholds?: {
     meanDeltaMin: number;

package/dist/apps/loadCheck.js

@@ -10,6 +10,7 @@ exports.resolveLoadCheckSurface = resolveLoadCheckSurface;
 exports.cloneLoadCheckContextOptions = cloneLoadCheckContextOptions;
 exports.isSoftwareWebGlRenderer = isSoftwareWebGlRenderer;
 exports.dispatchPlaytestTapeToFrame = dispatchPlaytestTapeToFrame;
+exports.verifyHostedEditorPhaseRoundTrip = verifyHostedEditorPhaseRoundTrip;
 exports.formatHostedLoadCheckFailure = formatHostedLoadCheckFailure;
 exports.redactHostedLoadCheckSecrets = redactHostedLoadCheckSecrets;
 exports.runLocalHostedLoadCheck = runLocalHostedLoadCheck;
@@ -417,6 +418,48 @@ async function findGameFrame(page, timeoutMs) {
     }
     return frame;
 }
+async function verifyHostedEditorPhaseRoundTrip(page, frame, timeoutMs) {
+    const armReadySignal = async () => {
+        await frame.evaluate(() => {
+            const runtimeWindow = window;
+            const state = runtimeWindow.__playdropEditorPhaseCheck ?? {
+                installed: false,
+                signals: [],
+            };
+            state.signals = [];
+            runtimeWindow.__playdropEditorPhaseCheck = state;
+            if (state.installed) {
+                return;
+            }
+            state.installed = true;
+            window.addEventListener('playdrop:loading-state', (event) => {
+                const detail = event.detail;
+                if (detail?.status === 'ready') {
+                    state.signals.push({ editor: detail.editor === true });
+                }
+            });
+        });
+    };
+    const changePhaseAndWait = async (phase, editor) => {
+        await armReadySignal();
+        await page.evaluate((nextPhase) => {
+            window.postMessage({ type: 'playdrop-studio-runtime-state', active: true, phase: nextPhase }, window.location.origin);
+        }, phase);
+        await frame.waitForFunction((expectedEditor) => {
+            const runtimeWindow = window;
+            return runtimeWindow.__playdropEditorPhaseCheck?.signals?.some((signal) => signal.editor === expectedEditor) === true;
+        }, editor, { timeout: timeoutMs });
+    };
+    try {
+        await changePhaseAndWait('play', false);
+        await changePhaseAndWait('editor', true);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error('project_check_editor_phase_switch_failed: The hosted bundle must switch Editor to Playtest and back '
+            + `inside the existing runtime frame. ${detail}`);
+    }
+}
 async function readWebGlRenderer(frame) {
     const renderer = await frame.evaluate(() => {
         const canvas = document.createElement('canvas');
@@ -489,9 +532,11 @@ function normalizeLoadCheckFailure(error, artifactFingerprint) {
 function formatHostedLoadCheckFailure(taskName, result, scope = 'local') {
     const scopeLabel = scope === 'final'
         ? 'final owner play route'
-        : scope === 'staged'
-            ? 'staged upload preview'
-            : 'local hosted preview';
+        : scope === 'editor'
+            ? 'staged Editor phase'
+            : scope === 'staged'
+                ? 'staged upload preview'
+                : 'local hosted preview';
     const errorCode = result.errorCode?.trim() || 'startup_failure';
     const message = normalizeLoadCheckMessage(result.message);
     return `hosted_load_check_failed: ${taskName} failed the ${scopeLabel} check (${errorCode}). ${message}`;
@@ -694,6 +739,9 @@ async function runHostedLoadCheck(options) {
             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) {
@@ -917,6 +965,12 @@ function appendLoadCheckParams(targetUrl, devAuth) {
 }
 async function runUploadedHostedLoadCheck(input) {
     const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
+    const withRequestedPhase = (rawUrl) => {
+        const url = new URL(rawUrl);
+        if (input.phase === 'editor')
+            url.searchParams.set('hostPhase', 'editor');
+        return url.toString();
+    };
     const captureSurface = resolveLoadCheckSurface(preview.localAppMetadata.surfaceTargets, input.task.primarySurface);
     const contextOptions = cloneLoadCheckContextOptions(captureSurface);
     const anonymousExpectedState = resolveAnonymousHostedLaunchState({
@@ -925,7 +979,7 @@ async function runUploadedHostedLoadCheck(input) {
     });
     let result;
     if (input.captureSession) {
-        const targetUrl = new URL(preview.launchUrl);
+        const targetUrl = new URL(withRequestedPhase(preview.launchUrl));
         (0, appUrls_1.appendTaskCaptureSession)(targetUrl, input.captureSession);
         result = await runHostedLoadCheck({
             targetUrl: targetUrl.toString(),
@@ -939,6 +993,7 @@ async function runUploadedHostedLoadCheck(input) {
             playtestTape: input.playtestTape,
             playtestSurface: captureSurface,
             postReadyWaitMs: input.postReadyWaitMs,
+            verifyEditorPhaseRoundTrip: input.verifyEditorPhaseRoundTrip,
         });
     }
     else if (anonymousExpectedState === 'login_required') {
@@ -947,7 +1002,7 @@ async function runUploadedHostedLoadCheck(input) {
         }
         else {
             const anonymousGateResult = await runHostedLoadCheck({
-                targetUrl: appendLoadCheckParams(preview.launchUrl, 'anonymous'),
+                targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'anonymous')),
                 artifactFingerprint: preview.session.manifestHash,
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: anonymousExpectedState,
@@ -958,7 +1013,7 @@ async function runUploadedHostedLoadCheck(input) {
             }
             else {
                 result = await runHostedLoadCheck({
-                    targetUrl: appendLoadCheckParams(preview.launchUrl, 'viewer'),
+                    targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'viewer')),
                     artifactFingerprint: preview.session.manifestHash,
                     timeoutMs: input.timeoutMs,
                     expectedHostedLaunchState: resolvePostAuthHostedLaunchState(preview.localAppMetadata.controllerMode),
@@ -972,13 +1027,14 @@ async function runUploadedHostedLoadCheck(input) {
                     playtestTape: input.playtestTape,
                     playtestSurface: captureSurface,
                     postReadyWaitMs: input.postReadyWaitMs,
+                    verifyEditorPhaseRoundTrip: input.verifyEditorPhaseRoundTrip,
                 });
             }
         }
     }
     else {
         result = await runHostedLoadCheck({
-            targetUrl: appendLoadCheckParams(preview.launchUrl, 'anonymous'),
+            targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'anonymous')),
             artifactFingerprint: preview.session.manifestHash,
             timeoutMs: input.timeoutMs,
             expectedHostedLaunchState: anonymousExpectedState,
@@ -989,6 +1045,7 @@ async function runUploadedHostedLoadCheck(input) {
             playtestTape: input.playtestTape,
             playtestSurface: captureSurface,
             postReadyWaitMs: input.postReadyWaitMs,
+            verifyEditorPhaseRoundTrip: input.verifyEditorPhaseRoundTrip,
         });
     }
     const recorded = await input.client.recordAppUploadLaunchCheck(input.creatorUsername, input.task.name, input.sessionId, {

package/dist/apps/staticHtml.js

@@ -257,6 +257,7 @@ function buildStaticAppTask(input) {
         hostingMode: 'HOSTED',
         authMode: 'NONE',
         previewable: true,
+        editorSupported: false,
         ...(buildListing(input.metadata.imagePath, input.primarySurface)
             ? { listing: buildListing(input.metadata.imagePath, input.primarySurface) }
             : {}),

package/dist/apps/upload.d.ts

@@ -22,8 +22,45 @@ export type AppUploadOptions = {
     loadCheckTimeoutMs?: number;
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
-    mediaCaptureRequired?: boolean;
     playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
 };
+type PreparedSessionFile = {
+    fileKey: string;
+    file: File;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+};
+type PreparedOwnedAssetUpload = {
+    uploadKey: string;
+    runtimeKey?: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    category: string;
+    subcategory: string | null;
+    format: string;
+    visibility?: string;
+    license: string;
+    assetSpec?: string;
+    tags: string[];
+    shopListed?: boolean;
+    shopPriceCredits?: number;
+    files: Array<{
+        role: string;
+        file: File;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        sha256: string;
+    }>;
+};
+type PreparedAppUploadFiles = {
+    sessionFiles: PreparedSessionFile[];
+    ownedAssets: PreparedOwnedAssetUpload[];
+};
+export declare function prepareAppUploadFiles(task: AppTask, artifacts: AppBuildArtifacts | null): Promise<PreparedAppUploadFiles>;
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;
+export {};

package/dist/apps/upload.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAppUploadFiles = prepareAppUploadFiles;
 exports.uploadApp = uploadApp;
 const config_1 = require("@playdrop/config");
 const types_1 = require("@playdrop/types");
@@ -8,7 +9,6 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
 const loadCheck_1 = require("./loadCheck");
-const listingPreflight_1 = require("../listingPreflight");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -149,37 +149,20 @@ function pushPreparedArtifact(task, currentTotal, file, maxBytes, code, label) {
     const bytes = ensurePreparedArtifactSize(file, maxBytes, code, label);
     return accumulateUploadBytes(task.name, currentTotal, bytes);
 }
-async function uploadApp(client, task, artifacts, options) {
-    // Version is required - no legacy fallback
-    if (!task.version) {
-        throw new Error(`Missing "version" field in catalogue.json for app "${task.name}".\n` +
-            `Add a version field like "version": "1.0.0" to upload your app.`);
-    }
-    return uploadAppVersion(client, task, artifacts, options);
-}
-/**
- * Upload an app version using the versioned API.
- */
-async function uploadAppVersion(client, task, artifacts, options) {
-    const creatorUsername = typeof options?.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
-    if (!creatorUsername) {
-        throw new Error(`Missing creator username for app "${task.name}" upload.`);
-    }
+async function prepareAppUploadFiles(task, artifacts) {
     let totalUploadBytes = 0;
-    const achievements = task.achievements ?? [];
-    const leaderboards = task.leaderboards ?? [];
     const listing = task.listing;
-    const preparedSessionFiles = [];
-    const preparedOwnedAssets = await Promise.all(task.ownedAssets.map((ownedAsset) => prepareOwnedAssetUpload(ownedAsset)));
-    for (const ownedAsset of preparedOwnedAssets) {
+    const sessionFiles = [];
+    const ownedAssets = await Promise.all(task.ownedAssets.map((ownedAsset) => prepareOwnedAssetUpload(ownedAsset)));
+    for (const ownedAsset of ownedAssets) {
         for (const file of ownedAsset.files) {
             totalUploadBytes = accumulateUploadBytes(task.name, totalUploadBytes, file.sizeBytes);
         }
     }
-    for (const definition of achievements) {
+    for (const definition of task.achievements ?? []) {
         const prepared = createFileFromPath(definition.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'achievement_icon_too_large', 'invalid_achievement_icon_content_type', `Achievement icon "${definition.key}"`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile(`achievementIcon:${definition.key}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile(`achievementIcon:${definition.key}`, prepared.file));
     }
     if (task.hostingMode === 'EXTERNAL') {
         // no hosted files
@@ -187,48 +170,70 @@ async function uploadAppVersion(client, task, artifacts, options) {
     else if (artifacts) {
         totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, 'bundle_too_large', 'Bundle');
         totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, 'source_too_large', 'Source archive');
-        preparedSessionFiles.push(await buildPreparedSessionFile('bundle', artifacts.bundleFile));
-        preparedSessionFiles.push(await buildPreparedSessionFile('source', artifacts.sourceFile));
+        sessionFiles.push(await buildPreparedSessionFile('bundle', artifacts.bundleFile));
+        sessionFiles.push(await buildPreparedSessionFile('source', artifacts.sourceFile));
     }
     if (listing?.iconPath) {
         const prepared = createFileFromPath(listing.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'icon_too_large', 'invalid_icon_content_type', 'Icon', isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile('icon', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile('icon', prepared.file));
     }
     if (listing?.heroPortraitPath) {
         const prepared = createFileFromPath(listing.heroPortraitPath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_portrait_too_large', 'invalid_hero_portrait_content_type', 'Hero portrait', isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile('heroPortrait', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile('heroPortrait', prepared.file));
     }
     if (listing?.heroLandscapePath) {
         const prepared = createFileFromPath(listing.heroLandscapePath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_landscape_too_large', 'invalid_hero_landscape_content_type', 'Hero landscape', isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile('heroLandscape', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile('heroLandscape', prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.screenshotPortraitPaths[index];
         const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_portrait_too_large', 'invalid_screenshot_portrait_content_type', `Portrait screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile(`screenshotsPortrait:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile(`screenshotsPortrait:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.screenshotLandscapePaths[index];
         const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_landscape_too_large', 'invalid_screenshot_landscape_content_type', `Landscape screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile(`screenshotsLandscape:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile(`screenshotsLandscape:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.videoPortraitPaths[index];
         const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_portrait_too_large', 'invalid_video_portrait_content_type', `Portrait video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile(`videosPortrait:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile(`videosPortrait:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.videoLandscapePaths[index];
         const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_landscape_too_large', 'invalid_video_landscape_content_type', `Landscape video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        preparedSessionFiles.push(await buildPreparedSessionFile(`videosLandscape:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile(`videosLandscape:${index}`, prepared.file));
     }
+    return { sessionFiles, ownedAssets };
+}
+async function uploadApp(client, task, artifacts, options) {
+    // Version is required - no legacy fallback
+    if (!task.version) {
+        throw new Error(`Missing "version" field in catalogue.json for app "${task.name}".\n` +
+            `Add a version field like "version": "1.0.0" to upload your app.`);
+    }
+    return uploadAppVersion(client, task, artifacts, options);
+}
+/**
+ * Upload an app version using the versioned API.
+ */
+async function uploadAppVersion(client, task, artifacts, options) {
+    const creatorUsername = typeof options?.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
+    if (!creatorUsername) {
+        throw new Error(`Missing creator username for app "${task.name}" upload.`);
+    }
+    const achievements = task.achievements ?? [];
+    const leaderboards = task.leaderboards ?? [];
+    const listing = task.listing;
+    const { sessionFiles: preparedSessionFiles, ownedAssets: preparedOwnedAssets, } = await prepareAppUploadFiles(task, artifacts);
     const initializeRequest = {
         version: task.version,
         agentTaskId: options?.agentTaskId,
@@ -259,6 +264,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
         authMode: task.authMode,
         controllerMode: task.controllerMode,
         previewable: task.previewable,
+        editorSupported: task.editorSupported,
         skipReview: options?.skipReview,
         displayName: task.displayName,
         subtitle: task.subtitle,
@@ -346,15 +352,6 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     })),
                 });
             }
-            if (options?.mediaCaptureRequired === true
-                && task.hostingMode !== 'EXTERNAL'
-                && !task.externalUrl) {
-                const mediaCaptureProof = (0, listingPreflight_1.readMediaCaptureProof)({
-                    task,
-                    preparedSessionFiles,
-                });
-                await client.recordAppUploadMediaCapture(creatorUsername, task.name, sessionId, mediaCaptureProof);
-            }
             if (task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl
                 && options?.playtestSmokeCheckRequired) {
@@ -363,7 +360,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     creatorUsername,
                     task,
                     sessionId,
-                    timeoutMs: options.loadCheckTimeoutMs,
+                    timeoutMs: options?.loadCheckTimeoutMs,
                     token: options?.token ?? null,
                     currentUser: options?.user ?? null,
                     captureSession: options?.captureSession,
@@ -377,7 +374,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     creatorUsername,
                     task,
                     sessionId,
-                    timeoutMs: options.loadCheckTimeoutMs,
+                    timeoutMs: options?.loadCheckTimeoutMs,
                     token: options?.token ?? null,
                     currentUser: options?.user ?? null,
                     captureSession: options?.captureSession,
@@ -386,6 +383,23 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, 'staged'));
                 }
             }
+            if (task.editorSupported && task.hostingMode !== 'EXTERNAL' && !task.externalUrl) {
+                const editorLoadCheck = await (0, loadCheck_1.runUploadedHostedLoadCheck)({
+                    client,
+                    creatorUsername,
+                    task,
+                    sessionId,
+                    timeoutMs: options?.loadCheckTimeoutMs,
+                    token: options?.token ?? null,
+                    currentUser: options?.user ?? null,
+                    captureSession: options?.captureSession,
+                    phase: 'editor',
+                    verifyEditorPhaseRoundTrip: true,
+                });
+                if (editorLoadCheck.status !== 'PASSED') {
+                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, editorLoadCheck, 'editor'));
+                }
+            }
         }
         const finalized = initialized.status === 'finalized'
             ? initialized.finalized

package/dist/catalogue.d.ts

@@ -63,6 +63,7 @@ export type AppCatalogueEntry = {
     authMode?: string;
     controllerMode?: string;
     previewable?: boolean;
+    editorSupported?: boolean;
     externalUrl?: string;
     listing?: AppListingConfig;
     username?: string;
@@ -210,6 +211,7 @@ export type AppTask = {
     authMode?: AppAuthMode;
     controllerMode?: AppControllerMode;
     previewable?: boolean;
+    editorSupported?: boolean;
     externalUrl?: string;
     listing?: ResolvedListingAssets;
     username?: string;
@@ -368,6 +370,7 @@ export type ValidatedAppMetadata = {
     surfaceTargetMap: SurfaceTargetsMap;
     primarySurface?: AppSurface;
     playtestTapes?: AppPlaytestTapes;
+    editorSupported?: boolean;
     missingFields: string[];
     warnings: string[];
     errors: string[];

package/dist/catalogue.js

@@ -948,6 +948,18 @@ function validateAppMetadata(entry) {
             warnings.push(`description is ${normalizedDescription.length} characters and ${wordCount} words. Aim for at least ${exports.APP_DESCRIPTION_RECOMMENDED_MIN_CHARACTERS} characters and ${exports.APP_DESCRIPTION_RECOMMENDED_MIN_WORDS} words describing what the player does, the objective, and the game's distinctive hook.`);
         }
     }
+    let editorSupported;
+    if (Object.prototype.hasOwnProperty.call(entry, 'editorSupported')) {
+        if (typeof entry.editorSupported !== 'boolean') {
+            errors.push('editorSupported must be true or false');
+        }
+        else {
+            editorSupported = entry.editorSupported;
+            if (editorSupported && entry.hostingMode === 'EXTERNAL') {
+                errors.push('editorSupported can only be true for HOSTED apps, not external apps');
+            }
+        }
+    }
     let surfaceTargetsList = [];
     let surfaceTargetsMap = { desktop: false, mobileLandscape: false, mobilePortrait: false };
     try {
@@ -992,6 +1004,7 @@ function validateAppMetadata(entry) {
         surfaceTargetMap: surfaceTargetsMap,
         primarySurface,
         playtestTapes,
+        editorSupported,
         missingFields,
         warnings,
         errors,
@@ -1204,6 +1217,14 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 previewable = Boolean(entry.previewable);
             }
+            let editorSupported;
+            if (Object.prototype.hasOwnProperty.call(entry, 'editorSupported')) {
+                if (typeof entry.editorSupported !== 'boolean') {
+                    errors.push(`[${label}] Skipping ${rawName}: editorSupported must be true or false.`);
+                    continue;
+                }
+                editorSupported = Boolean(entry.editorSupported);
+            }
             let externalUrl;
             const rawExternalUrl = typeof entry.externalUrl === 'string' ? entry.externalUrl.trim() : '';
             if (rawExternalUrl) {
@@ -1226,6 +1247,10 @@ function buildAppTasks(rootDir, catalogues, options) {
                 errors.push(`[${label}] Skipping ${rawName}: previewable can only be true for HOSTED apps.`);
                 continue;
             }
+            if ((hostingMode ?? 'HOSTED') === 'EXTERNAL' && editorSupported) {
+                errors.push(`[${label}] Skipping ${rawName}: editorSupported can only be true for HOSTED apps.`);
+                continue;
+            }
             const defaultLicense = (hostingMode ?? 'HOSTED') === 'EXTERNAL' ? 'CLOSED' : types_1.DEFAULT_CONTENT_LICENSE;
             const license = normalizeContentLicenseValue(entry.license, errors, `${label} app "${rawName}"`, APP_ALLOWED_LICENSES, defaultLicense);
             if (!license) {
@@ -1600,6 +1625,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 authMode,
                 controllerMode,
                 previewable,
+                editorSupported,
                 externalUrl,
                 listing,
                 // Admin-only field