@playdrop/playdrop-cli 0.5.5 → 0.6.0

package/dist/commandContext.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAuthenticatedEnvironmentContext = resolveAuthenticatedEnvironmentContext;
+exports.resolveOptionalEnvironmentContext = resolveOptionalEnvironmentContext;
 exports.withEnvironment = withEnvironment;
 exports.withPublicEnvironment = withPublicEnvironment;
 const config_1 = require("./config");
@@ -27,7 +29,7 @@ function resolveConfiguredEnvironment(envName, command, options) {
     }
     return envConfig;
 }
-function buildContext(cfg, envConfig, account) {
+function buildContext(cfg, envConfig, account, workspaceAuth = null) {
     const token = account?.token ?? cfg.token ?? '';
     const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token });
     const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token });
@@ -39,6 +41,7 @@ function buildContext(cfg, envConfig, account) {
         token,
         config: cfg,
         account,
+        workspaceAuth,
     };
 }
 function buildLegacyAccountSession(cfg) {
@@ -77,32 +80,7 @@ async function migrateLegacyConfigIfNeeded(cfg, envConfig, command) {
         return null;
     }
 }
-function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth) {
-    const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
-    if (workspaceAuth.config.env) {
-        return {
-            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, workspaceAuth.config.env, cfg),
-            matchingSessions,
-        };
-    }
-    if (matchingSessions.length === 1) {
-        return {
-            account: matchingSessions[0],
-            matchingSessions,
-        };
-    }
-    if (currentAccount && currentAccount.username === workspaceAuth.config.ownerUsername) {
-        return {
-            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, currentAccount.env, cfg),
-            matchingSessions,
-        };
-    }
-    return {
-        account: null,
-        matchingSessions,
-    };
-}
-async function resolveAuthenticatedEnvironment(command, actionLabel, options = {}) {
+async function loadWorkspaceAwareConfig(command, options) {
     let cfg = (0, config_1.loadConfig)();
     let workspaceAuth = null;
     try {
@@ -133,6 +111,39 @@ async function resolveAuthenticatedEnvironment(command, actionLabel, options = {
         }
         cfg = migrated;
     }
+    return { cfg, workspaceAuth };
+}
+function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth) {
+    const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+    if (workspaceAuth.config.env) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, workspaceAuth.config.env, cfg),
+            matchingSessions,
+        };
+    }
+    if (matchingSessions.length === 1) {
+        return {
+            account: matchingSessions[0],
+            matchingSessions,
+        };
+    }
+    if (currentAccount && currentAccount.username === workspaceAuth.config.ownerUsername) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, currentAccount.env, cfg),
+            matchingSessions,
+        };
+    }
+    return {
+        account: null,
+        matchingSessions,
+    };
+}
+async function resolveAuthenticatedEnvironment(command, actionLabel, options = {}) {
+    const loaded = await loadWorkspaceAwareConfig(command, options);
+    if (!loaded) {
+        return null;
+    }
+    const { cfg, workspaceAuth } = loaded;
     const currentAccount = (0, config_1.getCurrentAccountSession)(cfg) ?? buildLegacyAccountSession(cfg);
     const selectedAccount = workspaceAuth
         ? resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth).account
@@ -171,14 +182,64 @@ async function resolveAuthenticatedEnvironment(command, actionLabel, options = {
         cfg: (0, config_1.loadConfig)(),
         account: selectedAccount,
         envConfig,
+        workspaceAuth,
     };
 }
-async function withEnvironment(command, actionLabel, callback, options = {}) {
+async function resolveAuthenticatedEnvironmentContext(command, actionLabel, options = {}) {
     const resolved = await resolveAuthenticatedEnvironment(command, actionLabel, options);
     if (!resolved) {
+        return null;
+    }
+    return buildContext(resolved.cfg, resolved.envConfig, resolved.account, resolved.workspaceAuth);
+}
+async function resolveOptionalEnvironmentContext(command, options = {}) {
+    const loaded = await loadWorkspaceAwareConfig(command, options);
+    if (!loaded) {
+        return null;
+    }
+    const { cfg, workspaceAuth } = loaded;
+    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg) ?? buildLegacyAccountSession(cfg);
+    if (!currentAccount && !workspaceAuth) {
+        return null;
+    }
+    const selectedAccount = workspaceAuth
+        ? resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth).account
+        : currentAccount;
+    if (!selectedAccount) {
+        if (workspaceAuth) {
+            const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+            if (!workspaceAuth.config.env && matchingSessions.length > 1) {
+                (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}, but that account is logged in on multiple environments.`, [
+                    `Run "playdrop auth use ${workspaceAuth.config.ownerUsername} --env <env>" to select the matching environment.`,
+                    'Or add an "env" field to .playdrop.json.',
+                ], { command });
+            }
+            else {
+                const envSuffix = workspaceAuth.config.env ? ` on ${workspaceAuth.config.env}` : '';
+                (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}${envSuffix}, but that account is not logged in.`, [
+                    `Run "playdrop auth login${workspaceAuth.config.env ? ` --env ${workspaceAuth.config.env}` : ''}" while authenticated as ${workspaceAuth.config.ownerUsername}.`,
+                    'Or remove .playdrop.json if this workspace should use your current default account.',
+                ], { command });
+            }
+            process.exitCode = 1;
+        }
+        return null;
+    }
+    const envConfig = resolveConfiguredEnvironment(selectedAccount.env, command, {
+        requireAuth: true,
+        allowDefaultPublicEnv: false,
+    });
+    if (!envConfig) {
+        return null;
+    }
+    return buildContext((0, config_1.loadConfig)(), envConfig, selectedAccount, workspaceAuth);
+}
+async function withEnvironment(command, actionLabel, callback, options = {}) {
+    const ctx = await resolveAuthenticatedEnvironmentContext(command, actionLabel, options);
+    if (!ctx) {
         return;
     }
-    await callback(buildContext(resolved.cfg, resolved.envConfig, resolved.account));
+    await callback(ctx);
 }
 async function withPublicEnvironment(command, callback) {
     const cfg = (0, config_1.loadConfig)();

package/dist/commands/browse.d.ts

@@ -4,6 +4,9 @@ export type BrowseOptions = {
     kind?: string;
     creator?: string;
     appType?: string;
+    auth?: string;
+    controller?: string;
+    surface?: string;
     assetCategory?: string;
     assetSubcategory?: string;
     assetSpec?: string;

package/dist/commands/browse.js

@@ -71,6 +71,9 @@ function parseBrowseSort(raw) {
         return undefined;
     }
     const normalized = raw.trim().toLowerCase();
+    if (types_1.APP_LIST_SORT_VALUES.includes(normalized)) {
+        return normalized;
+    }
     if (types_1.ASSET_LIST_SORT_VALUES.includes(normalized)) {
         return normalized;
     }
@@ -117,12 +120,6 @@ function buildCountsSuffix(item) {
         if (typeof item.item.viewCount === 'number') {
             parts.push(`view ${formatCountValue(item.item.viewCount)}`);
         }
-        if (typeof item.item.downloadCount === 'number') {
-            parts.push(`download ${formatCountValue(item.item.downloadCount)}`);
-        }
-        if (typeof item.item.playCount === 'number') {
-            parts.push(`play ${formatCountValue(item.item.playCount)}`);
-        }
     }
     if (item.kind === 'asset-pack' && typeof item.item.downloadCount === 'number') {
         parts.push(`download ${formatCountValue(item.item.downloadCount)}`);
@@ -249,12 +246,17 @@ function buildTagSuffix(tags) {
 function parseBrowseSortOption(rawSort, kind) {
     const sort = parseBrowseSort(rawSort);
     if (sort === null) {
-        (0, messages_1.printErrorWithHelp)(`Sort "${rawSort ?? ''}" is not supported.`, ['Use one of: recent, likes, downloads, remixes, comments, assets, apps, alpha.'], { command: 'browse' });
+        (0, messages_1.printErrorWithHelp)(`Sort "${rawSort ?? ''}" is not supported.`, ['Use one of: newest, updated, views, likes, used, recent, remixes, comments, assets, apps, alpha.'], { command: 'browse' });
         process.exitCode = 1;
         return null;
     }
     if (sort && kind === 'all') {
-        (0, messages_1.printErrorWithHelp)('The --sort option is not supported with --kind all.', ['Choose --kind asset or --kind asset-spec when sorting browse results.'], { command: 'browse' });
+        (0, messages_1.printErrorWithHelp)('The --sort option is not supported with --kind all.', ['Choose --kind app, --kind asset, or --kind asset-spec when sorting browse results.'], { command: 'browse' });
+        process.exitCode = 1;
+        return null;
+    }
+    if (sort && kind === 'app' && !types_1.APP_LIST_SORT_VALUES.includes(sort)) {
+        (0, messages_1.printErrorWithHelp)(`Sort "${sort}" is not supported for apps.`, ['Use one of: newest, updated, views, likes, used.'], { command: 'browse' });
         process.exitCode = 1;
         return null;
     }
@@ -264,7 +266,7 @@ function parseBrowseSortOption(rawSort, kind) {
         return null;
     }
     if (sort && kind === 'asset' && !types_1.ASSET_LIST_SORT_VALUES.includes(sort)) {
-        (0, messages_1.printErrorWithHelp)(`Sort "${sort}" is not supported for assets.`, ['Use one of: recent, likes, downloads, remixes, comments.'], { command: 'browse' });
+        (0, messages_1.printErrorWithHelp)(`Sort "${sort}" is not supported for assets.`, ['Use one of: recent, likes, remixes, comments.'], { command: 'browse' });
         process.exitCode = 1;
         return null;
     }
@@ -321,6 +323,30 @@ function parseBrowseCommandOptions(options) {
         process.exitCode = 1;
         return { ok: false };
     }
+    const auth = options.auth === undefined ? undefined : (0, types_1.parseAppAuthFilter)(options.auth);
+    if (options.auth !== undefined && !auth) {
+        (0, messages_1.printErrorWithHelp)(`Auth filter "${options.auth}" is not supported.`, ['Use one of: required, optional, none.'], { command: 'browse' });
+        process.exitCode = 1;
+        return { ok: false };
+    }
+    const controller = options.controller === undefined ? undefined : (0, types_1.parseAppControllerFilter)(options.controller);
+    if (options.controller !== undefined && !controller) {
+        (0, messages_1.printErrorWithHelp)(`Controller filter "${options.controller}" is not supported.`, ['Use one of: required, optional, none.'], { command: 'browse' });
+        process.exitCode = 1;
+        return { ok: false };
+    }
+    const surface = options.surface === undefined ? undefined : (0, types_1.parseAppSurfaceFilter)(options.surface);
+    if (options.surface !== undefined && !surface) {
+        (0, messages_1.printErrorWithHelp)(`Surface filter "${options.surface}" is not supported.`, ['Use one of: desktop, mobile-portrait, mobile-landscape.'], { command: 'browse' });
+        process.exitCode = 1;
+        return { ok: false };
+    }
+    const hasCapabilityFilters = Boolean(auth || controller || surface);
+    if (hasCapabilityFilters && kind !== 'app') {
+        (0, messages_1.printErrorWithHelp)('Capability filters only support app browse.', ['Use --kind app together with --auth, --surface, or --controller.'], { command: 'browse' });
+        process.exitCode = 1;
+        return { ok: false };
+    }
     const browseFilters = parseBrowseLimitsAndFilters(options);
     if (!browseFilters) {
         return { ok: false };
@@ -341,6 +367,9 @@ function parseBrowseCommandOptions(options) {
             kind,
             creator,
             appType: appType ?? undefined,
+            auth: auth ?? undefined,
+            controller: controller ?? undefined,
+            surface: surface ?? undefined,
             ...browseFilters,
             assetSpec: normalizeOptionalOption(options.assetSpec),
             assetSpecOwner: normalizeOptionalOption(options.assetSpecOwner),
@@ -353,17 +382,33 @@ function parseBrowseCommandOptions(options) {
 async function loadMergedBrowseResults(input) {
     const { client, creator, creatorUsername, appType, assetCategory, assetSubcategory, assetSpec, assetSpecOwner, assetSpecName, limit, offset, tags, } = input;
     const appResultsPromise = creatorUsername
-        ? collectPaginatedItems((pageLimit, pageOffset) => client.fetchAppsByCreator(creatorUsername, { limit: pageLimit, offset: pageOffset, type: appType, ...(tags.length > 0 ? { tags } : {}) })
+        ? collectPaginatedItems((pageLimit, pageOffset) => client.fetchAppsByCreator(creatorUsername, {
+            limit: pageLimit,
+            offset: pageOffset,
+            type: appType,
+            ...(tags.length > 0 ? { tags } : {}),
+            ...(input.sort ? { sort: input.sort } : {}),
+        })
             .then((response) => ({
             items: response.apps ?? [],
             pagination: requirePagination(response.pagination, 'browse_all_creator_apps'),
         })))
         : (appType
-            ? collectPaginatedItems((pageLimit, pageOffset) => client.fetchAppsByType(appType, { limit: pageLimit, offset: pageOffset, ...(tags.length > 0 ? { tags } : {}) }).then((response) => ({
+            ? collectPaginatedItems((pageLimit, pageOffset) => client.fetchAppsByType(appType, {
+                limit: pageLimit,
+                offset: pageOffset,
+                ...(tags.length > 0 ? { tags } : {}),
+                ...(input.sort ? { sort: input.sort } : {}),
+            }).then((response) => ({
                 items: response.apps ?? [],
                 pagination: requirePagination(response.pagination, 'browse_all_type_apps'),
             })))
-            : collectPaginatedItems((pageLimit, pageOffset) => client.fetchApps({ limit: pageLimit, offset: pageOffset, ...(tags.length > 0 ? { tags } : {}) }).then((response) => ({
+            : collectPaginatedItems((pageLimit, pageOffset) => client.fetchApps({
+                limit: pageLimit,
+                offset: pageOffset,
+                ...(tags.length > 0 ? { tags } : {}),
+                ...(input.sort ? { sort: input.sort } : {}),
+            }).then((response) => ({
                 items: response.apps ?? [],
                 pagination: requirePagination(response.pagination, 'browse_all_apps'),
             }))));
@@ -501,23 +546,48 @@ async function runAssetPackBrowseCommand(input) {
     };
 }
 async function runBrowseCommand(input) {
-    const { client, kind, creator, creatorUsername, appType, limit, offset, tags, } = input;
+    const { client, kind, creator, creatorUsername, appType, auth, controller, surface, sort, limit, offset, tags, } = input;
     if (kind === 'app') {
         if (creatorUsername) {
-            const response = await client.fetchAppsByCreator(creatorUsername, { limit, offset, type: appType, ...(tags.length > 0 ? { tags } : {}) });
+            const response = await client.fetchAppsByCreator(creatorUsername, {
+                limit,
+                offset,
+                type: appType,
+                ...(auth ? { auth } : {}),
+                ...(controller ? { controller } : {}),
+                ...(surface ? { surface } : {}),
+                ...(tags.length > 0 ? { tags } : {}),
+                ...(sort ? { sort: sort } : {}),
+            });
             return {
                 items: (response.apps ?? []).map((item) => toBrowseItem('app', item)),
                 pagination: requirePagination(response.pagination, 'browse_app_creator'),
             };
         }
         if (appType) {
-            const response = await client.fetchAppsByType(appType, { limit, offset, ...(tags.length > 0 ? { tags } : {}) });
+            const response = await client.fetchAppsByType(appType, {
+                limit,
+                offset,
+                ...(auth ? { auth } : {}),
+                ...(controller ? { controller } : {}),
+                ...(surface ? { surface } : {}),
+                ...(tags.length > 0 ? { tags } : {}),
+                ...(sort ? { sort: sort } : {}),
+            });
             return {
                 items: (response.apps ?? []).map((item) => toBrowseItem('app', item)),
                 pagination: requirePagination(response.pagination, 'browse_app_type'),
             };
         }
-        const response = await client.fetchApps({ limit, offset, ...(tags.length > 0 ? { tags } : {}) });
+        const response = await client.fetchApps({
+            limit,
+            offset,
+            ...(auth ? { auth } : {}),
+            ...(controller ? { controller } : {}),
+            ...(surface ? { surface } : {}),
+            ...(tags.length > 0 ? { tags } : {}),
+            ...(sort ? { sort: sort } : {}),
+        });
         return {
             items: (response.apps ?? []).map((item) => toBrowseItem('app', item)),
             pagination: requirePagination(response.pagination, 'browse_app_all'),
@@ -539,7 +609,7 @@ async function browse(options = {}) {
     if (!parsed.ok) {
         return;
     }
-    const { kind, creator, appType, assetCategory, assetSubcategory, assetSpec, assetSpecOwner, assetSpecName, sort, limit, offset, tags } = parsed.input;
+    const { kind, creator, appType, auth, controller, surface, assetCategory, assetSubcategory, assetSpec, assetSpecOwner, assetSpecName, sort, limit, offset, tags, } = parsed.input;
     await (0, commandContext_1.withPublicEnvironment)('browse', async ({ client }) => {
         try {
             const creatorUsername = await resolveCreatorUsername(creator, 'browse', async () => {
@@ -559,6 +629,9 @@ async function browse(options = {}) {
                 creator,
                 creatorUsername,
                 appType,
+                auth,
+                controller,
+                surface,
                 assetCategory,
                 assetSubcategory,
                 assetSpec,

package/dist/commands/build.js

@@ -27,7 +27,7 @@ async function build(pathOrName) {
                 await (0, apps_1.validateAppTask)(task);
                 await (0, apps_1.buildApp)(task);
             }
-            else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
+            else if (task.kind === 'asset' || task.kind === 'owned-asset') {
                 const generated = await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
                 if (!generated) {
                     throw new Error(`project build does not support ${task.kind} "${entityId}" because it has no local build step.`);

package/dist/commands/capture.d.ts

@@ -4,6 +4,9 @@ type CaptureOptions = {
     logLevel?: string;
     screenshotPath?: string;
     surfaceTarget?: string;
+    devAuth?: string;
+    player?: string | number;
+    resetDevPlayer?: string;
     username?: string;
     password?: string;
 };

package/dist/commands/capture.js

@@ -7,11 +7,15 @@ const types_1 = require("@playdrop/types");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
 const catalogue_utils_1 = require("../catalogue-utils");
+const catalogue_1 = require("../catalogue");
 const devShared_1 = require("./devShared");
 const devServer_1 = require("./devServer");
 const commandContext_1 = require("../commandContext");
 const appUrls_1 = require("../appUrls");
 const captureRuntime_1 = require("../captureRuntime");
+const devAuth_1 = require("../devAuth");
+const devRuntimeAssets_1 = require("./devRuntimeAssets");
+const dev_1 = require("./dev");
 const 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_PRESETS = {
     desktop: {
@@ -96,22 +100,55 @@ function resolveCaptureLoginOverride(options) {
     }
     return { username, password };
 }
+function resolveCaptureDevOptions(options) {
+    const selection = (0, devAuth_1.parseHostedDevAuthSelection)({
+        devAuth: options.devAuth,
+        player: options.player,
+        defaultMode: 'anonymous',
+        allowPrompt: false,
+    });
+    const resetMode = (0, devAuth_1.parseResetDevPlayerMode)(options.resetDevPlayer);
+    if (selection.devAuth !== 'player' && resetMode !== 'never') {
+        throw new Error('reset_dev_player_requires_player_auth');
+    }
+    return {
+        selection,
+        resetMode,
+    };
+}
 // eslint-disable-next-line max-lines-per-function
 async function capture(targetArg, options = {}) {
     const timeoutSeconds = (0, captureRuntime_1.validateCaptureTimeout)(options.timeoutSeconds);
     const timeoutMs = Math.round(timeoutSeconds * 1000);
     let minimumLogLevel;
     let loginOverride;
+    let devOptions;
     try {
         minimumLogLevel = (0, captureRuntime_1.resolveCaptureLogLevel)(options.logLevel);
         loginOverride = resolveCaptureLoginOverride(options);
+        devOptions = resolveCaptureDevOptions(options);
     }
     catch (error) {
         if (error instanceof Error && error.message === 'invalid_credentials_pair') {
             (0, messages_1.printErrorWithHelp)('Use --username and --password together.', [], { command: 'project capture' });
         }
+        else if (error instanceof Error && error.message === 'dev_auth_prompt_not_supported') {
+            (0, messages_1.printErrorWithHelp)('Use --dev-auth anonymous, viewer, or player for deterministic capture.', [], { command: 'project capture' });
+        }
+        else if (error instanceof Error && error.message === 'dev_auth_player_slot_required') {
+            (0, messages_1.printErrorWithHelp)('Use --player 1, 2, 3, or 4 when --dev-auth player is selected.', [], { command: 'project capture' });
+        }
+        else if (error instanceof Error && error.message === 'reset_dev_player_requires_player_auth') {
+            (0, messages_1.printErrorWithHelp)('Use --reset-dev-player only with --dev-auth player.', [], { command: 'project capture' });
+        }
+        else if (error instanceof Error && error.message === 'reset_dev_player_invalid') {
+            (0, messages_1.printErrorWithHelp)('Use --reset-dev-player before, after, before-and-after, or never.', [], { command: 'project capture' });
+        }
         else {
-            (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid log level.', ['Valid values: debug, info, warn, error'], { command: 'project capture' });
+            (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid capture options.', [
+                'Valid log levels: debug, info, warn, error',
+                'Valid --dev-auth values: anonymous, viewer, player',
+            ], { command: 'project capture' });
         }
         process.exitCode = 1;
         return;
@@ -203,11 +240,10 @@ async function capture(targetArg, options = {}) {
     }
     const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
     const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
-    await (0, commandContext_1.withEnvironment)('project capture', 'Capturing app logs', async ({ client, env, envConfig, token }) => {
-        let currentUser = null;
+    await (0, commandContext_1.withEnvironment)('project capture', 'Capturing app logs', async ({ client, env, envConfig }) => {
         let currentUsername = '';
         try {
-            currentUser = await (0, devShared_1.fetchDevUser)(client);
+            const currentUser = await (0, devShared_1.fetchDevUser)(client);
             currentUsername = currentUser.username.trim();
         }
         catch (error) {
@@ -242,8 +278,14 @@ async function capture(targetArg, options = {}) {
             }
             throw error;
         }
+        if ((devOptions.selection.devAuth === 'viewer' || devOptions.selection.devAuth === 'player') && !loginOverride) {
+            (0, messages_1.printErrorWithHelp)(`Use --username and --password to establish a browser session before running --dev-auth ${devOptions.selection.devAuth}.`, [], { command: 'project capture' });
+            process.exitCode = 1;
+            return;
+        }
+        let registeredApp = null;
         try {
-            await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
+            registeredApp = await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
         }
         catch (error) {
             if (error instanceof http_1.CLIUnsupportedClientError) {
@@ -302,6 +344,35 @@ async function capture(targetArg, options = {}) {
                 }
             }
         };
+        let runtimeAssetManifest = (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)();
+        const taskLookup = (0, catalogue_1.findAppTaskByFile)(filePath);
+        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' });
+            process.exitCode = 1;
+            return;
+        }
+        if (taskLookup.task) {
+            try {
+                runtimeAssetManifest = await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+                    client,
+                    apiBase: envConfig.apiBase,
+                    task: taskLookup.task,
+                    creatorUsername: currentUsername,
+                    appBaseUrl: new URL('.', (0, devServer_1.buildLocalDevAppUrl)({
+                        creatorUsername: currentUsername,
+                        appType: appTypeSlug,
+                        appName,
+                        port: devServer_1.DEV_ROUTER_PORT,
+                    })).toString(),
+                });
+            }
+            catch (error) {
+                const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
+                (0, messages_1.printErrorWithHelp)(formatted.message, formatted.suggestions, { command: 'project capture' });
+                process.exitCode = 1;
+                return;
+            }
+        }
         if (serverAlreadyRunning) {
             console.log(`[capture] Reusing dev server at ${(0, devServer_1.buildLocalDevAppUrl)({
                 creatorUsername: currentUsername,
@@ -309,6 +380,21 @@ async function capture(targetArg, options = {}) {
                 appName,
                 port: devServer_1.DEV_ROUTER_PORT,
             })}`);
+            try {
+                await (0, devServer_1.updateMountedDevRuntimeAssetManifest)({
+                    creatorUsername: currentUsername,
+                    appName,
+                    runtimeAssetManifest,
+                    port: devServer_1.DEV_ROUTER_PORT,
+                });
+            }
+            catch (error) {
+                (0, messages_1.printErrorWithHelp)(error?.message || 'Failed to refresh the local runtime asset manifest on the shared dev router.', [
+                    'Restart "playdrop project dev" for this app and try capture again.',
+                ], { command: 'project capture' });
+                process.exitCode = 1;
+                return;
+            }
         }
         else {
             try {
@@ -319,6 +405,7 @@ async function capture(targetArg, options = {}) {
                     htmlPath: filePath,
                     port: devServer_1.DEV_ROUTER_PORT,
                     projectInfo,
+                    runtimeAssetManifest,
                 });
                 signalHandler = () => {
                     void cleanup().finally(() => process.exit(130));
@@ -355,8 +442,22 @@ async function capture(targetArg, options = {}) {
             await new Promise(resolve => setTimeout(resolve, 1000));
         }
         const webBase = envConfig.webBase ?? 'https://www.playdrop.ai';
-        const frameUrl = `${webBase}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`;
+        const frameUrl = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(`${webBase}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`, devOptions.selection);
         console.log(`[capture] Launching Playwright against ${frameUrl}`);
+        const shouldResetBefore = devOptions.selection.devAuth === 'player'
+            && (devOptions.resetMode === 'before' || devOptions.resetMode === 'before-and-after');
+        const shouldResetAfter = devOptions.selection.devAuth === 'player'
+            && (devOptions.resetMode === 'after' || devOptions.resetMode === 'before-and-after');
+        const selectedPlayerSlot = devOptions.selection.player;
+        const registeredAppId = typeof registeredApp.id === 'number' ? registeredApp.id : null;
+        if ((shouldResetBefore || shouldResetAfter) && registeredAppId === null) {
+            (0, messages_1.printErrorWithHelp)('The registered app is missing a numeric id, so test-player reset is unavailable.', [], { command: 'project capture' });
+            process.exitCode = 1;
+            return;
+        }
+        if (shouldResetBefore && selectedPlayerSlot !== null) {
+            await client.resetDevPlayer(registeredAppId, selectedPlayerSlot);
+        }
         try {
             const result = await (0, captureRuntime_1.runCapture)({
                 targetUrl: frameUrl,
@@ -365,9 +466,11 @@ async function capture(targetArg, options = {}) {
                 minimumLogLevel,
                 screenshotPath,
                 contextOptions: surfaceContextOptions,
-                token: loginOverride ? undefined : token,
-                user: loginOverride ? undefined : currentUser,
-                login: loginOverride,
+                login: loginOverride ? {
+                    username: loginOverride.username,
+                    password: loginOverride.password,
+                } : undefined,
+                savedSessionBootstrap: false,
                 enableCaptureBridge: true,
             });
             if (result.errorCount > 0) {
@@ -396,6 +499,15 @@ async function capture(targetArg, options = {}) {
             process.exitCode = 1;
         }
         finally {
+            if (shouldResetAfter && selectedPlayerSlot !== null) {
+                try {
+                    await client.resetDevPlayer(registeredAppId, selectedPlayerSlot);
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    process.exitCode = 1;
+                }
+            }
             if (signalHandler) {
                 process.off('SIGINT', signalHandler);
                 process.off('SIGTERM', signalHandler);

package/dist/commands/captureListing.d.ts

@@ -45,6 +45,8 @@ type CropRect = {
     width: number;
     height: number;
 };
+export declare function resolveListingCaptureRouteSegment(previewable: boolean): 'dev' | 'dev-preview';
+export declare function resolveListingCaptureSceneId(width: number, height: number): 'listing-landscape' | 'listing-portrait';
 export declare function parseCaptureListingOptions(targetArg: string | undefined, options?: CaptureListingOptions): ParsedCaptureListingOptions;
 export declare function assertSupportedListingEnvironment(platform?: NodeJS.Platform, macosVersion?: string): void;
 export declare function resolveListingRecorderPath(baseDir?: string): string;