@playdrop/playdrop-cli 0.14.0 → 0.14.2

package/dist/commands/captureListing.js

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveListingCaptureRouteSegment = resolveListingCaptureRouteSegment;
 exports.resolveCaptureListingDevRouterPort = resolveCaptureListingDevRouterPort;
@@ -49,6 +52,7 @@ exports.resolveListingCaptureBrowserContextOptions = resolveListingCaptureBrowse
 exports.assertExportedListingAudio = assertExportedListingAudio;
 exports.assertListingCaptureWindowCanContainViewport = assertListingCaptureWindowCanContainViewport;
 exports.computeRecordedCrop = computeRecordedCrop;
+exports.assertListingCapturePixelMetrics = assertListingCapturePixelMetrics;
 exports.runListingRecorder = runListingRecorder;
 exports.formatCommandError = formatCommandError;
 exports.captureCommandMatchesExceptPoster = captureCommandMatchesExceptPoster;
@@ -59,6 +63,7 @@ const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const sharp_1 = __importDefault(require("sharp"));
 const appUrls_1 = require("../appUrls");
 const build_1 = require("../apps/build");
 const catalogue_1 = require("../catalogue");
@@ -96,6 +101,11 @@ const SURFACE_CAPTURE_DIMENSIONS = {
     MOBILE_LANDSCAPE: { width: 844, height: 390 },
     MOBILE_PORTRAIT: { width: 390, height: 844 },
 };
+const MIN_LISTING_REFERENCE_FRAME_SIMILARITY = 0.25;
+const MIN_LISTING_FRAME_MEAN_LUMA = 0.02;
+const MIN_LISTING_VISIBLE_PIXEL_RATIO = 0.005;
+const MIN_LISTING_MOTION_MEAN_DELTA = 0.002;
+const MIN_LISTING_MOTION_CHANGED_PIXEL_RATIO = 0.01;
 const SURFACE_OUTPUT_SLUG = {
     DESKTOP: 'desktop',
     MOBILE_LANDSCAPE: 'mobile-landscape',
@@ -627,6 +637,125 @@ async function probeMediaFile(filePath, deadlineAt) {
 async function computeFileSha256(filePath) {
     return (0, node_crypto_1.createHash)('sha256').update(await (0, promises_1.readFile)(filePath)).digest('hex');
 }
+async function readListingValidationPixels(filePath) {
+    return (0, sharp_1.default)(filePath)
+        .resize(64, 64, { fit: 'fill' })
+        .greyscale()
+        .raw()
+        .toBuffer();
+}
+async function measureListingFrameVisibility(filePath) {
+    const pixels = await readListingValidationPixels(filePath);
+    if (pixels.length === 0) {
+        throw new Error('listing_capture_frame_pixels_missing');
+    }
+    let total = 0;
+    let visiblePixels = 0;
+    for (const pixel of pixels) {
+        total += pixel;
+        if (pixel >= 24)
+            visiblePixels += 1;
+    }
+    return {
+        meanLuma: total / pixels.length / 255,
+        visiblePixelRatio: visiblePixels / pixels.length,
+    };
+}
+async function assertListingCaptureFrameVisible(surface, label, filePath) {
+    const visibility = await measureListingFrameVisibility(filePath);
+    if (visibility.meanLuma < MIN_LISTING_FRAME_MEAN_LUMA
+        && visibility.visiblePixelRatio < MIN_LISTING_VISIBLE_PIXEL_RATIO) {
+        throw new Error(`listing_capture_black_frame:${surface}:${label}`);
+    }
+}
+async function measureListingFrameMotion(firstPath, lastPath) {
+    const [first, last] = await Promise.all([
+        readListingValidationPixels(firstPath),
+        readListingValidationPixels(lastPath),
+    ]);
+    if (first.length !== last.length || first.length === 0) {
+        throw new Error('listing_capture_frame_shape_mismatch');
+    }
+    let deltaTotal = 0;
+    let changedPixels = 0;
+    for (let index = 0; index < first.length; index += 1) {
+        const delta = Math.abs(first[index] - last[index]);
+        deltaTotal += delta;
+        if (delta >= 16)
+            changedPixels += 1;
+    }
+    return {
+        meanDelta: deltaTotal / first.length / 255,
+        changedPixelRatio: changedPixels / first.length,
+    };
+}
+function calculateListingFrameSimilarity(referencePath, capturedPath, deadlineAt) {
+    const { stderr } = runTool('ffmpeg', [
+        '-hide_banner',
+        '-i',
+        referencePath,
+        '-i',
+        capturedPath,
+        '-filter_complex',
+        '[0:v]scale=320:320:force_original_aspect_ratio=decrease,pad=320:320:(ow-iw)/2:(oh-ih)/2,format=yuv420p[ref];[1:v]scale=320:320:force_original_aspect_ratio=decrease,pad=320:320:(ow-iw)/2:(oh-ih)/2,format=yuv420p[cap];[ref][cap]ssim',
+        '-f',
+        'null',
+        '-',
+    ], 'ffmpeg_failed', deadlineAt);
+    const match = stderr.match(/All:([0-9.]+)/);
+    if (!match) {
+        throw new Error('listing_capture_similarity_missing');
+    }
+    return Number.parseFloat(match[1]);
+}
+function assertListingCapturePixelMetrics(surface, metrics) {
+    if (!Number.isFinite(metrics.referenceFrameSimilarity)
+        || metrics.referenceFrameSimilarity < MIN_LISTING_REFERENCE_FRAME_SIMILARITY) {
+        throw new Error(`listing_capture_wrong_game:${surface}:${Number.isFinite(metrics.referenceFrameSimilarity) ? metrics.referenceFrameSimilarity.toFixed(3) : 'unknown'}`);
+    }
+    if (metrics.firstFrameMeanLuma < MIN_LISTING_FRAME_MEAN_LUMA
+        && metrics.firstFrameVisiblePixelRatio < MIN_LISTING_VISIBLE_PIXEL_RATIO) {
+        throw new Error(`listing_capture_black_frame:${surface}:first`);
+    }
+    if (metrics.posterFrameMeanLuma < MIN_LISTING_FRAME_MEAN_LUMA
+        && metrics.posterFrameVisiblePixelRatio < MIN_LISTING_VISIBLE_PIXEL_RATIO) {
+        throw new Error(`listing_capture_black_frame:${surface}:poster`);
+    }
+    if (metrics.motionMeanDelta < MIN_LISTING_MOTION_MEAN_DELTA
+        && metrics.motionChangedPixelRatio < MIN_LISTING_MOTION_CHANGED_PIXEL_RATIO) {
+        throw new Error(`listing_capture_stale_video:${surface}`);
+    }
+}
+async function validateListingCapturePixels(input) {
+    const [firstVisibility, posterVisibility, motion] = await Promise.all([
+        measureListingFrameVisibility(input.firstFramePath),
+        measureListingFrameVisibility(input.posterPath),
+        measureListingFrameMotion(input.firstFramePath, input.lastFramePath),
+    ]);
+    const metrics = {
+        referenceFrameSimilarity: calculateListingFrameSimilarity(input.referencePath, input.firstFramePath, input.deadlineAt),
+        firstFrameMeanLuma: firstVisibility.meanLuma,
+        firstFrameVisiblePixelRatio: firstVisibility.visiblePixelRatio,
+        posterFrameMeanLuma: posterVisibility.meanLuma,
+        posterFrameVisiblePixelRatio: posterVisibility.visiblePixelRatio,
+        motionMeanDelta: motion.meanDelta,
+        motionChangedPixelRatio: motion.changedPixelRatio,
+    };
+    assertListingCapturePixelMetrics(input.surface, metrics);
+    return { status: 'passed', ...metrics };
+}
+function extractListingValidationFrame(videoPath, atSeconds, outputPath, deadlineAt) {
+    runTool('ffmpeg', [
+        '-y',
+        '-ss',
+        String(atSeconds),
+        '-i',
+        videoPath,
+        '-frames:v',
+        '1',
+        outputPath,
+    ], 'ffmpeg_failed', deadlineAt);
+}
 function parseFrameRate(raw) {
     if (!raw) {
         return null;
@@ -741,6 +870,13 @@ function formatCommandError(error) {
             suggestions: ['Fix or remove the incomplete canonical capture directory, then record the runtime once.'],
         };
     }
+    if (error.message === 'listing_capture_report_pixels_unvalidated'
+        || error.message.startsWith('listing_capture_artifact_changed:')) {
+        return {
+            message: 'The existing canonical recording is unvalidated or its files changed after capture.',
+            suggestions: ['Remove the invalid capture directory and rerun "playdrop project capture" once.'],
+        };
+    }
     if (error.message.startsWith('listing_capture_dimensions_exceed_display:')) {
         const [, requested = 'unknown', available = 'unknown'] = error.message.split(':');
         return {
@@ -760,6 +896,24 @@ function formatCommandError(error) {
             suggestions: [],
         };
     }
+    if (error.message.startsWith('listing_capture_wrong_game:')) {
+        return {
+            message: 'The recorded pixels do not match the selected game preview.',
+            suggestions: ['Verify preview mode shows the selected game, then rerun "playdrop project capture".'],
+        };
+    }
+    if (error.message.startsWith('listing_capture_black_frame:')) {
+        return {
+            message: 'The gameplay recording contains a black first frame or poster.',
+            suggestions: ['Make preview mode visibly ready before capture starts, then rerun "playdrop project capture".'],
+        };
+    }
+    if (error.message.startsWith('listing_capture_stale_video:')) {
+        return {
+            message: 'The gameplay recording is visually static.',
+            suggestions: ['Make preview mode show real gameplay motion, then rerun "playdrop project capture".'],
+        };
+    }
     return {
         message: error.message,
         suggestions: [],
@@ -830,6 +984,9 @@ async function reuseCurrentListingCapture(input) {
     if (report.appName !== input.appName) {
         throw new Error(`listing_capture_report_app_mismatch:${report.appName}:${input.appName}`);
     }
+    if (report.binding?.pixelValidation !== 'passed') {
+        throw new Error('listing_capture_report_pixels_unvalidated');
+    }
     if (!input.runtimeBundleHash || report.binding?.runtimeBundleHash !== input.runtimeBundleHash) {
         return false;
     }
@@ -837,6 +994,15 @@ async function reuseCurrentListingCapture(input) {
     const captures = input.surfaces.map((surface) => report.captures.find((candidate) => candidate.surface === surface));
     for (const capture of captures) {
         await (0, promises_1.access)(capture.finalVideo.path);
+        await (0, promises_1.access)(capture.posterPath);
+        for (const artifactPath of [capture.finalVideo.path, capture.posterPath]) {
+            const artifactKey = (0, node_path_1.relative)(input.outputPaths.outputDir, artifactPath);
+            const expectedHash = report.binding.artifactHashes[artifactKey];
+            const actualHash = await computeFileSha256(artifactPath);
+            if (!expectedHash || actualHash !== expectedHash) {
+                throw new Error(`listing_capture_artifact_changed:${artifactKey}`);
+            }
+        }
     }
     if (action === 'reuse') {
         console.log('[listing] The current runtime already has a matching canonical capture; reusing it.');
@@ -857,6 +1023,7 @@ async function reuseCurrentListingCapture(input) {
         capture.command.posterAtSeconds = input.parsedOptions.posterAtSeconds;
         const artifactKey = (0, node_path_1.relative)(input.outputPaths.outputDir, capture.posterPath) || 'poster.png';
         report.binding.artifactHashes[artifactKey] = await computeFileSha256(capture.posterPath);
+        await assertListingCaptureFrameVisible(capture.surface, 'poster', capture.posterPath);
     }
     await (0, promises_1.writeFile)(input.outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
     console.log(`[listing] Refreshed the canonical poster at ${input.parsedOptions.posterAtSeconds}s without relaunching the game.`);
@@ -1206,6 +1373,12 @@ async function captureListing(targetArg, options = {}) {
                 const dimensions = resolveCaptureDimensions(surface, parsedOptions);
                 const captureSceneId = resolveListingCaptureSceneId(dimensions.width, dimensions.height);
                 const surfaceOutputPaths = buildSurfaceOutputPaths(outputPaths.outputDir, surface, useSurfacePrefix);
+                const validationPrefix = useSurfacePrefix ? `${surface.toLowerCase().replace(/_/g, '-')}-` : '';
+                const validationPaths = {
+                    reference: (0, node_path_1.join)(outputPaths.outputDir, `.${validationPrefix}capture-reference.png`),
+                    first: (0, node_path_1.join)(outputPaths.outputDir, `.${validationPrefix}capture-first.png`),
+                    last: (0, node_path_1.join)(outputPaths.outputDir, `.${validationPrefix}capture-last.png`),
+                };
                 console.log(`[listing] Capturing ${surface} at ${dimensions.width}x${dimensions.height}.`);
                 const contextOptions = resolveListingCaptureBrowserContextOptions(surface, dimensions);
                 browserHandle = await launchListingBrowser(dimensions, frameUrlObject.origin, contextOptions);
@@ -1233,6 +1406,7 @@ async function captureListing(targetArg, options = {}) {
                     });
                     let recorderMetadata;
                     try {
+                        await browserHandle.page.locator(CAPTURE_FRAME_SELECTOR).screenshot({ path: validationPaths.reference });
                         recorderMetadata = await runListingRecorder(recorderPath, browserHandle.processId, parsedOptions.durationSeconds, surfaceOutputPaths.rawVideoPath, surfaceOutputPaths.metadataPath, shouldExportPreviewAudio ? false : parsedOptions.audio, captureDeadlineAt);
                     }
                     finally {
@@ -1262,6 +1436,16 @@ async function captureListing(targetArg, options = {}) {
                     if (parsedOptions.audio && finalAudioTrackCount === 0) {
                         throw new Error('audio_track_missing');
                     }
+                    extractListingValidationFrame(surfaceOutputPaths.finalVideoPath, Math.min(0.1, finalDurationSeconds / 4), validationPaths.first, captureDeadlineAt);
+                    extractListingValidationFrame(surfaceOutputPaths.finalVideoPath, Math.max(0, finalDurationSeconds - 0.1), validationPaths.last, captureDeadlineAt);
+                    const validation = await validateListingCapturePixels({
+                        surface,
+                        referencePath: validationPaths.reference,
+                        firstFramePath: validationPaths.first,
+                        lastFramePath: validationPaths.last,
+                        posterPath: surfaceOutputPaths.posterPath,
+                        deadlineAt: captureDeadlineAt,
+                    });
                     const warnings = createWarnings(finalProbe, parsedOptions.audio);
                     for (const warning of warnings) {
                         allWarnings.push(`${surface}: ${warning}`);
@@ -1300,6 +1484,7 @@ async function captureListing(targetArg, options = {}) {
                             fps: finalFps,
                         },
                         posterPath: surfaceOutputPaths.posterPath,
+                        validation,
                         warnings,
                     });
                     if (!parsedOptions.keepRaw) {
@@ -1314,6 +1499,7 @@ async function captureListing(targetArg, options = {}) {
                     }
                 }
                 finally {
+                    await Promise.all(Object.values(validationPaths).map((filePath) => (0, promises_1.rm)(filePath, { force: true })));
                     await browserHandle.close();
                     browserHandle = null;
                 }
@@ -1326,6 +1512,7 @@ async function captureListing(targetArg, options = {}) {
                 binding: {
                     artifactHashes,
                     capturedSurfaces,
+                    pixelValidation: 'passed',
                     runtimeBundleHash,
                 },
             };

package/dist/commands/check.d.ts

@@ -1,9 +1,19 @@
+import { type AppSurface } from '@playdrop/types';
 type ProjectCheckOptions = {
     app?: string;
     timeout?: string | number;
     screenshot?: string;
-    actions?: string;
     tape?: string;
 };
+export declare function formatPlaytestCheckSuccess(input: {
+    creatorUsername: string;
+    appName: string;
+    surface: AppSurface;
+    actionCount: number;
+    meanDelta: number;
+    changedPixelRatio: number;
+    idleCapture: string;
+    tapeCapture: string;
+}): string;
 export declare function check(targetArg: string | undefined, options?: ProjectCheckOptions): Promise<void>;
 export {};

package/dist/commands/check.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPlaytestCheckSuccess = formatPlaytestCheckSuccess;
 exports.check = check;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -42,14 +43,6 @@ function parseProjectCheckTimeoutMs(value) {
     }
     return Math.round(numeric * 1000);
 }
-function readProjectCheckActions(actionsPath) {
-    const normalizedPath = actionsPath?.trim() ?? '';
-    if (!normalizedPath) {
-        return [];
-    }
-    const raw = (0, node_fs_1.readFileSync)(normalizedPath, 'utf8');
-    return (0, loadCheck_1.normalizeProjectCheckActions)(JSON.parse(raw));
-}
 function defaultProjectCheckScreenshotPath(appName) {
     return (0, node_path_1.join)('assets', 'marketing', 'playdrop', 'check', `${appName}.png`);
 }
@@ -60,15 +53,18 @@ function buildComparisonScreenshotPath(basePath, run) {
     }
     return `${basePath.slice(0, -extension.length)}-${run}${extension}`;
 }
+function formatPlaytestCheckSuccess(input) {
+    return `[check] Passed ${input.creatorUsername}/${input.appName} on ${input.surface}: input delivery ${input.actionCount}/${input.actionCount}, `
+        + `visible change mean=${input.meanDelta.toFixed(4)} changedPixels=${(input.changedPixelRatio * 100).toFixed(1)}%. `
+        + `Gameplay success was not assessed. Evidence: idle=${input.idleCapture}; tape=${input.tapeCapture}`;
+}
 async function check(targetArg, options = {}) {
     let timeoutMs;
-    let actions;
     try {
         timeoutMs = parseProjectCheckTimeoutMs(options.timeout);
-        actions = readProjectCheckActions(options.actions);
     }
     catch (error) {
-        (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid project check options.', ['Use --actions with a JSON array of click, press, and wait actions.'], { command: 'project check' });
+        (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid project check options.', ['Use --tape with DESKTOP, MOBILE_LANDSCAPE, or MOBILE_PORTRAIT.'], { command: 'project check' });
         process.exitCode = 1;
         return;
     }
@@ -96,11 +92,6 @@ async function check(targetArg, options = {}) {
     let tapeSurface = null;
     let playtestTape = null;
     if (options.tape) {
-        if (actions.length > 0) {
-            (0, messages_1.printErrorWithHelp)('--tape and --actions cannot be used together.', ['Use the catalogue playtest tape by itself so the timed sequence remains deterministic.'], { command: 'project check' });
-            process.exitCode = 1;
-            return;
-        }
         tapeSurface = (0, types_1.parseAppSurface)(options.tape);
         if (!tapeSurface) {
             (0, messages_1.printErrorWithHelp)(`Invalid tape surface "${options.tape}".`, ['Use DESKTOP, MOBILE_LANDSCAPE, or MOBILE_PORTRAIT.'], { command: 'project check' });
@@ -192,18 +183,6 @@ async function check(targetArg, options = {}) {
             process.exitCode = 1;
             return;
         }
-        const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
-        const devScriptAvailable = Boolean(projectInfo.projectDir
-            && projectInfo.packageJson
-            && typeof projectInfo.packageJson.scripts?.dev === 'string');
-        const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
-        console.log(`[check] Preparing ${entryLabel}.`);
-        if (projectInfo.projectDir && !devScriptAvailable && projectInfo.packageJsonPath) {
-            const projectLabel = (0, devShared_1.formatProjectLabel)(projectInfo);
-            if (projectLabel) {
-                console.log(`[check] package.json detected at ${projectLabel}, but no "dev" script was found. Run your app build manually if needed.`);
-            }
-        }
         const runCheck = async (input) => await (0, loadCheck_1.runLocalHostedLoadCheck)({
             client,
             apiBase: envConfig.apiBase,
@@ -215,7 +194,6 @@ async function check(targetArg, options = {}) {
             currentUser: null,
             captureSession,
             screenshotPath: input.screenshotPath,
-            actions,
             surface: input.surface,
             playtestTape: input.tape,
             postReadyWaitMs: input.postReadyWaitMs,
@@ -223,7 +201,6 @@ async function check(targetArg, options = {}) {
         if (tapeSurface && playtestTape) {
             const idleScreenshotPath = buildComparisonScreenshotPath(screenshotPath, 'idle');
             const tapeScreenshotPath = buildComparisonScreenshotPath(screenshotPath, 'tape');
-            console.log(`[check] Running ${playtestTape.durationMs} ms zero-input baseline on ${tapeSurface}.`);
             const idleResult = await runCheck({
                 screenshotPath: idleScreenshotPath,
                 surface: tapeSurface,
@@ -234,7 +211,6 @@ async function check(targetArg, options = {}) {
                 process.exitCode = 1;
                 return;
             }
-            console.log(`[check] Reopening a clean run and executing the ${tapeSurface} tape.`);
             const tapeResult = await runCheck({
                 screenshotPath: tapeScreenshotPath,
                 surface: tapeSurface,
@@ -258,10 +234,16 @@ async function check(targetArg, options = {}) {
                 process.exitCode = 1;
                 return;
             }
-            console.log(`[check] Playtest smoke check passed for ${currentUsername}/${appName}.`);
-            console.log(`[check] ${playtestTape.events.length} tape actions completed without a crash and produced a visible response.`);
-            console.log(`[check] Idle: ${idleCapture}`);
-            console.log(`[check] Tape: ${tapeCapture}`);
+            console.log(formatPlaytestCheckSuccess({
+                creatorUsername: currentUsername,
+                appName,
+                surface: tapeSurface,
+                actionCount: playtestTape.events.length,
+                meanDelta: comparison.meanDelta,
+                changedPixelRatio: comparison.changedPixelRatio,
+                idleCapture,
+                tapeCapture,
+            }));
             return;
         }
         const result = await runCheck({ screenshotPath });
@@ -270,9 +252,7 @@ async function check(targetArg, options = {}) {
             process.exitCode = 1;
             return;
         }
-        console.log(`[check] Passed ${currentUsername}/${appName}.`);
-        if (result.webglRenderer) {
-            console.log(`[check] Hardware renderer: ${result.webglRenderer}`);
-        }
+        const checkedSurface = (0, loadCheck_1.resolveLoadCheckSurface)(taskLookup.task.surfaceTargets, taskLookup.task.primarySurface);
+        console.log(`[check] Passed ${currentUsername}/${appName} on ${checkedSurface}: launch ready${result.webglRenderer ? ` with hardware renderer ${result.webglRenderer}` : ''}. Gameplay success was not assessed. Screenshot=${result.screenshotPath ?? screenshotPath}`);
     }, { workspacePath });
 }

package/dist/commands/detail.js

@@ -72,9 +72,34 @@ function decorateAsset(apiBase, ref, asset) {
         },
     };
 }
-function decorateAssetPack(apiBase, ref, pack) {
+function decorateAssetPackMember(asset) {
+    const revisionLabel = asset.currentVersion?.revisionLabel?.trim();
+    if (!revisionLabel) {
+        throw new Error(`asset_pack_member_current_revision_missing:${asset.creatorUsername}/${asset.name}`);
+    }
+    const files = asset.currentVersion?.fileManifest?.files;
+    return {
+        assetRef: `asset:${asset.creatorUsername}/${asset.name}@${revisionLabel}`,
+        name: asset.name,
+        displayName: asset.displayName,
+        category: asset.category,
+        subcategory: asset.currentVersion?.subcategory ?? null,
+        format: asset.currentVersion?.format ?? null,
+        files: Array.isArray(files)
+            ? files
+                .filter((file) => typeof file?.role === 'string' && typeof file?.key === 'string')
+                .map((file) => ({
+                role: file.role,
+                key: file.key,
+                contentType: typeof file.contentType === 'string' ? file.contentType : null,
+            }))
+            : [],
+    };
+}
+function decorateAssetPack(apiBase, ref, pack, assets) {
     return {
         ...pack,
+        members: assets.map(decorateAssetPackMember),
         urls: {
             download: pack.currentVersion?.version ? buildAssetPackDownloadUrl(apiBase, ref, pack.currentVersion.version) : null,
             source: pack.currentVersion?.version ? buildAssetPackSourceUrl(apiBase, ref, pack.currentVersion.version) : null,
@@ -154,6 +179,14 @@ function printAssetPackText(ref, pack) {
     console.log(`Updated: ${(0, output_1.formatTimestamp)(pack.updatedAt)}`);
     console.log(`Current version: ${(0, output_1.formatOptionalValue)(pack.currentVersion?.version)}`);
     console.log(`Tags: ${formatTagSummary(pack.tags)}`);
+    console.log(`Pack members: ${pack.members.length}`);
+    for (const member of pack.members) {
+        const classification = [member.category, member.subcategory, member.format].filter(Boolean).join('/');
+        const files = member.files.length > 0
+            ? member.files.map((file) => `${file.role}:${file.contentType ?? file.key}`).join(', ')
+            : 'none';
+        console.log(`- assetRef=${member.assetRef} | ${member.displayName} | ${classification} | files=${files}`);
+    }
     console.log(`Download URL: ${(0, output_1.formatOptionalValue)(pack.urls.download)}`);
     console.log(`Source URL: ${(0, output_1.formatOptionalValue)(pack.urls.source)}`);
     console.log('\nNext: run "playdrop versions browse ' + ref + '" to inspect other versions.');
@@ -205,7 +238,7 @@ async function detail(rawRef, options = {}) {
             }
             if (ref.kind === 'asset-pack') {
                 const response = await client.fetchAssetPackBySlug(ref.creator, ref.name);
-                const item = decorateAssetPack(envConfig.apiBase, ref, response.pack);
+                const item = decorateAssetPack(envConfig.apiBase, ref, response.pack, response.assets);
                 if (options.json) {
                     (0, output_1.printJson)({ kind: ref.kind, ref: ref.ref, item });
                     return;

package/dist/commands/review.d.ts

@@ -1,4 +1,13 @@
-export declare const REVIEW_CRITERIA: readonly ["Gameplay / Core Loop", "Depth / Replayability", "Controls / Input", "UX / Usability", "First Time User Experience", "Visuals / Art Direction", "Audio / Feedback", "Store Listing & Metadata Accuracy", "Safety / Age Rating / Compliance", "Performance / Stability"];
+export declare const REVIEW_CRITERIA: readonly ["Gameplay / Core Loop", "Depth / Replayability", "Controls / Input", "UX / Usability", "First Time User Experience", "Visuals / Art Direction", "Store Listing & Metadata Accuracy", "Safety / Age Rating / Compliance", "Performance / Stability"];
+declare const STATE_OUTCOME: {
+    readonly EXCELLENT: "Excellent";
+    readonly FAILED: "Blocked";
+    readonly GOOD: "Good";
+    readonly LOW_QUALITY: "Limited";
+    readonly PASSED: "Passed";
+};
+export type TerminalReviewState = keyof typeof STATE_OUTCOME;
+export declare function normalizeTerminalReviewState(value: string | undefined): TerminalReviewState;
 export declare const REQUIRED_REVIEW_EVIDENCE_FILES: string[];
 export type ValidateGameReviewResultInput = {
     creatorFeedback?: string;
@@ -44,3 +53,4 @@ export declare function createReviewRatingCard(options: ReviewRatingCardOptions)
     width: number;
     height: number;
 }>;
+export {};

package/dist/commands/review.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REQUIRED_REVIEW_EVIDENCE_FILES = exports.REVIEW_CRITERIA = void 0;
+exports.normalizeTerminalReviewState = normalizeTerminalReviewState;
 exports.validateGameReviewResult = validateGameReviewResult;
 exports.validateReviewResultCommand = validateReviewResultCommand;
 exports.composeReviewEvidence = composeReviewEvidence;
@@ -19,18 +20,10 @@ exports.REVIEW_CRITERIA = [
     'UX / Usability',
     'First Time User Experience',
     'Visuals / Art Direction',
-    'Audio / Feedback',
     'Store Listing & Metadata Accuracy',
     'Safety / Age Rating / Compliance',
     'Performance / Stability',
 ];
-const TERMINAL_REVIEW_STATES = new Set([
-    'FAILED',
-    'LOW_QUALITY',
-    'PASSED',
-    'GOOD',
-    'EXCELLENT',
-]);
 const STATE_OUTCOME = {
     EXCELLENT: 'Excellent',
     FAILED: 'Blocked',
@@ -38,6 +31,23 @@ const STATE_OUTCOME = {
     LOW_QUALITY: 'Limited',
     PASSED: 'Passed',
 };
+const REVIEW_STATE_ALIASES = {
+    BLOCKED: 'FAILED',
+    EXCELLENT: 'EXCELLENT',
+    FAILED: 'FAILED',
+    GOOD: 'GOOD',
+    LIMITED: 'LOW_QUALITY',
+    LOW_QUALITY: 'LOW_QUALITY',
+    PASSED: 'PASSED',
+};
+function normalizeTerminalReviewState(value) {
+    const input = typeof value === 'string' ? value.trim() : '';
+    const state = REVIEW_STATE_ALIASES[input.toUpperCase()];
+    if (!state) {
+        throw new Error(`invalid_review_state:${input || 'missing'}:expected=Blocked|Limited|Passed|Good|Excellent`);
+    }
+    return state;
+}
 exports.REQUIRED_REVIEW_EVIDENCE_FILES = [
     'first-frame.png',
     'core.png',
@@ -135,7 +145,7 @@ function validateRequiredEvidenceLines(reviewMessage) {
         throw new Error('challenge_evidence_too_vague');
     }
     if (punchline.length < 8 || punchline.length > 160) {
-        throw new Error('punchline_assessment_invalid_length');
+        throw new Error(`punchline_assessment_invalid_length: Punchline assessment length=${punchline.length}; expected 8..160 characters.`);
     }
     if (benchmark.length < 8) {
         throw new Error('comparable_benchmark_too_vague');
@@ -169,10 +179,7 @@ async function assertPngFile(filePath) {
     }
 }
 async function validateGameReviewResult(input) {
-    const normalizedState = String(input.reviewState || '').trim().toUpperCase();
-    if (!TERMINAL_REVIEW_STATES.has(normalizedState)) {
-        return { skipped: true, reason: 'non_terminal_state' };
-    }
+    const normalizedState = normalizeTerminalReviewState(input.reviewState);
     if (!input.reviewMessage.trim()) {
         throw new Error('missing_review_message');
     }

package/dist/commands/upload.d.ts

@@ -21,8 +21,6 @@ export type WorkerAppPublishInput = {
     expectedSubtitle?: string | null;
     expectedPrimarySurface?: AppSurface | null;
     remixSourceRef?: string | null;
-    playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
-    creatorRequest?: string | null;
     projectDir: string;
     creatorUsername: string;
     apiBase: string;
@@ -62,16 +60,12 @@ export type StaticHtmlPublishResult = WorkerAppPublishResult & {
     runtimeContainsInjectedSdk: true;
     hostedLoadCheckPassed: true;
 };
-export type WorkerPlaydropAssetRequirement = 'PACK' | 'ASSET_OR_PACK';
-export declare function resolveWorkerPlaydropAssetRequirement(value: unknown): WorkerPlaydropAssetRequirement | null;
+export declare function assertAgentPrimarySurfaceContract(task: AppTask, kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE'): void;
 export declare function assertAgentNewGamePlaytestContract(task: AppTask): void;
 export declare function assertWorkerAppLocalUploadPreflight(input: {
     task: AppTask;
     kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
     executionTarget?: AgentExecutionTarget;
-    creatorUsername?: string | null;
-    playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
-    creatorRequest?: string | null;
     stage?: 'PRE_CAPTURE' | 'COMPLETE';
     expectedRuntimeBundleHash?: string;
 }): Promise<void>;