@playdrop/playdrop-cli 0.14.0 → 0.14.2

package/dist/commands/upload.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveUploadOwner = resolveUploadOwner;
 exports.resolveDefaultUploadCreator = resolveDefaultUploadCreator;
 exports.upload = upload;
-exports.resolveWorkerPlaydropAssetRequirement = resolveWorkerPlaydropAssetRequirement;
+exports.assertAgentPrimarySurfaceContract = assertAgentPrimarySurfaceContract;
 exports.assertAgentNewGamePlaytestContract = assertAgentNewGamePlaytestContract;
 exports.assertWorkerAppLocalUploadPreflight = assertWorkerAppLocalUploadPreflight;
 exports.preflightWorkerAppProject = preflightWorkerAppProject;
@@ -27,7 +27,6 @@ const uploadLog_1 = require("../uploadLog");
 const workerAppProject_1 = require("../workerAppProject");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
-const devRuntimeAssets_1 = require("./devRuntimeAssets");
 const ownedRuntimeImageValidation_1 = require("./ownedRuntimeImageValidation");
 const listingPreflight_1 = require("../listingPreflight");
 const upload_graph_1 = require("./upload-graph");
@@ -1247,26 +1246,16 @@ async function upload(pathOrName, options) {
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
     (0, uploadLog_1.printPublishedAppNextSteps)(results);
 }
-function resolveWorkerPlaydropAssetRequirement(value) {
-    const text = typeof value === 'string' ? value.toLowerCase() : '';
-    if (!text.trim() || !/\bplay\s*drop\b|\bplaydrop\b/.test(text)) {
-        return null;
-    }
-    if (/\basset\s*pack(s)?\b|\bpack(s)?\b/.test(text)) {
-        return 'PACK';
-    }
-    if (/\basset(s)?\b|\bsprite(s)?\b|\bmodel(s)?\b|\bart\b|\bcharacter(s)?\b|\bprop(s)?\b/.test(text)) {
-        return 'ASSET_OR_PACK';
-    }
-    return null;
-}
-function assertAgentNewGamePlaytestContract(task) {
+function assertAgentPrimarySurfaceContract(task, kind) {
     if (!task.primarySurface) {
-        throw new Error('agent_task_primary_surface_required: NEW_GAME catalogue.json must declare primarySurface.');
+        throw new Error(`agent_task_primary_surface_required: ${kind} catalogue.json must declare primarySurface.`);
     }
     if (!task.surfaceTargets.includes(task.primarySurface)) {
         throw new Error(`agent_task_primary_surface_not_supported:${task.primarySurface}`);
     }
+}
+function assertAgentNewGamePlaytestContract(task) {
+    assertAgentPrimarySurfaceContract(task, 'NEW_GAME');
     if (!task.playtestTapes) {
         throw new Error('agent_task_playtest_tapes_required: NEW_GAME catalogue.json must declare one playtest tape per supported surface.');
     }
@@ -1277,424 +1266,6 @@ function assertAgentNewGamePlaytestContract(task) {
         }
     }
 }
-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;
-}
-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 formatRuntimeSourceLocation(runtimeSource, offset) {
-    const location = resolveRuntimeSourceLocation(runtimeSource, offset);
-    if (!location) {
-        return 'unknown source location';
-    }
-    return `${location.path}:${location.line}:${location.column}`;
-}
-function findRuntimeSourcePattern(runtimeSource, pattern) {
-    const match = pattern.exec(runtimeSource.source);
-    if (!match) {
-        return null;
-    }
-    return {
-        match: match[0],
-        location: formatRuntimeSourceLocation(runtimeSource, match.index),
-    };
-}
-function assertNoLaunchCheckConditionalSource(runtimeSource) {
-    const directMarker = findRuntimeSourcePattern(runtimeSource, /\b(?:launchCheck|launch-check|upload-check|previewToken|localDevPort)\b/i);
-    if (directMarker) {
-        throw new Error(`agent_task_launch_check_conditional_disallowed: game source must not branch on PlayDrop validation markers. First match "${directMarker.match}" at ${directMarker.location}.`);
-    }
-    const environmentSniff = findRuntimeSourcePattern(runtimeSource, /(?:document\.referrer|window\.location|\blocation\.(?:href|search|origin)|new\s+URLSearchParams)[\s\S]{0,320}(?:localhost|127\.0\.0\.1|_auth\/creators|\/upload-check\/)|(?:localhost|127\.0\.0\.1|_auth\/creators|\/upload-check\/)[\s\S]{0,320}(?:document\.referrer|window\.location|\blocation\.(?:href|search|origin)|new\s+URLSearchParams)/i);
-    if (environmentSniff) {
-        throw new Error(`agent_task_launch_check_conditional_disallowed: game source must not sniff validation or local route context. First match at ${environmentSniff.location}.`);
-    }
-}
-function hasDeclaredRuntimeAssetDependency(task) {
-    return task.uses.packs.length > 0
-        || task.uses.assets.length > 0
-        || task.ownedAssets.some((ownedAsset) => !isListingOwnedAsset(task, ownedAsset));
-}
-function isListingOwnedAsset(task, ownedAsset) {
-    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 isAudioOwnedAsset(ownedAsset) {
-    return ownedAsset.category === 'AUDIO';
-}
-function sourceMentionsRuntimeKey(source, runtimeKey) {
-    return source.includes(runtimeKey);
-}
-function hasRuntimeAssetLoadOrRenderPath(source) {
-    return /\bsdk\.assets\b|\.resolveAppAsset\s*\(|\.listAppAssets\s*\(/.test(source)
-        && /\bnew\s+(?:Image|Audio)\s*\(|createImageBitmap\s*\(|\.src\s*=|\.load(?:Async)?\s*\(|\.drawImage\s*\(|\.add\.image\s*\(|\.load\.image\s*\(|\.textures\.add|\.sound\.add|\.scene\.add\s*\(/i.test(source);
-}
-function assertAudioAssetsAreNonBlocking(task, runtimeSource) {
-    const source = runtimeSource.source;
-    for (const ownedAsset of task.ownedAssets) {
-        if (!isAudioOwnedAsset(ownedAsset)) {
-            continue;
-        }
-        const runtimeKey = ownedAsset.runtimeKey?.trim() ?? '';
-        const name = ownedAsset.name.trim();
-        if (!runtimeKey || (!source.includes(runtimeKey) && !source.includes(name))) {
-            continue;
-        }
-        const lowerRuntimeKey = runtimeKey.toLowerCase();
-        const lowerName = name.toLowerCase();
-        const executableSource = stripRuntimeSourceCommentsAndStrings(source);
-        const fatalAudioPattern = /\bthrow\s+new\s+Error\s*\([^)]*(?:missing|asset|sound|audio|sfx)[^)]*\)|\bthrow\s+new\s+Error\s*\([^)]*\)|Promise\.reject\s*\([^)]*(?:missing|asset|sound|audio|sfx)[^)]*\)/ig;
-        let match;
-        while ((match = fatalAudioPattern.exec(executableSource)) !== null) {
-            const start = Math.max(0, match.index - 800);
-            const end = Math.min(source.length, match.index + 800);
-            const nearby = source.slice(start, end).toLowerCase();
-            if (nearby.includes(lowerRuntimeKey) || nearby.includes(lowerName)) {
-                throw new Error(`agent_task_audio_asset_boot_fatal_disallowed: audio SFX owned asset "${ownedAsset.name}" must not block play when it fails to load; log a console warning and continue.`);
-            }
-        }
-    }
-}
-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}.`);
-        }
-    }
-}
-async function assertNewGameDeclaredAssetsAreUsedAtRuntime(input) {
-    const runtimeSource = readRuntimeSourceText(input.task.projectDir);
-    const source = runtimeSource.source;
-    assertNoLaunchCheckConditionalSource(runtimeSource);
-    if (!hasDeclaredRuntimeAssetDependency(input.task)) {
-        return;
-    }
-    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 (input.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().');
-    }
-    if (!hasRuntimeAssetLoadOrRenderPath(source)) {
-        throw new Error('agent_task_game_assets_runtime_missing: declared game assets must be loaded and rendered or played at runtime, not only listed in catalogue.json.');
-    }
-    if (input.task.uses.packs.length > 0 && !/\bassetRef\b|\bsourceType\b|\bcontentType\b/i.test(source)) {
-        throw new Error('agent_task_game_pack_runtime_missing: new game tasks that declare uses.packs must select pack assets from the runtime manifest by assetRef/sourceType/contentType before rendering them.');
-    }
-    const manifest = input.task.ownedAssets.length > 0
-        ? await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
-            apiBase: 'http://127.0.0.1',
-            task: {
-                ...input.task,
-                uses: { assets: [], packs: [] },
-            },
-            creatorUsername: input.creatorUsername,
-            appBaseUrl: `http://127.0.0.1/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent((0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME'))}/${encodeURIComponent(input.task.name)}/`,
-        })
-        : null;
-    const runtimeKeys = new Set((manifest?.response.assets ?? [])
-        .map((asset) => typeof asset.runtimeKey === 'string' ? asset.runtimeKey.trim() : '')
-        .filter(Boolean));
-    for (const ownedAsset of input.task.ownedAssets) {
-        const runtimeKey = ownedAsset.runtimeKey?.trim() ?? '';
-        if (!runtimeKey) {
-            throw new Error(`agent_task_owned_asset_runtime_key_missing: owned asset "${ownedAsset.name}" must declare a runtimeKey.`);
-        }
-        if (!runtimeKeys.has(runtimeKey)) {
-            throw new Error(`agent_task_owned_asset_runtime_manifest_missing: owned asset "${ownedAsset.name}" runtimeKey "${runtimeKey}" was not present in the runtime manifest.`);
-        }
-        if (isListingOwnedAsset(input.task, ownedAsset)) {
-            continue;
-        }
-        if (!sourceMentionsRuntimeKey(source, runtimeKey)) {
-            throw new Error(`agent_task_owned_asset_runtime_key_unused: owned asset "${ownedAsset.name}" runtimeKey "${runtimeKey}" does not appear in runtime source.`);
-        }
-    }
-    for (const dependency of input.task.uses.assets) {
-        const runtimeKey = dependency.runtimeKey?.trim() ?? '';
-        if (runtimeKey && !sourceMentionsRuntimeKey(source, runtimeKey)) {
-            throw new Error(`agent_task_declared_asset_runtime_key_unused: declared asset "${dependency.ref}" runtimeKey "${runtimeKey}" does not appear in runtime source.`);
-        }
-    }
-    assertAudioAssetsAreNonBlocking(input.task, runtimeSource);
-    const hasDirectGameplayAssets = input.task.ownedAssets.some((ownedAsset) => !isListingOwnedAsset(input.task, ownedAsset)) || input.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.');
-    }
-}
 async function collectUploadPreflightErrors(checks) {
     const errors = [];
     for (const check of checks) {
@@ -1710,13 +1281,13 @@ async function collectUploadPreflightErrors(checks) {
 function assertAgentTaskReleaseNotes(task) {
     const releaseNotes = task.releaseNotes?.trim() ?? '';
     if (!releaseNotes) {
-        throw new Error('agent_task_release_notes_missing');
+        throw new Error('agent_task_release_notes_missing: catalogue releaseNotes must contain one line with 1..240 characters.');
     }
     if (/[\r\n]/.test(releaseNotes)) {
-        throw new Error('agent_task_release_notes_multiline');
+        throw new Error(`agent_task_release_notes_multiline: releaseNotes has ${releaseNotes.split(/\r?\n/).length} lines; expected one line with 1..240 characters.`);
     }
     if (releaseNotes.length > 240) {
-        throw new Error('agent_task_release_notes_too_long');
+        throw new Error(`agent_task_release_notes_too_long: releaseNotes length=${releaseNotes.length}; expected 1..240 characters on one line.`);
     }
 }
 async function assertWorkerAppLocalUploadPreflight(input) {
@@ -1727,23 +1298,18 @@ async function assertWorkerAppLocalUploadPreflight(input) {
         && (0, node_fs_1.existsSync)(existingCaptureReport);
     const errors = await collectUploadPreflightErrors([
         () => assertAgentTaskReleaseNotes(input.task),
-        ...(complete ? [() => (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(input.task)] : []),
-        ...(input.kind === 'NEW_GAME' ? [() => assertAgentNewGamePlaytestContract(input.task)] : []),
-        () => {
-            if (!appTaskSatisfiesPlaydropAssetRequirement(input.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.');
-            }
-        },
+        ...(complete
+            ? [
+                () => (0, listingPreflight_1.assertAgentGameIconListingPreflight)(input.task),
+                () => (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(input.task),
+                () => (0, listingPreflight_1.assertAgentGamePreviewListingPreflight)(input.task),
+                () => (0, listingPreflight_1.assertAgentGameVideoListingPreflight)(input.task),
+            ]
+            : []),
+        ...(input.kind === 'NEW_GAME'
+            ? [() => assertAgentNewGamePlaytestContract(input.task)]
+            : [() => assertAgentPrimarySurfaceContract(input.task, input.kind)]),
         () => (0, ownedRuntimeImageValidation_1.assertOwnedRuntimeImagesAreValid)(input.task),
-        () => assertRequestedPlaydropAssetsAreUsedAtRuntime({
-            task: input.task,
-            requirement: input.playdropAssetRequirement,
-            creatorRequest: input.creatorRequest,
-        }),
-        () => assertNewGameDeclaredAssetsAreUsedAtRuntime({
-            creatorUsername: input.creatorUsername?.trim() ?? '',
-            task: input.task,
-        }),
         ...(complete
             ? [
                 () => (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(input.task),
@@ -1825,17 +1391,9 @@ async function prepareWorkerAppProject(input, stage) {
         task,
         kind: input.kind,
         executionTarget: input.executionTarget,
-        creatorUsername,
-        playdropAssetRequirement: input.playdropAssetRequirement,
-        creatorRequest: input.creatorRequest,
         stage,
         expectedRuntimeBundleHash: artifacts?.bundleHash,
     });
-    await assertDeclared3dPlaydropPacksContainRuntimeModels({
-        client: input.client,
-        task,
-        creatorRequest: input.creatorRequest,
-    });
     return {
         task,
         artifacts,

package/dist/commands/validate.js

@@ -199,9 +199,6 @@ async function validate(pathOrName, options = {}) {
                         task,
                         kind: workerContext.kind,
                         executionTarget: workerContext.target,
-                        creatorUsername: workerContext.creatorUsername,
-                        creatorRequest: workerContext.creatorRequest,
-                        playdropAssetRequirement: (0, upload_1.resolveWorkerPlaydropAssetRequirement)(workerContext.creatorRequest),
                     });
                 }
                 else {

package/dist/commands/worker.d.ts

@@ -2,7 +2,6 @@ import type { ApiClient } from '@playdrop/api-client';
 import { type AgentAvailabilityFailureReason, type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AppSurface, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type JsonValue, type WorkerTaskAssignmentV2, type WorkerTaskPluginV2, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
 import { loadConfig } from '../config';
 import { runShell } from '../shellProbe';
-import { type WorkerPlaydropAssetRequirement } from './upload';
 import { type WorkerInstrumentSurface, type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './worker/runtime';
 export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCleanRoomChildEnv, buildCodexExecArgs, buildPlaywrightMcpCommand, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_CREATOR_AGENT_TIMEOUT_MS, DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractClaudeSessionId, extractCodexThreadId, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess } from './worker/runtime';
 export type { AgentTokenUsage, LoggedProcessResult, LoggedProcessTranscriptChunk } from './worker/runtime';
@@ -215,7 +214,7 @@ export declare function appendWorkerTranscriptChunks(input: {
     chunks: LoggedProcessTranscriptChunk[];
     batchSize?: number;
 }): Promise<void>;
-export declare function readTaskNextStepsFile(filePath: string | undefined): AgentTaskNextStepSuggestion[] | undefined;
+export declare function readTaskNextStepsFile(filePath: string | undefined, workspaceDir?: string): AgentTaskNextStepSuggestion[] | undefined;
 export declare function assertTaskUploadResultMatchesContext(input: {
     taskContext: {
         taskId: number;
@@ -256,7 +255,6 @@ export declare function classifyWorkerEventDrainError(error: unknown): 'session_
 export declare function isWorkerTransientNetworkError(error: unknown): boolean;
 export declare function classifyWorkerHeartbeatError(error: unknown): 'session_expired' | 'lease_invalid' | 'transient_network' | null;
 export declare function assertWorkerClaimErrorRetryable(error: unknown): void;
-export declare function resolvePlaydropAssetRequirementFromText(value: unknown): WorkerPlaydropAssetRequirement | null;
 export declare function resolvePlaywrightBrowsersPathFromExecutable(executablePath: string): string;
 export declare function loadWorkerEnvFile(envName: string | undefined, cwd?: string): string | null;
 export declare function buildWorkerCapabilities(input: {