demofly 0.2.8 → 0.2.10

package/dist/commands/generate.js

@@ -1,5 +1,5 @@
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, writeFileSync, readFileSync, copyFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, writeFileSync, readFileSync, copyFileSync, renameSync, unlinkSync, } from "node:fs";
 import { resolve, basename, extname } from "node:path";
 import * as readline from "node:readline";
 import { parseTimingMarkers, normalizeTimingData } from "../lib/timing.js";
@@ -7,19 +7,22 @@ import { debug } from "../lib/logger.js";
 import { generateAllAudio, parseTranscript } from "../lib/tts.js";
 import { extractTimestamps } from "../lib/timestamps.js";
 import { buildAndWriteAlignment } from "../lib/alignment.js";
-import { generateAndWriteEditProposals } from "../lib/edit-proposals.js";
-import { retimeAndAssemble } from "../lib/retiming.js";
 import { getToken } from "../lib/credentials.js";
 import { createApiClient, getAppUrl } from "../lib/api-client.js";
 import { getDefaultVoice } from "../lib/voice-config.js";
-import { isCloudVoice, KOKORO_VOICES, KOKORO_DEFAULT_VOICE, resolveVoiceFromFlags, } from "../lib/voice-resolver.js";
+import { getDemoVoicePreference, setDemoVoicePreference } from "../lib/demo-config.js";
+import { isCloudVoice, KOKORO_DEFAULT_VOICE, resolveVoiceFromFlags, } from "../lib/voice-resolver.js";
 import { generateCloudAudio, getSubscriptionStatus } from "../lib/cloud-tts.js";
+import { assembleScenes } from "../lib/scene-assembler.js";
 function validateDemoArtifacts(demoDir, demo) {
-    const specPath = resolve(demoDir, "demo.spec.ts");
     const configPath = resolve(demoDir, "playwright.config.ts");
+    const scenesDir = resolve(demoDir, "scenes");
+    const legacySpecPath = resolve(demoDir, "demo.spec.ts");
     let valid = true;
-    if (!existsSync(specPath)) {
-        console.error(`No demo.spec.ts found in demofly/${demo}/. Create one with /demofly:create ${demo} in Claude Code.`);
+    const hasScenes = existsSync(scenesDir) && readdirSync(scenesDir).some(f => f.endsWith(".spec.ts"));
+    const hasLegacySpec = existsSync(legacySpecPath);
+    if (!hasScenes && !hasLegacySpec) {
+        console.error(`No scene specs or demo.spec.ts found in demofly/${demo}/. Create one with /demofly:create ${demo} in Claude Code.`);
         valid = false;
     }
     if (!existsSync(configPath)) {
@@ -28,6 +31,264 @@ function validateDemoArtifacts(demoDir, demo) {
     }
     return valid;
 }
+function readSceneGroups(demoDir) {
+    const sharedPath = resolve(demoDir, "scenes", "shared.ts");
+    if (!existsSync(sharedPath))
+        return null;
+    const content = readFileSync(sharedPath, "utf-8");
+    const match = content.match(/export\s+const\s+SCENE_GROUPS\s*=\s*(\[[\s\S]*?\n\];)/);
+    if (!match)
+        return null;
+    try {
+        // Parse the TypeScript array literal as JSON (strip trailing commas, convert single quotes)
+        const jsonStr = match[1]
+            .replace(/'/g, '"')
+            .replace(/,\s*]/g, "]")
+            .replace(/,\s*}/g, "}")
+            .replace(/(\w+)\s*:/g, '"$1":');
+        return JSON.parse(jsonStr);
+    }
+    catch {
+        debug("Could not parse SCENE_GROUPS from shared.ts, falling back to file scan");
+        return null;
+    }
+}
+function discoverSceneGroups(demoDir) {
+    // Try reading from shared.ts first
+    const fromShared = readSceneGroups(demoDir);
+    if (fromShared)
+        return fromShared;
+    // Fall back to scanning scene spec files
+    const scenesDir = resolve(demoDir, "scenes");
+    if (!existsSync(scenesDir))
+        return [];
+    const specFiles = readdirSync(scenesDir)
+        .filter(f => f.endsWith(".spec.ts") && f.startsWith("scene-"))
+        .sort();
+    return specFiles.map(f => {
+        const id = f.replace(".spec.ts", "");
+        const scenes = id.split("-").filter(p => /^\d+$/.test(p)).map(n => `scene-${n}`);
+        if (scenes.length === 0)
+            scenes.push(id);
+        return { id, scenes, startUrl: "/", independent: scenes.length === 1 };
+    });
+}
+function findGroupForScene(groups, sceneId) {
+    return groups.find(g => g.scenes.includes(sceneId)) ?? null;
+}
+function runSceneGroupRecording(demoDir, demo, group, force) {
+    const scenesRecordingsDir = resolve(demoDir, "recordings", "scenes");
+    const groupVideoDir = resolve(scenesRecordingsDir, group.id);
+    const groupVideoPath = resolve(groupVideoDir, "video.webm");
+    // Skip if already recorded (unless --force)
+    if (!force && existsSync(groupVideoPath)) {
+        debug(`Skipping ${group.id}: recording exists at ${groupVideoPath}`);
+        return { groupId: group.id, scenes: group.scenes, status: "skipped" };
+    }
+    const specPath = `demofly/${demo}/scenes/${group.id}.spec.ts`;
+    const configPath = `demofly/${demo}/playwright.config.ts`;
+    const cmd = `npx playwright test ${specPath} --config ${configPath}`;
+    debug(`Recording scene group: ${cmd}`);
+    console.log(`\nRecording ${group.id}...`);
+    try {
+        const output = execSync(cmd, {
+            encoding: "utf-8",
+            timeout: 600_000,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: resolve(demoDir, "..", ".."),
+        });
+        // Extract timing and save
+        const timingData = parseTimingMarkers(output);
+        mkdirSync(groupVideoDir, { recursive: true });
+        // Find and move video
+        const videoPath = findRecordedVideo(demoDir);
+        if (videoPath) {
+            execSync(`cp "${videoPath}" "${groupVideoPath}"`);
+        }
+        // Write timing data for the group
+        writeFileSync(resolve(groupVideoDir, "timing.json"), JSON.stringify(timingData, null, 2), "utf-8");
+        // If this is a multi-scene group, split into per-scene clips and timing
+        if (group.scenes.length > 1 && videoPath) {
+            splitGroupIntoScenes(groupVideoPath, timingData, scenesRecordingsDir, group);
+        }
+        else if (group.scenes.length === 1 && group.scenes[0] !== group.id) {
+            // Single scene with different scene name — symlink/copy
+            const sceneDir = resolve(scenesRecordingsDir, group.scenes[0]);
+            mkdirSync(sceneDir, { recursive: true });
+            execSync(`cp "${groupVideoPath}" "${resolve(sceneDir, "video.webm")}"`);
+            writeFileSync(resolve(sceneDir, "timing.json"), JSON.stringify(timingData, null, 2), "utf-8");
+        }
+        const durationMs = timingData.totalDuration;
+        console.log(`  ${group.id}: recorded (${formatDuration(durationMs)})`);
+        return {
+            groupId: group.id,
+            scenes: group.scenes,
+            status: "success",
+            videoPath: groupVideoPath,
+            durationMs,
+        };
+    }
+    catch (error) {
+        const execError = error;
+        const errMsg = execError.stderr ?? execError.stdout ?? "Unknown error";
+        console.error(`  ${group.id}: FAILED`);
+        debug(`Recording failed for ${group.id}: ${errMsg}`);
+        return {
+            groupId: group.id,
+            scenes: group.scenes,
+            status: "failed",
+            error: errMsg.slice(0, 500),
+        };
+    }
+}
+function splitGroupIntoScenes(groupVideoPath, timingData, scenesRecordingsDir, group) {
+    for (const sceneId of group.scenes) {
+        const sceneTimingData = extractSceneTiming(timingData, sceneId);
+        if (!sceneTimingData)
+            continue;
+        const sceneDir = resolve(scenesRecordingsDir, sceneId);
+        mkdirSync(sceneDir, { recursive: true });
+        // Split video for this scene
+        const startSec = sceneTimingData.scenes[0].startMs / 1000;
+        const durationSec = (sceneTimingData.scenes[0].endMs - sceneTimingData.scenes[0].startMs) / 1000;
+        const outputPath = resolve(sceneDir, "video.webm");
+        // Use a temp file when input and output are the same (single-scene groups)
+        const sameFile = resolve(groupVideoPath) === resolve(outputPath);
+        const writePath = sameFile ? resolve(sceneDir, "video.trimmed.webm") : outputPath;
+        try {
+            execSync(`ffmpeg -y -i "${groupVideoPath}" -ss ${startSec} -t ${durationSec} -c copy "${writePath}"`, { encoding: "utf-8", timeout: 300_000, stdio: ["pipe", "pipe", "pipe"] });
+            if (sameFile) {
+                renameSync(writePath, outputPath);
+            }
+        }
+        catch (err) {
+            const execError = err;
+            console.warn(`  Warning: Failed to split ${sceneId} from group ${group.id}`);
+            if (execError.stderr)
+                debug(execError.stderr);
+        }
+        // Write scene-relative timing
+        writeFileSync(resolve(sceneDir, "timing.json"), JSON.stringify(sceneTimingData, null, 2), "utf-8");
+    }
+}
+function extractSceneTiming(timingData, sceneId) {
+    const scene = timingData.scenes.find(s => s.sceneId === sceneId);
+    if (!scene)
+        return null;
+    const sceneStartMs = scene.startMs;
+    return {
+        totalDuration: scene.endMs - scene.startMs,
+        scenes: [{
+                sceneId: scene.sceneId,
+                startMs: 0,
+                endMs: scene.endMs - sceneStartMs,
+                markers: scene.markers.map(m => ({
+                    ...m,
+                    ms: m.ms - sceneStartMs,
+                })),
+            }],
+    };
+}
+function buildCombinedTimingData(demoDir, groups) {
+    const allScenes = [];
+    let cumulativeMs = 0;
+    for (const group of groups) {
+        for (const sceneId of group.scenes) {
+            const sceneTimingPath = resolve(demoDir, "recordings", "scenes", sceneId, "timing.json");
+            if (!existsSync(sceneTimingPath)) {
+                // Also check group-level timing
+                const groupTimingPath = resolve(demoDir, "recordings", "scenes", group.id, "timing.json");
+                if (existsSync(groupTimingPath)) {
+                    try {
+                        const groupTiming = normalizeTimingData(JSON.parse(readFileSync(groupTimingPath, "utf-8")));
+                        const sceneData = groupTiming.scenes.find(s => s.sceneId === sceneId);
+                        if (sceneData) {
+                            allScenes.push({
+                                ...sceneData,
+                                startMs: cumulativeMs,
+                                endMs: cumulativeMs + (sceneData.endMs - sceneData.startMs),
+                                markers: sceneData.markers.map(m => ({
+                                    ...m,
+                                    ms: cumulativeMs + m.ms - sceneData.startMs,
+                                })),
+                            });
+                            cumulativeMs += sceneData.endMs - sceneData.startMs;
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+                continue;
+            }
+            try {
+                const sceneTiming = normalizeTimingData(JSON.parse(readFileSync(sceneTimingPath, "utf-8")));
+                for (const scene of sceneTiming.scenes) {
+                    allScenes.push({
+                        ...scene,
+                        startMs: cumulativeMs + scene.startMs,
+                        endMs: cumulativeMs + scene.endMs,
+                        markers: scene.markers.map(m => ({
+                            ...m,
+                            ms: cumulativeMs + m.ms,
+                        })),
+                    });
+                }
+                cumulativeMs += sceneTiming.totalDuration;
+            }
+            catch { /* skip */ }
+        }
+    }
+    return { totalDuration: cumulativeMs, scenes: allScenes };
+}
+function collectSceneClips(demoDir, groups) {
+    const clips = [];
+    for (const group of groups) {
+        for (const sceneId of group.scenes) {
+            const sceneDir = resolve(demoDir, "recordings", "scenes", sceneId);
+            const videoPath = resolve(sceneDir, "video.webm");
+            const timingPath = resolve(sceneDir, "timing.json");
+            if (!existsSync(videoPath))
+                continue;
+            let durationMs = 0;
+            let trimStartMs = 0;
+            if (existsSync(timingPath)) {
+                try {
+                    const timing = normalizeTimingData(JSON.parse(readFileSync(timingPath, "utf-8")));
+                    const firstScene = timing.scenes[0];
+                    if (firstScene) {
+                        trimStartMs = firstScene.startMs;
+                        durationMs = firstScene.endMs - firstScene.startMs;
+                    }
+                    else {
+                        durationMs = timing.totalDuration;
+                    }
+                }
+                catch { /* use 0 */ }
+            }
+            clips.push({
+                sceneId,
+                videoPath,
+                durationMs,
+                trimStartMs,
+                transition: "hard_cut", // default; could be overridden from narration metadata
+            });
+        }
+    }
+    return clips;
+}
+function printSceneResults(results) {
+    console.log("\n--- Per-Scene Recording Results ---\n");
+    console.log("  Scene Group     Status     Duration");
+    console.log("  ─────────────   ────────   ────────");
+    for (const r of results) {
+        const status = r.status === "success" ? "OK" : r.status === "skipped" ? "skipped" : "FAILED";
+        const duration = r.durationMs ? formatDuration(r.durationMs) : "-";
+        console.log(`  ${r.groupId.padEnd(16)}${status.padEnd(11)}${duration}`);
+    }
+    const succeeded = results.filter(r => r.status === "success").length;
+    const skipped = results.filter(r => r.status === "skipped").length;
+    const failed = results.filter(r => r.status === "failed").length;
+    console.log(`\n  Total: ${succeeded} recorded, ${skipped} skipped, ${failed} failed\n`);
+}
 function runPlaywrightTest(demoDir, demo) {
     const specPath = `demofly/${demo}/demo.spec.ts`;
     const configPath = `demofly/${demo}/playwright.config.ts`;
@@ -119,94 +380,6 @@ function findAudioFiles(demoDir, timingData) {
     }
     return { matched, missing };
 }
-function getWatermarkPath() {
-    return resolve(import.meta.dirname ?? __dirname, "../../assets/watermark.png");
-}
-function buildFfmpegCommand(videoPath, audioMatches, timingData, outputPath, applyWatermark = false) {
-    const sceneMap = new Map(timingData.scenes.map((s) => [s.sceneId, s]));
-    const inputArgs = ["-i", videoPath];
-    const filterParts = [];
-    // If watermarking, add the watermark PNG as an input
-    const watermarkPath = applyWatermark ? getWatermarkPath() : null;
-    let watermarkInputIndex = -1;
-    if (watermarkPath && existsSync(watermarkPath)) {
-        watermarkInputIndex = 1; // will be shifted after audio inputs are added
-    }
-    for (let i = 0; i < audioMatches.length; i++) {
-        const match = audioMatches[i];
-        const scene = sceneMap.get(match.sceneId);
-        if (!scene)
-            continue;
-        inputArgs.push("-i", match.filePath);
-        const audioIndex = i + 1;
-        const delayMs = scene.startMs;
-        filterParts.push(`[${audioIndex}:a]adelay=${delayMs}|${delayMs}[a${audioIndex}]`);
-    }
-    // Add watermark input after all audio inputs
-    if (watermarkPath && existsSync(watermarkPath)) {
-        inputArgs.push("-i", watermarkPath);
-        watermarkInputIndex = inputArgs.filter((a) => a === "-i").length - 1;
-    }
-    const mixInputs = filterParts
-        .map((_, i) => `[a${i + 1}]`)
-        .join("");
-    let filterComplex = filterParts.join("; ") +
-        `; ${mixInputs}amix=inputs=${audioMatches.length}:normalize=0[aout]`;
-    // Build video filter chain with optional watermark overlay
-    let videoMap = "0:v";
-    if (applyWatermark && watermarkInputIndex >= 0) {
-        // Scale watermark to ~8% of video width, position bottom-right with padding
-        // Use scale2ref so dimensions reference the main video, not the watermark PNG
-        filterComplex +=
-            `; [${watermarkInputIndex}:v][0:v]scale2ref=w=main_w*0.08:h=-1[wm_scaled][vmain]` +
-                `; [wm_scaled]format=rgba,colorchannelmixer=aa=0.6[wm]` +
-                `; [vmain][wm]overlay=W-w-24:H-h-16[vout]`;
-        videoMap = "[vout]";
-    }
-    const args = [
-        "ffmpeg",
-        "-y",
-        ...inputArgs,
-        "-filter_complex",
-        `"${filterComplex}"`,
-        "-map",
-        videoMap,
-        "-map",
-        "[aout]",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "fast",
-        "-crf",
-        "23",
-        "-pix_fmt",
-        "yuv420p",
-        "-shortest",
-        outputPath,
-    ];
-    return args.join(" ");
-}
-function stitchAudio(videoPath, audioMatches, timingData, recordingsDir, applyWatermark = false) {
-    const outputPath = resolve(recordingsDir, "final.mp4");
-    const cmd = buildFfmpegCommand(videoPath, audioMatches, timingData, outputPath, applyWatermark);
-    console.log(`Stitching audio with ffmpeg...\n`);
-    try {
-        execSync(cmd, {
-            encoding: "utf-8",
-            timeout: 600_000,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        return outputPath;
-    }
-    catch (error) {
-        const execError = error;
-        console.error("ffmpeg stitching failed:");
-        if (execError.stderr) {
-            console.error(execError.stderr);
-        }
-        return null;
-    }
-}
 export function splitScenes(videoPath, timingData, recordingsDir) {
     const scenesDir = resolve(recordingsDir, "scenes");
     const outputs = [];
@@ -216,8 +389,14 @@ export function splitScenes(videoPath, timingData, recordingsDir) {
         const startSec = scene.startMs / 1000;
         const durationSec = (scene.endMs - scene.startMs) / 1000;
         const outputPath = resolve(sceneDir, "video.webm");
+        // Use a temp file when input and output are the same path
+        const sameFile = resolve(videoPath) === resolve(outputPath);
+        const writePath = sameFile ? resolve(sceneDir, "video.trimmed.webm") : outputPath;
         try {
-            execSync(`ffmpeg -y -i "${videoPath}" -ss ${startSec} -t ${durationSec} -c copy "${outputPath}"`, { encoding: "utf-8", timeout: 300_000, stdio: ["pipe", "pipe", "pipe"] });
+            execSync(`ffmpeg -y -i "${videoPath}" -ss ${startSec} -t ${durationSec} -c copy "${writePath}"`, { encoding: "utf-8", timeout: 300_000, stdio: ["pipe", "pipe", "pipe"] });
+            if (sameFile) {
+                renameSync(writePath, outputPath);
+            }
             outputs.push(outputPath);
         }
         catch (error) {
@@ -307,7 +486,7 @@ function formatDuration(ms) {
     }
     return `${seconds}s`;
 }
-function printSummary(videoPath, timingPath, finalPath, timingData, voice) {
+function printSummary(videoPath, timingPath, finalPath, timingData, voice, assemblyResult) {
     console.log("\n--- demofly generate summary ---\n");
     if (videoPath) {
         console.log(`  Video:       ${videoPath}`);
@@ -323,7 +502,18 @@ function printSummary(videoPath, timingPath, finalPath, timingData, voice) {
     else {
         console.log(`  Stitched:    no`);
     }
-    console.log(`  Duration:    ${formatDuration(timingData.totalDuration)}`);
+    if (assemblyResult) {
+        const corrected = assemblyResult.corrections.filter((c) => c.correction !== "none");
+        if (corrected.length > 0) {
+            const methods = new Set(corrected.map((c) => c.correction));
+            const methodStr = [...methods].join(", ");
+            console.log(`  Corrected:   ${corrected.length} scene(s) via ${methodStr}`);
+        }
+        console.log(`  Duration:    ${formatDuration(assemblyResult.adjustedTotalDurationMs)}`);
+    }
+    else {
+        console.log(`  Duration:    ${formatDuration(timingData.totalDuration)}`);
+    }
     console.log(`  Scenes:      ${timingData.scenes.length}`);
     console.log();
 }
@@ -396,11 +586,13 @@ function shouldRegenerateAudio(projectDir, resolvedVoice, explicitVoiceFlag, tim
         return true;
     return meta.name !== resolvedVoice.name || meta.provider !== resolvedVoice.provider;
 }
-function resolveVoiceForGenerate(voiceName, providerName) {
+function resolveVoiceForGenerate(voiceName, providerName, projectDir) {
+    const demoVoicePreference = projectDir ? getDemoVoicePreference(projectDir) : null;
     return resolveVoiceFromFlags(voiceName, providerName, {
         getDefaultVoice,
         getToken,
         createApiClient,
+        demoVoicePreference,
     });
 }
 async function generateAudioForProject(narrationPath, projectDir, voice, speed, sceneFilter) {
@@ -419,23 +611,31 @@ async function generateAudioForProject(narrationPath, projectDir, voice, speed,
     }
     if (results.length > 0) {
         writeVoiceMetadata(projectDir, actualVoice);
+        // Auto-set demo voice preference on first generation
+        if (!getDemoVoicePreference(projectDir)) {
+            setDemoVoicePreference(projectDir, { name: actualVoice.name, provider: actualVoice.provider });
+        }
     }
     return { ttsResults: results, actualVoice };
 }
 async function generateCloudTtsInline(narrationPath, projectDir, voice, speed, sceneFilter) {
     const token = await getToken();
     if (!token) {
-        return fallbackToKokoro(narrationPath, projectDir, speed, "Not authenticated.", sceneFilter);
+        console.error("Not authenticated. Premium voices require authentication.");
+        console.error("Run `demofly auth login` to authenticate, or use a free voice.\n");
+        process.exit(1);
     }
     const api = createApiClient(token);
     try {
         const sub = await getSubscriptionStatus(api);
         if (sub.plan !== "pro") {
-            return fallbackToKokoro(narrationPath, projectDir, speed, `Premium voices require a Pro subscription. Upgrade at ${getAppUrl()}/upgrade`, sceneFilter);
+            console.error(`Premium voices require a Pro subscription. Upgrade at ${getAppUrl()}/upgrade`);
+            process.exit(1);
         }
     }
     catch {
-        return fallbackToKokoro(narrationPath, projectDir, speed, "Cloud TTS unavailable.", sceneFilter);
+        console.error("Could not verify subscription status. Cloud TTS unavailable.");
+        process.exit(1);
     }
     const content = readFileSync(narrationPath, "utf-8");
     let scenes = parseTranscript(content);
@@ -444,10 +644,42 @@ async function generateCloudTtsInline(narrationPath, projectDir, voice, speed, s
     }
     if (scenes.length === 0)
         return { ttsResults: [], actualVoice: voice };
+    // Credit pre-check: estimate total cost before starting
+    const allText = scenes.map(s => s.text).join(" ");
+    const operationType = `${voice.provider}-tts`;
+    try {
+        const estimate = await api.post("/credits/estimate", { operation: operationType, input: { text: allText } });
+        if (!estimate.sufficient) {
+            console.log(`\nThis demo needs ~${estimate.estimatedCredits} credits but you have ${estimate.available}.`);
+            if (process.stdin.isTTY) {
+                const useFree = await promptYesNo(`Generate with free voice (${getDefaultFreeVoice().name}) instead?`);
+                if (useFree) {
+                    console.log();
+                    const freeVoice = getDefaultFreeVoice();
+                    const ttsResults = generateAllAudio(narrationPath, projectDir, {
+                        voice: freeVoice.providerId,
+                        speed,
+                        sceneFilter,
+                    });
+                    return { ttsResults, actualVoice: freeVoice };
+                }
+            }
+            else {
+                console.log(`Run interactively to switch to a free voice, or use --voice heart.`);
+            }
+            console.log(`\nUse \`demofly voices select ${basename(projectDir)}\` to choose a different voice, or add credits at ${getAppUrl()}`);
+            process.exit(1);
+        }
+    }
+    catch {
+        // Credit API unreachable — warn and proceed optimistically
+        console.warn("Warning: Could not verify credit balance. Proceeding with generation.\n");
+    }
     const audioDir = resolve(projectDir, "audio");
     if (!existsSync(audioDir))
         mkdirSync(audioDir, { recursive: true });
     const results = [];
+    const generatedFiles = [];
     for (const scene of scenes) {
         console.log(`  TTS: ${scene.sceneId} (${scene.text.length} chars)`);
         try {
@@ -456,27 +688,35 @@ async function generateCloudTtsInline(narrationPath, projectDir, voice, speed, s
             const elapsedS = (performance.now() - start) / 1000;
             const outputPath = resolve(audioDir, `${scene.sceneId}.mp3`);
             writeFileSync(outputPath, Buffer.from(audio));
+            generatedFiles.push(outputPath);
             results.push({ sceneId: scene.sceneId, filePath: outputPath, durationS, peakMemoryMb: 0, elapsedS });
             console.log(`    -> ${durationS.toFixed(1)}s audio, ${elapsedS.toFixed(1)}s elapsed`);
         }
         catch (err) {
-            if (err.status === 403) {
-                return fallbackToKokoro(narrationPath, projectDir, speed, `Premium voices require a Pro subscription. Upgrade at ${getAppUrl()}/upgrade`, sceneFilter);
+            // Clean up audio files generated during this failed run
+            for (const file of generatedFiles) {
+                try {
+                    unlinkSync(file);
+                }
+                catch { }
             }
-            console.warn(`    Cloud TTS failed for ${scene.sceneId}: ${err.message}`);
-            return fallbackToKokoro(narrationPath, projectDir, speed, "Cloud TTS unavailable, falling back to local voice.", sceneFilter);
+            if (err.status === 402) {
+                console.error(`\nRan out of credits during generation at ${scene.sceneId}. No audio was produced.`);
+            }
+            else if (err.status === 403) {
+                console.error(`\nPremium voices require a Pro subscription. Upgrade at ${getAppUrl()}/upgrade`);
+            }
+            else {
+                console.error(`\nPremium voice generation failed for ${scene.sceneId}: ${err.message}`);
+            }
+            console.error(`Re-run with a free voice (--voice heart) or use \`demofly voices select ${basename(projectDir)}\` to change voice.\n`);
+            process.exit(1);
         }
     }
     return { ttsResults: results, actualVoice: voice };
 }
-function fallbackToKokoro(narrationPath, projectDir, speed, reason, sceneFilter) {
-    console.warn(`${reason} Falling back to Kokoro.\n`);
-    const ttsResults = generateAllAudio(narrationPath, projectDir, {
-        voice: KOKORO_VOICES[0].kokoroId,
-        speed,
-        sceneFilter,
-    });
-    return { ttsResults, actualVoice: KOKORO_DEFAULT_VOICE };
+function getDefaultFreeVoice() {
+    return KOKORO_DEFAULT_VOICE;
 }
 export function registerGenerateCommand(program) {
     program
@@ -488,11 +728,13 @@ export function registerGenerateCommand(program) {
         .option("--align", "Produce alignment.json from timestamps + timing data")
         .option("--assemble", "Full intelligent assembly (align + edit proposals + retiming)")
         .option("--video", "Record video only (skip audio generation)")
-        .option("--scene <id>", "Generate audio for a specific scene only")
+        .option("--scene <id>", "Record or generate audio for a specific scene only")
+        .option("--force", "Re-record scenes even if recordings exist")
         .option("--voice <name>", "TTS voice name")
         .option("--provider <provider>", "TTS provider (e.g., elevenlabs, openai, kokoro)")
         .option("--speed <multiplier>", "TTS speed multiplier", "1.0")
         .option("--no-audio", "Skip TTS generation entirely")
+        .option("--atempo", "Speed up audio instead of freeze-framing when audio overflows scene window")
         .action(async (demo, opts) => {
         const projectDir = resolve(process.cwd(), "demofly", demo);
         debug(`Resolved demo directory: ${projectDir}`);
@@ -517,7 +759,7 @@ export function registerGenerateCommand(program) {
                 process.exit(1);
             }
             const speed = parseFloat(opts.speed);
-            const voice = await resolveVoiceForGenerate(opts.voice, opts.provider);
+            const voice = await resolveVoiceForGenerate(opts.voice, opts.provider, projectDir);
             const { ttsResults, actualVoice } = await generateAudioForProject(sourcePath, projectDir, voice, speed, opts.scene);
             console.log("\n--- demofly generate --audio summary ---\n");
             console.log(`  Voice:       ${actualVoice.name} (${actualVoice.provider})`);
@@ -563,7 +805,31 @@ export function registerGenerateCommand(program) {
         }
         // Video-only mode: record and exit
         if (opts.video) {
-            debug("Video-only mode: running Playwright test");
+            const sceneGroups = discoverSceneGroups(projectDir);
+            if (sceneGroups.length > 0) {
+                // Per-scene recording
+                debug("Video-only mode: per-scene recording");
+                let groupsToRecord = sceneGroups;
+                if (opts.scene) {
+                    const group = findGroupForScene(sceneGroups, opts.scene);
+                    if (!group) {
+                        console.error(`Scene "${opts.scene}" not found in any scene group.`);
+                        process.exit(1);
+                    }
+                    groupsToRecord = [group];
+                }
+                const results = [];
+                for (const group of groupsToRecord) {
+                    results.push(runSceneGroupRecording(projectDir, demo, group, opts.force ?? false));
+                }
+                printSceneResults(results);
+                const anyFailed = results.some(r => r.status === "failed");
+                if (anyFailed)
+                    process.exit(2);
+                return;
+            }
+            // Legacy monolithic recording
+            debug("Video-only mode: running Playwright test (legacy)");
             const result = recordDemo(projectDir, demo);
             const videoPath = result.videoPath
                 ? resolve(recordingsDir, "video.webm")
@@ -582,27 +848,64 @@ export function registerGenerateCommand(program) {
         let timingPath;
         // Step 2: Record or use existing artifacts
         if (opts.record) {
-            debug("Recording mode: running Playwright test");
-            const result = recordDemo(projectDir, demo);
-            videoPath = result.videoPath
-                ? resolve(recordingsDir, "video.webm")
-                : null;
-            const stdout = result.stdout;
-            timingData = parseTimingMarkers(stdout);
-            timingPath = resolve(recordingsDir, "timing.json");
-            if (timingData.scenes.length === 0) {
-                console.warn("Warning: No DEMOFLY timing markers found in test output. Video was still recorded.");
+            const sceneGroups = discoverSceneGroups(projectDir);
+            if (sceneGroups.length > 0) {
+                // Per-scene recording mode
+                debug("Recording mode: per-scene recording");
+                let groupsToRecord = sceneGroups;
+                if (opts.scene) {
+                    const group = findGroupForScene(sceneGroups, opts.scene);
+                    if (!group) {
+                        console.error(`Scene "${opts.scene}" not found in any scene group.`);
+                        process.exit(1);
+                    }
+                    groupsToRecord = [group];
+                }
+                const results = [];
+                for (const group of groupsToRecord) {
+                    results.push(runSceneGroupRecording(projectDir, demo, group, opts.force ?? false));
+                }
+                printSceneResults(results);
+                const anyFailed = results.some(r => r.status === "failed");
+                // Build combined timing data from per-scene recordings
+                timingData = buildCombinedTimingData(projectDir, sceneGroups);
+                timingPath = resolve(recordingsDir, "timing.json");
+                writeTimingJson(recordingsDir, timingData);
+                // Use the first successful scene's parent video or look for combined
+                const firstSuccess = results.find(r => r.status === "success");
+                videoPath = firstSuccess?.videoPath ?? null;
+                if (anyFailed) {
+                    console.warn("Some scenes failed to record. Assembly will use available clips.\n");
+                }
+            }
+            else {
+                // Legacy monolithic recording
+                debug("Recording mode: running Playwright test (legacy)");
+                const result = recordDemo(projectDir, demo);
+                videoPath = result.videoPath
+                    ? resolve(recordingsDir, "video.webm")
+                    : null;
+                const stdout = result.stdout;
+                timingData = parseTimingMarkers(stdout);
+                timingPath = resolve(recordingsDir, "timing.json");
+                if (timingData.scenes.length === 0) {
+                    console.warn("Warning: No DEMOFLY timing markers found in test output. Video was still recorded.");
+                }
             }
         }
         else {
             // Assembler-first: look for existing artifacts
             const existingVideo = resolve(recordingsDir, "video.webm");
             const existingTiming = resolve(recordingsDir, "timing.json");
+            // Check for video: either legacy combined video or per-scene clips
             const hasVideo = existsSync(existingVideo);
+            const scenesDir = resolve(recordingsDir, "scenes");
+            const hasSceneClips = existsSync(scenesDir) && readdirSync(scenesDir, { withFileTypes: true })
+                .some(d => d.isDirectory() && existsSync(resolve(scenesDir, d.name, "video.webm")));
             const hasTiming = existsSync(existingTiming);
-            if (!hasVideo || !hasTiming) {
+            if ((!hasVideo && !hasSceneClips) || !hasTiming) {
                 const missingParts = [];
-                if (!hasVideo)
+                if (!hasVideo && !hasSceneClips)
                     missingParts.push("recordings/video.webm");
                 if (!hasTiming)
                     missingParts.push("recordings/timing.json");
@@ -637,7 +940,7 @@ export function registerGenerateCommand(program) {
             }
             // If we didn't record (existing artifacts found), load from disk
             if (!videoPath) {
-                videoPath = existingVideo;
+                videoPath = hasVideo ? existingVideo : null; // null when only scene clips exist
                 timingData = normalizeTimingData(JSON.parse(readFileSync(existingTiming, "utf-8")));
                 timingPath = existingTiming;
             }
@@ -660,7 +963,7 @@ export function registerGenerateCommand(program) {
         const narrationSourcePath = resolve(projectDir, "narration.md");
         if (opts.audio !== false && existsSync(narrationSourcePath)) {
             const speed = parseFloat(opts.speed);
-            const voice = await resolveVoiceForGenerate(opts.voice, opts.provider);
+            const voice = await resolveVoiceForGenerate(opts.voice, opts.provider, projectDir);
             const explicitVoiceFlag = !!(opts.voice || opts.provider);
             if (opts.scene || shouldRegenerateAudio(projectDir, voice, explicitVoiceFlag, timingData)) {
                 const { ttsResults, actualVoice } = await generateAudioForProject(narrationSourcePath, projectDir, voice, speed, opts.scene);
@@ -692,87 +995,53 @@ export function registerGenerateCommand(program) {
         if (applyWatermark) {
             debug("Applying DemoFly watermark (free tier)");
         }
-        // Step 5: Find audio files and check ffmpeg
+        // Step 5: Assemble video with per-scene pipeline
+        const audioDir = resolve(projectDir, "audio");
         const { matched, missing } = findAudioFiles(projectDir, timingData);
         debug(`Audio files: ${matched.length} matched, ${missing.length} missing`);
         let finalPath = null;
-        if (matched.length > 0) {
-            if (!hasFfmpeg()) {
-                console.error("Audio files found but ffmpeg is not installed. Install ffmpeg to stitch audio with video.");
-                process.exit(1);
-            }
-            if (missing.length > 0) {
+        let assemblyResult = null;
+        // Check for per-scene clips
+        const sceneGroups = discoverSceneGroups(projectDir);
+        const sceneClips = sceneGroups.length > 0
+            ? collectSceneClips(projectDir, sceneGroups)
+            : [];
+        if (sceneClips.length > 0 && hasFfmpeg()) {
+            if (missing.length > 0 && matched.length > 0) {
                 console.warn(`Warning: No audio files found for scenes: ${missing.join(", ")}`);
             }
-            if (opts.assemble) {
-                // Intelligent assembly: align → edit proposals → retiming
-                console.log("Running intelligent assembly pipeline...\n");
-                // Step 4a: Build alignment
-                console.log("  Step 1: Building alignment...");
-                const alignment = buildAndWriteAlignment(projectDir);
-                if (alignment) {
-                    // Step 4b: Generate edit proposals
-                    console.log("  Step 2: Generating edit proposals...");
-                    const proposals = generateAndWriteEditProposals(projectDir);
-                    if (proposals && proposals.decisions.length > 0) {
-                        // Step 4c: Retiming + assembly
-                        console.log("  Step 3: Retiming and assembling...\n");
-                        const audioDir = resolve(projectDir, "audio");
-                        finalPath = retimeAndAssemble(videoPath, audioDir, timingData, proposals, recordingsDir);
-                    }
-                }
-                // Fall back to simple stitch if intelligent assembly failed
-                if (!finalPath) {
-                    console.log("  Intelligent assembly incomplete, falling back to simple stitch.\n");
-                    finalPath = stitchAudio(videoPath, matched, timingData, recordingsDir, applyWatermark);
-                }
+            console.log("Assembling video with per-scene pipeline...\n");
+            try {
+                assemblyResult = assembleScenes(sceneClips.map(c => ({ sceneId: c.sceneId, videoPath: c.videoPath, durationMs: c.durationMs })), audioDir, recordingsDir, { useAtempo: opts.atempo });
+                finalPath = assemblyResult.finalPath;
             }
-            else {
-                // Simple stitch (default)
-                finalPath = stitchAudio(videoPath, matched, timingData, recordingsDir, applyWatermark);
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(`Assembly failed: ${msg}`);
             }
         }
-        else if (videoPath) {
-            // No audio — copy or convert video as final output
-            if (hasFfmpeg()) {
-                const outputPath = resolve(recordingsDir, "final.mp4");
-                console.log("No audio files found. Converting video to mp4...\n");
-                try {
-                    const watermarkPath = getWatermarkPath();
-                    if (applyWatermark && existsSync(watermarkPath)) {
-                        execSync(`ffmpeg -y -i "${videoPath}" -i "${watermarkPath}" ` +
-                            `-filter_complex "[1:v][0:v]scale2ref=w=main_w*0.08:h=-1[wm_scaled][vmain];[wm_scaled]format=rgba,colorchannelmixer=aa=0.6[wm];[vmain][wm]overlay=W-w-24:H-h-16[vout]" ` +
-                            `-map "[vout]" -c:v libx264 -preset fast -crf 23 -pix_fmt yuv420p "${outputPath}"`, { encoding: "utf-8", timeout: 600_000, stdio: ["pipe", "pipe", "pipe"] });
-                    }
-                    else {
-                        execSync(`ffmpeg -y -i "${videoPath}" -c:v libx264 -preset fast -crf 23 -pix_fmt yuv420p "${outputPath}"`, { encoding: "utf-8", timeout: 600_000, stdio: ["pipe", "pipe", "pipe"] });
-                    }
-                    finalPath = outputPath;
-                }
-                catch (error) {
-                    const execError = error;
-                    console.error("ffmpeg conversion failed:");
-                    if (execError.stderr) {
-                        console.error(execError.stderr);
-                    }
-                }
-            }
-            else {
-                // No ffmpeg — copy webm as-is
-                const outputPath = resolve(recordingsDir, "final.webm");
-                console.log("No audio and no ffmpeg. Copying video as-is.\n");
-                copyFileSync(videoPath, outputPath);
-                finalPath = outputPath;
-            }
+        else if (videoPath && !hasFfmpeg()) {
+            // No ffmpeg — copy webm as-is
+            const outputPath = resolve(recordingsDir, "final.webm");
+            console.log("No ffmpeg available. Copying video as-is.\n");
+            copyFileSync(videoPath, outputPath);
+            finalPath = outputPath;
         }
-        else if (!videoPath) {
+        else if (!videoPath && sceneClips.length === 0) {
             console.warn("Warning: No recorded video found. Skipping assembly.");
         }
         // Step 5: Split scenes and extract thumbnails
-        if (videoPath && timingData.scenes.length > 0 && hasFfmpeg()) {
+        // Skip splitting when per-scene recordings already exist — splitScenes is
+        // for legacy monolithic recordings and would corrupt per-scene videos by
+        // seeking with cumulative timing offsets into individual scene files.
+        const hasPerSceneRecordings = sceneGroups.length > 0
+            && sceneGroups.some(g => existsSync(resolve(recordingsDir, "scenes", g.id, "video.webm")));
+        if (videoPath && timingData.scenes.length > 0 && hasFfmpeg() && !hasPerSceneRecordings) {
             console.log("Splitting video into per-scene clips...\n");
             const sceneClips = splitScenes(videoPath, timingData, recordingsDir);
             console.log(`  Split ${sceneClips.length} scene clip(s)`);
+        }
+        if (videoPath && timingData.scenes.length > 0 && hasFfmpeg()) {
             console.log("Extracting thumbnails...\n");
             const thumbnails = extractThumbnails(videoPath, timingData, recordingsDir);
             console.log(`  Extracted ${thumbnails.length} thumbnail(s)\n`);
@@ -781,7 +1050,7 @@ export function registerGenerateCommand(program) {
             console.warn("Warning: ffmpeg not available. Skipping scene splitting and thumbnail extraction.");
         }
         // Step 6: Print summary
-        printSummary(videoPath, timingPath, finalPath, timingData, voiceUsed);
+        printSummary(videoPath, timingPath, finalPath, timingData, voiceUsed, assemblyResult);
     });
 }
 //# sourceMappingURL=generate.js.map