blitzreels 0.1.8 → 0.1.10

package/dist/commands/clips.js

@@ -1,7 +1,71 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { CliOperationError, CliUsageError } from "../cli-errors.js";
 import { commandSpec } from "../command-metadata.js";
 export const CLIPS_COMMAND_SPECS = [
+    commandSpec({
+        command: ["clip-share-pages", "get"],
+        usage: "blitzreels clip-share-pages get --asset-id ID [--json]",
+        flags: ["asset-id"],
+        description: "Inspect the public clip share page and its hidden clip ids.",
+    }),
+    commandSpec({
+        command: ["clip-share-pages", "publish"],
+        usage: "blitzreels clip-share-pages publish --asset-id ID --idempotency-key KEY [--allow-downloads true|false] [--dry-run] [--json]",
+        flags: [
+            "asset-id",
+            { name: "allow-downloads", type: "boolean" },
+            { name: "idempotency-key", required: true },
+        ],
+        description: "Publish the clip share page for a source asset.",
+        mutates: true,
+        dryRunSupported: true,
+    }),
+    commandSpec({
+        command: ["clip-share-pages", "unpublish"],
+        usage: "blitzreels clip-share-pages unpublish --asset-id ID --idempotency-key KEY [--dry-run] [--json]",
+        flags: ["asset-id", { name: "idempotency-key", required: true }],
+        description: "Disable the public clip share page for a source asset.",
+        mutates: true,
+        dryRunSupported: true,
+    }),
+    commandSpec({
+        command: ["clip-share-pages", "set-clip-visibility"],
+        usage: "blitzreels clip-share-pages set-clip-visibility --asset-id ID --clip-id ID --visibility visible|hidden --idempotency-key KEY [--dry-run] [--json]",
+        flags: [
+            "asset-id",
+            "clip-id",
+            { name: "visibility", enum: ["visible", "hidden"], required: true },
+            { name: "idempotency-key", required: true },
+        ],
+        description: "Show or hide one clip on its source asset share page.",
+        mutates: true,
+        dryRunSupported: true,
+    }),
+    commandSpec({
+        command: ["clip-batches", "get"],
+        usage: "blitzreels clip-batches get --batch-id ID [--json]",
+        flags: ["batch-id"],
+        description: "Inspect clip batch progress, Studio Sound status, and terminal errors.",
+    }),
+    commandSpec({
+        command: ["clip-batches", "wait"],
+        usage: "blitzreels clip-batches wait --batch-id ID [--interval-ms 3000] [--timeout-ms 1200000] [--json]",
+        flags: ["batch-id", "interval-ms", "timeout-ms"],
+        description: "Wait for a clip batch to complete or fail, including asynchronous Studio Sound.",
+    }),
+    commandSpec({
+        command: ["clip-batches", "recover"],
+        usage: "blitzreels clip-batches recover --batch-id ID [--target-count 10] --idempotency-key KEY [--dry-run] [--json]",
+        flags: [
+            "batch-id",
+            { name: "target-count", type: "number" },
+            { name: "idempotency-key", required: true },
+        ],
+        description: "Preserve accepted clips and refill a terminal batch in its existing project folder.",
+        mutates: true,
+        dryRunSupported: true,
+    }),
     commandSpec({
         command: ["clip-batches", "delete"],
         usage: "blitzreels clip-batches delete --batch-id ID --retention retain_projects_and_exports|delete_projects_and_exports --idempotency-key KEY --confirm-delete [--dry-run] [--json]",
@@ -42,14 +106,46 @@ export const CLIPS_COMMAND_SPECS = [
                     "failed",
                 ],
             },
-            "limit",
+            {
+                name: "limit",
+                type: "number",
+                description: "Maximum 50 clips per page.",
+            },
             "offset",
         ],
         description: "List managed clip runs with bounded output.",
     }),
+    commandSpec({
+        command: ["clips", "attach-export"],
+        usage: "blitzreels clips attach-export --asset-id ID --project-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY [--dry-run] [--json]",
+        flags: [
+            "asset-id",
+            "project-id",
+            "export-id",
+            { name: "confirm-visual-qa", required: true },
+            { name: "idempotency-key", required: true },
+        ],
+        description: "Attach one visually accepted completed project export to managed clips.",
+        mutates: true,
+        destructive: true,
+        dryRunSupported: true,
+    }),
+    commandSpec({
+        command: ["clips", "promote-export"],
+        usage: "blitzreels clips promote-export --clip-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY [--dry-run] [--json]",
+        flags: [
+            "clip-id",
+            "export-id",
+            { name: "confirm-visual-qa", required: true },
+            { name: "idempotency-key", required: true },
+        ],
+        description: "Promote one visually accepted completed export as the managed clip delivery.",
+        mutates: true,
+        dryRunSupported: true,
+    }),
     commandSpec({
         command: ["clips", "create"],
-        usage: "blitzreels clips create [--asset-id ID|--youtube-url URL] [--output ./clips] [--count 5] [--idempotency-key KEY]",
+        usage: "blitzreels clips create [--asset-id ID|--youtube-url URL] [--output ./clips] [--count 5] [--studio-sound] [--layout-mode people_first] [--content-type-hint podcast] [--idempotency-key KEY]",
         flags: [
             { name: "asset-id", enum: [] },
             "youtube-url",
@@ -62,7 +158,7 @@ export const CLIPS_COMMAND_SPECS = [
                 name: "count",
                 type: "number",
                 default: 5,
-                description: "Maximum rendered clips to download from the batch.",
+                description: "Maximum clips created by the batch.",
             },
             {
                 name: "preset",
@@ -79,6 +175,28 @@ export const CLIPS_COMMAND_SPECS = [
                 hidden: false,
             },
             { name: "caption-theme-id" },
+            {
+                name: "studio-sound",
+                type: "boolean",
+                description: "Clean the source audio once before rendering clips.",
+            },
+            {
+                name: "layout-mode",
+                enum: [
+                    "auto",
+                    "people_first",
+                    "screen_first",
+                    "preserve_full_source",
+                    "prefer_split",
+                    "prefer_focus",
+                    "prefer_tutorial",
+                    "prefer_demo",
+                ],
+            },
+            {
+                name: "content-type-hint",
+                enum: ["auto", "podcast", "tutorial", "demo", "generic"],
+            },
             {
                 name: "idempotency-key",
                 description: "Stable retry key; reuse only with identical inputs.",
@@ -90,6 +208,7 @@ export const CLIPS_COMMAND_SPECS = [
         examples: [
             "blitzreels clips create --asset-id ID --output ./clips",
             "blitzreels clips create --asset-id ID --logo-asset-id LOGO_ID --output ./clips --count 5",
+            "blitzreels clips create --asset-id ID --layout-mode people_first --content-type-hint podcast",
             "blitzreels clips create --youtube-url https://youtube.com/watch?v=...",
         ],
     }),
@@ -107,7 +226,7 @@ export const CLIPS_COMMAND_SPECS = [
     }),
     commandSpec({
         command: ["clips", "reselect"],
-        usage: "blitzreels clips reselect --clip-id ID [--suggestion-id ID | --start-seconds 52 --end-seconds 64]",
+        usage: "blitzreels clips reselect --clip-id ID [--suggestion-id ID | --start-seconds 52 --end-seconds 64] [--layout-mode people_first] [--content-type-hint podcast] [--caption-style-id cinematic-film] [--caption-word-reveal-animation fade] [--caption-max-lines 2] [--caption-words-per-line 8] [--caption-page-combine-ms 3000]",
         flags: [
             "clip-id",
             "suggestion-id",
@@ -120,8 +239,54 @@ export const CLIPS_COMMAND_SPECS = [
             },
             { name: "min-duration", hidden: true },
             { name: "max-duration", hidden: true },
+            {
+                name: "layout-mode",
+                enum: [
+                    "auto",
+                    "people_first",
+                    "screen_first",
+                    "preserve_full_source",
+                    "prefer_split",
+                    "prefer_focus",
+                    "prefer_tutorial",
+                    "prefer_demo",
+                ],
+            },
+            {
+                name: "content-type-hint",
+                enum: ["auto", "podcast", "tutorial", "demo", "generic"],
+            },
+            {
+                name: "tutorial-stack-ratio",
+                enum: ["screen_70_face_30", "screen_50_face_50"],
+                hidden: true,
+            },
+            "captions-enabled",
+            "caption-style-id",
+            {
+                name: "caption-word-reveal-animation",
+                enum: [
+                    "none",
+                    "fade",
+                    "scale",
+                    "slide-up",
+                    "slide-left",
+                    "slide-mix",
+                    "pop",
+                    "drop",
+                    "slam",
+                    "typewriter",
+                    "glitch",
+                    "mask-reveal",
+                    "bounce-up",
+                    "split-reveal",
+                ],
+            },
+            "caption-max-lines",
+            "caption-words-per-line",
+            "caption-page-combine-ms",
         ],
-        description: "Choose a different suggestion or time range for a clip.",
+        description: "Regenerate a clip from a suggestion or time range with optional layout and caption settings.",
         mutates: true,
     }),
     commandSpec({
@@ -163,10 +328,111 @@ export const CLIPS_COMMAND_SPECS = [
         mutates: true,
     }),
 ];
+function parseClipShareVisibility({ value, }) {
+    if (value === "visible" || value === "hidden") {
+        return value;
+    }
+    throw new CliUsageError({
+        code: "invalid_flag_value",
+        message: "--visibility must be visible or hidden.",
+    });
+}
+function parseClipListLimit({ value, }) {
+    if (value === undefined)
+        return undefined;
+    if (Number.isInteger(value) && value >= 1 && value <= 50)
+        return value;
+    throw new CliUsageError({
+        code: "invalid_flag_value",
+        message: "--limit must be an integer between 1 and 50.",
+    });
+}
+function printClipBatchResult({ context, result, helpers, }) {
+    helpers.printResult({
+        json: context.json,
+        value: result,
+        human: [
+            `Batch ${result.batch.batch_id}: ${result.batch.status}`,
+            `Studio Sound: ${result.batch.studio_sound.status}`,
+            `Accepted: ${result.batch.rendered_count}/${result.batch.estimated_clip_count}`,
+            ...(result.batch.last_error_message === null
+                ? []
+                : [`Error: ${result.batch.last_error_message}`]),
+        ],
+    });
+}
+async function waitForClipBatch({ context, helpers, }) {
+    const batchId = helpers.requireStringFlag({
+        flags: context.args.flags,
+        name: "batch-id",
+    });
+    const intervalMs = helpers.getNumberFlag({
+        flags: context.args.flags,
+        name: "interval-ms",
+    }) ?? 3000;
+    const timeoutMs = helpers.getNumberFlag({
+        flags: context.args.flags,
+        name: "timeout-ms",
+    }) ?? 20 * 60 * 1000;
+    const startedAt = Date.now();
+    while (true) {
+        const result = await context.client.clipBatches.get({ batchId });
+        if (result.batch.studio_sound.status === "failed") {
+            throw new CliOperationError({
+                code: "studio_sound_failed",
+                exitCode: 5,
+                message: `Clip batch ${batchId} failed Studio Sound: ${result.batch.studio_sound.error_message ?? result.batch.last_error_message ?? "treatment was not applied"}`,
+                retryable: false,
+                suggestions: [
+                    `blitzreels clip-batches recover --batch-id ${batchId} --idempotency-key NEW_KEY --json`,
+                ],
+            });
+        }
+        if (result.batch.status === "failed") {
+            throw new CliOperationError({
+                code: "clip_batch_failed",
+                exitCode: 5,
+                message: `Clip batch ${batchId} failed: ${result.batch.last_error_message ?? result.batch.studio_sound.error_message ?? "clip processing failed"}`,
+                retryable: false,
+                suggestions: [
+                    `blitzreels clip-batches recover --batch-id ${batchId} --idempotency-key NEW_KEY --json`,
+                ],
+            });
+        }
+        if (result.batch.status === "completed_with_errors") {
+            throw new CliOperationError({
+                code: "clip_batch_incomplete",
+                exitCode: 5,
+                message: `Clip batch ${batchId} completed with ${result.batch.failed_count + result.batch.review_count} clips needing recovery.`,
+                retryable: false,
+                suggestions: [
+                    `blitzreels clip-batches recover --batch-id ${batchId} --idempotency-key NEW_KEY --json`,
+                ],
+            });
+        }
+        if (result.batch.status === "completed") {
+            return result;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new CliOperationError({
+                code: "clip_batch_wait_timeout",
+                exitCode: 7,
+                message: `Timed out waiting for clip batch ${batchId}.`,
+                retryable: true,
+                suggestions: [
+                    `blitzreels clip-batches get --batch-id ${batchId} --json`,
+                ],
+            });
+        }
+        await helpers.sleep({ ms: intervalMs });
+    }
+}
 export function createClipsCommandOperation({ helpers, }) {
     return {
         name: "clips",
-        matches: ({ command }) => command[0] === "clips" || command[0] === "clip-batches",
+        matches: ({ command }) => command[0] === "clips" ||
+            command[0] === "clip-batches" ||
+            command[0] === "clip-share-pages",
         handle: ({ context }) => handleClipsCommand({ context, helpers }),
         buildDryRun: ({ context, spec }) => buildClipsDryRun({ context, spec, helpers }),
     };
@@ -174,6 +440,118 @@ export function createClipsCommandOperation({ helpers, }) {
 async function handleClipsCommand({ context, helpers, }) {
     const action = context.args.command[1];
     const flags = context.args.flags;
+    if (context.args.command[0] === "clip-share-pages") {
+        const assetId = helpers.requireStringFlag({ flags, name: "asset-id" });
+        if (action === "get") {
+            const result = await context.client.clipSharePages.get({ assetId });
+            helpers.printResult({
+                json: context.json,
+                value: result,
+                human: [
+                    result.enabled
+                        ? `Published: ${result.share_url}`
+                        : "Share page is not published.",
+                    `Hidden clips: ${result.hidden_clip_ids.length}`,
+                ],
+            });
+            return true;
+        }
+        if (action === "publish" || action === "unpublish") {
+            const result = await context.client.clipSharePages.setEnabled({
+                assetId,
+                enabled: action === "publish",
+                allowDownloads: helpers.getOptionalBooleanFlag({
+                    flags,
+                    name: "allow-downloads",
+                }),
+                idempotencyKey: helpers.requireStringFlag({
+                    flags,
+                    name: "idempotency-key",
+                }),
+            });
+            helpers.printResult({
+                json: context.json,
+                value: result,
+                human: [
+                    result.enabled
+                        ? `Published: ${result.share_url}`
+                        : "Share page unpublished.",
+                ],
+            });
+            return true;
+        }
+        if (action === "set-clip-visibility") {
+            const visibility = parseClipShareVisibility({
+                value: helpers.requireStringFlag({
+                    flags,
+                    name: "visibility",
+                }),
+            });
+            const result = await context.client.clipSharePages.setClipVisibility({
+                assetId,
+                clipId: helpers.requireStringFlag({ flags, name: "clip-id" }),
+                visibility,
+                idempotencyKey: helpers.requireStringFlag({
+                    flags,
+                    name: "idempotency-key",
+                }),
+            });
+            helpers.printResult({
+                json: context.json,
+                value: result,
+                human: [`Clip ${result.clip_id}: ${result.visibility}`],
+            });
+            return true;
+        }
+    }
+    if (context.args.command[0] === "clip-batches" && action === "get") {
+        const result = await context.client.clipBatches.get({
+            batchId: helpers.requireStringFlag({ flags, name: "batch-id" }),
+        });
+        printClipBatchResult({ context, result, helpers });
+        return true;
+    }
+    if (context.args.command[0] === "clip-batches" && action === "wait") {
+        const result = await waitForClipBatch({ context, helpers });
+        printClipBatchResult({ context, result, helpers });
+        return true;
+    }
+    if (context.args.command[0] === "clip-batches" && action === "recover") {
+        const result = await context.client.clipBatches.recover({
+            batchId: helpers.requireStringFlag({ flags, name: "batch-id" }),
+            targetClipCount: helpers.getNumberFlag({ flags, name: "target-count" }) ?? null,
+            idempotencyKey: helpers.requireStringFlag({
+                flags,
+                name: "idempotency-key",
+            }),
+        });
+        if (result.status === "failed") {
+            throw new CliOperationError({
+                code: "clip_batch_recovery_failed",
+                exitCode: 5,
+                message: `Recovery batch ${result.recovery_batch_id ?? result.source_batch_id} failed: ${result.queue_reason ?? "clip recovery failed"}`,
+                retryable: false,
+                suggestions: [
+                    'blitzreels agent-context --command "clip-batches recover" --json',
+                ],
+            });
+        }
+        const statusLine = result.status === "satisfied"
+            ? `Batch ${result.source_batch_id} already has ${result.retained_clip_count}/${result.target_clip_count} accepted clips.`
+            : result.status === "queued"
+                ? `Recovery batch ${result.recovery_batch_id} queued for ${result.refill_clip_count} missing clips.`
+                : `Recovery batch ${result.recovery_batch_id} created; waiting: ${result.queue_reason ?? "not ready to queue"}.`;
+        helpers.printResult({
+            json: context.json,
+            value: result,
+            human: [
+                statusLine,
+                `Folder: ${result.project_folder_id}`,
+                "Duration policy: quality first; suggestion boundaries preserved.",
+            ],
+        });
+        return true;
+    }
     if (context.args.command[0] === "clip-batches" && action === "delete") {
         if (helpers.getOptionalBooleanFlag({ flags, name: "confirm-delete" }) !== true) {
             throw new Error("Pass --confirm-delete to delete a clip batch.");
@@ -216,6 +594,66 @@ async function handleClipsCommand({ context, helpers, }) {
         });
         return true;
     }
+    if (action === "attach-export") {
+        if (helpers.getOptionalBooleanFlag({
+            flags,
+            name: "confirm-visual-qa",
+        }) !== true) {
+            throw new CliUsageError({
+                code: "missing_visual_qa_confirmation",
+                message: "Pass --confirm-visual-qa only after reviewing the completed MP4.",
+                usage: "blitzreels clips attach-export --asset-id ID --project-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY",
+            });
+        }
+        const result = await context.client.clips.attachExport({
+            assetId: helpers.requireStringFlag({ flags, name: "asset-id" }),
+            projectId: helpers.requireStringFlag({ flags, name: "project-id" }),
+            exportId: helpers.requireStringFlag({ flags, name: "export-id" }),
+            confirmVisualQa: true,
+            idempotencyKey: helpers.requireStringFlag({
+                flags,
+                name: "idempotency-key",
+            }),
+        });
+        helpers.printResult({
+            json: context.json,
+            value: result,
+            human: [
+                `Attached export ${result.export_id} to managed clip ${result.clip_id}.`,
+            ],
+        });
+        return true;
+    }
+    if (action === "promote-export") {
+        if (helpers.getOptionalBooleanFlag({
+            flags,
+            name: "confirm-visual-qa",
+        }) !== true) {
+            throw new CliUsageError({
+                code: "missing_visual_qa_confirmation",
+                message: "Pass --confirm-visual-qa only after reviewing the completed MP4.",
+                usage: "blitzreels clips promote-export --clip-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY",
+            });
+        }
+        const result = await context.client.clips.promoteExport({
+            clipId: helpers.requireStringFlag({ flags, name: "clip-id" }),
+            exportId: helpers.requireStringFlag({ flags, name: "export-id" }),
+            confirmVisualQa: true,
+            idempotencyKey: helpers.requireStringFlag({
+                flags,
+                name: "idempotency-key",
+            }),
+        });
+        helpers.printResult({
+            json: context.json,
+            value: result,
+            human: [
+                `Promoted export ${result.export_id} for managed clip ${result.clip_id}.`,
+                `Previous export retained: ${result.previous_export_id}.`,
+            ],
+        });
+        return true;
+    }
     if (action === "list") {
         const result = await context.client.clips.list({
             assetId: helpers.getStringFlag({ flags, name: "asset-id" }),
@@ -223,7 +661,9 @@ async function handleClipsCommand({ context, helpers, }) {
             status: parseClipStatus({
                 value: helpers.getStringFlag({ flags, name: "status" }),
             }),
-            limit: helpers.getNumberFlag({ flags, name: "limit" }),
+            limit: parseClipListLimit({
+                value: helpers.getNumberFlag({ flags, name: "limit" }),
+            }),
             offset: helpers.getNumberFlag({ flags, name: "offset" }),
         });
         helpers.printResult({
@@ -259,6 +699,8 @@ async function handleClipsCommand({ context, helpers, }) {
             flags,
             name: "selection-mode",
         });
+        const layout = buildReselectLayout({ flags, helpers });
+        const captions = buildReselectCaptions({ flags, helpers });
         const result = await context.client.clips.reselect({
             clipId,
             ...(selectionMode === undefined
@@ -267,10 +709,14 @@ async function handleClipsCommand({ context, helpers, }) {
                     startSeconds: selection.startSeconds,
                     endSeconds: selection.endSeconds,
                     target,
+                    layout,
+                    captions,
                 }
                 : {
                     selection,
                     target,
+                    layout,
+                    captions,
                 }),
         });
         helpers.printClipResult({ context, result });
@@ -342,6 +788,128 @@ function formatClipListLine({ clip }) {
 function buildClipsDryRun({ context, spec, helpers, }) {
     const action = context.args.command[1];
     const flags = context.args.flags;
+    if (context.args.command[0] === "clips" && action === "attach-export") {
+        if (helpers.getOptionalBooleanFlag({
+            flags,
+            name: "confirm-visual-qa",
+        }) !== true) {
+            throw new CliUsageError({
+                code: "missing_visual_qa_confirmation",
+                message: "Pass --confirm-visual-qa only after reviewing the completed MP4.",
+                usage: "blitzreels clips attach-export --asset-id ID --project-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY",
+            });
+        }
+        return helpers.dryRunRequest({
+            spec,
+            method: "POST",
+            path: "/clips/attach-export",
+            headers: {
+                "Idempotency-Key": helpers.requireStringFlag({
+                    flags,
+                    name: "idempotency-key",
+                }),
+            },
+            body: {
+                asset_id: helpers.requireStringFlag({ flags, name: "asset-id" }),
+                project_id: helpers.requireStringFlag({ flags, name: "project-id" }),
+                export_id: helpers.requireStringFlag({ flags, name: "export-id" }),
+                confirm_visual_qa: true,
+            },
+        });
+    }
+    if (context.args.command[0] === "clips" && action === "promote-export") {
+        if (helpers.getOptionalBooleanFlag({
+            flags,
+            name: "confirm-visual-qa",
+        }) !== true) {
+            throw new CliUsageError({
+                code: "missing_visual_qa_confirmation",
+                message: "Pass --confirm-visual-qa only after reviewing the completed MP4.",
+                usage: "blitzreels clips promote-export --clip-id ID --export-id ID --confirm-visual-qa --idempotency-key KEY",
+            });
+        }
+        const clipId = helpers.requireStringFlag({ flags, name: "clip-id" });
+        return helpers.dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/clips/${encodeURIComponent(clipId)}/promote-export`,
+            headers: {
+                "Idempotency-Key": helpers.requireStringFlag({
+                    flags,
+                    name: "idempotency-key",
+                }),
+            },
+            body: {
+                export_id: helpers.requireStringFlag({ flags, name: "export-id" }),
+                confirm_visual_qa: true,
+            },
+        });
+    }
+    if (context.args.command[0] === "clip-share-pages") {
+        const assetId = helpers.requireStringFlag({ flags, name: "asset-id" });
+        if (action === "publish" || action === "unpublish") {
+            return helpers.dryRunRequest({
+                spec,
+                method: "POST",
+                path: `/clip-share-pages/${encodeURIComponent(assetId)}`,
+                headers: {
+                    "Idempotency-Key": helpers.requireStringFlag({
+                        flags,
+                        name: "idempotency-key",
+                    }),
+                },
+                body: {
+                    enabled: action === "publish",
+                    allow_downloads: helpers.getOptionalBooleanFlag({
+                        flags,
+                        name: "allow-downloads",
+                    }),
+                },
+            });
+        }
+        if (action === "set-clip-visibility") {
+            const clipId = helpers.requireStringFlag({ flags, name: "clip-id" });
+            return helpers.dryRunRequest({
+                spec,
+                method: "POST",
+                path: `/clip-share-pages/${encodeURIComponent(assetId)}/clips/${encodeURIComponent(clipId)}/visibility`,
+                headers: {
+                    "Idempotency-Key": helpers.requireStringFlag({
+                        flags,
+                        name: "idempotency-key",
+                    }),
+                },
+                body: {
+                    visibility: parseClipShareVisibility({
+                        value: helpers.requireStringFlag({
+                            flags,
+                            name: "visibility",
+                        }),
+                    }),
+                },
+            });
+        }
+    }
+    if (context.args.command[0] === "clip-batches" && action === "recover") {
+        return helpers.dryRunRequest({
+            spec,
+            method: "POST",
+            path: `/clip-batches/${encodeURIComponent(helpers.requireStringFlag({ flags, name: "batch-id" }))}/recover`,
+            headers: {
+                "Idempotency-Key": helpers.requireStringFlag({
+                    flags,
+                    name: "idempotency-key",
+                }),
+            },
+            body: {
+                target_clip_count: helpers.getNumberFlag({ flags, name: "target-count" }) ?? null,
+            },
+            notes: [
+                "Accepted exports remain linked; only the missing accepted count is refilled.",
+                "Suggestion boundaries are preserved even when a coherent clip exceeds the target duration.",
+            ],
+        });
+    }
     if (context.args.command[0] === "clip-batches" && action === "delete") {
         return helpers.dryRunRequest({
             spec,
@@ -392,8 +960,10 @@ function buildClipsDryRun({ context, spec, helpers, }) {
                     quality: null,
                 },
                 clip_preset_id: options.clipPresetId,
+                max_clip_count: options.count,
                 caption_theme_id: options.captionThemeId,
-                create_flow_options: {},
+                studio_sound: options.studioSound,
+                create_flow_options: buildClipWorkflowCreateFlowOptions({ options }),
                 branding_options: buildClipWorkflowBrandingOptions({
                     logoAssetId: options.logoAssetId,
                 }),
@@ -426,6 +996,8 @@ function buildClipsDryRun({ context, spec, helpers, }) {
             flags,
             name: "selection-mode",
         });
+        const layout = buildReselectLayout({ flags, helpers });
+        const captions = buildReselectCaptions({ flags, helpers });
         return helpers.dryRunRequest({
             spec,
             method: "POST",
@@ -449,6 +1021,12 @@ function buildClipsDryRun({ context, spec, helpers, }) {
                                 max_duration_seconds: target.maxDurationSeconds,
                             },
                         }),
+                    ...(layout === null
+                        ? {}
+                        : { layout: toApiClipLayout({ layout }) }),
+                    ...(captions === null
+                        ? {}
+                        : { captions: toApiClipCaptions({ captions }) }),
                 }
                 : {
                     selection: toApiClipSelection({ selection }),
@@ -458,6 +1036,8 @@ function buildClipsDryRun({ context, spec, helpers, }) {
                             min_duration_seconds: target.minDurationSeconds,
                             max_duration_seconds: target.maxDurationSeconds,
                         },
+                    layout: layout === null ? null : toApiClipLayout({ layout }),
+                    captions: captions === null ? null : toApiClipCaptions({ captions }),
                 },
         });
     }
@@ -501,6 +1081,17 @@ function parseClipBatchDeleteRetention({ value, }) {
     }
     throw new Error("--retention must be retain_projects_and_exports or delete_projects_and_exports.");
 }
+function buildClipWorkflowCreateFlowOptions({ options, }) {
+    return {
+        ...(options.layoutMode === undefined
+            ? {}
+            : { reframeLayoutMode: options.layoutMode }),
+        ...(options.contentTypeHint === undefined
+            ? {}
+            : { reframeContentTypeHint: options.contentTypeHint }),
+        ...(options.studioSound ? { useStudioSound: true } : {}),
+    };
+}
 function parseClipWorkflowOptions({ flags, helpers, }) {
     const count = helpers.getNumberFlag({ flags, name: "count" }) ?? 5;
     if (!Number.isInteger(count) || count < 1 || count > 10) {
@@ -540,6 +1131,13 @@ function parseClipWorkflowOptions({ flags, helpers, }) {
         captionThemeId: parseNullableWorkflowString({
             value: helpers.getStringFlag({ flags, name: "caption-theme-id" }),
         }),
+        layoutMode: parseClipLayoutMode({
+            value: helpers.getStringFlag({ flags, name: "layout-mode" }),
+        }),
+        contentTypeHint: parseClipContentTypeHint({
+            value: helpers.getStringFlag({ flags, name: "content-type-hint" }),
+        }),
+        studioSound: helpers.getOptionalBooleanFlag({ flags, name: "studio-sound" }) ?? false,
         idempotencyKey: helpers.getStringFlag({ flags, name: "idempotency-key" }) ?? null,
     };
 }
@@ -574,8 +1172,10 @@ async function createClipWorkflow({ context, helpers, }) {
             quality: null,
         },
         clipPresetId: options.clipPresetId,
+        maxClipCount: options.count,
         captionThemeId: options.captionThemeId,
-        createFlowOptions: {},
+        studioSound: options.studioSound,
+        createFlowOptions: buildClipWorkflowCreateFlowOptions({ options }),
         brandingOptions: buildClipWorkflowBrandingOptions({
             logoAssetId: options.logoAssetId,
         }),
@@ -695,4 +1295,138 @@ function toApiClipSelection({ selection, }) {
         end_seconds: selection.endSeconds,
     };
 }
+function parseClipLayoutMode({ value, }) {
+    if (value === undefined ||
+        value === "auto" ||
+        value === "people_first" ||
+        value === "screen_first" ||
+        value === "preserve_full_source" ||
+        value === "prefer_split" ||
+        value === "prefer_focus" ||
+        value === "prefer_tutorial" ||
+        value === "prefer_demo") {
+        return value;
+    }
+    throw new Error(`Unsupported clip layout mode: ${value}`);
+}
+function parseClipContentTypeHint({ value, }) {
+    if (value === undefined ||
+        value === "auto" ||
+        value === "podcast" ||
+        value === "tutorial" ||
+        value === "demo" ||
+        value === "generic") {
+        return value;
+    }
+    throw new Error(`Unsupported clip content type hint: ${value}`);
+}
+function parseTutorialStackRatio({ value, }) {
+    if (value === undefined ||
+        value === "screen_70_face_30" ||
+        value === "screen_50_face_50") {
+        return value;
+    }
+    throw new Error(`Unsupported tutorial stack ratio: ${value}`);
+}
+function buildReselectLayout({ flags, helpers, }) {
+    const mode = parseClipLayoutMode({
+        value: helpers.getStringFlag({ flags, name: "layout-mode" }),
+    });
+    const contentTypeHint = parseClipContentTypeHint({
+        value: helpers.getStringFlag({ flags, name: "content-type-hint" }),
+    });
+    const tutorialStackRatio = parseTutorialStackRatio({
+        value: helpers.getStringFlag({ flags, name: "tutorial-stack-ratio" }),
+    });
+    if (mode === undefined &&
+        contentTypeHint === undefined &&
+        tutorialStackRatio === undefined) {
+        return null;
+    }
+    return { mode, contentTypeHint, tutorialStackRatio };
+}
+function buildReselectCaptions({ flags, helpers, }) {
+    const enabled = helpers.getOptionalBooleanFlag({
+        flags,
+        name: "captions-enabled",
+    });
+    const styleId = helpers.getStringFlag({
+        flags,
+        name: "caption-style-id",
+    });
+    const wordRevealAnimation = parseCaptionWordRevealAnimation({
+        value: helpers.getStringFlag({
+            flags,
+            name: "caption-word-reveal-animation",
+        }),
+    });
+    const maxLinesPerCaption = helpers.getNumberFlag({
+        flags,
+        name: "caption-max-lines",
+    });
+    const wordsPerLineLimit = helpers.getNumberFlag({
+        flags,
+        name: "caption-words-per-line",
+    });
+    const pageCombineMs = helpers.getNumberFlag({
+        flags,
+        name: "caption-page-combine-ms",
+    });
+    if (enabled === undefined &&
+        styleId === undefined &&
+        wordRevealAnimation === undefined &&
+        maxLinesPerCaption === undefined &&
+        wordsPerLineLimit === undefined &&
+        pageCombineMs === undefined) {
+        return null;
+    }
+    return {
+        enabled,
+        styleId,
+        wordRevealAnimation,
+        maxLinesPerCaption,
+        wordsPerLineLimit,
+        pageCombineMs,
+    };
+}
+function parseCaptionWordRevealAnimation({ value, }) {
+    const supported = [
+        "none",
+        "fade",
+        "scale",
+        "slide-up",
+        "slide-left",
+        "slide-mix",
+        "pop",
+        "drop",
+        "slam",
+        "typewriter",
+        "glitch",
+        "mask-reveal",
+        "bounce-up",
+        "split-reveal",
+    ];
+    if (value === undefined ||
+        supported.some((candidate) => candidate === value)) {
+        return value;
+    }
+    throw new Error(`Unsupported caption word reveal animation: ${value}`);
+}
+function toApiClipLayout({ layout }) {
+    return {
+        layout_mode: layout.mode,
+        content_type_hint: layout.contentTypeHint,
+        tutorial_stack_ratio: layout.tutorialStackRatio,
+    };
+}
+function toApiClipCaptions({ captions }) {
+    return {
+        enabled: captions.enabled,
+        style_id: captions.styleId,
+        word_reveal_animation: captions.wordRevealAnimation,
+        max_lines_per_caption: captions.maxLinesPerCaption,
+        words_per_line_limit: captions.wordsPerLineLimit,
+        page_combine_ms: captions.pageCombineMs,
+    };
+}
 //# sourceMappingURL=clips.js.map