@playdrop/playdrop-cli 0.12.27 → 0.12.29

package/dist/commands/upload.js

@@ -1,40 +1,11 @@
 "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.resolveUploadOwner = resolveUploadOwner;
+exports.resolveDefaultUploadCreator = resolveDefaultUploadCreator;
 exports.upload = upload;
+exports.resolveWorkerPlaydropAssetRequirement = resolveWorkerPlaydropAssetRequirement;
 exports.assertTaskPlaytestEvidenceManifest = assertTaskPlaytestEvidenceManifest;
+exports.assertWorkerAppLocalUploadPreflight = assertWorkerAppLocalUploadPreflight;
 exports.publishWorkerAppProject = publishWorkerAppProject;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -53,6 +24,7 @@ const uploadLog_1 = require("../uploadLog");
 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");
 function normalizeSavedItemKinds(kinds) {
@@ -222,6 +194,19 @@ function normalizeCreatorUsername(username) {
     }
     return trimmed;
 }
+function resolveUploadOwner(actorUsername, workspaceOwnerUsername) {
+    const workspaceOwner = workspaceOwnerUsername?.trim() ?? '';
+    if (workspaceOwner) {
+        return workspaceOwner;
+    }
+    const actor = actorUsername?.trim() ?? '';
+    return actor || 'unknown';
+}
+function resolveDefaultUploadCreator(owner, actorUsername) {
+    return normalizeCreatorUsername(owner ?? null)
+        ?? normalizeCreatorUsername(actorUsername ?? null)
+        ?? 'unknown';
+}
 function isNotFoundApiError(error) {
     return error instanceof types_1.ApiError && error.status === 404;
 }
@@ -512,7 +497,10 @@ function validateTagRefsForTarget(tagRegistry, target) {
 function collectTaskTagValidationTargets(task) {
     if (task.kind === 'app') {
         return [
-            { tags: task.tags, targetKind: 'APP' },
+            {
+                tags: Array.from(new Set([...task.tags, ...Object.values(task.design ?? {})])),
+                targetKind: 'APP',
+            },
             ...task.ownedAssets.map((ownedAsset) => ({
                 tags: ownedAsset.tags,
                 targetKind: 'ASSET',
@@ -1059,7 +1047,7 @@ async function flushGraphState(client, graphState, results) {
 }
 async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, localTagGroups, currentUser, token, warnings, apiBase, webBase, options) {
     const portalBase = normalizePortalBase(webBase);
-    const defaultCreator = normalizeCreatorUsername(ownerUsername) ?? owner;
+    const defaultCreator = resolveDefaultUploadCreator(owner, ownerUsername);
     const results = [];
     const preflight = await buildUploadPreflight(client, tasks, defaultCreator, currentUserRole, localTagGroups);
     const sortedTasks = preflight.nodes.map((node) => node.task);
@@ -1177,9 +1165,7 @@ async function upload(pathOrName, options) {
         }
         throw error;
     }
-    const owner = typeof userInfo.username === 'string' && userInfo.username.trim().length > 0
-        ? userInfo.username.trim()
-        : 'unknown';
+    const owner = resolveUploadOwner(userInfo.username, ctx.workspaceAuth?.config.ownerUsername);
     const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
     if (tagGroupLoad.errors.length > 0) {
         (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
@@ -1223,6 +1209,19 @@ 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;
+}
 const WORKER_SUPERVISOR_SOURCE_EXCLUDES = [
     'PLAYDROP_TASK.md',
     '.playdrop/',
@@ -1234,8 +1233,6 @@ const WORKER_SUPERVISOR_BUNDLE_EXCLUDES = [
     'assets/marketing/',
     'listing/',
 ];
-const OWNED_RUNTIME_IMAGE_CHECK_SIZE = 96;
-const OWNED_RUNTIME_IMAGE_GRID_CHECK_SIZE = 512;
 function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
     if (!requirement) {
         return true;
@@ -1253,361 +1250,6 @@ function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
     });
     return hasFirstPartyPack || hasFirstPartyAsset || 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 clean owned PNG assets through the PlayDrop make-assets 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 make-assets 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',
@@ -1700,24 +1342,11 @@ function assertNoLaunchCheckConditionalSource(runtimeSource) {
         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 hasProceduralAssetStrategy(task) {
-    const strategy = task.design?.assetStrategy;
-    return strategy?.value === 'procedural';
-}
 function hasDeclaredRuntimeAssetDependency(task) {
     return task.uses.packs.length > 0
         || task.uses.assets.length > 0
         || task.ownedAssets.some((ownedAsset) => !isListingOwnedAsset(task, ownedAsset));
 }
-function assertNewGameAssetStrategy(task) {
-    if (hasDeclaredRuntimeAssetDependency(task)) {
-        return;
-    }
-    if (hasProceduralAssetStrategy(task)) {
-        return;
-    }
-    throw new Error('agent_task_asset_strategy_missing: new game tasks must either declare true runtime assets/packs or set design.assetStrategy to { "value": "procedural", "note": "..." } for an honest procedural draft.');
-}
 function isListingOwnedAsset(task, ownedAsset) {
     const primaryPath = ownedAsset.filePaths?.primary;
     if (!primaryPath) {
@@ -1966,7 +1595,6 @@ async function assertNewGameDeclaredAssetsAreUsedAtRuntime(input) {
     const runtimeSource = readRuntimeSourceText(input.task.projectDir);
     const source = runtimeSource.source;
     assertNoLaunchCheckConditionalSource(runtimeSource);
-    assertNewGameAssetStrategy(input.task);
     if (!hasDeclaredRuntimeAssetDependency(input.task)) {
         return;
     }
@@ -1984,8 +1612,7 @@ async function assertNewGameDeclaredAssetsAreUsedAtRuntime(input) {
     }
     const manifest = input.task.ownedAssets.length > 0
         ? await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
-            client: input.client,
-            apiBase: input.apiBase,
+            apiBase: 'http://127.0.0.1',
             task: {
                 ...input.task,
                 uses: { assets: [], packs: [] },
@@ -2183,6 +1810,35 @@ function readRuntimeSourceLastModifiedAt(rootDir) {
     walk(root);
     return latest > 0 ? new Date(latest).toISOString() : null;
 }
+async function assertWorkerAppLocalUploadPreflight(input) {
+    if (input.kind === 'GAME_UPDATE') {
+        return assertTaskPlaytestEvidenceManifest(input.task);
+    }
+    (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(input.task);
+    if (input.kind === 'NEW_GAME') {
+        (0, listingPreflight_1.assertAgentNewGameArtDirectionPreflight)(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.');
+    }
+    await (0, ownedRuntimeImageValidation_1.assertOwnedRuntimeImagesAreValid)(input.task);
+    assertRequestedPlaydropAssetsAreUsedAtRuntime({
+        task: input.task,
+        requirement: input.playdropAssetRequirement,
+        creatorRequest: input.creatorRequest,
+    });
+    await assertNewGameDeclaredAssetsAreUsedAtRuntime({
+        creatorUsername: input.creatorUsername?.trim() ?? '',
+        task: input.task,
+    });
+    (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(input.task);
+    (0, listingPreflight_1.assertAgentGameCaptureReportPreflight)(input.task, {
+        requireCaptureReport: input.executionTarget === 'FIRST_PARTY',
+    });
+    return assertTaskPlaytestEvidenceManifest(input.task, {
+        requireOutcomeProof: input.kind === 'NEW_GAME',
+    });
+}
 // 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.
@@ -2229,38 +1885,14 @@ async function publishWorkerAppProject(input) {
             throw new Error(`agent_task_remix_ref_mismatch:${catalogueRemixRef}:${expectedRemixRef}`);
         }
     }
-    if (input.kind === 'GAME_UPDATE') {
-        assertTaskPlaytestEvidenceManifest(task);
-    }
-    if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
-        (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(task);
-    }
-    if (input.kind === 'NEW_GAME') {
-        (0, listingPreflight_1.assertAgentNewGameArtDirectionPreflight)(task);
-    }
-    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' || input.kind === 'REMIX_GAME') {
-        await assertNewGameDirectPlaydropAssetsAreRuntimeSafe({
-            client: input.client,
-            task,
-        });
-        await assertNewGameOwnedRuntimeImageAssetsAreClean(task);
-    }
-    assertRequestedPlaydropAssetsAreUsedAtRuntime({
+    const playtestProof = await assertWorkerAppLocalUploadPreflight({
         task,
-        requirement: input.playdropAssetRequirement,
+        kind: input.kind,
+        executionTarget: input.executionTarget,
+        creatorUsername,
+        playdropAssetRequirement: input.playdropAssetRequirement,
         creatorRequest: input.creatorRequest,
     });
-    if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
-        await assertNewGameDeclaredAssetsAreUsedAtRuntime({
-            client: input.client,
-            apiBase: input.apiBase,
-            creatorUsername,
-            task,
-        });
-    }
     await assertDeclared3dPlaydropPacksContainRuntimeModels({
         client: input.client,
         task,
@@ -2284,13 +1916,6 @@ async function publishWorkerAppProject(input) {
         taskId: input.taskId,
         taskToken,
     };
-    let playtestProof = null;
-    if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
-        (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(task);
-        playtestProof = assertTaskPlaytestEvidenceManifest(task, {
-            requireOutcomeProof: input.kind === 'NEW_GAME',
-        });
-    }
     const { upload: uploadResult, warnings } = await (0, apps_1.runAppPipeline)(input.client, task, {
         creatorUsername,
         apiBase: input.apiBase,

package/dist/commands/validate.js

@@ -11,6 +11,7 @@ const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const listingPreflight_1 = require("../listingPreflight");
 const upload_content_1 = require("./upload-content");
+const upload_1 = require("./upload");
 function buildLocalAssetSpecLookups(tasks) {
     const exactByRef = new Map();
     const uniqueByNameVersion = new Map();
@@ -192,7 +193,20 @@ async function validate(pathOrName, options = {}) {
         const entityId = task.name;
         try {
             if (task.kind === 'app') {
-                (0, listingPreflight_1.assertProjectListingPreflight)(task);
+                const workerContext = (0, listingPreflight_1.readWorkerUploadPreflightContext)(task.projectDir);
+                if (workerContext) {
+                    await (0, upload_1.assertWorkerAppLocalUploadPreflight)({
+                        task,
+                        kind: workerContext.kind,
+                        executionTarget: workerContext.target,
+                        creatorUsername: workerContext.creatorUsername,
+                        creatorRequest: workerContext.creatorRequest,
+                        playdropAssetRequirement: (0, upload_1.resolveWorkerPlaydropAssetRequirement)(workerContext.creatorRequest),
+                    });
+                }
+                else {
+                    (0, listingPreflight_1.assertProjectListingPreflight)(task);
+                }
                 await (0, apps_1.validateAppTask)(task);
                 (0, apps_1.collectAppValidationWarnings)(task, 'source').forEach((warning) => warnings.add(warning));
             }

package/dist/commands/worker.d.ts

@@ -310,6 +310,22 @@ export declare function acquireWorkerSupervisorLock(input: {
     file?: string;
 }): WorkerSupervisorLock;
 export declare function releaseWorkerSupervisorLock(lock: WorkerSupervisorLock): void;
+export type TaskUploadLockOwner = {
+    schemaVersion: 1;
+    command: 'task upload';
+    pid: number;
+    processStartIdentity: string;
+    createdAt: string;
+};
+export type TaskUploadLock = {
+    file: string;
+    owner: TaskUploadLockOwner;
+};
+export declare function resolveTaskUploadLockFile(workspaceDir: string): string;
+export declare function removeStaleTaskUploadLockIfUnchanged(file: string, observedHolder: TaskUploadLockOwner): boolean;
+export declare function acquireTaskUploadLock(workspaceDir: string): TaskUploadLock;
+export declare function releaseTaskUploadLock(lock: TaskUploadLock): void;
+export declare function withTaskUploadLock<T>(workspaceDir: string, work: () => Promise<T>): Promise<T>;
 export declare function readActivePersonalWorkerRuntimeState(): WorkerRuntimeState | null;
 export declare function parseLaunchAgentProgramArguments(plist: string): string[];
 export declare function assertLaunchAgentPlistCompatible(input: {