@playdrop/playdrop-cli 0.16.5 → 0.16.11

package/dist/commands/captureListing.js

@@ -95,7 +95,7 @@ const MAX_FPS = 120;
 const MIN_SUPPORTED_MACOS_MAJOR = 26;
 const MIN_SUPPORTED_MACOS_MINOR = 4;
 const LISTING_CAPTURE_HOOK_TIMEOUT_MS = 60000;
-const LISTING_CAPTURE_MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1';
+const LISTING_CAPTURE_MOBILE_USER_AGENT = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1";
 const SURFACE_CAPTURE_DIMENSIONS = {
     DESKTOP: { width: 1280, height: 720 },
     MOBILE_LANDSCAPE: { width: 844, height: 390 },
@@ -107,15 +107,15 @@ 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',
-    MOBILE_PORTRAIT: 'mobile-portrait',
+    DESKTOP: "desktop",
+    MOBILE_LANDSCAPE: "mobile-landscape",
+    MOBILE_PORTRAIT: "mobile-portrait",
 };
 function resolveListingCaptureRouteSegment(previewable) {
     if (!previewable) {
-        throw new Error('listing_preview_support_missing');
+        throw new Error("listing_preview_support_missing");
     }
-    return 'dev-preview';
+    return "dev-preview";
 }
 function resolveCaptureListingDevRouterPort(env = process.env) {
     return (0, dev_1.resolveCliDevRouterPort)(env);
@@ -125,23 +125,23 @@ function resolveListingCaptureLocalDevPort(devRouterPort) {
 }
 function buildListingCaptureFrameUrl({ webBase, currentUsername, appTypeSlug, appName, routeSegment, localDevPort, captureSession, }) {
     const frameUrlObject = new URL(`${(0, appUrls_1.normalizePlaydropWebBase)(webBase)}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/${routeSegment}`);
-    frameUrlObject.searchParams.set('launchCheck', '1');
-    frameUrlObject.searchParams.set('captureShell', 'listing');
-    frameUrlObject.searchParams.set('mobileFrameHost', 'admin');
+    frameUrlObject.searchParams.set("launchCheck", "1");
+    frameUrlObject.searchParams.set("captureShell", "listing");
+    frameUrlObject.searchParams.set("mobileFrameHost", "admin");
     if (localDevPort !== null) {
-        frameUrlObject.searchParams.set('localDevPort', String(localDevPort));
+        frameUrlObject.searchParams.set("localDevPort", String(localDevPort));
     }
     (0, appUrls_1.appendTaskCaptureSession)(frameUrlObject, captureSession);
     return frameUrlObject.toString();
 }
 function resolveListingCaptureSceneId(width, height) {
-    return height > width ? 'listing-portrait' : 'listing-landscape';
+    return height > width ? "listing-portrait" : "listing-landscape";
 }
 function parsePositiveNumber(raw, fallback, fieldName, { minimum = 0, maximum = Number.POSITIVE_INFINITY, integer = false, } = {}) {
     if (raw === undefined) {
         return fallback;
     }
-    const parsed = typeof raw === 'number' ? raw : Number.parseFloat(String(raw));
+    const parsed = typeof raw === "number" ? raw : Number.parseFloat(String(raw));
     if (!Number.isFinite(parsed)) {
         throw new Error(`${fieldName}_invalid`);
     }
@@ -154,27 +154,27 @@ function parsePositiveNumber(raw, fallback, fieldName, { minimum = 0, maximum =
     return parsed;
 }
 function parseCaptureListingOptions(targetArg, options = {}) {
-    const durationSeconds = parsePositiveNumber(options.duration, DEFAULT_DURATION_SECONDS, 'duration', {
+    const durationSeconds = parsePositiveNumber(options.duration, DEFAULT_DURATION_SECONDS, "duration", {
         minimum: MIN_CAPTURE_SECONDS,
         maximum: MAX_CAPTURE_SECONDS,
     });
     const explicitDimensions = options.width !== undefined || options.height !== undefined;
-    const width = parsePositiveNumber(options.width, DEFAULT_WIDTH, 'width', {
+    const width = parsePositiveNumber(options.width, DEFAULT_WIDTH, "width", {
         minimum: MIN_DIMENSION,
         maximum: MAX_DIMENSION,
         integer: true,
     });
-    const height = parsePositiveNumber(options.height, DEFAULT_HEIGHT, 'height', {
+    const height = parsePositiveNumber(options.height, DEFAULT_HEIGHT, "height", {
         minimum: MIN_DIMENSION,
         maximum: MAX_DIMENSION,
         integer: true,
     });
-    const fps = parsePositiveNumber(options.fps, DEFAULT_FPS, 'fps', {
+    const fps = parsePositiveNumber(options.fps, DEFAULT_FPS, "fps", {
         minimum: 1,
         maximum: MAX_FPS,
         integer: true,
     });
-    const posterAtSeconds = parsePositiveNumber(options.posterAt, DEFAULT_POSTER_AT_SECONDS, 'poster_at', {
+    const posterAtSeconds = parsePositiveNumber(options.posterAt, DEFAULT_POSTER_AT_SECONDS, "poster_at", {
         minimum: 0,
         maximum: durationSeconds,
     });
@@ -198,36 +198,34 @@ function parseCaptureListingOptions(targetArg, options = {}) {
 function resolveCaptureListingExplicitOutputDir(outputDirInput, cwdResolvedOutputDir, projectDir) {
     if (!outputDirInput || !cwdResolvedOutputDir)
         return null;
-    return (0, node_path_1.isAbsolute)(outputDirInput)
-        ? cwdResolvedOutputDir
-        : (0, node_path_1.resolve)(projectDir, outputDirInput);
+    return (0, node_path_1.isAbsolute)(outputDirInput) ? cwdResolvedOutputDir : (0, node_path_1.resolve)(projectDir, outputDirInput);
 }
 function readMacOsVersion() {
-    const result = (0, node_child_process_1.spawnSync)('sw_vers', ['-productVersion'], {
-        encoding: 'utf8',
+    const result = (0, node_child_process_1.spawnSync)("sw_vers", ["-productVersion"], {
+        encoding: "utf8",
     });
     if (result.status !== 0) {
-        throw new Error('macos_version_probe_failed');
+        throw new Error("macos_version_probe_failed");
     }
     return result.stdout.trim();
 }
-function assertSupportedListingEnvironment(platform = process.platform, macosVersion = platform === 'darwin' ? readMacOsVersion() : '') {
-    if (platform !== 'darwin') {
-        throw new Error('unsupported_platform');
-    }
-    const [majorRaw, minorRaw] = macosVersion.split('.');
-    const major = Number.parseInt(majorRaw ?? '', 10);
-    const minor = Number.parseInt(minorRaw ?? '', 10);
-    if (!Number.isInteger(major)
-        || !Number.isInteger(minor)
-        || major !== MIN_SUPPORTED_MACOS_MAJOR
-        || minor < MIN_SUPPORTED_MACOS_MINOR) {
+function assertSupportedListingEnvironment(platform = process.platform, macosVersion = platform === "darwin" ? readMacOsVersion() : "") {
+    if (platform !== "darwin") {
+        throw new Error("unsupported_platform");
+    }
+    const [majorRaw, minorRaw] = macosVersion.split(".");
+    const major = Number.parseInt(majorRaw ?? "", 10);
+    const minor = Number.parseInt(minorRaw ?? "", 10);
+    if (!Number.isInteger(major) ||
+        !Number.isInteger(minor) ||
+        major !== MIN_SUPPORTED_MACOS_MAJOR ||
+        minor < MIN_SUPPORTED_MACOS_MINOR) {
         throw new Error(`unsupported_macos_version:${macosVersion}`);
     }
 }
 function commandExists(command) {
-    const result = (0, node_child_process_1.spawnSync)('which', [command], {
-        encoding: 'utf8',
+    const result = (0, node_child_process_1.spawnSync)("which", [command], {
+        encoding: "utf8",
     });
     return result.status === 0 && result.stdout.trim().length > 0;
 }
@@ -239,20 +237,20 @@ function resolveListingRecorderPath(workerHome) {
 }
 function buildTimestampFolder(date = new Date()) {
     const iso = date.toISOString();
-    return iso.replace(/[:]/g, '-').replace(/\.\d{3}Z$/, 'Z');
+    return iso.replace(/[:]/g, "-").replace(/\.\d{3}Z$/, "Z");
 }
 async function ensureOutputPaths(appName, explicitOutputDir) {
     const outputDir = explicitOutputDir
         ? explicitOutputDir
-        : (0, node_path_1.resolve)(process.cwd(), 'output', 'listing-capture', appName, buildTimestampFolder());
+        : (0, node_path_1.resolve)(process.cwd(), "output", "listing-capture", appName, buildTimestampFolder());
     await (0, promises_1.mkdir)(outputDir, { recursive: true });
     return {
         outputDir,
-        reportPath: (0, node_path_1.join)(outputDir, 'capture-report.json'),
+        reportPath: (0, node_path_1.join)(outputDir, "capture-report.json"),
     };
 }
 function buildSurfaceOutputPaths(outputDir, surface, useSurfacePrefix) {
-    const prefix = useSurfacePrefix ? `${SURFACE_OUTPUT_SLUG[surface]}-` : '';
+    const prefix = useSurfacePrefix ? `${SURFACE_OUTPUT_SLUG[surface]}-` : "";
     return {
         rawVideoPath: (0, node_path_1.join)(outputDir, `${prefix}listing-raw.mp4`),
         metadataPath: (0, node_path_1.join)(outputDir, `${prefix}listing-raw.json`),
@@ -261,9 +259,7 @@ function buildSurfaceOutputPaths(outputDir, surface, useSurfacePrefix) {
     };
 }
 function resolveWorkerCaptureOutputDir(projectDir, isWorkerGameTask) {
-    return isWorkerGameTask
-        ? (0, node_path_1.join)(projectDir, 'assets', 'marketing', 'playdrop', 'capture')
-        : null;
+    return isWorkerGameTask ? (0, node_path_1.join)(projectDir, "assets", "marketing", "playdrop", "capture") : null;
 }
 function resolveCaptureDimensions(surface, parsedOptions) {
     if (parsedOptions.explicitDimensions) {
@@ -275,7 +271,7 @@ function resolveCaptureDimensions(surface, parsedOptions) {
     return SURFACE_CAPTURE_DIMENSIONS[surface];
 }
 function resolveListingCaptureBrowserContextOptions(surface, dimensions) {
-    if (surface === 'DESKTOP') {
+    if (surface === "DESKTOP") {
         return { viewport: null };
     }
     return {
@@ -291,26 +287,26 @@ function resolveListingCaptureBrowserContextOptions(surface, dimensions) {
 }
 async function grantListingBrowserLocalNetworkAccess(context, origin) {
     const grantPermissions = context.grantPermissions;
-    if (typeof grantPermissions !== 'function') {
+    if (typeof grantPermissions !== "function") {
         return;
     }
-    await grantPermissions.call(context, ['local-network-access'], { origin });
+    await grantPermissions.call(context, ["local-network-access"], { origin });
 }
 async function launchListingBrowser(initialViewport, automationOrigin, contextOptions) {
-    const playwright = await Promise.resolve().then(() => __importStar(require('playwright-core')));
+    const playwright = await Promise.resolve().then(() => __importStar(require("playwright-core")));
     const args = [
-        '--no-sandbox',
-        '--disable-web-security',
-        '--app=about:blank',
+        "--no-sandbox",
+        "--disable-web-security",
+        "--app=about:blank",
         `--window-size=${initialViewport.width},${initialViewport.height}`,
-        '--autoplay-policy=no-user-gesture-required',
-        '--disable-extensions',
-        '--disable-background-networking',
-        '--disable-component-update',
-        '--disable-sync',
-        '--metrics-recording-only',
-        '--no-first-run',
-        '--no-default-browser-check',
+        "--autoplay-policy=no-user-gesture-required",
+        "--disable-extensions",
+        "--disable-background-networking",
+        "--disable-component-update",
+        "--disable-sync",
+        "--metrics-recording-only",
+        "--no-first-run",
+        "--no-default-browser-check",
     ];
     try {
         const server = await playwright.chromium.launchServer({
@@ -320,7 +316,7 @@ async function launchListingBrowser(initialViewport, automationOrigin, contextOp
         const processId = server.process()?.pid ?? 0;
         if (processId <= 0) {
             await server.close();
-            throw new Error('browser_process_missing');
+            throw new Error("browser_process_missing");
         }
         const browser = await playwright.chromium.connect(server.wsEndpoint());
         const context = await browser.newContext(contextOptions);
@@ -355,23 +351,23 @@ async function launchListingBrowser(initialViewport, automationOrigin, contextOp
         };
     }
     catch (error) {
-        throw (0, playwright_1.createPlaywrightLaunchError)('playdrop', error);
+        throw (0, playwright_1.createPlaywrightLaunchError)("playdrop", error);
     }
 }
 async function waitForHostedGameMeasurement(page, timeoutMs) {
     const startedAt = Date.now();
-    let lastSignature = '';
+    let lastSignature = "";
     let stableHits = 0;
     while (Date.now() - startedAt < timeoutMs) {
         try {
             const measurement = await page.evaluate((selector) => {
                 const frame = document.querySelector(selector);
                 if (!(frame instanceof HTMLIFrameElement)) {
-                    throw new Error('hosted_game_frame_missing');
+                    throw new Error("hosted_game_frame_missing");
                 }
                 const rect = frame.getBoundingClientRect();
                 if (rect.width <= 0 || rect.height <= 0) {
-                    throw new Error('hosted_game_frame_hidden');
+                    throw new Error("hosted_game_frame_hidden");
                 }
                 return {
                     outerWidth: window.outerWidth,
@@ -413,17 +409,19 @@ async function waitForHostedGameMeasurement(page, timeoutMs) {
             }
         }
         catch (error) {
-            if (error instanceof Error && error.message !== 'hosted_game_frame_missing' && error.message !== 'hosted_game_frame_hidden') {
+            if (error instanceof Error &&
+                error.message !== "hosted_game_frame_missing" &&
+                error.message !== "hosted_game_frame_hidden") {
                 throw error;
             }
         }
         await page.waitForTimeout(250);
     }
-    throw new Error('hosted_game_measurement_timeout');
+    throw new Error("hosted_game_measurement_timeout");
 }
 async function waitForHostedGameFrame(page, timeoutMs) {
     const frameHandle = await page.waitForSelector(CAPTURE_FRAME_SELECTOR, {
-        state: 'attached',
+        state: "attached",
         timeout: timeoutMs,
     });
     const startedAt = Date.now();
@@ -434,19 +432,19 @@ async function waitForHostedGameFrame(page, timeoutMs) {
         }
         await page.waitForTimeout(200);
     }
-    throw new Error('hosted_game_frame_missing');
+    throw new Error("hosted_game_frame_missing");
 }
 async function prepareHostedListingScene(page, sceneId) {
     const frame = await waitForHostedGameFrame(page, LISTING_CAPTURE_HOOK_TIMEOUT_MS);
     await frame.waitForFunction(() => {
         const captureWindow = window;
-        return typeof captureWindow.__listingCapture?.prepare === 'function';
+        return typeof captureWindow.__listingCapture?.prepare === "function";
     }, undefined, { timeout: LISTING_CAPTURE_HOOK_TIMEOUT_MS });
     await frame.evaluate(async (requestedSceneId) => {
         const captureWindow = window;
         const hook = captureWindow.__listingCapture;
-        if (!hook || typeof hook.prepare !== 'function') {
-            throw new Error('listing_capture_hook_missing');
+        if (!hook || typeof hook.prepare !== "function") {
+            throw new Error("listing_capture_hook_missing");
         }
         await hook.prepare(requestedSceneId);
     }, sceneId);
@@ -455,38 +453,34 @@ async function startHostedListingAudioCapture(page) {
     const frame = await waitForHostedGameFrame(page, 20000);
     await frame.waitForFunction(() => {
         const captureWindow = window;
-        return typeof captureWindow.__listingCapture?.startAudioCapture === 'function';
+        return typeof captureWindow.__listingCapture?.startAudioCapture === "function";
     }, undefined, { timeout: 20000 });
     await frame.evaluate(async () => {
         const captureWindow = window;
         const hook = captureWindow.__listingCapture;
-        if (!hook || typeof hook.startAudioCapture !== 'function') {
-            throw new Error('listing_audio_capture_hook_missing');
+        if (!hook || typeof hook.startAudioCapture !== "function") {
+            throw new Error("listing_audio_capture_hook_missing");
         }
         await hook.startAudioCapture();
     });
 }
 function assertExportedListingAudio(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('listing_audio_capture_export_missing');
-    }
-    const mimeType = typeof value.mimeType === 'string'
-        ? value.mimeType.trim()
-        : '';
-    const base64 = typeof value.base64 === 'string'
-        ? value.base64.trim()
-        : '';
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("listing_audio_capture_export_missing");
+    }
+    const mimeType = typeof value.mimeType === "string" ? value.mimeType.trim() : "";
+    const base64 = typeof value.base64 === "string" ? value.base64.trim() : "";
     if (!mimeType || !base64) {
-        throw new Error('listing_audio_capture_export_missing');
+        throw new Error("listing_audio_capture_export_missing");
     }
     return { mimeType, base64 };
 }
 function resolveExportedAudioFileName(mimeType) {
-    if (mimeType.includes('webm')) {
-        return 'listing-audio.webm';
+    if (mimeType.includes("webm")) {
+        return "listing-audio.webm";
     }
-    if (mimeType.includes('mp4') || mimeType.includes('aac') || mimeType.includes('m4a')) {
-        return 'listing-audio.m4a';
+    if (mimeType.includes("mp4") || mimeType.includes("aac") || mimeType.includes("m4a")) {
+        return "listing-audio.m4a";
     }
     throw new Error(`unsupported_listing_audio_mime_type:${mimeType}`);
 }
@@ -495,13 +489,13 @@ async function stopHostedListingAudioCapture(page, outputDir) {
     const exportedAudio = assertExportedListingAudio(await frame.evaluate(async () => {
         const captureWindow = window;
         const hook = captureWindow.__listingCapture;
-        if (!hook || typeof hook.stopAudioCapture !== 'function') {
-            throw new Error('listing_audio_capture_hook_missing');
+        if (!hook || typeof hook.stopAudioCapture !== "function") {
+            throw new Error("listing_audio_capture_hook_missing");
         }
         return hook.stopAudioCapture();
     }));
     const filePath = (0, node_path_1.join)(outputDir, resolveExportedAudioFileName(exportedAudio.mimeType));
-    await (0, promises_1.writeFile)(filePath, Buffer.from(exportedAudio.base64, 'base64'));
+    await (0, promises_1.writeFile)(filePath, Buffer.from(exportedAudio.base64, "base64"));
     return filePath;
 }
 async function assertHostedListingAudioCaptureContract(page, outputDir) {
@@ -513,13 +507,9 @@ async function fitWindowToRequestedGameplay(page, requestedWidth, requestedHeigh
     const cdpSession = await page.context().newCDPSession(page);
     let measurement = await waitForHostedGameMeasurement(page, 15000);
     for (let attempt = 0; attempt < 5; attempt += 1) {
-        const windowState = await cdpSession.send('Browser.getWindowForTarget');
-        const currentWidth = typeof windowState.bounds.width === 'number'
-            ? windowState.bounds.width
-            : Math.round(measurement.outerWidth);
-        const currentHeight = typeof windowState.bounds.height === 'number'
-            ? windowState.bounds.height
-            : Math.round(measurement.outerHeight);
+        const windowState = await cdpSession.send("Browser.getWindowForTarget");
+        const currentWidth = typeof windowState.bounds.width === "number" ? windowState.bounds.width : Math.round(measurement.outerWidth);
+        const currentHeight = typeof windowState.bounds.height === "number" ? windowState.bounds.height : Math.round(measurement.outerHeight);
         const deltaWidth = requestedWidth - Math.round(measurement.iframeRect.width);
         const deltaHeight = requestedHeight - Math.round(measurement.iframeRect.height);
         if (Math.abs(deltaWidth) <= 1 && Math.abs(deltaHeight) <= 1) {
@@ -531,7 +521,7 @@ async function fitWindowToRequestedGameplay(page, requestedWidth, requestedHeigh
         }
         const nextWidth = Math.max(400, currentWidth + deltaWidth);
         const nextHeight = Math.max(300, currentHeight + deltaHeight);
-        await cdpSession.send('Browser.setWindowBounds', {
+        await cdpSession.send("Browser.setWindowBounds", {
             windowId: windowState.windowId,
             bounds: {
                 width: nextWidth,
@@ -541,7 +531,7 @@ async function fitWindowToRequestedGameplay(page, requestedWidth, requestedHeigh
         await page.waitForTimeout(800);
         measurement = await waitForHostedGameMeasurement(page, 8000);
     }
-    throw new Error('hosted_game_resize_failed');
+    throw new Error("hosted_game_resize_failed");
 }
 function assertListingCaptureWindowCanContainViewport(measurement, windowBounds) {
     const requiredWidth = Math.ceil(measurement.innerWidth);
@@ -557,33 +547,33 @@ function roundCropValue(value) {
 }
 function computeRecordedCrop(measurement, recorder, rawWidth, rawHeight) {
     if (measurement.outerWidth <= 0 || measurement.outerHeight <= 0) {
-        throw new Error('invalid_window_geometry');
+        throw new Error("invalid_window_geometry");
     }
     if (measurement.innerWidth <= 0 || measurement.innerHeight <= 0) {
-        throw new Error('invalid_viewport_geometry');
+        throw new Error("invalid_viewport_geometry");
     }
     if (rawWidth <= 0 || rawHeight <= 0) {
-        throw new Error('invalid_raw_dimensions');
+        throw new Error("invalid_raw_dimensions");
     }
     const nativeOuterWidth = recorder.windowFramePoints.width;
     const nativeOuterHeight = recorder.windowFramePoints.height;
     if (nativeOuterWidth <= 0 || nativeOuterHeight <= 0) {
-        throw new Error('invalid_native_window_geometry');
+        throw new Error("invalid_native_window_geometry");
     }
     const horizontalChrome = nativeOuterWidth - measurement.innerWidth;
     const verticalChrome = nativeOuterHeight - measurement.innerHeight;
     if (horizontalChrome < 0 || verticalChrome < 0) {
-        throw new Error('invalid_chrome_geometry');
+        throw new Error("invalid_chrome_geometry");
     }
-    const usesSyntheticMobileWindow = Math.abs(measurement.outerWidth - measurement.innerWidth) <= 1
-        && Math.abs(measurement.outerHeight - measurement.innerHeight) <= 1
-        && (Math.abs(nativeOuterWidth - measurement.outerWidth) > 1
-            || Math.abs(nativeOuterHeight - measurement.outerHeight) > 1);
+    const usesSyntheticMobileWindow = Math.abs(measurement.outerWidth - measurement.innerWidth) <= 1 &&
+        Math.abs(measurement.outerHeight - measurement.innerHeight) <= 1 &&
+        (Math.abs(nativeOuterWidth - measurement.outerWidth) > 1 ||
+            Math.abs(nativeOuterHeight - measurement.outerHeight) > 1);
     const leftChrome = usesSyntheticMobileWindow ? 0 : horizontalChrome / 2;
     const bottomChrome = usesSyntheticMobileWindow ? 0 : leftChrome;
     const topChrome = verticalChrome - bottomChrome;
     if (topChrome < 0) {
-        throw new Error('invalid_vertical_chrome_geometry');
+        throw new Error("invalid_vertical_chrome_geometry");
     }
     const cropLeftCss = leftChrome + measurement.iframeRect.left;
     const cropTopCss = topChrome + measurement.iframeRect.top;
@@ -594,60 +584,50 @@ function computeRecordedCrop(measurement, recorder, rawWidth, rawHeight) {
     const width = roundCropValue(measurement.iframeRect.width * scaleX);
     const height = roundCropValue(measurement.iframeRect.height * scaleY);
     if (x < 0 || y < 0 || width <= 0 || height <= 0) {
-        throw new Error('invalid_crop_geometry');
+        throw new Error("invalid_crop_geometry");
     }
     if (x + width > rawWidth || y + height > rawHeight) {
-        throw new Error('crop_out_of_bounds');
+        throw new Error("crop_out_of_bounds");
     }
     return { x, y, width, height };
 }
 function runTool(command, args, failureCode, deadlineAt) {
     const result = (0, node_child_process_1.spawnSync)(command, args, {
-        encoding: 'utf8',
+        encoding: "utf8",
         maxBuffer: 20 * 1024 * 1024,
         timeout: (0, listingCaptureLease_1.remainingListingCaptureTime)(deadlineAt),
-        killSignal: 'SIGKILL',
+        killSignal: "SIGKILL",
     });
-    if (result.error?.code === 'ETIMEDOUT') {
-        throw new Error('listing_capture_timeout');
+    if (result.error?.code === "ETIMEDOUT") {
+        throw new Error("listing_capture_timeout");
     }
     if (result.status !== 0) {
-        const stderr = result.stderr?.trim() || '';
-        const stdout = result.stdout?.trim() || '';
-        const combined = [stdout, stderr].filter(Boolean).join('\n');
+        const stderr = result.stderr?.trim() || "";
+        const stdout = result.stdout?.trim() || "";
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
         throw new Error(`${failureCode}:${combined}`);
     }
     return {
-        stdout: result.stdout || '',
-        stderr: result.stderr || '',
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
     };
 }
 async function probeMediaFile(filePath, deadlineAt) {
-    const { stdout } = runTool('ffprobe', [
-        '-v',
-        'error',
-        '-show_streams',
-        '-show_format',
-        '-of',
-        'json',
-        filePath,
-    ], 'ffprobe_failed', deadlineAt);
+    const { stdout } = runTool("ffprobe", ["-v", "error", "-show_streams", "-show_format", "-of", "json", filePath], "ffprobe_failed", deadlineAt);
     return JSON.parse(stdout);
 }
 async function computeFileSha256(filePath) {
-    return (0, node_crypto_1.createHash)('sha256').update(await (0, promises_1.readFile)(filePath)).digest('hex');
+    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();
+    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');
+        throw new Error("listing_capture_frame_pixels_missing");
     }
     let total = 0;
     let visiblePixels = 0;
@@ -663,8 +643,8 @@ async function measureListingFrameVisibility(filePath) {
 }
 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) {
+    if (visibility.meanLuma < MIN_LISTING_FRAME_MEAN_LUMA &&
+        visibility.visiblePixelRatio < MIN_LISTING_VISIBLE_PIXEL_RATIO) {
         throw new Error(`listing_capture_black_frame:${surface}:${label}`);
     }
 }
@@ -674,7 +654,7 @@ async function measureListingFrameMotion(firstPath, lastPath) {
         readListingValidationPixels(lastPath),
     ]);
     if (first.length !== last.length || first.length === 0) {
-        throw new Error('listing_capture_frame_shape_mismatch');
+        throw new Error("listing_capture_frame_shape_mismatch");
     }
     let deltaTotal = 0;
     let changedPixels = 0;
@@ -690,39 +670,39 @@ async function measureListingFrameMotion(firstPath, lastPath) {
     };
 }
 function calculateListingFrameSimilarity(referencePath, capturedPath, deadlineAt) {
-    const { stderr } = runTool('ffmpeg', [
-        '-hide_banner',
-        '-i',
+    const { stderr } = runTool("ffmpeg", [
+        "-hide_banner",
+        "-i",
         referencePath,
-        '-i',
+        "-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);
+        "-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');
+        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 (!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) {
+    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) {
+    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) {
+    if (metrics.motionMeanDelta < MIN_LISTING_MOTION_MEAN_DELTA &&
+        metrics.motionChangedPixelRatio < MIN_LISTING_MOTION_CHANGED_PIXEL_RATIO) {
         throw new Error(`listing_capture_stale_video:${surface}`);
     }
 }
@@ -742,25 +722,16 @@ async function validateListingCapturePixels(input) {
         motionChangedPixelRatio: motion.changedPixelRatio,
     };
     assertListingCapturePixelMetrics(input.surface, metrics);
-    return { status: 'passed', ...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);
+    runTool("ffmpeg", ["-y", "-ss", String(atSeconds), "-i", videoPath, "-frames:v", "1", outputPath], "ffmpeg_failed", deadlineAt);
 }
 function parseFrameRate(raw) {
     if (!raw) {
         return null;
     }
-    const parts = raw.split('/');
+    const parts = raw.split("/");
     if (parts.length !== 2) {
         const parsed = Number.parseFloat(raw);
         return Number.isFinite(parsed) ? parsed : null;
@@ -773,144 +744,152 @@ function parseFrameRate(raw) {
     return numerator / denominator;
 }
 function extractVideoStream(probe) {
-    const videoStream = probe.streams?.find(stream => stream.codec_type === 'video');
-    if (!videoStream || typeof videoStream.width !== 'number' || typeof videoStream.height !== 'number') {
-        throw new Error('video_stream_missing');
+    const videoStream = probe.streams?.find((stream) => stream.codec_type === "video");
+    if (!videoStream || typeof videoStream.width !== "number" || typeof videoStream.height !== "number") {
+        throw new Error("video_stream_missing");
     }
     return videoStream;
 }
 function countAudioStreams(probe) {
-    return probe.streams?.filter(stream => stream.codec_type === 'audio').length ?? 0;
+    return probe.streams?.filter((stream) => stream.codec_type === "audio").length ?? 0;
 }
 function readDurationSeconds(probe) {
     const raw = probe.format?.duration;
     const parsed = raw ? Number.parseFloat(raw) : Number.NaN;
     if (!Number.isFinite(parsed)) {
-        throw new Error('duration_missing');
+        throw new Error("duration_missing");
     }
     return parsed;
 }
 async function runListingRecorder(recorderPath, pid, durationSeconds, rawOutputPath, metadataPath, audio, deadlineAt) {
     const args = [
-        '--pid',
+        "--pid",
         String(pid),
-        '--duration',
+        "--duration",
         String(durationSeconds),
-        '--output',
+        "--output",
         rawOutputPath,
-        '--metadata',
+        "--metadata",
         metadataPath,
     ];
     if (audio) {
-        args.push('--audio');
+        args.push("--audio");
     }
     const result = (0, node_child_process_1.spawnSync)(recorderPath, args, {
-        encoding: 'utf8',
+        encoding: "utf8",
         maxBuffer: 10 * 1024 * 1024,
         timeout: (0, listingCaptureLease_1.remainingListingCaptureTime)(deadlineAt),
-        killSignal: 'SIGKILL',
+        killSignal: "SIGKILL",
     });
-    if (result.error?.code === 'ETIMEDOUT') {
-        throw new Error('listing_capture_timeout');
+    if (result.error?.code === "ETIMEDOUT") {
+        throw new Error("listing_capture_timeout");
     }
     if (result.status !== 0) {
-        const message = result.stderr?.trim() || result.stdout?.trim() || 'Native recorder failed.';
+        const message = result.stderr?.trim() || result.stdout?.trim() || "Native recorder failed.";
         throw new Error(`listing_recorder_failed:${message}`);
     }
-    const metadata = JSON.parse(await (0, promises_1.readFile)(metadataPath, 'utf8'));
+    const metadata = JSON.parse(await (0, promises_1.readFile)(metadataPath, "utf8"));
     return metadata;
 }
 function formatCommandError(error) {
-    if (error.message === 'unsupported_platform') {
+    if (error.message === "unsupported_platform") {
         return {
-            message: 'Game media capture only runs on macOS.',
+            message: "Game media capture only runs on macOS.",
             suggestions: [],
         };
     }
-    if (error.message.startsWith('unsupported_macos_version:')) {
-        const version = error.message.split(':')[1] || 'unknown';
+    if (error.message.startsWith("unsupported_macos_version:")) {
+        const version = error.message.split(":")[1] || "unknown";
         return {
             message: `Game media capture requires macOS ${MIN_SUPPORTED_MACOS_MAJOR}.${MIN_SUPPORTED_MACOS_MINOR} or newer on this machine. Current version: ${version}.`,
             suggestions: [],
         };
     }
-    if (error.message === 'macos_version_probe_failed') {
+    if (error.message === "macos_version_probe_failed") {
         return {
-            message: 'Could not determine the local macOS version.',
+            message: "Could not determine the local macOS version.",
             suggestions: [],
         };
     }
-    if (error.message === 'listing_capture_timeout' || error.message.startsWith('listing_capture_lease_timeout:')) {
+    if (error.message === "listing_capture_timeout" || error.message.startsWith("listing_capture_lease_timeout:")) {
         return {
-            message: 'Listing capture did not finish within 30 minutes.',
+            message: "Listing capture did not finish within 30 minutes.",
             suggestions: [],
         };
     }
-    if (error.message === 'listing_preview_support_missing') {
+    if (error.message === "listing_preview_support_missing") {
         return {
-            message: 'This game does not declare preview support, so listing capture cannot run.',
-            suggestions: ['Set previewable: true in catalogue.json, implement the preview scene and __listingCapture hooks, then rerun "playdrop project capture".'],
+            message: "This game does not declare preview support, so listing capture cannot run.",
+            suggestions: [
+                'Set previewable: true in catalogue.json, implement the preview scene and __listingCapture hooks, then rerun "playdrop project capture".',
+            ],
         };
     }
-    if (error.message === 'listing_audio_capture_export_missing') {
+    if (error.message === "listing_audio_capture_export_missing") {
         return {
-            message: 'The game preview audio hook did not export recorded audio.',
-            suggestions: ['Make window.__listingCapture.stopAudioCapture() resolve { mimeType, base64 }; toggling game audio on or off is not an export.'],
+            message: "The game preview audio hook did not export recorded audio.",
+            suggestions: [
+                "Make window.__listingCapture.stopAudioCapture() resolve { mimeType, base64 }; toggling game audio on or off is not an export.",
+            ],
         };
     }
-    if (error.message === 'listing_capture_runtime_already_recorded') {
+    if (error.message === "listing_capture_runtime_already_recorded") {
         return {
-            message: 'This exact game runtime already has a canonical recording with different capture settings.',
-            suggestions: ['Use the existing video, or change and revalidate the preview implementation before recording the changed runtime once.'],
+            message: "This exact game runtime already has a canonical recording with different capture settings.",
+            suggestions: [
+                "Use the existing video, or change and revalidate the preview implementation before recording the changed runtime once.",
+            ],
         };
     }
-    if (error.message === 'listing_capture_current_report_incomplete') {
+    if (error.message === "listing_capture_current_report_incomplete") {
         return {
-            message: 'The canonical capture report is incomplete for this runtime.',
-            suggestions: ['Fix or remove the incomplete canonical capture directory, then record the runtime once.'],
+            message: "The canonical capture report is incomplete for this runtime.",
+            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:')) {
+    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.',
+            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(':');
+    if (error.message.startsWith("listing_capture_dimensions_exceed_display:")) {
+        const [, requested = "unknown", available = "unknown"] = error.message.split(":");
         return {
             message: `Requested capture size ${requested} cannot fit in this worker's ${available} browser window.`,
-            suggestions: ['Omit --width and --height to use the safe surface defaults, or request dimensions that fit this display.'],
+            suggestions: [
+                "Omit --width and --height to use the safe surface defaults, or request dimensions that fit this display.",
+            ],
         };
     }
-    if (error.message.startsWith('listing_recorder_failed:')) {
+    if (error.message.startsWith("listing_recorder_failed:")) {
         return {
-            message: error.message.slice('listing_recorder_failed:'.length),
+            message: error.message.slice("listing_recorder_failed:".length),
             suggestions: [],
         };
     }
-    if (error.message.startsWith('ffprobe_failed:') || error.message.startsWith('ffmpeg_failed:')) {
+    if (error.message.startsWith("ffprobe_failed:") || error.message.startsWith("ffmpeg_failed:")) {
         return {
-            message: error.message.slice(error.message.indexOf(':') + 1).trim() || 'ffmpeg validation failed.',
+            message: error.message.slice(error.message.indexOf(":") + 1).trim() || "ffmpeg validation failed.",
             suggestions: [],
         };
     }
-    if (error.message.startsWith('listing_capture_wrong_game:')) {
+    if (error.message.startsWith("listing_capture_wrong_game:")) {
         return {
-            message: 'The recorded pixels do not match the selected game preview.',
+            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:')) {
+    if (error.message.startsWith("listing_capture_black_frame:")) {
         return {
-            message: 'The gameplay recording contains a black first frame or poster.',
+            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:')) {
+    if (error.message.startsWith("listing_capture_stale_video:")) {
         return {
-            message: 'The gameplay recording is visually static.',
+            message: "The gameplay recording is visually static.",
             suggestions: ['Make preview mode show real gameplay motion, then rerun "playdrop project capture".'],
         };
     }
@@ -921,62 +900,53 @@ function formatCommandError(error) {
 }
 async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop, width, height, fps, posterAtSeconds, deadlineAt) {
     const filter = `crop=${crop.width}:${crop.height}:${crop.x}:${crop.y},scale=${width}:${height}:flags=lanczos,fps=${fps}`;
-    runTool('ffmpeg', [
-        '-y',
-        '-i',
+    runTool("ffmpeg", [
+        "-y",
+        "-i",
         rawVideoPath,
-        '-vf',
+        "-vf",
         filter,
-        '-c:v',
-        'h264_videotoolbox',
-        '-pix_fmt',
-        'yuv420p',
-        '-c:a',
-        'aac',
-        finalVideoPath,
-    ], 'ffmpeg_failed', deadlineAt);
-    runTool('ffmpeg', [
-        '-y',
-        '-ss',
-        String(posterAtSeconds),
-        '-i',
+        "-c:v",
+        "h264_videotoolbox",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
         finalVideoPath,
-        '-frames:v',
-        '1',
-        posterPath,
-    ], 'ffmpeg_failed', deadlineAt);
+    ], "ffmpeg_failed", deadlineAt);
+    runTool("ffmpeg", ["-y", "-ss", String(posterAtSeconds), "-i", finalVideoPath, "-frames:v", "1", posterPath], "ffmpeg_failed", deadlineAt);
 }
 function captureCommandMatchesExceptPoster(capture, surface, parsedOptions) {
     const dimensions = resolveCaptureDimensions(surface, parsedOptions);
-    return capture.command.durationSeconds === parsedOptions.durationSeconds
-        && capture.command.width === dimensions.width
-        && capture.command.height === dimensions.height
-        && capture.command.fps === parsedOptions.fps
-        && capture.command.audio === parsedOptions.audio
-        && capture.command.keepRaw === parsedOptions.keepRaw;
+    return (capture.command.durationSeconds === parsedOptions.durationSeconds &&
+        capture.command.width === dimensions.width &&
+        capture.command.height === dimensions.height &&
+        capture.command.fps === parsedOptions.fps &&
+        capture.command.audio === parsedOptions.audio &&
+        capture.command.keepRaw === parsedOptions.keepRaw);
 }
 function resolveCurrentCaptureReuseAction(captures, surfaces, parsedOptions) {
     if (captures.length !== surfaces.length) {
-        throw new Error('listing_capture_current_report_incomplete');
+        throw new Error("listing_capture_current_report_incomplete");
     }
     const orderedCaptures = surfaces.map((surface) => captures.find((candidate) => candidate.surface === surface));
     if (orderedCaptures.some((capture) => !capture)) {
-        throw new Error('listing_capture_current_report_incomplete');
+        throw new Error("listing_capture_current_report_incomplete");
     }
     if (orderedCaptures.some((capture, index) => !captureCommandMatchesExceptPoster(capture, surfaces[index], parsedOptions))) {
-        throw new Error('listing_capture_runtime_already_recorded');
+        throw new Error("listing_capture_runtime_already_recorded");
     }
     return orderedCaptures.some((capture) => capture.command.posterAtSeconds !== parsedOptions.posterAtSeconds)
-        ? 'refresh_poster'
-        : 'reuse';
+        ? "refresh_poster"
+        : "reuse";
 }
 async function reuseCurrentListingCapture(input) {
     let report;
     try {
-        report = JSON.parse(await (0, promises_1.readFile)(input.outputPaths.reportPath, 'utf8'));
+        report = JSON.parse(await (0, promises_1.readFile)(input.outputPaths.reportPath, "utf8"));
     }
     catch (error) {
-        if (error?.code === 'ENOENT') {
+        if (error?.code === "ENOENT") {
             return false;
         }
         throw new Error(`listing_capture_report_invalid:${input.outputPaths.reportPath}`);
@@ -984,8 +954,8 @@ 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 (report.binding?.pixelValidation !== "passed") {
+        throw new Error("listing_capture_report_pixels_unvalidated");
     }
     if (!input.runtimeBundleHash || report.binding?.runtimeBundleHash !== input.runtimeBundleHash) {
         return false;
@@ -1004,47 +974,35 @@ async function reuseCurrentListingCapture(input) {
             }
         }
     }
-    if (action === 'reuse') {
-        console.log('[listing] The current runtime already has a matching canonical capture; reusing it.');
+    if (action === "reuse") {
+        console.log("[listing] The current runtime already has a matching canonical capture; reusing it.");
         console.log(`[listing] Existing report: ${(0, node_path_1.relative)(process.cwd(), input.outputPaths.reportPath) || input.outputPaths.reportPath}`);
         return true;
     }
     for (const capture of captures) {
-        runTool('ffmpeg', [
-            '-y',
-            '-ss',
+        runTool("ffmpeg", [
+            "-y",
+            "-ss",
             String(input.parsedOptions.posterAtSeconds),
-            '-i',
+            "-i",
             capture.finalVideo.path,
-            '-frames:v',
-            '1',
+            "-frames:v",
+            "1",
             capture.posterPath,
-        ], 'ffmpeg_failed', input.deadlineAt);
+        ], "ffmpeg_failed", input.deadlineAt);
         capture.command.posterAtSeconds = input.parsedOptions.posterAtSeconds;
-        const artifactKey = (0, node_path_1.relative)(input.outputPaths.outputDir, capture.posterPath) || 'poster.png';
+        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 assertListingCaptureFrameVisible(capture.surface, "poster", capture.posterPath);
     }
-    await (0, promises_1.writeFile)(input.outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+    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.`);
     console.log(`[listing] Updated report: ${(0, node_path_1.relative)(process.cwd(), input.outputPaths.reportPath) || input.outputPaths.reportPath}`);
     return true;
 }
 async function muxListingAudio(finalVideoPath, audioPath, deadlineAt) {
     const muxedVideoPath = `${finalVideoPath}.muxed.mp4`;
-    runTool('ffmpeg', [
-        '-y',
-        '-i',
-        finalVideoPath,
-        '-i',
-        audioPath,
-        '-c:v',
-        'copy',
-        '-c:a',
-        'aac',
-        '-shortest',
-        muxedVideoPath,
-    ], 'ffmpeg_failed', deadlineAt);
+    runTool("ffmpeg", ["-y", "-i", finalVideoPath, "-i", audioPath, "-c:v", "copy", "-c:a", "aac", "-shortest", muxedVideoPath], "ffmpeg_failed", deadlineAt);
     await (0, promises_1.rename)(muxedVideoPath, finalVideoPath);
 }
 function ensureTolerance(actual, expected, tolerance, failureCode) {
@@ -1056,7 +1014,7 @@ function createWarnings(finalProbe, requestedAudio) {
     const warnings = [];
     const audioTrackCount = countAudioStreams(finalProbe);
     if (!requestedAudio && audioTrackCount > 0) {
-        warnings.push('final output contains audio even though --audio was not requested');
+        warnings.push("final output contains audio even though --audio was not requested");
     }
     return warnings;
 }
@@ -1065,7 +1023,7 @@ function ensureCaptureListingToolAvailable(command) {
         return true;
     }
     (0, messages_1.printErrorWithHelp)(`${command} is required for listing capture.`, [`Install ${command} and make sure it is available on PATH.`], {
-        command: 'project capture',
+        command: "project capture",
     });
     process.exitCode = 1;
     return false;
@@ -1076,7 +1034,7 @@ async function ensureListingRecorderAvailable(recorderPath) {
         return true;
     }
     catch {
-        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Start the PlayDrop worker once on this Mac to install the recorder from the PlayDrop CDN.'], { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ["Start the PlayDrop worker once on this Mac to install the recorder from the PlayDrop CDN."], { command: "project capture" });
         process.exitCode = 1;
         return false;
     }
@@ -1087,13 +1045,13 @@ function resolveCaptureListingTarget(parsedOptions) {
     }
     catch (error) {
         const code = error?.code;
-        const message = error?.message || 'Unable to resolve capture target.';
-        const suggestions = code === 'app_required'
+        const message = error?.message || "Unable to resolve capture target.";
+        const suggestions = code === "app_required"
             ? ['Use "--app <name>" to choose which app to capture.']
-            : code === 'catalogue_missing'
-                ? ['Run the command inside a Playdrop workspace or pass the direct HTML file path.']
-                : ['Provide a valid app target or HTML file path.'];
-        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'project capture' });
+            : code === "catalogue_missing"
+                ? ["Run the command inside a Playdrop workspace or pass the direct HTML file path."]
+                : ["Provide a valid app target or HTML file path."];
+        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: "project capture" });
         process.exitCode = 1;
         return null;
     }
@@ -1108,15 +1066,15 @@ async function captureListing(targetArg, options = {}) {
     }
     catch (error) {
         const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
         process.exitCode = 1;
         return;
     }
-    if (!ensureCaptureListingToolAvailable('ffmpeg') || !ensureCaptureListingToolAvailable('ffprobe')) {
+    if (!ensureCaptureListingToolAvailable("ffmpeg") || !ensureCaptureListingToolAvailable("ffprobe")) {
         return;
     }
     const recorderPath = resolveListingRecorderPath();
-    if (!await ensureListingRecorderAvailable(recorderPath)) {
+    if (!(await ensureListingRecorderAvailable(recorderPath))) {
         return;
     }
     const resolvedTarget = resolveCaptureListingTarget(parsedOptions);
@@ -1140,7 +1098,7 @@ async function captureListing(targetArg, options = {}) {
     }
     catch (error) {
         const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
         process.exitCode = 1;
         return;
     }
@@ -1152,15 +1110,15 @@ async function captureListing(targetArg, options = {}) {
     }
     catch (error) {
         const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
         process.exitCode = 1;
         return;
     }
     const explicitOutputDir = resolveCaptureListingExplicitOutputDir(parsedOptions.outputDirInput, parsedOptions.outputDir, projectDir);
     const outputPaths = await ensureOutputPaths(appName, explicitOutputDir ?? resolveWorkerCaptureOutputDir(projectDir, isWorkerGameTask));
-    const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
-    await (0, commandContext_1.withEnvironment)('project capture', 'Capturing game media', async ({ client, env, envConfig, account, workspaceAuth }) => {
-        let currentUsername = '';
+    const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === "string");
+    await (0, commandContext_1.withEnvironment)("project capture", "Capturing game media", async ({ client, env, envConfig, account, workspaceAuth }) => {
+        let currentUsername = "";
         try {
             currentUsername = await (0, devShared_1.resolveDevCreatorUsername)({
                 client,
@@ -1173,7 +1131,7 @@ async function captureListing(targetArg, options = {}) {
                 return;
             }
             if (error instanceof types_1.UnsupportedClientError) {
-                (0, http_1.handleUnsupportedError)(error, 'Authentication');
+                (0, http_1.handleUnsupportedError)(error, "Authentication");
                 process.exitCode = 1;
                 return;
             }
@@ -1181,12 +1139,12 @@ async function captureListing(targetArg, options = {}) {
                 (0, messages_1.printErrorWithHelp)(`Could not fetch your account (status ${error.status}).`, [
                     'Run "playdrop auth login" to refresh your session.',
                     'Use "playdrop auth whoami" afterwards to verify the current account.',
-                ], { command: 'project capture' });
+                ], { command: "project capture" });
                 process.exitCode = 1;
                 return;
             }
             if ((0, devShared_1.isNetworkError)(error)) {
-                (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to resolve your account.', 'project capture');
+                (0, messages_1.printNetworkIssue)("Could not reach the Playdrop API to resolve your account.", "project capture");
                 process.exitCode = 1;
                 return;
             }
@@ -1201,17 +1159,17 @@ async function captureListing(targetArg, options = {}) {
                 return;
             }
             if (error instanceof types_1.UnsupportedClientError) {
-                (0, http_1.handleUnsupportedError)(error, 'Game media capture');
+                (0, http_1.handleUnsupportedError)(error, "Game media capture");
                 process.exitCode = 1;
                 return;
             }
             if (error instanceof types_1.ApiError && error.status === 404) {
-                (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [`Run "playdrop project create app ${appName}" before using listing capture.`], { command: 'project capture' });
+                (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [`Run "playdrop project create app ${appName}" before using listing capture.`], { command: "project capture" });
                 process.exitCode = 1;
                 return;
             }
             if ((0, devShared_1.isNetworkError)(error)) {
-                (0, messages_1.printNetworkIssue)('Could not verify the app registration.', 'project capture');
+                (0, messages_1.printNetworkIssue)("Could not verify the app registration.", "project capture");
                 process.exitCode = 1;
                 return;
             }
@@ -1222,7 +1180,7 @@ async function captureListing(targetArg, options = {}) {
             captureSession = (0, taskCaptureSession_1.resolveTaskCaptureSession)(workspaceAuth, registeredApp);
         }
         catch (error) {
-            (0, messages_1.printErrorWithHelp)(error?.message || 'Worker capture session is invalid.', ['Run this command from the active worker task workspace.'], { command: 'project capture' });
+            (0, messages_1.printErrorWithHelp)(error?.message || "Worker capture session is invalid.", ["Run this command from the active worker task workspace."], { command: "project capture" });
             process.exitCode = 1;
             return;
         }
@@ -1230,7 +1188,7 @@ async function captureListing(targetArg, options = {}) {
         console.log(`[listing] Preparing ${entryLabel} for ${env} (${appTypeSlug}).`);
         const taskLookup = (0, catalogue_1.findAppTaskByFile)(resolvedTarget.htmlPath);
         if (taskLookup.errors.length > 0) {
-            (0, messages_1.printErrorWithHelp)(taskLookup.errors[0] || 'Failed to resolve the app task from catalogue.json.', taskLookup.errors.slice(1), { command: 'project capture' });
+            (0, messages_1.printErrorWithHelp)(taskLookup.errors[0] || "Failed to resolve the app task from catalogue.json.", taskLookup.errors.slice(1), { command: "project capture" });
             process.exitCode = 1;
             return;
         }
@@ -1243,7 +1201,7 @@ async function captureListing(targetArg, options = {}) {
                 runtimeBundleHash = (await (0, build_1.buildApp)(captureTask)).bundleHash;
             }
             catch (error) {
-                (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : String(error), ['Fix the game build before recording final gameplay.'], { command: 'project capture' });
+                (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : String(error), ["Fix the game build before recording final gameplay."], { command: "project capture" });
                 process.exitCode = 1;
                 return;
             }
@@ -1264,7 +1222,7 @@ async function captureListing(targetArg, options = {}) {
         }
         catch (error) {
             const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-            (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+            (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
             process.exitCode = 1;
             return;
         }
@@ -1282,12 +1240,12 @@ async function captureListing(targetArg, options = {}) {
                     apiBase: envConfig.apiBase,
                     task: taskLookup.task,
                     creatorUsername: currentUsername,
-                    appBaseUrl: new URL('.', localDevAppUrl).toString(),
+                    appBaseUrl: new URL(".", localDevAppUrl).toString(),
                 });
             }
             catch (error) {
                 const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
-                (0, messages_1.printErrorWithHelp)(formatted.message, formatted.suggestions, { command: 'project capture' });
+                (0, messages_1.printErrorWithHelp)(formatted.message, formatted.suggestions, { command: "project capture" });
                 process.exitCode = 1;
                 return;
             }
@@ -1345,9 +1303,9 @@ async function captureListing(targetArg, options = {}) {
                 }
             }
             if (devServerStartedByCapture) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                await new Promise((resolve) => setTimeout(resolve, 1000));
             }
-            const webBase = envConfig.webBase ?? 'https://www.playdrop.ai';
+            const webBase = envConfig.webBase ?? "https://www.playdrop.ai";
             const routeSegment = resolveListingCaptureRouteSegment(declaresPreviewSupport);
             const localDevPort = resolveListingCaptureLocalDevPort(devRouterPort);
             const frameUrl = buildListingCaptureFrameUrl({
@@ -1362,7 +1320,7 @@ async function captureListing(targetArg, options = {}) {
             const frameUrlObject = new URL(frameUrl);
             const reportFrameUrl = (0, appUrls_1.redactTaskCaptureSession)(frameUrl);
             console.log(`[listing] Opening ${reportFrameUrl}`);
-            const shouldExportPreviewAudio = parsedOptions.audio && routeSegment === 'dev-preview';
+            const shouldExportPreviewAudio = parsedOptions.audio && routeSegment === "dev-preview";
             const surfaces = resolvedTarget.surfaceTargets.list;
             const useSurfacePrefix = surfaces.length > 1;
             const captures = [];
@@ -1373,7 +1331,7 @@ 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 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`),
@@ -1383,9 +1341,9 @@ async function captureListing(targetArg, options = {}) {
                 const contextOptions = resolveListingCaptureBrowserContextOptions(surface, dimensions);
                 browserHandle = await launchListingBrowser(dimensions, frameUrlObject.origin, contextOptions);
                 try {
-                    await browserHandle.page.goto(frameUrl, { waitUntil: 'domcontentloaded' });
+                    await browserHandle.page.goto(frameUrl, { waitUntil: "domcontentloaded" });
                     await browserHandle.page.waitForTimeout(1000);
-                    if (routeSegment === 'dev-preview') {
+                    if (routeSegment === "dev-preview") {
                         console.log(`[listing] Preparing preview scene ${captureSceneId}.`);
                         await prepareHostedListingScene(browserHandle.page, captureSceneId);
                         await browserHandle.page.waitForTimeout(1000);
@@ -1393,13 +1351,13 @@ async function captureListing(targetArg, options = {}) {
                     const measurement = await fitWindowToRequestedGameplay(browserHandle.page, dimensions.width, dimensions.height);
                     console.log(`[listing] Gameplay frame ${Math.round(measurement.iframeRect.width)}x${Math.round(measurement.iframeRect.height)} in window ${Math.round(measurement.outerWidth)}x${Math.round(measurement.outerHeight)}.`);
                     if (shouldExportPreviewAudio) {
-                        console.log('[listing] Checking the in-app preview audio export contract.');
+                        console.log("[listing] Checking the in-app preview audio export contract.");
                         await assertHostedListingAudioCaptureContract(browserHandle.page, outputPaths.outputDir);
-                        console.log('[listing] Starting in-app preview audio capture.');
+                        console.log("[listing] Starting in-app preview audio capture.");
                         await startHostedListingAudioCapture(browserHandle.page);
                     }
                     await browserHandle.page.waitForTimeout(750);
-                    console.log('[listing] Waiting for the machine capture lease.');
+                    console.log("[listing] Waiting for the machine capture lease.");
                     const captureLease = await (0, listingCaptureLease_1.acquireListingCaptureLease)({
                         deadlineAt: captureDeadlineAt,
                         workspaceDir: (0, node_path_1.dirname)(resolvedTarget.htmlPath),
@@ -1430,11 +1388,11 @@ async function captureListing(targetArg, options = {}) {
                     const finalDurationSeconds = readDurationSeconds(finalProbe);
                     const finalAudioTrackCount = countAudioStreams(finalProbe);
                     const finalFps = parseFrameRate(finalVideoStream.avg_frame_rate);
-                    ensureTolerance(finalVideoStream.width, dimensions.width, 0, 'final_width_mismatch');
-                    ensureTolerance(finalVideoStream.height, dimensions.height, 0, 'final_height_mismatch');
-                    ensureTolerance(finalDurationSeconds, parsedOptions.durationSeconds, 1.5, 'final_duration_mismatch');
+                    ensureTolerance(finalVideoStream.width, dimensions.width, 0, "final_width_mismatch");
+                    ensureTolerance(finalVideoStream.height, dimensions.height, 0, "final_height_mismatch");
+                    ensureTolerance(finalDurationSeconds, parsedOptions.durationSeconds, 1.5, "final_duration_mismatch");
                     if (parsedOptions.audio && finalAudioTrackCount === 0) {
-                        throw new Error('audio_track_missing');
+                        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);
@@ -1450,8 +1408,10 @@ async function captureListing(targetArg, options = {}) {
                     for (const warning of warnings) {
                         allWarnings.push(`${surface}: ${warning}`);
                     }
-                    artifactHashes[(0, node_path_1.relative)(outputPaths.outputDir, surfaceOutputPaths.finalVideoPath) || 'listing.mp4'] = await computeFileSha256(surfaceOutputPaths.finalVideoPath);
-                    artifactHashes[(0, node_path_1.relative)(outputPaths.outputDir, surfaceOutputPaths.posterPath) || 'poster.png'] = await computeFileSha256(surfaceOutputPaths.posterPath);
+                    artifactHashes[(0, node_path_1.relative)(outputPaths.outputDir, surfaceOutputPaths.finalVideoPath) || "listing.mp4"] =
+                        await computeFileSha256(surfaceOutputPaths.finalVideoPath);
+                    artifactHashes[(0, node_path_1.relative)(outputPaths.outputDir, surfaceOutputPaths.posterPath) || "poster.png"] =
+                        await computeFileSha256(surfaceOutputPaths.posterPath);
                     capturedSurfaces.push(surface);
                     captures.push({
                         surface,
@@ -1512,11 +1472,11 @@ async function captureListing(targetArg, options = {}) {
                 binding: {
                     artifactHashes,
                     capturedSurfaces,
-                    pixelValidation: 'passed',
+                    pixelValidation: "passed",
                     runtimeBundleHash,
                 },
             };
-            await (0, promises_1.writeFile)(outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+            await (0, promises_1.writeFile)(outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
             console.log(`[listing] Saved report to ${(0, node_path_1.relative)(process.cwd(), outputPaths.reportPath) || outputPaths.reportPath}`);
         }
         catch (error) {
@@ -1524,12 +1484,12 @@ async function captureListing(targetArg, options = {}) {
                 return;
             }
             if (error instanceof types_1.UnsupportedClientError) {
-                (0, http_1.handleUnsupportedError)(error, 'Game media capture');
+                (0, http_1.handleUnsupportedError)(error, "Game media capture");
                 process.exitCode = 1;
                 return;
             }
             const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-            (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+            (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
             process.exitCode = 1;
         }
         finally {