@playdrop/playdrop-cli 0.9.5 → 0.10.0

package/dist/commands/upload.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = upload;
+exports.publishWorkerAppProject = publishWorkerAppProject;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const semver_1 = require("semver");
@@ -812,15 +846,6 @@ function appendTaskRelations(graphState, fromNodeId, relations, contextLabel) {
     });
 }
 async function uploadAppTask(state, task, taskCreator, options) {
-    const gameIdeaRef = typeof options?.gameIdea === 'string' ? options.gameIdea.trim() : '';
-    if (gameIdeaRef) {
-        await (0, registration_1.ensureRegisteredHostedAppShell)({
-            client: state.client,
-            creatorUsername: taskCreator,
-            task,
-        });
-        await state.client.startGameIdea(gameIdeaRef, { app: `${taskCreator}/${task.name}` });
-    }
     const { upload, warnings } = await (0, apps_1.runAppPipeline)(state.client, task, {
         skipEcs: options?.skipEcs,
         skipReview: options?.skipReview,
@@ -854,9 +879,6 @@ async function uploadAppTask(state, task, taskCreator, options) {
     };
     state.uploadedAppsByName.set(task.name, uploadedApp);
     (0, upload_graph_1.registerCanonicalNode)(state.graphState, appRef, uploadedApp.versionNodeId);
-    if (gameIdeaRef) {
-        await state.client.shipGameIdea(gameIdeaRef, { app: `${taskCreator}/${task.name}` });
-    }
     (0, upload_graph_1.registerLocalRef)(state.graphState.localAppNodeByName, state.graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
     appendTaskRelations(state.graphState, uploadedApp.versionNodeId, task.graph.relations, `[${task.cataloguePath}] app "${task.name}"`);
     const entry = {
@@ -1179,15 +1201,6 @@ async function upload(pathOrName, options) {
     }
     const warnings = selection.warnings;
     const tasks = selection.tasks;
-    const gameIdeaRef = typeof options?.gameIdea === 'string' ? options.gameIdea.trim() : '';
-    if (gameIdeaRef) {
-        const appTasks = tasks.filter((task) => task.kind === 'app');
-        if (appTasks.length !== 1) {
-            (0, messages_1.printErrorWithHelp)('--game-idea can only be used when publishing exactly one app.', ['Publish a single app name or file, then retry with --game-idea.'], { command: 'project publish' });
-            process.exitCode = 1;
-            return;
-        }
-    }
     if (tagGroupLoad.groups.length > 0 && userInfo.role !== 'ADMIN') {
         (0, messages_1.printErrorWithHelp)('Publishing tagGroups requires an admin account.', [
             'Log in as an admin before publishing taxonomy changes.',
@@ -1208,3 +1221,931 @@ async function upload(pathOrName, options) {
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
     (0, uploadLog_1.printPublishedAppNextSteps)(results);
 }
+const WORKER_SUPERVISOR_SOURCE_EXCLUDES = [
+    'PLAYDROP_TASK.md',
+    '.playdrop/',
+    '.playdrop-task-events/',
+    'bin/playdrop',
+];
+const MIN_HERO_PORTRAIT_WIDTH = 512;
+const MIN_HERO_PORTRAIT_HEIGHT = 768;
+const MIN_HERO_LANDSCAPE_WIDTH = 768;
+const MIN_HERO_LANDSCAPE_HEIGHT = 432;
+const OWNED_RUNTIME_IMAGE_CHECK_SIZE = 96;
+const OWNED_RUNTIME_IMAGE_GRID_CHECK_SIZE = 512;
+function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
+    if (!requirement) {
+        return true;
+    }
+    const hasFirstPartyPack = task.uses.packs.some((ref) => {
+        const parsed = (0, types_1.parseContentVersionRef)(ref);
+        return parsed?.kind === 'pack' && parsed.creatorUsername.toLowerCase() === 'playdrop';
+    });
+    if (requirement === 'PACK') {
+        return hasFirstPartyPack;
+    }
+    const hasFirstPartyAsset = task.uses.assets.some((dependency) => {
+        const parsed = (0, types_1.parseContentVersionRef)(dependency.ref);
+        return parsed?.kind === 'asset' && parsed.creatorUsername.toLowerCase() === 'playdrop';
+    });
+    return hasFirstPartyPack || hasFirstPartyAsset || task.ownedAssets.length > 0;
+}
+function appTaskHasRequiredNewGameAssets(task) {
+    return task.uses.packs.length > 0 || task.uses.assets.length > 0 || task.ownedAssets.length > 0;
+}
+function isUnsafeDirectPlaydropAiImageAsset(detail, parsedRevision) {
+    const asset = detail?.asset;
+    if (!asset || asset.category !== 'IMAGE') {
+        return false;
+    }
+    const currentVersion = asset.currentVersion;
+    if (!currentVersion || Number(currentVersion.revision) !== parsedRevision) {
+        return false;
+    }
+    const sourceKind = typeof currentVersion.sourceKind === 'string' ? currentVersion.sourceKind.toUpperCase() : '';
+    if (sourceKind !== 'AI') {
+        return false;
+    }
+    const format = typeof currentVersion.format === 'string' ? currentVersion.format.toUpperCase() : '';
+    const files = Array.isArray(currentVersion.fileManifest?.files) ? currentVersion.fileManifest.files : [];
+    const primary = files.find((file) => file?.role === 'primary');
+    const primaryContentType = typeof primary?.contentType === 'string' ? primary.contentType.toLowerCase() : '';
+    return format === 'JPEG' || primaryContentType === 'image/jpeg' || primaryContentType === 'image/jpg';
+}
+async function assertNewGameDirectPlaydropAssetsAreRuntimeSafe(input) {
+    const unsafeRefs = [];
+    for (const dependency of input.task.uses.assets) {
+        const parsed = (0, types_1.parseContentVersionRef)(dependency.ref);
+        if (!parsed || parsed.kind !== 'asset' || parsed.creatorUsername.toLowerCase() !== 'playdrop') {
+            continue;
+        }
+        const detail = await input.client.fetchAssetBySlug(parsed.creatorUsername, parsed.name);
+        if (isUnsafeDirectPlaydropAiImageAsset(detail, parsed.revision)) {
+            unsafeRefs.push((0, types_1.formatContentVersionRef)(parsed));
+        }
+    }
+    if (unsafeRefs.length > 0) {
+        throw new Error(`agent_task_playdrop_direct_ai_image_asset_unsafe: direct PlayDrop AI JPEG image assets cannot be used as new-game runtime sprites because their backgrounds are baked into the image. Use a PlayDrop asset pack or create owned PNG assets through the PlayDrop plugin asset-extraction-2d workflow instead. Unsafe refs: ${unsafeRefs.join(', ')}`);
+    }
+}
+function isOwnedRuntimeImageAsset(task, ownedAsset) {
+    if (!ownedAsset.runtimeKey || ownedAsset.category !== 'IMAGE') {
+        return false;
+    }
+    const primaryPath = ownedAsset.filePaths?.primary;
+    if (!primaryPath) {
+        return false;
+    }
+    const relativePath = primaryPath.slice((0, node_path_1.resolve)(task.projectDir).length + 1).replace(/\\/g, '/');
+    return !relativePath.startsWith('assets/marketing/') && !relativePath.startsWith('listing/');
+}
+function isBackgroundLikeOwnedRuntimeImageAsset(ownedAsset) {
+    const value = `${ownedAsset.name ?? ''} ${ownedAsset.runtimeKey ?? ''}`.toLowerCase();
+    return /\b(background|backdrop|scene|sky|floor|ground|wall|terrain|landscape|level|arena)\b/i.test(value);
+}
+function looksLikeBakedCheckerboardPreview(input) {
+    const { data, width, height, channels } = input;
+    if (width < 24 || height < 24 || channels < 4) {
+        return false;
+    }
+    const border = Math.max(8, Math.floor(Math.min(width, height) * 0.16));
+    let sampled = 0;
+    let transparent = 0;
+    let opaqueGray = 0;
+    let lowGray = 0;
+    let highGray = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const inBorder = x < border || y < border || x >= width - border || y >= height - border;
+            if (!inBorder) {
+                continue;
+            }
+            sampled += 1;
+            const offset = (y * width + x) * channels;
+            const red = data[offset] ?? 0;
+            const green = data[offset + 1] ?? 0;
+            const blue = data[offset + 2] ?? 0;
+            const alpha = data[offset + 3] ?? 255;
+            if (alpha < 32) {
+                transparent += 1;
+                continue;
+            }
+            const brightness = (red + green + blue) / 3;
+            const grayish = Math.max(Math.abs(red - green), Math.abs(red - blue), Math.abs(green - blue)) <= 10;
+            if (alpha > 240 && grayish && brightness >= 70 && brightness <= 210) {
+                opaqueGray += 1;
+                if (brightness < 125) {
+                    lowGray += 1;
+                }
+                else if (brightness > 145) {
+                    highGray += 1;
+                }
+            }
+        }
+    }
+    if (sampled === 0 || transparent / sampled > 0.18) {
+        return false;
+    }
+    return opaqueGray / sampled > 0.58
+        && lowGray / sampled > 0.08
+        && highGray / sampled > 0.18;
+}
+function looksLikeBakedSolidMattePreview(input) {
+    const { data, width, height, channels } = input;
+    if (width < 24 || height < 24 || channels < 4) {
+        return false;
+    }
+    const border = Math.max(8, Math.floor(Math.min(width, height) * 0.18));
+    let sampled = 0;
+    let transparent = 0;
+    let matteLike = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const inBorder = x < border || y < border || x >= width - border || y >= height - border;
+            if (!inBorder) {
+                continue;
+            }
+            sampled += 1;
+            const offset = (y * width + x) * channels;
+            const red = data[offset] ?? 0;
+            const green = data[offset + 1] ?? 0;
+            const blue = data[offset + 2] ?? 0;
+            const alpha = data[offset + 3] ?? 255;
+            if (alpha < 32) {
+                transparent += 1;
+                continue;
+            }
+            const dominant = Math.max(red, green, blue);
+            const weakest = Math.min(red, green, blue);
+            const chroma = dominant - weakest;
+            const brightGreenMatte = green >= 220 && green - Math.max(red, blue) >= 65 && Math.max(red, blue) >= 70;
+            const brightRedMatte = red >= 220 && red - Math.max(green, blue) >= 65;
+            const brightBlueMatte = blue >= 220 && blue - Math.max(red, green) >= 65;
+            const brightTwoChannelMatte = dominant >= 220
+                && chroma >= 65
+                && ((red >= 220 && green >= 220) || (red >= 220 && blue >= 220) || (green >= 220 && blue >= 220));
+            if (brightGreenMatte || brightRedMatte || brightBlueMatte || brightTwoChannelMatte) {
+                matteLike += 1;
+            }
+        }
+    }
+    if (sampled === 0 || transparent / sampled > 0.18) {
+        return false;
+    }
+    return matteLike / sampled > 0.58;
+}
+function looksLikeBakedNeutralSolidMattePreview(input) {
+    const { data, width, height, channels } = input;
+    if (width < 24 || height < 24 || channels < 4) {
+        return false;
+    }
+    const border = Math.max(8, Math.floor(Math.min(width, height) * 0.18));
+    let sampled = 0;
+    let transparent = 0;
+    let neutralMatteLike = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const inBorder = x < border || y < border || x >= width - border || y >= height - border;
+            if (!inBorder) {
+                continue;
+            }
+            sampled += 1;
+            const offset = (y * width + x) * channels;
+            const red = data[offset] ?? 0;
+            const green = data[offset + 1] ?? 0;
+            const blue = data[offset + 2] ?? 0;
+            const alpha = data[offset + 3] ?? 255;
+            if (alpha < 32) {
+                transparent += 1;
+                continue;
+            }
+            const brightness = (red + green + blue) / 3;
+            const grayish = Math.max(Math.abs(red - green), Math.abs(red - blue), Math.abs(green - blue)) <= 12;
+            if (alpha > 240 && grayish && (brightness >= 235 || brightness <= 20)) {
+                neutralMatteLike += 1;
+            }
+        }
+    }
+    if (sampled === 0 || transparent / sampled > 0.18) {
+        return false;
+    }
+    return neutralMatteLike / sampled > 0.58;
+}
+function looksLikeResidualMatteGridArtifact(input) {
+    const { data, width, height, channels } = input;
+    if (width < 48 || height < 48 || channels < 4) {
+        return false;
+    }
+    const rowCounts = new Uint32Array(height);
+    const columnCounts = new Uint32Array(width);
+    let matteLike = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const offset = (y * width + x) * channels;
+            const red = data[offset] ?? 0;
+            const green = data[offset + 1] ?? 0;
+            const blue = data[offset + 2] ?? 0;
+            const alpha = data[offset + 3] ?? 255;
+            if (alpha < 24 || alpha > 190) {
+                continue;
+            }
+            const greenMatte = green >= 35 && green - Math.max(red, blue) >= 25 && red <= 110 && blue <= 110;
+            const redMatte = red >= 35 && red - Math.max(green, blue) >= 25 && green <= 120 && blue <= 120;
+            const blueMatte = blue >= 35 && blue - Math.max(red, green) >= 25 && red <= 120 && green <= 120;
+            const purpleMatte = red >= 35 && blue >= 35 && Math.min(red, blue) - green >= 25 && green <= 120;
+            if (!greenMatte && !redMatte && !blueMatte && !purpleMatte) {
+                continue;
+            }
+            matteLike += 1;
+            rowCounts[y] += 1;
+            columnCounts[x] += 1;
+        }
+    }
+    const matteRatio = matteLike / (width * height);
+    if (matteRatio < 0.0015) {
+        return false;
+    }
+    let rowsWithLines = 0;
+    for (const count of rowCounts) {
+        if (count / width >= 0.12) {
+            rowsWithLines += 1;
+        }
+    }
+    let columnsWithLines = 0;
+    for (const count of columnCounts) {
+        if (count / height >= 0.12) {
+            columnsWithLines += 1;
+        }
+    }
+    return rowsWithLines + columnsWithLines >= 3
+        && (rowsWithLines >= 2 || columnsWithLines >= 2);
+}
+function looksLikeResidualTransparentGridLineArtifact(input) {
+    const { data, width, height, channels } = input;
+    if (width < 48 || height < 48 || channels < 4) {
+        return false;
+    }
+    const rowVisibleCounts = new Uint32Array(height);
+    const rowSemiCounts = new Uint32Array(height);
+    const columnVisibleCounts = new Uint32Array(width);
+    const columnSemiCounts = new Uint32Array(width);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const offset = (y * width + x) * channels;
+            const alpha = data[offset + 3] ?? 255;
+            if (alpha <= 0) {
+                continue;
+            }
+            rowVisibleCounts[y] += 1;
+            columnVisibleCounts[x] += 1;
+            if (alpha < 255) {
+                rowSemiCounts[y] += 1;
+                columnSemiCounts[x] += 1;
+            }
+        }
+    }
+    let rowsWithLines = 0;
+    for (let row = 0; row < height; row += 1) {
+        const visibleRatio = rowVisibleCounts[row] / width;
+        const semiRatio = rowSemiCounts[row] / width;
+        if (visibleRatio >= 0.94 && semiRatio >= 0.72) {
+            rowsWithLines += 1;
+        }
+    }
+    let columnsWithLines = 0;
+    for (let column = 0; column < width; column += 1) {
+        const visibleRatio = columnVisibleCounts[column] / height;
+        const semiRatio = columnSemiCounts[column] / height;
+        if (visibleRatio >= 0.94 && semiRatio >= 0.72) {
+            columnsWithLines += 1;
+        }
+    }
+    return rowsWithLines + columnsWithLines >= 3
+        && (rowsWithLines >= 2 || columnsWithLines >= 2);
+}
+async function imageHasBakedPreviewBackground(filePath, options = {}) {
+    let sharp;
+    try {
+        const sharpModule = await Promise.resolve().then(() => __importStar(require('sharp')));
+        sharp = sharpModule.default ?? sharpModule;
+    }
+    catch {
+        return false;
+    }
+    try {
+        const { data, info } = await sharp(filePath, { failOn: 'error' })
+            .rotate()
+            .resize(OWNED_RUNTIME_IMAGE_CHECK_SIZE, OWNED_RUNTIME_IMAGE_CHECK_SIZE, { fit: 'fill' })
+            .ensureAlpha()
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        const hasPreviewBackground = looksLikeBakedCheckerboardPreview({
+            data,
+            width: info.width,
+            height: info.height,
+            channels: info.channels,
+        }) || looksLikeBakedSolidMattePreview({
+            data,
+            width: info.width,
+            height: info.height,
+            channels: info.channels,
+        }) || (!options.allowNeutralSolidMatte && looksLikeBakedNeutralSolidMattePreview({
+            data,
+            width: info.width,
+            height: info.height,
+            channels: info.channels,
+        }));
+        if (hasPreviewBackground) {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    try {
+        const { data, info } = await sharp(filePath, { failOn: 'error' })
+            .rotate()
+            .resize(OWNED_RUNTIME_IMAGE_GRID_CHECK_SIZE, OWNED_RUNTIME_IMAGE_GRID_CHECK_SIZE, { fit: 'inside', withoutEnlargement: true })
+            .ensureAlpha()
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        if (looksLikeResidualMatteGridArtifact({
+            data,
+            width: info.width,
+            height: info.height,
+            channels: info.channels,
+        }) || looksLikeResidualTransparentGridLineArtifact({
+            data,
+            width: info.width,
+            height: info.height,
+            channels: info.channels,
+        })) {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+async function assertNewGameOwnedRuntimeImageAssetsAreClean(task) {
+    const unsafeAssets = [];
+    for (const ownedAsset of task.ownedAssets) {
+        if (!isOwnedRuntimeImageAsset(task, ownedAsset)) {
+            continue;
+        }
+        const primaryPath = ownedAsset.filePaths?.primary;
+        if (!primaryPath) {
+            continue;
+        }
+        if (await imageHasBakedPreviewBackground(primaryPath, {
+            allowNeutralSolidMatte: isBackgroundLikeOwnedRuntimeImageAsset(ownedAsset),
+        })) {
+            unsafeAssets.push(`${ownedAsset.name}:${ownedAsset.runtimeKey}`);
+        }
+    }
+    if (unsafeAssets.length > 0) {
+        throw new Error(`agent_task_owned_image_asset_checkerboard_background: owned runtime image assets must not contain baked transparency checkerboard, matte-color, or preview backgrounds. Recreate the asset through the PlayDrop plugin asset-extraction-2d workflow, use a cleaner PlayDrop asset, or use the image as non-runtime listing art only. Unsafe owned assets: ${unsafeAssets.join(', ')}`);
+    }
+}
+const RUNTIME_SOURCE_EXTENSIONS = new Set([
+    '.html',
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.ts',
+    '.tsx',
+    '.jsx',
+    '.css',
+]);
+const RUNTIME_SOURCE_EXCLUDED_DIRS = new Set([
+    '.git',
+    '.playdrop',
+    'node_modules',
+    'dist',
+    'build',
+    '.playdrop-task-events',
+    'listing',
+    'assets/marketing',
+]);
+function has3dIntent(value) {
+    return /\b3d\b|\bthree[-\s]?d\b|\bthree\.js\b|\bglb\b|\bgltf\b/i.test(value ?? '');
+}
+function blankPreservingNewlines(value) {
+    return value.replace(/[^\n\r]/g, ' ');
+}
+function stripRuntimeSourceCommentsAndStrings(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, blankPreservingNewlines)
+        .replace(/`(?:\\[\s\S]|[^`\\])*`/g, blankPreservingNewlines)
+        .replace(/'(?:\\.|[^'\\])*'/g, blankPreservingNewlines)
+        .replace(/"(?:\\.|[^"\\])*"/g, blankPreservingNewlines)
+        .replace(/\/\/[^\n\r]*/g, blankPreservingNewlines);
+}
+function hasDisallowed3dPlaydropAssetFallback(source) {
+    const executableSource = stripRuntimeSourceCommentsAndStrings(source);
+    return /\bemergency\s+mesh\b|\bemergency[A-Z][A-Za-z]*Mesh\b|\bbuildEmergencyMesh\b|\bfallback(?:Mesh|Model|Geometry|Material|Mats?|Size|Character|Obstacle|Enemy|Collectible)?\b|\bfallback\s+(?:mesh|model|geometry|material|character|obstacle|enemy|collectible)\b|\bplaceholder(?:Mesh|Model|Geometry|Material|Character|Obstacle|Enemy|Collectible)?\b|\bplaceholder\s+(?:mesh|model|geometry|material|character|obstacle|enemy|collectible)\b|catch\s*\([^)]*\)\s*=>\s*[^;\n]*(?:new\s+THREE\.(?:Box|Sphere|Capsule|Cone|Cylinder)Geometry|fallback|placeholder|emergency)|if\s*\([^)]*!url[^)]*\)\s*return\s+(?:new\s+THREE\.(?:Box|Sphere|Capsule|Cone|Cylinder)Geometry|fallback|placeholder|emergency)/i.test(executableSource);
+}
+function findDisallowedVisible3dPrimitiveGeometry(runtimeSource) {
+    const executableSource = stripRuntimeSourceCommentsAndStrings(runtimeSource.source);
+    const primitivePattern = /new\s+THREE\.(?:Box|Sphere|Capsule|Cone|Cylinder|Torus|TorusKnot|Dodecahedron|Icosahedron|Octahedron|Tetrahedron|Ring)Geometry\s*\(/ig;
+    let match;
+    while ((match = primitivePattern.exec(executableSource)) !== null) {
+        const before = executableSource.slice(Math.max(0, match.index - 220), match.index);
+        const after = executableSource.slice(match.index, Math.min(executableSource.length, match.index + 420));
+        const meshStart = before.lastIndexOf('new THREE.Mesh');
+        const meshWindow = `${meshStart >= 0 ? before.slice(meshStart) : before}${after}`;
+        if (/\bvisible\s*:\s*false\b/i.test(meshWindow)) {
+            continue;
+        }
+        const location = resolveRuntimeSourceLocation(runtimeSource, match.index);
+        const constructorName = match[0]
+            .replace(/^new\s+THREE\./i, 'THREE.')
+            .replace(/\s*\($/, '');
+        if (location) {
+            return `${constructorName} at ${location.path}:${location.line}:${location.column}`;
+        }
+        return constructorName;
+    }
+    return null;
+}
+function hasDisallowedGameplayAssetFallback(source) {
+    const executableSource = stripRuntimeSourceCommentsAndStrings(source);
+    return /\bdrawFallback[A-Za-z0-9_]*\b|\bfallback(?:Image|Sprite|Asset|Draw|Visual|Character|Obstacle|Collectible|Prop|Enemy|Item|Piñata|Pinata|Candy)?\b|\bplaceholder(?:Image|Sprite|Asset|Draw|Visual|Character|Obstacle|Collectible|Prop|Enemy|Item)?\b|img\.onerror\s*=\s*(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>\s*(?:\{[^}]*\bresolve\s*\(|\bresolve\s*\(|\{[^}]*\breturn\b)|if\s*\([^)]*!url[^)]*\)\s*\{[^}]*\bresolve\s*\([^}]*\breturn\b|if\s*\([^)]*!url[^)]*\)\s*(?:return|continue|resolve\s*\()/i.test(executableSource);
+}
+function hasRuntimeAssetUrlExtensionAssumption(source) {
+    return /(?:\.url|\.href|\burl\b)[^;\n]{0,220}(?:\\\.gl(?:b|tf)|\.gl(?:b|tf)|\.endsWith\s*\(\s*['"]\.gl(?:b|tf)['"]\s*\)|\.includes\s*\(\s*['"]\.gl(?:b|tf)['"]\s*\)|\.match\s*\([^)]*\.gl(?:b|tf))/i.test(source);
+}
+function hasPackRuntimeManifestShape(source) {
+    return /\bassetRef\b/.test(source) && /\bcontentType\b/.test(source);
+}
+function manifestHasGltfFile(fileManifest) {
+    const files = fileManifest && typeof fileManifest === 'object' && Array.isArray(fileManifest.files)
+        ? fileManifest.files
+        : [];
+    return files.some((file) => {
+        const contentType = typeof file?.contentType === 'string' ? file.contentType.toLowerCase() : '';
+        return contentType === 'model/gltf-binary' || contentType === 'model/gltf+json';
+    });
+}
+function assetVersionHasGltfFile(version) {
+    if (version.format === 'GLB' || version.format === 'GLTF') {
+        return true;
+    }
+    const primaryContentType = typeof version.primaryContentType === 'string'
+        ? version.primaryContentType.toLowerCase()
+        : '';
+    return primaryContentType === 'model/gltf-binary'
+        || primaryContentType === 'model/gltf+json'
+        || manifestHasGltfFile(version.fileManifest);
+}
+async function findRemoteAssetVersionForRef(client, ref) {
+    let offset = 0;
+    for (let page = 0; page < 200; page += 1) {
+        const response = await client.listAssetVersions(ref.creatorUsername, ref.name, {
+            limit: 100,
+            offset,
+        });
+        const version = (response.versions ?? []).find((entry) => entry.revision === ref.revision);
+        if (version) {
+            return version;
+        }
+        if (!response.pagination?.hasMore) {
+            break;
+        }
+        offset += response.pagination.limit;
+    }
+    return null;
+}
+async function assertDeclared3dPlaydropPacksContainRuntimeModels(input) {
+    if (!has3dIntent(input.creatorRequest) || input.task.uses.packs.length === 0) {
+        return;
+    }
+    const inspectedRefs = [];
+    for (const rawRef of input.task.uses.packs) {
+        const parsed = (0, types_1.parseContentVersionRef)(rawRef);
+        if (!parsed || parsed.kind !== 'pack') {
+            throw new Error(`agent_task_playdrop_3d_pack_ref_invalid: invalid pack ref "${rawRef}".`);
+        }
+        inspectedRefs.push(rawRef);
+        let offset = 0;
+        let packVersion = null;
+        for (let page = 0; page < 200; page += 1) {
+            const response = await input.client.listAssetPackVersions(parsed.creatorUsername, parsed.name, {
+                limit: 100,
+                offset,
+            });
+            packVersion = (response.versions ?? []).find((entry) => entry.version === parsed.version) ?? null;
+            if (packVersion || !response.pagination?.hasMore) {
+                break;
+            }
+            offset += response.pagination.limit;
+        }
+        if (!packVersion) {
+            throw new Error(`agent_task_playdrop_3d_pack_models_missing: could not inspect exact pack version "${rawRef}".`);
+        }
+        const modelCount = Number(packVersion.assetCategoryBreakdown?.MODEL_3D ?? 0);
+        if (!Number.isFinite(modelCount) || modelCount <= 0) {
+            continue;
+        }
+        for (const assetRef of packVersion.assets ?? []) {
+            const version = await findRemoteAssetVersionForRef(input.client, assetRef);
+            if (version && assetVersionHasGltfFile(version)) {
+                return;
+            }
+        }
+    }
+    throw new Error(`agent_task_playdrop_3d_pack_models_missing: declared 3D PlayDrop pack refs do not expose model/gltf-binary or model/gltf+json files. Inspected: ${inspectedRefs.join(', ')}.`);
+}
+function collectLineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === '\n') {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function resolveRuntimeSourceLocation(runtimeSource, offset) {
+    let entry = null;
+    for (const candidate of runtimeSource.offsetEntries) {
+        if (candidate.start <= offset) {
+            entry = candidate;
+            continue;
+        }
+        break;
+    }
+    if (!entry) {
+        return null;
+    }
+    const localOffset = Math.max(0, offset - entry.start);
+    let lineIndex = 0;
+    for (let index = 0; index < entry.lineStarts.length; index += 1) {
+        if (entry.lineStarts[index] <= localOffset) {
+            lineIndex = index;
+            continue;
+        }
+        break;
+    }
+    const lineStart = entry.lineStarts[lineIndex] ?? 0;
+    return {
+        path: entry.path,
+        line: lineIndex + 1,
+        column: localOffset - lineStart + 1,
+    };
+}
+function readRuntimeSourceText(rootDir) {
+    const root = (0, node_path_1.resolve)(rootDir);
+    const chunks = [];
+    const offsetEntries = [];
+    let totalBytes = 0;
+    const maxBytes = 1000000;
+    const walk = (dir) => {
+        if (totalBytes >= maxBytes) {
+            return;
+        }
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            const absolute = (0, node_path_1.join)(dir, entry.name);
+            const relative = absolute.slice(root.length + 1).replace(/\\/g, '/');
+            if (entry.isDirectory()) {
+                if (RUNTIME_SOURCE_EXCLUDED_DIRS.has(entry.name) || RUNTIME_SOURCE_EXCLUDED_DIRS.has(relative)) {
+                    continue;
+                }
+                walk(absolute);
+                continue;
+            }
+            if (!entry.isFile() || !RUNTIME_SOURCE_EXTENSIONS.has((0, node_path_1.extname)(entry.name).toLowerCase())) {
+                continue;
+            }
+            const stats = (0, node_fs_1.statSync)(absolute);
+            if (stats.size > 300000) {
+                continue;
+            }
+            totalBytes += stats.size;
+            const source = (0, node_fs_1.readFileSync)(absolute, 'utf8');
+            const prefix = chunks.length > 0 ? '\n' : '';
+            const start = chunks.join('').length + prefix.length;
+            chunks.push(prefix, source);
+            offsetEntries.push({
+                path: relative,
+                start,
+                lineStarts: collectLineStarts(source),
+            });
+            if (totalBytes >= maxBytes) {
+                return;
+            }
+        }
+    };
+    walk(root);
+    return {
+        source: chunks.join(''),
+        offsetEntries,
+    };
+}
+function assertRequestedPlaydropAssetsAreUsedAtRuntime(input) {
+    if (!input.requirement) {
+        return;
+    }
+    const runtimeSource = readRuntimeSourceText(input.task.projectDir);
+    const source = runtimeSource.source;
+    if (!/\bsdk\.assets\b|\.resolveAppAsset\s*\(|\.listAppAssets\s*\(/.test(source)) {
+        throw new Error('agent_task_playdrop_asset_runtime_missing: the creator asked for PlayDrop assets, but the app source does not load runtime assets through sdk.assets.');
+    }
+    if (input.requirement === 'PACK' && !/\.listAppAssets\s*\(/.test(source)) {
+        throw new Error('agent_task_playdrop_pack_runtime_missing: the creator asked for a PlayDrop asset pack, but the app source does not enumerate pack assets with sdk.assets.listAppAssets().');
+    }
+    if (has3dIntent(input.creatorRequest) && input.task.uses.packs.length > 0 && !/\bGLTFLoader\b|\.gltf\b|\.glb\b|model\/gltf/i.test(source)) {
+        throw new Error('agent_task_playdrop_3d_asset_runtime_missing: the creator asked for a 3D PlayDrop asset pack, but the app source does not load GLB/GLTF models at runtime.');
+    }
+    if (has3dIntent(input.creatorRequest) && (input.task.uses.packs.length > 0 || input.task.uses.assets.length > 0) && hasRuntimeAssetUrlExtensionAssumption(source)) {
+        throw new Error('agent_task_playdrop_3d_url_extension_assumption: PlayDrop runtime asset URLs do not need to end in .glb or .gltf; choose GLB/GLTF files using file.contentType from the SDK asset manifest.');
+    }
+    if (has3dIntent(input.creatorRequest) && input.task.uses.packs.length > 0 && !hasPackRuntimeManifestShape(source)) {
+        throw new Error('agent_task_playdrop_pack_manifest_shape_invalid: 3D PlayDrop pack runtime code must select pack files through asset.assetRef and file.contentType from sdk.assets.listAppAssets().');
+    }
+    if (has3dIntent(input.creatorRequest) && input.task.uses.packs.length > 0 && hasDisallowed3dPlaydropAssetFallback(source)) {
+        throw new Error('agent_task_playdrop_3d_asset_fallback_disallowed: the creator asked for a 3D PlayDrop asset pack, but the app source includes emergency or placeholder mesh fallbacks instead of failing when pack models are unavailable.');
+    }
+    if (has3dIntent(input.creatorRequest) && input.task.uses.packs.length > 0) {
+        const primitiveGeometry = findDisallowedVisible3dPrimitiveGeometry(runtimeSource);
+        if (primitiveGeometry) {
+            throw new Error(`agent_task_playdrop_3d_primitive_geometry_disallowed: the creator asked for a 3D PlayDrop asset pack, but the app source includes visible Three.js primitive geometry instead of real pack models for gameplay visuals. First match: ${primitiveGeometry}.`);
+        }
+    }
+}
+function assertNewGameDeclaredAssetsAreUsedAtRuntime(task) {
+    const source = readRuntimeSourceText(task.projectDir).source;
+    if (!/\bsdk\.assets\b|\.resolveAppAsset\s*\(|\.listAppAssets\s*\(/.test(source)) {
+        throw new Error('agent_task_game_assets_runtime_missing: new game tasks must load declared gameplay assets through sdk.assets at runtime.');
+    }
+    if (task.uses.packs.length > 0 && !/\.listAppAssets\s*\(/.test(source)) {
+        throw new Error('agent_task_game_pack_runtime_missing: new game tasks that declare uses.packs must enumerate pack assets with sdk.assets.listAppAssets().');
+    }
+    const hasDirectGameplayAssets = task.ownedAssets.length > 0 || task.uses.assets.length > 0;
+    if (hasDirectGameplayAssets && hasDisallowedGameplayAssetFallback(source)) {
+        throw new Error('agent_task_game_asset_fallback_disallowed: new game tasks must fail clearly when declared gameplay assets cannot load instead of rendering placeholder or fallback visuals.');
+    }
+}
+function readPngDimensions(filePath) {
+    const buffer = (0, node_fs_1.readFileSync)(filePath);
+    if (buffer.length < 24) {
+        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} is too small to be a valid PNG.`);
+    }
+    const isPng = (buffer[0] === 0x89
+        && buffer[1] === 0x50
+        && buffer[2] === 0x4e
+        && buffer[3] === 0x47
+        && buffer[4] === 0x0d
+        && buffer[5] === 0x0a
+        && buffer[6] === 0x1a
+        && buffer[7] === 0x0a);
+    if (!isPng || buffer.toString('ascii', 12, 16) !== 'IHDR') {
+        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} must be a PNG with an IHDR header.`);
+    }
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} has invalid PNG dimensions.`);
+    }
+    return { width, height };
+}
+function readPngTextMetadata(filePath) {
+    const buffer = (0, node_fs_1.readFileSync)(filePath);
+    const metadata = {};
+    if (buffer.length < 24) {
+        return metadata;
+    }
+    let offset = 8;
+    while (offset + 12 <= buffer.length) {
+        const length = buffer.readUInt32BE(offset);
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + length;
+        const chunkEnd = dataEnd + 4;
+        if (chunkEnd > buffer.length) {
+            break;
+        }
+        const type = buffer.toString('ascii', offset + 4, offset + 8);
+        if (type === 'tEXt') {
+            const chunkData = buffer.subarray(dataStart, dataEnd);
+            const separatorOffset = chunkData.indexOf(0);
+            if (separatorOffset > 0) {
+                const keyword = chunkData.toString('latin1', 0, separatorOffset).trim();
+                const value = chunkData.toString('latin1', separatorOffset + 1).trim();
+                if (keyword && value) {
+                    metadata[keyword] = value;
+                }
+            }
+        }
+        offset = chunkEnd;
+        if (type === 'IEND') {
+            break;
+        }
+    }
+    return metadata;
+}
+function normalizeHeroPromptText(value) {
+    return value.normalize('NFKC').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+function heroPromptContainsRequiredTitleInstruction(prompt, displayName) {
+    const normalizedPrompt = normalizeHeroPromptText(prompt);
+    const normalizedDisplayName = normalizeHeroPromptText(displayName);
+    if (!normalizedDisplayName || !normalizedPrompt.includes(normalizedDisplayName)) {
+        return false;
+    }
+    const hasTitleLanguage = /\btitle\b|\blogo\b|\bwordmark\b/.test(normalizedPrompt);
+    const hasProminenceLanguage = /\bfront[-\s]?and[-\s]?center\b|\bfront center\b|\bcenter(?:ed)?\b|\bprominent\b|\blarge readable\b/.test(normalizedPrompt);
+    return hasTitleLanguage && hasProminenceLanguage && heroPromptForbidsExtraReadableText(prompt);
+}
+function heroPromptForbidsExtraReadableText(prompt) {
+    const normalizedPrompt = normalizeHeroPromptText(prompt);
+    return /\bno\b[^.]{0,180}\b(?:extra|other|additional)\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|banners|signs|captions|labels|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
+        || /\bno\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
+        || /\bno\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|banners|signs|captions|labels|dates|taglines|subtitles)\b[^.]{0,180}\banywhere\b/i.test(normalizedPrompt)
+        || /\bforbid\b[^.]{0,180}\b(?:all\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
+        || /\b(?:text|word|letter|typography|writing)[-\s]?free\b/i.test(normalizedPrompt)
+        || /\bwithout\b[^.]{0,180}\b(?:any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
+        || /\b(?:do\s+not|don't|dont|never)\b[^.]{0,180}\b(?:include|add|render|show|place|draw|write)\b[^.]{0,180}\b(?:any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
+        || /\b(?:avoid|exclude|omit|remove)\b[^.]{0,180}\b(?:all\s+|any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt);
+}
+function assertNewGameHeroListingPromptMetadata(input) {
+    const metadata = readPngTextMetadata(input.filePath);
+    const tool = metadata['playdrop:cliOutputTool'] ?? '';
+    const prompt = metadata['playdrop:cliOutputPrompt'] ?? '';
+    const titleTool = metadata['playdrop:listingTitleTool'] ?? '';
+    if (titleTool === 'playdrop compose-listing-title') {
+        throw new Error(`agent_task_listing_hero_art_composed_title_disallowed: ${input.field} must be generated directly by PlayDrop AI with the exact display name "${input.displayName}" integrated front and center, not added afterward by a title overlay script.`);
+    }
+    if (tool !== 'playdrop ai create image --output' || !prompt) {
+        throw new Error(`agent_task_listing_hero_art_metadata_missing: ${input.field} must be produced by "playdrop ai create image --output" or by the staged listing title composition script so PlayDrop can verify listing-art metadata.`);
+    }
+    if (!heroPromptContainsRequiredTitleInstruction(prompt, input.displayName)) {
+        throw new Error(`agent_task_listing_hero_art_title_prompt_missing: ${input.field} must be generated from a prompt containing the exact display name "${input.displayName}" as prominent front-and-center title/logo text and forbidding all extra readable text.`);
+    }
+}
+function readAgentTaskCatalogueApp(task) {
+    let data;
+    try {
+        data = JSON.parse((0, node_fs_1.readFileSync)(task.catalogueAbsolutePath, 'utf8'));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`agent_task_catalogue_invalid_json: ${task.cataloguePath} must be valid JSON. ${reason}`);
+    }
+    const apps = Array.isArray(data?.apps) ? data.apps : [];
+    const app = apps.find((entry) => entry && typeof entry === 'object' && entry.name === task.name);
+    if (!app || typeof app !== 'object') {
+        throw new Error(`agent_task_catalogue_app_missing: ${task.cataloguePath} must contain apps[] entry "${task.name}".`);
+    }
+    return app;
+}
+function assertNewGameHeroListingKeys(task) {
+    const app = readAgentTaskCatalogueApp(task);
+    const listing = app.listing;
+    if (!listing || typeof listing !== 'object' || Array.isArray(listing)) {
+        return;
+    }
+    const hasLegacyPortrait = typeof listing.heroPortraitPath === 'string' && listing.heroPortraitPath.trim().length > 0;
+    const hasLegacyLandscape = typeof listing.heroLandscapePath === 'string' && listing.heroLandscapePath.trim().length > 0;
+    if (hasLegacyPortrait || hasLegacyLandscape) {
+        throw new Error('agent_task_listing_hero_art_legacy_keys: new game tasks must reference hero art through listing.heroPortrait and listing.heroLandscape, not listing.heroPortraitPath or listing.heroLandscapePath.');
+    }
+}
+function assertNewGameHeroListingPath(task, filePath, field) {
+    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), (0, node_path_1.resolve)(filePath)).replace(/\\/g, '/');
+    if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
+        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG inside the project under assets/marketing/playdrop/.`);
+    }
+    if (!relativePath.startsWith('assets/marketing/playdrop/') || (0, node_path_1.extname)(relativePath).toLowerCase() !== '.png') {
+        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG under assets/marketing/playdrop/.`);
+    }
+}
+function assertNewGameHeroListingArt(task) {
+    const app = readAgentTaskCatalogueApp(task);
+    const displayName = typeof app.displayName === 'string' && app.displayName.trim()
+        ? app.displayName.trim()
+        : task.name;
+    const heroPortraitPath = task.listing?.heroPortraitPath;
+    const heroLandscapePath = task.listing?.heroLandscapePath;
+    if (!heroPortraitPath || !heroLandscapePath) {
+        throw new Error('agent_task_listing_hero_art_missing: new game tasks must include listing.heroPortrait and listing.heroLandscape PNG assets.');
+    }
+    assertNewGameHeroListingKeys(task);
+    assertNewGameHeroListingPath(task, heroPortraitPath, 'listing.heroPortrait');
+    assertNewGameHeroListingPath(task, heroLandscapePath, 'listing.heroLandscape');
+    const portrait = readPngDimensions(heroPortraitPath);
+    if (portrait.width < MIN_HERO_PORTRAIT_WIDTH || portrait.height < MIN_HERO_PORTRAIT_HEIGHT || portrait.height <= portrait.width) {
+        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroPortrait must be a portrait PNG at least ${MIN_HERO_PORTRAIT_WIDTH}x${MIN_HERO_PORTRAIT_HEIGHT}.`);
+    }
+    const landscape = readPngDimensions(heroLandscapePath);
+    if (landscape.width < MIN_HERO_LANDSCAPE_WIDTH || landscape.height < MIN_HERO_LANDSCAPE_HEIGHT || landscape.width <= landscape.height) {
+        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroLandscape must be a landscape PNG at least ${MIN_HERO_LANDSCAPE_WIDTH}x${MIN_HERO_LANDSCAPE_HEIGHT}.`);
+    }
+    assertNewGameHeroListingPromptMetadata({
+        projectDir: task.projectDir,
+        filePath: heroPortraitPath,
+        field: 'listing.heroPortrait',
+        displayName,
+    });
+    assertNewGameHeroListingPromptMetadata({
+        projectDir: task.projectDir,
+        filePath: heroLandscapePath,
+        field: 'listing.heroLandscape',
+        displayName,
+    });
+}
+// Task upload path used by "playdrop task upload": same internal pipeline as
+// "playdrop project publish", but always as one PRIVATE draft version for the
+// task's creator, with browser launch checks on before the version is created.
+async function publishWorkerAppProject(input) {
+    const creatorUsername = input.creatorUsername.trim();
+    if (!creatorUsername) {
+        throw new Error('agent_task_creator_username_missing');
+    }
+    if (input.user.username !== creatorUsername && input.user.role !== 'ADMIN') {
+        throw new Error(`worker_publish_on_behalf_requires_admin: the worker session user "${input.user.username}" cannot publish for "${creatorUsername}".`);
+    }
+    const selection = (0, taskSelection_1.selectTasks)(input.projectDir);
+    if (selection.errors.length > 0) {
+        throw new Error(`agent_task_project_invalid: ${selection.errors.map((error) => error.message).join('; ')}`);
+    }
+    const appTask = selection.tasks.find((task) => task.kind === 'app');
+    if (!appTask || selection.tasks.length !== 1) {
+        const found = selection.tasks.map((task) => `${task.kind}:${task.name}`).join(', ') || 'none';
+        throw new Error(`agent_task_project_requires_single_app: expected exactly one app task in ${input.projectDir}, found ${found}.`);
+    }
+    const expectedAppName = input.expectedAppName?.trim() ?? '';
+    if (expectedAppName && appTask.name !== expectedAppName) {
+        throw new Error(`agent_task_output_app_name_mismatch: expected catalogue app "${expectedAppName}", found "${appTask.name}".`);
+    }
+    const task = {
+        ...appTask,
+        versionVisibility: 'PRIVATE',
+        sourceArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_SOURCE_EXCLUDES,
+        bundleArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_SOURCE_EXCLUDES,
+    };
+    if (input.kind === 'NEW_GAME') {
+        assertNewGameHeroListingArt(task);
+        if (!appTaskHasRequiredNewGameAssets(task)) {
+            throw new Error('agent_task_game_assets_missing: new game tasks must declare at least one real owned asset, PlayDrop asset, or PlayDrop asset pack in catalogue.json.');
+        }
+    }
+    if (!appTaskSatisfiesPlaydropAssetRequirement(task, input.playdropAssetRequirement)) {
+        throw new Error('agent_task_playdrop_asset_dependency_missing: the creator asked for PlayDrop assets, but catalogue.json does not declare a matching uses.assets, uses.packs, or ownedAssets dependency.');
+    }
+    if (input.kind === 'NEW_GAME') {
+        await assertNewGameDirectPlaydropAssetsAreRuntimeSafe({
+            client: input.client,
+            task,
+        });
+        await assertNewGameOwnedRuntimeImageAssetsAreClean(task);
+        assertNewGameDeclaredAssetsAreUsedAtRuntime(task);
+    }
+    assertRequestedPlaydropAssetsAreUsedAtRuntime({
+        task,
+        requirement: input.playdropAssetRequirement,
+        creatorRequest: input.creatorRequest,
+    });
+    await assertDeclared3dPlaydropPacksContainRuntimeModels({
+        client: input.client,
+        task,
+        creatorRequest: input.creatorRequest,
+    });
+    const { app } = await (0, registration_1.ensureRegisteredHostedAppShell)({
+        client: input.client,
+        creatorUsername,
+        task,
+        agentTaskId: input.taskId,
+    });
+    if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
+        throw new Error(`App "${task.name}" registration did not return an app id.`);
+    }
+    const { upload: uploadResult, warnings } = await (0, apps_1.runAppPipeline)(input.client, task, {
+        creatorUsername,
+        apiBase: input.apiBase,
+        webBase: normalizePortalBase(input.webBase ?? undefined),
+        token: input.token,
+        user: input.user,
+        runLocalLaunchCheck: true,
+        runStagedUploadLaunchCheck: true,
+        ensureRegisteredAppShell: true,
+        agentTaskId: input.taskId,
+    });
+    if (!uploadResult.versionCreated || !uploadResult.version) {
+        throw new Error(`App "${task.name}" upload did not return a created version.`);
+    }
+    if (typeof uploadResult.versionId !== 'number') {
+        throw new Error(`App "${task.name}" upload did not return version ID.`);
+    }
+    if (typeof uploadResult.versionNodeId !== 'string' || uploadResult.versionNodeId.trim().length === 0) {
+        throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
+    }
+    return {
+        appId: app.id,
+        appVersionId: uploadResult.versionId,
+        versionNodeId: uploadResult.versionNodeId,
+        version: uploadResult.version,
+        appName: task.name,
+        creatorUsername,
+        warnings: [...selection.warnings, ...warnings],
+    };
+}