@playdrop/playdrop-cli 0.7.0 → 0.7.2

package/README.md

@@ -61,6 +61,7 @@ playdrop credits balance
 playdrop notifications browse
 playdrop creations browse
 playdrop ai create image "Pixel art hero portrait"
+playdrop ai create image "Wide fantasy vista" --ratio 16:9 --size 4K
 playdrop project init .
 playdrop project create app my-app --template playdrop/template/html_template
 playdrop project dev my-app

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.7.0",
-  "build": 1,
+  "version": "0.7.2",
+  "build": 12,
   "platforms": {
     "ios": {
       "minimumVersion": "16.0"
@@ -26,12 +26,12 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.7.0",
-      "minimumBuild": 1
+      "minimumVersion": "0.7.2",
+      "minimumBuild": 12
     },
     "admin": {
-      "minimumVersion": "0.7.0",
-      "minimumBuild": 1
+      "minimumVersion": "0.7.2",
+      "minimumBuild": 12
     },
     "apple": {
       "minimumVersion": "0.3.10",
@@ -46,11 +46,11 @@
       "minimumBuild": 1
     },
     "android-games": {
-      "minimumVersion": "0.1.0",
-      "minimumBuild": 1
+      "minimumVersion": "0.7.1",
+      "minimumBuild": 5
     },
     "cli": {
-      "minimumVersion": "0.7.0"
+      "minimumVersion": "0.7.2"
     }
   }
 }

package/dist/commands/devBrowser.d.ts

@@ -0,0 +1,7 @@
+type DevBrowserOptions = {
+    app?: string;
+    devAuth?: string;
+    player?: string | number;
+};
+export declare function devBrowser(targetArg: string | undefined, options?: DevBrowserOptions): Promise<void>;
+export {};

package/dist/commands/devBrowser.js

@@ -0,0 +1,360 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devBrowser = devBrowser;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = require("node:path");
+const types_1 = require("@playdrop/types");
+const commandContext_1 = require("../commandContext");
+const http_1 = require("../http");
+const messages_1 = require("../messages");
+const catalogue_1 = require("../catalogue");
+const catalogue_utils_1 = require("../catalogue-utils");
+const devShared_1 = require("./devShared");
+const appUrls_1 = require("../appUrls");
+const devServer_1 = require("./devServer");
+const devRuntimeAssets_1 = require("./devRuntimeAssets");
+const devAuth_1 = require("../devAuth");
+const dev_1 = require("./dev");
+const playwright_1 = require("../playwright");
+function resolveDevBrowserAuthSelection(options) {
+    const normalizedMode = options.devAuth?.trim().toLowerCase() || 'prompt';
+    if (options.player !== undefined && normalizedMode !== 'player') {
+        throw new Error('dev_auth_player_requires_player_mode');
+    }
+    return (0, devAuth_1.parseHostedDevAuthSelection)({
+        devAuth: options.devAuth,
+        player: options.player,
+        defaultMode: 'prompt',
+        allowPrompt: true,
+    });
+}
+function waitForContextClose(context) {
+    return new Promise((resolve) => {
+        context.once?.('close', () => {
+            resolve();
+        });
+    });
+}
+async function devBrowser(targetArg, options = {}) {
+    let resolvedTarget;
+    let devAuthSelection;
+    try {
+        resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, options.app);
+        devAuthSelection = resolveDevBrowserAuthSelection(options);
+    }
+    catch (error) {
+        const message = error?.message || 'Unable to start the dev browser.';
+        if (message === 'dev_auth_player_requires_player_mode') {
+            (0, messages_1.printErrorWithHelp)('Use --player only with --dev-auth player.', [], { command: 'project dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+        if (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 dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+        const code = error?.code;
+        let suggestions = [];
+        switch (code) {
+            case 'app_required':
+                suggestions = ['Use "--app <name>" to select which app to run.'];
+                break;
+            case 'app_not_found':
+                suggestions = ['Check the app name in catalogue.json or run "playdrop project create app" to register a new app.'];
+                break;
+            case 'catalogue_missing':
+                suggestions = ['Run "playdrop project dev-browser" from a workspace with catalogue.json or provide the path to an HTML file.'];
+                break;
+            case 'invalid_target':
+                suggestions = ['Provide a path to an HTML file or directory containing a catalogue.json.'];
+                break;
+            case 'empty_catalogue':
+                suggestions = ['Add apps to catalogue.json before running "playdrop project dev-browser".'];
+                break;
+            case 'invalid_catalogue':
+                suggestions = ['Fix the catalogue.json file and rerun "playdrop project dev-browser".'];
+                break;
+            default:
+                suggestions = ['Use --dev-auth prompt, anonymous, viewer, or player.', 'If you choose --dev-auth player, also pass --player 1, 2, 3, or 4.'];
+                break;
+        }
+        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'project dev-browser' });
+        process.exitCode = 1;
+        return;
+    }
+    let appName = resolvedTarget.appName;
+    const filePath = resolvedTarget.htmlPath;
+    if (!(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
+        (0, messages_1.printErrorWithHelp)(`App HTML was not found at ${filePath}.`, ['Ensure the catalogue entry points to a compiled HTML file or provide the correct file path.'], { command: 'project dev-browser' });
+        process.exitCode = 1;
+        return;
+    }
+    let appTypeSlug = 'game';
+    try {
+        const match = (0, catalogue_utils_1.findAppDefinition)(filePath);
+        appName = match.name;
+        appTypeSlug = (0, appUrls_1.getAppTypeSlug)(match.type);
+    }
+    catch (error) {
+        if (resolvedTarget.cataloguePath) {
+            (0, messages_1.printErrorWithHelp)(error?.message || 'Catalogue lookup failed.', [
+                'Ensure the HTML file is listed exactly once in catalogue.json with a valid type.',
+                'Run "playdrop project create app <name>" to scaffold a new entry if needed.',
+            ], { command: 'project dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const workspacePath = resolvedTarget.cataloguePath ?? (0, node_path_1.dirname)(filePath);
+    await (0, commandContext_1.withEnvironment)('project dev-browser', 'Launching the Playdrop dev browser', async ({ client, env, envConfig, account }) => {
+        let currentUsername = account?.username?.trim() ?? '';
+        if (!currentUsername) {
+            try {
+                currentUsername = await (0, devShared_1.fetchDevUsername)(client);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Authentication');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Could not fetch your account (status ${error.status}).`, [
+                        'Run "playdrop auth login" to refresh your session and ensure the API is reachable.',
+                        'Use "playdrop auth whoami" afterwards to confirm your status.',
+                    ], { command: 'project dev-browser' });
+                    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 dev-browser');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        if (resolvedTarget.cataloguePath) {
+            try {
+                await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Dev browser');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    if (error.status === 404) {
+                        (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [
+                            `Run "playdrop project create app ${appName}" to register the app before opening the dev browser.`,
+                            'If you expected it to exist, ensure you are logged into the correct environment.',
+                        ], { command: 'project dev-browser' });
+                    }
+                    else {
+                        (0, messages_1.printErrorWithHelp)(`Failed to verify app registration (status ${error.status}).`, ['Retry in a moment.', 'If the issue persists, contact the Playdrop team.'], { command: 'project dev-browser' });
+                    }
+                    process.exitCode = 1;
+                    return;
+                }
+                if ((0, devShared_1.isNetworkError)(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'project dev-browser');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
+        const devScriptAvailable = Boolean(projectInfo.projectDir
+            && projectInfo.packageJson
+            && typeof projectInfo.packageJson.scripts?.dev === 'string');
+        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 dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+        const localDevAppUrl = (0, devServer_1.buildLocalDevAppUrl)({
+            creatorUsername: currentUsername,
+            appType: appTypeSlug,
+            appName,
+            port: devServer_1.DEV_ROUTER_PORT,
+        });
+        let runtimeAssetManifest = (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)();
+        if (taskLookup.task) {
+            try {
+                runtimeAssetManifest = await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+                    client,
+                    apiBase: envConfig.apiBase,
+                    task: taskLookup.task,
+                    creatorUsername: currentUsername,
+                    appBaseUrl: new URL('.', localDevAppUrl).toString(),
+                });
+            }
+            catch (error) {
+                const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
+                (0, messages_1.printErrorWithHelp)(formatted.message, formatted.suggestions, { command: 'project dev-browser' });
+                process.exitCode = 1;
+                return;
+            }
+        }
+        let handle;
+        try {
+            handle = await (0, devServer_1.startDevServer)({
+                appName,
+                appType: appTypeSlug,
+                creatorUsername: currentUsername,
+                htmlPath: filePath,
+                port: devServer_1.DEV_ROUTER_PORT,
+                projectInfo,
+                runtimeAssetManifest,
+            });
+        }
+        catch (error) {
+            const message = typeof error?.message === 'string' ? error.message : '';
+            const mountConflict = (0, devServer_1.parseMountConflictError)(message);
+            if (mountConflict) {
+                (0, messages_1.printErrorWithHelp)(`A different dev session already owns ${mountConflict.ref}.`, [
+                    `Active owner pid: ${mountConflict.ownerPid}.`,
+                    `Mounted repo root: ${mountConflict.repoRoot}.`,
+                    `Mounted HTML path: ${mountConflict.htmlPath}.`,
+                ], { command: 'project dev-browser' });
+            }
+            else if (message.startsWith('dev_router_incompatible:')) {
+                (0, messages_1.printErrorWithHelp)(`An incompatible shared dev router is already running on port ${devServer_1.DEV_ROUTER_PORT}.`, [
+                    'Stop the existing dev router process, then retry "playdrop project dev-browser".',
+                    'If needed, rebuild the local CLI first with "npm run build --workspace @playdrop/playdrop-cli".',
+                ], { command: 'project dev-browser' });
+            }
+            else {
+                (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devServer_1.DEV_ROUTER_PORT}.`, [
+                    'Close the conflicting process or wait for the stale mount to exit.',
+                    'Ensure the app HTML file exists and is readable.',
+                ], { command: 'project dev-browser' });
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const devUrl = (0, appUrls_1.buildPlatformDevUrl)(envConfig.webBase, {
+            creatorUsername: currentUsername,
+            appName,
+            appType: appTypeSlug,
+            devAuth: devAuthSelection.devAuth,
+            player: devAuthSelection.player ? String(devAuthSelection.player) : null,
+        });
+        let launchUrl = devUrl;
+        if (devAuthSelection.devAuth !== 'anonymous') {
+            try {
+                const target = new URL(devUrl);
+                const launch = await client.startCliWebLaunch({
+                    redirectPath: `${target.pathname}${target.search}`,
+                });
+                launchUrl = launch.launchUrl;
+            }
+            catch (error) {
+                await handle.close().catch(() => { });
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Dev browser launch');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Could not prepare the Playdrop browser session (status ${error.status}).`, ['Run "playdrop auth login" and retry the dev browser command.'], { command: 'project dev-browser' });
+                    process.exitCode = 1;
+                    return;
+                }
+                if ((0, devShared_1.isNetworkError)(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to prepare the browser session.', 'project dev-browser');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
+        const runtimeRootLabel = (0, node_path_1.relative)(process.cwd(), (0, node_path_1.dirname)(filePath)) || (0, node_path_1.dirname)(filePath);
+        const profileDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)(node_os_1.default.tmpdir(), 'playdrop-dev-browser-'));
+        console.log(`App dev router mounted at ${handle.appUrl}`);
+        console.log(`Serving ${entryLabel}`);
+        console.log(`Static root ${runtimeRootLabel}`);
+        if (projectInfo.projectDir && !devScriptAvailable && projectInfo.packageJsonPath) {
+            const projectLabel = (0, devShared_1.formatProjectLabel)(projectInfo);
+            if (projectLabel) {
+                console.log(`package.json detected at ${projectLabel}, but no "dev" script was found. Run your build/watch scripts manually if needed.`);
+            }
+        }
+        console.log(`Dev URL: ${devUrl}`);
+        if (launchUrl !== devUrl) {
+            console.log(`Launch URL: ${launchUrl}`);
+        }
+        console.log('Opening an isolated Chromium dev window.');
+        console.log('Close the browser window or press Ctrl+C to stop.');
+        let context = null;
+        let cleanedUp = false;
+        const cleanup = async () => {
+            if (cleanedUp) {
+                return;
+            }
+            cleanedUp = true;
+            process.off('SIGINT', handleSignal);
+            process.off('SIGTERM', handleSignal);
+            if (context) {
+                try {
+                    await context.close();
+                }
+                catch {
+                    // Ignore browser shutdown noise during cleanup.
+                }
+            }
+            try {
+                await handle.close();
+            }
+            finally {
+                (0, node_fs_1.rmSync)(profileDir, { recursive: true, force: true });
+            }
+        };
+        const handleSignal = () => {
+            void cleanup();
+        };
+        process.on('SIGINT', handleSignal);
+        process.on('SIGTERM', handleSignal);
+        try {
+            context = await (0, playwright_1.launchPersistentChromiumContext)(profileDir, {
+                viewport: { width: 1440, height: 960 },
+            });
+        }
+        catch (error) {
+            await cleanup();
+            (0, messages_1.printErrorWithHelp)(error?.message || 'Failed to launch the Playdrop dev browser.', ['Install Playwright Chromium with "npx playwright install chromium" and retry.'], { command: 'project dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const page = context.pages()[0] ?? await context.newPage();
+            await page.goto(launchUrl, { waitUntil: 'domcontentloaded' });
+            await waitForContextClose(context);
+        }
+        catch (error) {
+            await cleanup();
+            (0, messages_1.printErrorWithHelp)(error?.message || 'Failed to open the Playdrop dev browser window.', [], { command: 'project dev-browser' });
+            process.exitCode = 1;
+            return;
+        }
+        await cleanup();
+    }, { workspacePath });
+}

package/dist/commands/devServer.js

@@ -22,6 +22,10 @@ exports.DEV_ROUTER_PORT = 8888;
 const DEV_ROUTER_HOST = '127.0.0.1';
 const CONTROL_PREFIX = '/_playdrop';
 const DEV_ROUTER_PROTOCOL_VERSION = 3;
+const APPROVED_PLAYDROP_WEB_ORIGINS = new Set([
+    'https://playdrop.ai',
+    'https://www.playdrop.ai',
+]);
 const CONTENT_TYPE_BY_EXTENSION = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
@@ -42,6 +46,25 @@ const CONTENT_TYPE_BY_EXTENSION = {
 };
 const routerMountsById = new Map();
 const routerMountIdsByKey = new Map();
+function resolveApprovedDevRouterOrigin(originHeader) {
+    const origin = originHeader?.trim();
+    if (!origin) {
+        return null;
+    }
+    let parsedOrigin;
+    try {
+        parsedOrigin = new URL(origin);
+    }
+    catch {
+        return null;
+    }
+    if (APPROVED_PLAYDROP_WEB_ORIGINS.has(parsedOrigin.origin)) {
+        return parsedOrigin.origin;
+    }
+    const isLocalWebOrigin = (parsedOrigin.protocol === 'http:' || parsedOrigin.protocol === 'https:')
+        && (parsedOrigin.hostname === 'localhost' || parsedOrigin.hostname === '127.0.0.1');
+    return isLocalWebOrigin ? parsedOrigin.origin : null;
+}
 function resolveContentType(filePath) {
     const extension = (0, node_path_1.extname)(filePath).toLowerCase();
     return CONTENT_TYPE_BY_EXTENSION[extension] || 'application/octet-stream';
@@ -426,7 +449,11 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
     // eslint-disable-next-line complexity
     const handleRequest = async (req, res) => {
         const method = req.method || 'GET';
-        res.setHeader('Access-Control-Allow-Origin', '*');
+        const allowedOrigin = resolveApprovedDevRouterOrigin(typeof req.headers.origin === 'string' ? req.headers.origin : undefined);
+        if (allowedOrigin) {
+            res.setHeader('Access-Control-Allow-Origin', allowedOrigin);
+        }
+        res.setHeader('Vary', 'Origin');
         res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Playdrop-Client, X-Playdrop-Client-Version, X-Playdrop-Client-Build, X-Playdrop-Platform, X-Playdrop-Platform-Version');
         res.setHeader('Access-Control-Allow-Private-Network', 'true');

package/dist/commands/generation.d.ts

@@ -12,7 +12,10 @@ type AiGenerateOptions = {
     instrumental?: boolean;
     loop?: boolean;
     coverPrompt?: string;
+    voice?: string;
+    providerVoiceId?: string;
     ratio?: string;
+    size?: string;
     resolution?: string;
     sourceMode?: string;
     topology?: string;

package/dist/commands/generation.js

@@ -13,15 +13,18 @@ const errors_1 = require("../errors");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
 const IMAGE_ASPECT_RATIO_SET = new Set(['1:1', '3:4', '9:16', '4:3', '16:9']);
+const IMAGE_SIZE_SET = new Set(['1K', '4K']);
 const VIDEO_ASPECT_RATIO_SET = new Set(['16:9', '9:16']);
 const DEFAULT_SUBCATEGORY_BY_MODALITY = {
     IMAGE: 'generic',
     MUSIC: 'music',
     SFX: 'sfx',
+    SPEECH: 'speech',
     VIDEO: 'generic',
     MODEL_3D: 'generic',
 };
 const DEFAULT_IMAGE_ASPECT_RATIO = '1:1';
+const DEFAULT_IMAGE_SIZE = '1K';
 const DEFAULT_VIDEO_ASPECT_RATIO = '16:9';
 const DEFAULT_VIDEO_DURATION_SECONDS = 4;
 const VIDEO_FIRST_LAST_FRAME_DURATION_SECONDS = 8;
@@ -37,11 +40,14 @@ const LOCAL_IMAGE_MIME_BY_EXTENSION = {
     '.jpeg': 'image/jpeg',
     '.webp': 'image/webp',
 };
+function isPlaydropSpeechVoiceId(value) {
+    return types_1.PLAYDROP_SPEECH_VOICE_IDS.includes(value);
+}
 function handleGenerateBuildRequestError(message) {
     const errorByCode = {
         missing_type: {
             title: 'A generation type is required.',
-            details: ['Use one of: image, music, sfx, video, model_3d.'],
+            details: ['Use one of: image, music, sfx, speech, video, model_3d.'],
         },
         missing_prompt: {
             title: 'A prompt is required.',
@@ -49,7 +55,7 @@ function handleGenerateBuildRequestError(message) {
         },
         invalid_type: {
             title: 'The generation type is invalid.',
-            details: ['Use one of: image, music, sfx, video, model_3d.'],
+            details: ['Use one of: image, music, sfx, speech, video, model_3d.'],
         },
         invalid_duration: {
             title: 'The --duration value is invalid.',
@@ -63,6 +69,14 @@ function handleGenerateBuildRequestError(message) {
             title: 'The --ratio value is invalid.',
             details: ['Image: 1:1, 3:4, 9:16, 4:3, 16:9. Video: 16:9, 9:16.'],
         },
+        invalid_image_size: {
+            title: 'The --size value is invalid.',
+            details: ['Image size must be 1K or 4K.'],
+        },
+        image_size_not_supported_for_modality: {
+            title: 'The --size option is only supported for image generation.',
+            details: ['Use --size 1K or --size 4K with "playdrop ai create image ...".'],
+        },
         missing_model3d_images: {
             title: 'Model 3D IMAGE source mode requires at least one reference image.',
             details: ['Provide --image1 <url> or --image2 <url>, or switch to --source-mode TEXT.'],
@@ -75,6 +89,26 @@ function handleGenerateBuildRequestError(message) {
             title: 'The --subcategory value is invalid.',
             details: ['Use a lowercase slug such as generic, music, sfx, or avatar.'],
         },
+        speech_disallows_subcategory: {
+            title: 'Speech does not accept --subcategory.',
+            details: ['Speech jobs always create AUDIO assets with subcategory speech.'],
+        },
+        invalid_speech_voice_selection: {
+            title: 'Speech voice options are invalid.',
+            details: ['Use either --voice <alias> or --provider-voice-id <id>, but not both.'],
+        },
+        invalid_speech_voice: {
+            title: 'The --voice value is invalid.',
+            details: [`Use one of: ${types_1.PLAYDROP_SPEECH_VOICE_IDS.join(', ')}.`],
+        },
+        speech_voice_unavailable: {
+            title: 'The provider voice is unavailable.',
+            details: ['Use a different --provider-voice-id or a curated --voice alias.'],
+        },
+        speech_input_too_long: {
+            title: 'The speech input is too long.',
+            details: [`Use ${types_1.PLAYDROP_SPEECH_MAX_WORDS} words or fewer.`],
+        },
     };
     const entry = errorByCode[message];
     if (!entry) {
@@ -139,6 +173,8 @@ function normalizeModality(value) {
         return 'MUSIC';
     if (normalized === 'SFX')
         return 'SFX';
+    if (normalized === 'SPEECH')
+        return 'SPEECH';
     if (normalized === 'VIDEO')
         return 'VIDEO';
     if (normalized === 'MODEL3D' || normalized === 'MODEL_3D')
@@ -271,6 +307,7 @@ function parseListType(raw) {
         || normalized === 'image'
         || normalized === 'music'
         || normalized === 'sfx'
+        || normalized === 'speech'
         || normalized === 'video'
         || normalized === 'model_3d') {
         return normalized;
@@ -369,10 +406,17 @@ function buildGenerateRequest(typeInput, promptInput, options) {
     if (!modality) {
         throw new Error('invalid_type');
     }
-    const prompt = typeof promptInput === 'string' ? promptInput.trim() : '';
+    const prompt = modality === 'SPEECH'
+        ? (0, types_1.normalizeSpeechText)(typeof promptInput === 'string' ? promptInput : '')
+        : typeof promptInput === 'string'
+            ? promptInput.trim()
+            : '';
     if (!prompt.length) {
         throw new Error('missing_prompt');
     }
+    if (modality === 'SPEECH' && (0, types_1.countSpeechWords)(prompt) > types_1.PLAYDROP_SPEECH_MAX_WORDS) {
+        throw new Error('speech_input_too_long');
+    }
     const visibility = normalizeVisibility(options.visibility);
     if (options.visibility && !visibility) {
         throw new Error('invalid_visibility');
@@ -386,7 +430,6 @@ function buildGenerateRequest(typeInput, promptInput, options) {
     const request = {
         modality,
         input: prompt,
-        assetSubcategory: parseAssetSubcategory(options.subcategory) ?? DEFAULT_SUBCATEGORY_BY_MODALITY[modality],
         assetName: typeof options.assetName === 'string' && options.assetName.trim().length > 0 ? options.assetName.trim() : undefined,
         assetDisplayName: typeof options.assetDisplayName === 'string' && options.assetDisplayName.trim().length > 0
             ? options.assetDisplayName.trim()
@@ -397,6 +440,12 @@ function buildGenerateRequest(typeInput, promptInput, options) {
         assetVisibility: visibility ?? 'PUBLIC',
         attachAppVersionId: parseOptionalPositiveInt(options.attachAppVersionId, 'attach_app_version_id'),
     };
+    if (modality !== 'SPEECH') {
+        request.assetSubcategory = parseAssetSubcategory(options.subcategory) ?? DEFAULT_SUBCATEGORY_BY_MODALITY[modality];
+    }
+    else if (typeof options.subcategory === 'string' && options.subcategory.trim().length > 0) {
+        throw new Error('speech_disallows_subcategory');
+    }
     if (modality === 'IMAGE') {
         request.image1 = resolveImageAttachment(options.image1, 'image1');
         request.image2 = resolveImageAttachment(options.image2, 'image2');
@@ -410,6 +459,19 @@ function buildGenerateRequest(typeInput, promptInput, options) {
         else {
             request.aspectRatio = DEFAULT_IMAGE_ASPECT_RATIO;
         }
+        if (typeof options.size === 'string' && options.size.trim().length > 0) {
+            const imageSize = options.size.trim().toUpperCase();
+            if (!IMAGE_SIZE_SET.has(imageSize)) {
+                throw new Error('invalid_image_size');
+            }
+            request.imageSize = imageSize;
+        }
+        else {
+            request.imageSize = DEFAULT_IMAGE_SIZE;
+        }
+    }
+    else if (typeof options.size === 'string' && options.size.trim().length > 0) {
+        throw new Error('image_size_not_supported_for_modality');
     }
     if (modality === 'MUSIC') {
         request.durationMs = parseMusicDurationMs(duration);
@@ -421,6 +483,24 @@ function buildGenerateRequest(typeInput, promptInput, options) {
         request.loop = Boolean(options.loop);
         request.coverPrompt = typeof options.coverPrompt === 'string' && options.coverPrompt.trim().length > 0 ? options.coverPrompt.trim() : undefined;
     }
+    if (modality === 'SPEECH') {
+        const speechVoice = typeof options.voice === 'string' && options.voice.trim().length > 0 ? options.voice.trim() : undefined;
+        const speechProviderVoiceId = typeof options.providerVoiceId === 'string' && options.providerVoiceId.trim().length > 0
+            ? options.providerVoiceId.trim()
+            : undefined;
+        if (speechVoice && speechProviderVoiceId) {
+            throw new Error('invalid_speech_voice_selection');
+        }
+        let validatedSpeechVoice;
+        if (speechVoice) {
+            if (!isPlaydropSpeechVoiceId(speechVoice)) {
+                throw new Error('invalid_speech_voice');
+            }
+            validatedSpeechVoice = speechVoice;
+        }
+        request.speechVoice = validatedSpeechVoice;
+        request.speechProviderVoiceId = speechProviderVoiceId;
+    }
     if (modality === 'VIDEO') {
         request.image1 = resolveImageAttachment(options.image1, 'image1');
         request.image2 = resolveImageAttachment(options.image2, 'image2');