hyperframes 0.8.188 → 0.8.190-hdr.1

package/dist/{chunk-YCW345M4.js → chunk-4BINHKAB.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-56IOFIYB.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -63,7 +63,7 @@ import {
   sourceTimeAt,
   timeAtSourceTime,
   volumeSegmentSampleCount
-} from "./chunk-BPX7LZG6.js";
+} from "./chunk-DIV37NUE.js";
 import {
   clampAudioGain,
   clipGain,
@@ -1090,7 +1090,6 @@ var BEGINFRAME_ONLY_FLAGS = /* @__PURE__ */ new Set([
 function stripBeginFrameFlags(args) {
   return args.filter((a) => !BEGINFRAME_ONLY_FLAGS.has(a));
 }
-var BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS = 10;
 var BEGINFRAME_PROBE_TIMEOUT_MS = 2e3;
 var BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS = 250;
 async function awaitBeforeDeadline(operation, deadline, label) {
@@ -1174,7 +1173,8 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
     let bytes = Buffer.alloc(0);
     let isPng = false;
     let attempts = 0;
-    for (attempts = 1; attempts <= BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS; attempts += 1) {
+    while (!isPng && Date.now() < deadline) {
+      attempts += 1;
       const response = await awaitBeforeDeadline(
         client.send("HeadlessExperimental.beginFrame", {
           frameTimeTicks: 1e3 + (attempts - 1) * 33,
@@ -1187,7 +1187,7 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
       const screenshot = response.screenshotData ?? "";
       bytes = screenshot ? Buffer.from(screenshot, "base64") : Buffer.alloc(0);
       isPng = bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
-      if (isPng) break;
+      if (isPng || Date.now() + 10 >= deadline) break;
       await awaitBeforeDeadline(
         new Promise((resolveDelay) => setTimeout(resolveDelay, 10)),
         deadline,
@@ -1196,7 +1196,7 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
     }
     if (!isPng) {
       throw new Error(
-        `beginFrame screenshot returned ${bytes.length} bytes after ${BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS} attempts with signature ${bytes.length >= 4 ? bytes.subarray(0, 4).toString("hex") : "<empty>"}`
+        `beginFrame screenshot returned ${bytes.length} bytes after ${attempts} attempts in ${Date.now() - started}ms with signature ${bytes.length >= 4 ? bytes.subarray(0, 4).toString("hex") : "<empty>"}`
       );
     }
     await awaitBeforeDeadline(client.detach(), deadline, "CDP detach").catch(() => {
@@ -1691,6 +1691,24 @@ identically under Docker. Consider:
 import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
 import { join as join3 } from "path";
 
+// ../engine/src/services/renderFrameVideoHold.ts
+function holdRenderFrameVideos(ids, renderIdAttr) {
+  const held = new Set(ids);
+  window.__HF_RENDER_FRAME_VIDEO_IDS = ids;
+  const hold = (el) => {
+    if (el instanceof HTMLVideoElement && held.has(el.getAttribute(renderIdAttr) || el.id))
+      el.preload = "none";
+  };
+  new MutationObserver((records) => {
+    for (const record2 of records)
+      for (const node of record2.addedNodes) {
+        if (node.nodeType !== 1) continue;
+        hold(node);
+        for (const video of node.querySelectorAll("video")) hold(video);
+      }
+  }).observe(document, { childList: true, subtree: true });
+}
+
 // ../engine/src/services/drawElementCaptureError.ts
 var DrawElementCaptureError = class extends Error {
   frameIndex;
@@ -2548,15 +2566,17 @@ async function readPageMotionBlur(page) {
     const report = api && typeof api === "object" ? Reflect.get(api, "report") : null;
     const got = typeof report === "function" ? report() : null;
     if (!got || typeof got !== "object") return null;
+    const tier = Reflect.get(got, "tier");
     return {
       state: String(Reflect.get(got, "state")),
       code: String(Reflect.get(got, "reasonCode")),
       movers: Number(Reflect.get(got, "movers")),
-      failedFrames: Number(Reflect.get(got, "failedFrames")) || 0
+      failedFrames: Number(Reflect.get(got, "failedFrames")) || 0,
+      tier: typeof tier === "string" ? tier : null
     };
   });
 }
-var formatPageMotionBlur = (r) => `[motion-blur] ${r.state} reasonCode=${r.code} movers=${r.movers} failedFrames=${r.failedFrames}`;
+var formatPageMotionBlur = (r) => `[motion-blur] ${r.state} reasonCode=${r.code} movers=${r.movers} failedFrames=${r.failedFrames}${r.tier ? ` tier=${r.tier}` : ""}`;
 async function describePageMotionBlur(page) {
   const r = await readPageMotionBlur(page);
   return r && formatPageMotionBlur(r);
@@ -5488,6 +5508,13 @@ async function constructCaptureSession(input) {
     }
   });
   await installMediaRenderIdBridge(page);
+  if (options.skipReadinessVideoIds?.length) {
+    await page.evaluateOnNewDocument(
+      holdRenderFrameVideos,
+      options.skipReadinessVideoIds,
+      MEDIA_RENDER_ID_ATTR
+    );
+  }
   if (useDrawElement) {
     await page.evaluateOnNewDocument(instrumentAcceleratedCanvases);
   }
@@ -8993,6 +9020,14 @@ async function analyzeKeyframeIntervalsUncached(filePath, videoStreamStartSecond
   };
 }
 
+// ../engine/src/services/softwareEncoderThreads.ts
+import { availableParallelism } from "os";
+var X265_MAX_THREADS = 16;
+function appendSoftwareEncoderThreadsArg(args, encoder, parallelism = availableParallelism()) {
+  const cap = encoder === "libx265" ? X265_MAX_THREADS : Infinity;
+  args.push("-threads", String(Math.min(cap, Math.max(1, Math.floor(parallelism)))));
+}
+
 // ../engine/src/utils/renderProvenance.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join5 } from "path";
@@ -9217,6 +9252,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const gop = resolveLockedGopSize(options);
@@ -9921,6 +9957,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const lockedGop = resolveLockedGopSize(options);
@@ -12472,6 +12509,7 @@ function resolveVideoExtractionDuration(video, metadata, timelineEnd) {
   return resolveVideoExtractionWindow(video, metadata, timelineEnd).durationSeconds;
 }
 var ALPHA_CAPABLE_CODECS = /* @__PURE__ */ new Set(["vp9", "vp8", "prores"]);
+var SIDECAR_ALPHA_CODECS = /* @__PURE__ */ new Set(["vp9", "vp8"]);
 function codecMayHaveAlpha(codec) {
   return ALPHA_CAPABLE_CODECS.has((codec ?? "").toLowerCase());
 }
@@ -12479,7 +12517,8 @@ function decoderForCodec(codec) {
   return alphaDecoderFor(codec) ?? (codec ?? "").toLowerCase();
 }
 function resolveFrameFormat(metadata, requested) {
-  if (metadata.hasAlpha || codecMayHaveAlpha(metadata.videoCodec)) return "png";
+  if (metadata.hasAlpha || SIDECAR_ALPHA_CODECS.has((metadata.videoCodec ?? "").toLowerCase()))
+    return "png";
   if (requested === "png" || requested === "jpg") return requested;
   return "jpg";
 }
@@ -14011,6 +14050,9 @@ function clampFadesToDuration(fades, duration) {
   return { fadeIn: fadeIn * scale, fadeOut: fadeOut * scale };
 }
 
+// ../engine/src/services/audioMixer.ts
+import { cpus as cpus2 } from "os";
+
 // ../engine/src/services/aacEncode.ts
 import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, join as join11 } from "path";
@@ -15126,6 +15168,7 @@ function escapeExpressionCommas(expression) {
 function legacyFilterScriptOptionIsUnsupported(stderr) {
   return /filter_complex_script/i.test(stderr) && /(?:unrecognized option|option (?:was )?not found)/i.test(stderr);
 }
+var inPrepareSlot = createConcurrencyLimit(Math.max(2, Math.floor(cpus2().length / 2)));
 var MAX_VOLUME_SEGMENTS = 32;
 var VOLUME_SIMPLIFY_EPSILON = 5e-3;
 var STEREO_CHANNEL_FILTER = "pan=stereo|FL=FL+FC|FR=FR+FC";
@@ -15239,7 +15282,8 @@ function boundedDetail(message, maxLength = 2e3) {
     /(^|[\s"'(])\/.+?(?=:\s[A-Z]|\s(?:ENOENT|EACCES|EPERM)\b|\r?$)/gm,
     "$1<redacted-path>"
   );
-  return redacted.length <= maxLength ? redacted : `${redacted.slice(0, maxLength - 1)}\u2026`;
+  const head = Math.floor(maxLength / 4);
+  return redacted.length <= maxLength ? redacted : `${redacted.slice(0, head)}\u2026${redacted.slice(-(maxLength - head - 1))}`;
 }
 function probeFailure(message, elementId) {
   const unavailable = /(?:not found|ENOENT|spawn)/i.test(message);
@@ -15303,7 +15347,7 @@ function ffmpegFailure(stage, result, timeoutMs, elementId) {
     elementId,
     subprocess: audioSubprocessEvidence(result),
     detail: boundedDetail(
-      result.error?.message ? `${describeFfmpegFailure(result, timeoutMs)}: ${result.error.message}` : describeFfmpegFailure(result, timeoutMs)
+      `(ran ${result.durationMs} ms, limit ${timeoutMs} ms) ` + (result.error?.message ? `${describeFfmpegFailure(result, timeoutMs)}: ${result.error.message}` : describeFfmpegFailure(result, timeoutMs))
     )
   };
 }
@@ -15500,8 +15544,13 @@ async function generateSilence(outputPath, duration, signal, config) {
     failure
   };
 }
-async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config) {
-  const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+var MIX_TIMEOUT_MS_PER_FILM_SECOND = 100;
+function mixProcessTimeout(config, totalDuration) {
+  const configured = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+  return Math.max(configured, Math.ceil(totalDuration * MIX_TIMEOUT_MS_PER_FILM_SECOND));
+}
+async function mixAudioTracksFlat(tracks, outputPath, totalDuration, signal, config) {
+  const ffmpegProcessTimeout = mixProcessTimeout(config, totalDuration);
   const masterOutputGain = config?.audioGain ?? DEFAULT_CONFIG.audioGain;
   if (tracks.length === 0) {
     const result2 = await generateSilence(outputPath, totalDuration, signal, config);
@@ -15621,8 +15670,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
 function groupNormalizeOptionUnsupported(stderr) {
   return /normalize/i.test(stderr) && /(?:unrecognized option|option (?:was )?not found|no option name)/i.test(stderr);
 }
-async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
-  const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+async function mixGroupMembersFlat(memberTracks, outputPath, totalDuration, signal, config) {
+  const ffmpegProcessTimeout = mixProcessTimeout(config, totalDuration);
   const outputDir = dirname7(outputPath);
   if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes, padMembers) => memberTracks.map((track, i) => {
@@ -15707,6 +15756,100 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
   }
   return { success: true, degradedAutomation };
 }
+var MAX_MIX_INPUTS = 96;
+async function sumInSlices(tracks, scratchDir, totalDuration, signal, config) {
+  const wavTrack = (id, srcPath) => ({
+    id,
+    srcPath,
+    start: 0,
+    end: totalDuration,
+    mediaStart: 0,
+    duration: totalDuration,
+    volume: 1
+  });
+  let running = null;
+  let degradedAutomation = false;
+  for (let at = 0; at < tracks.length; at += MAX_MIX_INPUTS) {
+    const id = `sum-${at / MAX_MIX_INPUTS}`;
+    const slicePath = join14(scratchDir, `${id}-slice.wav`);
+    const slice = await mixGroupMembersFlat(
+      tracks.slice(at, at + MAX_MIX_INPUTS),
+      slicePath,
+      totalDuration,
+      signal,
+      config
+    );
+    if (!slice.success) return slice;
+    degradedAutomation ||= slice.degradedAutomation === true;
+    if (!running) {
+      running = wavTrack(id, slicePath);
+      continue;
+    }
+    const foldedPath = join14(scratchDir, `${id}.wav`);
+    const folded = await mixGroupMembersFlat(
+      [running, wavTrack(`${id}-slice`, slicePath)],
+      foldedPath,
+      totalDuration,
+      signal,
+      config
+    );
+    rmSync8(running.srcPath, { force: true });
+    rmSync8(slicePath, { force: true });
+    if (!folded.success) return folded;
+    running = wavTrack(id, foldedPath);
+  }
+  if (!running) throw new Error("[audioMixer] sumInSlices needs at least one track");
+  return { success: true, track: running, degradedAutomation };
+}
+async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
+  if (memberTracks.length <= MAX_MIX_INPUTS) {
+    return mixGroupMembersFlat(memberTracks, outputPath, totalDuration, signal, config);
+  }
+  mkdirSync7(dirname7(outputPath), { recursive: true });
+  const scratchDir = mkdtempSync7(join14(dirname7(outputPath), ".mix-batches-"));
+  try {
+    const summed = await sumInSlices(memberTracks, scratchDir, totalDuration, signal, config);
+    if (!summed.success) return summed;
+    renameSync3(summed.track.srcPath, outputPath);
+    return { success: true, degradedAutomation: summed.degradedAutomation };
+  } finally {
+    rmSync8(scratchDir, { recursive: true, force: true });
+  }
+}
+async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config) {
+  if (tracks.length <= MAX_MIX_INPUTS) {
+    return mixAudioTracksFlat(tracks, outputPath, totalDuration, signal, config);
+  }
+  mkdirSync7(dirname7(outputPath), { recursive: true });
+  const scratchDir = mkdtempSync7(join14(dirname7(outputPath), ".mix-batches-"));
+  try {
+    const summed = await sumInSlices(tracks, scratchDir, totalDuration, signal, config);
+    if (!summed.success) {
+      return {
+        success: false,
+        outputPath,
+        durationMs: 0,
+        tracksProcessed: 0,
+        error: summed.error,
+        failures: [summed.failure]
+      };
+    }
+    const mixed = await mixAudioTracksFlat(
+      [summed.track],
+      outputPath,
+      totalDuration,
+      signal,
+      config
+    );
+    return mixed.success ? {
+      ...mixed,
+      tracksProcessed: tracks.length,
+      error: summed.degradedAutomation ? "Volume automation exceeded this ffmpeg build's expression limits; rendered at base volume" : mixed.error
+    } : mixed;
+  } finally {
+    rmSync8(scratchDir, { recursive: true, force: true });
+  }
+}
 async function mixThroughFloatSum(tracks, masterChain, outputPath, workDir, totalDuration, signal, config) {
   const sumPath = join14(workDir, "master-sum.wav");
   const sum = await mixAudioTracks(tracks, sumPath, totalDuration, signal, config);
@@ -15752,216 +15895,220 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     else signal.addEventListener("abort", () => internalController.abort(), { once: true });
   }
   await Promise.all(
-    elements.map(async (element, index) => {
-      if (effectiveSignal.aborted) {
-        failures.push({
-          stage: "cancelled",
-          reason: "cancelled",
-          owner: "user",
-          retryable: false,
-          elementId: element.id,
-          detail: boundedDetail(`Cancelled audio element ${element.id}`)
-        });
-        return;
-      }
-      try {
-        let srcPath = element.src;
-        let readInPlace = false;
-        if (!isHttpUrl(srcPath)) {
-          srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
-          const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
-          if (remoteUrl) {
-            srcPath = remoteUrl;
-            readInPlace = true;
-          }
-        }
-        if (isHttpUrl(srcPath) && !readInPlace) {
-          try {
-            srcPath = await downloadToTemp(
-              srcPath,
-              workDir,
-              void 0,
-              effectiveSignal,
-              void 0,
-              {
-                onTelemetry: writeUrlDownloadTelemetry
-              }
-            );
-          } catch (err) {
-            failures.push(downloadFailure(err, element.id));
-            return;
-          }
-        }
-        if (!readInPlace && !existsSync11(srcPath)) {
+    elements.map(
+      (element, index) => inPrepareSlot(async () => {
+        if (effectiveSignal.aborted) {
           failures.push({
-            stage: "source",
-            reason: "source_not_found",
+            stage: "cancelled",
+            reason: "cancelled",
             owner: "user",
             retryable: false,
             elementId: element.id,
-            detail: boundedDetail(missingSourceMessage(element.id, element.src, baseDir, srcPath))
+            detail: boundedDetail(`Cancelled audio element ${element.id}`)
           });
           return;
         }
-        if (await isNotMediaPayload(srcPath)) {
-          failures.push({
-            stage: "source",
-            reason: "invalid_media",
-            owner: "user",
-            retryable: false,
-            elementId: element.id,
-            detail: boundedDetail(
-              `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`
-            )
-          });
-          return;
-        }
-        if (element.end - element.start <= 0) {
-          let metadata;
-          try {
-            metadata = await extractAudioMetadata(
+        try {
+          let srcPath = element.src;
+          let readInPlace = false;
+          if (!isHttpUrl(srcPath)) {
+            srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
+            const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
+            if (remoteUrl) {
+              srcPath = remoteUrl;
+              readInPlace = true;
+            }
+          }
+          if (isHttpUrl(srcPath) && !readInPlace) {
+            try {
+              srcPath = await downloadToTemp(
+                srcPath,
+                workDir,
+                void 0,
+                effectiveSignal,
+                void 0,
+                {
+                  onTelemetry: writeUrlDownloadTelemetry
+                }
+              );
+            } catch (err) {
+              failures.push(downloadFailure(err, element.id));
+              return;
+            }
+          }
+          if (!readInPlace && !existsSync11(srcPath)) {
+            failures.push({
+              stage: "source",
+              reason: "source_not_found",
+              owner: "user",
+              retryable: false,
+              elementId: element.id,
+              detail: boundedDetail(
+                missingSourceMessage(element.id, element.src, baseDir, srcPath)
+              )
+            });
+            return;
+          }
+          if (await isNotMediaPayload(srcPath)) {
+            failures.push({
+              stage: "source",
+              reason: "invalid_media",
+              owner: "user",
+              retryable: false,
+              elementId: element.id,
+              detail: boundedDetail(
+                `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`
+              )
+            });
+            return;
+          }
+          if (element.end - element.start <= 0) {
+            let metadata;
+            try {
+              metadata = await extractAudioMetadata(
+                srcPath,
+                readInPlace ? { signal: effectiveSignal } : void 0
+              );
+            } catch (err) {
+              failures.push(
+                probeFailure(err instanceof Error ? err.message : String(err), element.id)
+              );
+              return;
+            }
+            const effectiveDuration = timeAtSourceTime(
+              normalizeRateSpec(element.playbackRate),
+              metadata.durationSeconds - element.mediaStart
+            );
+            element.end = element.start + (effectiveDuration > 0 ? effectiveDuration : metadata.durationSeconds);
+          }
+          let audioSrcPath = srcPath;
+          if (element.type === "video") {
+            const extractedPath = join14(workDir, `${element.id}-extracted.wav`);
+            const extractResult = await extractAudioSegment(
               srcPath,
-              readInPlace ? { signal: effectiveSignal } : void 0
+              extractedPath,
+              "extract",
+              element.mediaStart,
+              element.end - element.start,
+              element.playbackRate,
+              effectiveSignal,
+              config
             );
-          } catch (err) {
-            failures.push(
-              probeFailure(err instanceof Error ? err.message : String(err), element.id)
+            if (!extractResult.success) {
+              failures.push(
+                extractResult.failure ? { ...extractResult.failure, elementId: element.id } : {
+                  stage: "extract",
+                  reason: "ffmpeg_failed",
+                  owner: "system",
+                  retryable: false,
+                  elementId: element.id,
+                  detail: boundedDetail(`Audio extract failed for element ${element.id}`)
+                }
+              );
+              return;
+            }
+            audioSrcPath = extractedPath;
+          } else {
+            const trimmedPath = join14(workDir, `${element.id}-trimmed.wav`);
+            const prepResult = await extractAudioSegment(
+              srcPath,
+              trimmedPath,
+              "prepare",
+              element.mediaStart,
+              element.end - element.start,
+              element.playbackRate,
+              effectiveSignal,
+              config
             );
-            return;
+            if (!prepResult.success) {
+              failures.push(
+                prepResult.failure ? { ...prepResult.failure, elementId: element.id } : {
+                  stage: "prepare",
+                  reason: "ffmpeg_failed",
+                  owner: "system",
+                  retryable: false,
+                  elementId: element.id,
+                  detail: boundedDetail(`Audio prepare failed for element ${element.id}`)
+                }
+              );
+              return;
+            }
+            audioSrcPath = trimmedPath;
           }
-          const effectiveDuration = timeAtSourceTime(
-            normalizeRateSpec(element.playbackRate),
-            metadata.durationSeconds - element.mediaStart
-          );
-          element.end = element.start + (effectiveDuration > 0 ? effectiveDuration : metadata.durationSeconds);
-        }
-        let audioSrcPath = srcPath;
-        if (element.type === "video") {
-          const extractedPath = join14(workDir, `${element.id}-extracted.wav`);
-          const extractResult = await extractAudioSegment(
-            srcPath,
-            extractedPath,
-            "extract",
-            element.mediaStart,
+          const chain = element.fxChain ? parseAudioFxChain(element.fxChain) : void 0;
+          const automation = element.automation ? resolveAutomation(parseAutomation(element.automation), chain) : null;
+          const gainBeforeFx = chain !== void 0 && enabledAudioFxNodes(chain).length > 0;
+          const laneKeyframes = automation ? volumeLaneKeyframes(
+            automation,
+            element.start,
             element.end - element.start,
-            element.playbackRate,
-            effectiveSignal,
-            config
-          );
-          if (!extractResult.success) {
-            failures.push(
-              extractResult.failure ? { ...extractResult.failure, elementId: element.id } : {
-                stage: "extract",
-                reason: "ffmpeg_failed",
-                owner: "system",
-                retryable: false,
-                elementId: element.id,
-                detail: boundedDetail(`Audio extract failed for element ${element.id}`)
+            element.volume ?? 1,
+            gainBeforeFx
+          ) : null;
+          const tweened = !laneKeyframes && (element.volumeKeyframes?.length ?? 0) > 0;
+          const envelopeKeyframes = laneKeyframes ?? element.volumeKeyframes;
+          const envelope = envelopeKeyframes && envelopeKeyframes.length > 0 ? {
+            keyframes: envelopeKeyframes,
+            trackStart: element.start,
+            baseVolume: element.volume ?? 1
+          } : null;
+          let bakedEnvelope = false;
+          let tailSeconds = 0;
+          if (chain) {
+            tailSeconds = chainTailSeconds(chain, automation ?? void 0);
+            const fxResult = await applyAudioFxChain(
+              audioSrcPath,
+              chain,
+              join14(workDir, `${element.id}-fx.wav`),
+              {
+                trackId: element.id,
+                signal: effectiveSignal,
+                ...automation ? { automation } : {},
+                ...envelope ? { envelope } : {},
+                ...gainBeforeFx ? { inputGain: clipGain(element.volume ?? 1, tweened) } : {}
               }
             );
-            return;
+            audioSrcPath = fxResult.path;
+            bakedEnvelope = fxResult.envelopeBaked;
           }
-          audioSrcPath = extractedPath;
-        } else {
-          const trimmedPath = join14(workDir, `${element.id}-trimmed.wav`);
-          const prepResult = await extractAudioSegment(
-            srcPath,
-            trimmedPath,
-            "prepare",
-            element.mediaStart,
-            element.end - element.start,
-            element.playbackRate,
-            effectiveSignal,
-            config
-          );
-          if (!prepResult.success) {
-            failures.push(
-              prepResult.failure ? { ...prepResult.failure, elementId: element.id } : {
-                stage: "prepare",
-                reason: "ffmpeg_failed",
-                owner: "system",
-                retryable: false,
-                elementId: element.id,
-                detail: boundedDetail(`Audio prepare failed for element ${element.id}`)
-              }
+          if (envelope && !bakedEnvelope) {
+            bakedEnvelope = applyVolumeEnvelopeToWav(
+              audioSrcPath,
+              envelope.keyframes,
+              envelope.trackStart,
+              envelope.baseVolume
             );
-            return;
           }
-          audioSrcPath = trimmedPath;
-        }
-        const chain = element.fxChain ? parseAudioFxChain(element.fxChain) : void 0;
-        const automation = element.automation ? resolveAutomation(parseAutomation(element.automation), chain) : null;
-        const gainBeforeFx = chain !== void 0 && enabledAudioFxNodes(chain).length > 0;
-        const laneKeyframes = automation ? volumeLaneKeyframes(
-          automation,
-          element.start,
-          element.end - element.start,
-          element.volume ?? 1,
-          gainBeforeFx
-        ) : null;
-        const tweened = !laneKeyframes && (element.volumeKeyframes?.length ?? 0) > 0;
-        const envelopeKeyframes = laneKeyframes ?? element.volumeKeyframes;
-        const envelope = envelopeKeyframes && envelopeKeyframes.length > 0 ? {
-          keyframes: envelopeKeyframes,
-          trackStart: element.start,
-          baseVolume: element.volume ?? 1
-        } : null;
-        let bakedEnvelope = false;
-        let tailSeconds = 0;
-        if (chain) {
-          tailSeconds = chainTailSeconds(chain, automation ?? void 0);
-          const fxResult = await applyAudioFxChain(
-            audioSrcPath,
-            chain,
-            join14(workDir, `${element.id}-fx.wav`),
-            {
-              trackId: element.id,
-              signal: effectiveSignal,
-              ...automation ? { automation } : {},
-              ...envelope ? { envelope } : {},
-              ...gainBeforeFx ? { inputGain: clipGain(element.volume ?? 1, tweened) } : {}
-            }
-          );
-          audioSrcPath = fxResult.path;
-          bakedEnvelope = fxResult.envelopeBaked;
-        }
-        if (envelope && !bakedEnvelope) {
-          bakedEnvelope = applyVolumeEnvelopeToWav(
-            audioSrcPath,
-            envelope.keyframes,
-            envelope.trackStart,
-            envelope.baseVolume
-          );
+          const track = {
+            id: element.id,
+            srcPath: audioSrcPath,
+            start: element.start,
+            end: element.end,
+            mediaStart: element.mediaStart,
+            duration: element.end - element.start,
+            // Gain is already in the samples when baked, so mix at unity.
+            volume: bakedEnvelope || gainBeforeFx && !tweened ? 1 : element.volume ?? 1,
+            volumeKeyframes: bakedEnvelope ? void 0 : envelopeKeyframes ?? void 0,
+            ...element.fadeIn ? { fadeIn: element.fadeIn } : {},
+            ...element.fadeOut ? { fadeOut: element.fadeOut } : {},
+            ...tailSeconds > 0 ? { tailSeconds } : {}
+          };
+          preparedTracks[index] = track;
+        } catch (err) {
+          if (err instanceof AudioFxRenderError) throw err;
+          failures.push({
+            stage: "internal",
+            reason: "internal",
+            owner: "system",
+            retryable: false,
+            elementId: element.id,
+            detail: boundedDetail(
+              `Audio processing failed for element ${element.id}: ${err instanceof Error ? err.message : String(err)}`
+            )
+          });
         }
-        const track = {
-          id: element.id,
-          srcPath: audioSrcPath,
-          start: element.start,
-          end: element.end,
-          mediaStart: element.mediaStart,
-          duration: element.end - element.start,
-          // Gain is already in the samples when baked, so mix at unity.
-          volume: bakedEnvelope || gainBeforeFx && !tweened ? 1 : element.volume ?? 1,
-          volumeKeyframes: bakedEnvelope ? void 0 : envelopeKeyframes ?? void 0,
-          ...element.fadeIn ? { fadeIn: element.fadeIn } : {},
-          ...element.fadeOut ? { fadeOut: element.fadeOut } : {},
-          ...tailSeconds > 0 ? { tailSeconds } : {}
-        };
-        preparedTracks[index] = track;
-      } catch (err) {
-        if (err instanceof AudioFxRenderError) throw err;
-        failures.push({
-          stage: "internal",
-          reason: "internal",
-          owner: "system",
-          retryable: false,
-          elementId: element.id,
-          detail: boundedDetail(
-            `Audio processing failed for element ${element.id}: ${err instanceof Error ? err.message : String(err)}`
-          )
-        });
-      }
-    })
+      }, effectiveSignal)
+    )
   ).catch((err) => {
     internalController.abort();
     try {
@@ -16144,7 +16291,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 }
 
 // ../engine/src/services/parallelCoordinator.ts
-import { cpus as cpus2, freemem } from "os";
+import { cpus as cpus3, freemem } from "os";
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
 import { join as join16 } from "path";
@@ -16259,7 +16406,7 @@ var MIN_WORKERS = 1;
 var MAX_WORKER_DIAGNOSTIC_LINES = 8;
 var ABSOLUTE_MAX_WORKERS = 24;
 function defaultSafeMaxWorkers() {
-  return Math.max(6, Math.min(16, Math.floor(cpus2().length / 8)));
+  return Math.max(6, Math.min(16, Math.floor(cpus3().length / 8)));
 }
 var MIN_FRAMES_PER_WORKER = 30;
 function shouldDisableBrowserPoolForParallelWorker({
@@ -16299,7 +16446,7 @@ function formatWorkerFailure(result) {
   return `${base}; diagnostics: ${diagnostics}`;
 }
 function computeWorkerSizing(totalFrames, requested, config) {
-  const cpuCount = cpus2().length;
+  const cpuCount = cpus3().length;
   const totalMemoryMb = getSystemTotalMb();
   const heapLimitMb = Math.round(getHeapStatistics().heap_size_limit / (1024 * 1024));
   const heapBasedWorkers = Math.max(
@@ -16854,7 +17001,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
 }
 function getSystemResources() {
   return {
-    cpuCores: cpus2().length,
+    cpuCores: cpus3().length,
     totalMemoryMB: getSystemTotalMb(),
     freeMemoryMB: Math.round(freemem() / (1024 * 1024)),
     recommendedWorkers: calculateOptimalWorkers(1e3)
@@ -17396,6 +17543,7 @@ export {
   extractVideoMetadata,
   extractAudioMetadata,
   analyzeKeyframeIntervals,
+  appendSoftwareEncoderThreadsArg,
   PROVENANCE_RENDERER_TAG,
   PROVENANCE_VERSION_TAG,
   PROVENANCE_RENDERER_NAME,