hyperframes 0.8.189 → 0.8.191

package/dist/{chunk-HXM2ISEK.js → chunk-NMDUSCCE.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-WYCFMNU3.js";
+} from "./chunk-GM3WIOO6.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-LM265QNK.js";
 import {
   clampAudioGain,
   clipGain,
@@ -83,7 +83,7 @@ import {
 } from "./chunk-4UMPIPCQ.js";
 import {
   resolveReferencedStart
-} from "./chunk-TSFA2Y5C.js";
+} from "./chunk-3NRB7YXW.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -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);
@@ -3715,6 +3735,7 @@ async function produceDrawElementFrameBatch(page, times, width, height, quality
         const { t, fid } = frame;
         try {
           if (aw.__hf && typeof aw.__hf.seek === "function") aw.__hf.seek(t);
+          await aw.__hfWaitForSeekCompletion?.();
           await aw.__hfDecodeDynamicCssBackgroundImages?.();
           aw.__hf3d?.update();
           const accel = (aw.__hf_accel_canvases ?? []).filter((c) => root.contains(c));
@@ -5488,6 +5509,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);
   }
@@ -5711,16 +5739,60 @@ async function listUnregisteredTimelineIds(page) {
   })()`);
   return Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
 }
-async function waitForSubCompositionTimelines(session, page, timeoutMs) {
+function isScriptFailure(session) {
+  const outcome = session.subTimelineWaitOutcome;
+  return outcome === "script_failure" || outcome === "timeout" && session.pageErrors.length > 0;
+}
+async function isolateUnregisteredCompositions(page) {
+  const isolated = await page.evaluate(`(function() {
+    var timelines = (window.__timelines = window.__timelines || {});
+    var out = [];
+    if (!window.gsap) return out;
+    var broken = [];
+    var live = 0;
+    var hosts = document.querySelectorAll("[data-composition-id]");
+    for (var i = 0; i < hosts.length; i++) {
+      var host = hosts[i];
+      var id = host.getAttribute("data-composition-id");
+      if (!id || host.hasAttribute("data-no-timeline")) continue;
+      var isRoot = !host.parentElement || !host.parentElement.closest("[data-composition-id]");
+      if (timelines[id]) {
+        if (!isRoot) live++;
+      } else if (isRoot) {
+        return out;
+      } else {
+        broken.push(host);
+      }
+    }
+    if (live === 0) return out;
+    broken.forEach(function(host) {
+      var tl = window.gsap.timeline({ paused: true });
+      var duration = parseFloat(host.getAttribute("data-duration"));
+      if (duration > 0) tl.set({}, {}, duration);
+      var id = host.getAttribute("data-composition-id");
+      timelines[id] = tl;
+      out.push({ compositionId: id, elementId: host.id || host.getAttribute("data-hf-id") || null });
+    });
+    if (out.length && typeof window.__hfForceTimelineRebind === "function") window.__hfForceTimelineRebind();
+    return out;
+  })()`);
+  return Array.isArray(isolated) ? isolated : [];
+}
+async function waitForSubCompositionTimelines(session, page, timeoutMs, options = {}) {
   const memo = session.subTimelineWaitMemo;
   session.subTimelineWaitOutcome = await pollSubCompositionTimelines(page, timeoutMs, {
     getScriptLoadFailures: () => session.scriptLoadFailures,
+    getPageErrors: () => session.pageErrors,
+    scriptErrorGraceMs: options.scriptErrorGraceMs,
     onPending: (ids) => {
       session.pendingTimelineIds = [...ids];
     },
     shouldStop: () => session.vfxFailure !== void 0,
     knownUnregisteredIds: memo.unregisteredIds
   });
+  if (isScriptFailure(session) && session.scriptLoadFailures.length === 0) {
+    session.isolatedCompositions = await isolateUnregisteredCompositions(page);
+  }
   const cleanTimeout = session.subTimelineWaitOutcome === "timeout" && session.vfxFailure === void 0 && session.pageErrors.length === 0 && session.scriptLoadFailures.length === 0;
   if (cleanTimeout) {
     memo.unregisteredIds = session.pendingTimelineIds ?? [];
@@ -5730,6 +5802,8 @@ async function pollSubCompositionTimelines(page, timeoutMs, {
   intervalMs = 150,
   getScriptLoadFailures,
   scriptFailureGraceMs = 2e3,
+  getPageErrors,
+  scriptErrorGraceMs = 5e3,
   onPending,
   shouldStop,
   knownUnregisteredIds = []
@@ -5751,16 +5825,22 @@ async function pollSubCompositionTimelines(page, timeoutMs, {
   const deadline = start + timeoutMs;
   let ready = false;
   let scriptFailureBail = false;
+  let errorSeenAt;
   for (; ; ) {
     ready = Boolean(await page.evaluate(expression));
     if (ready || shouldStop?.()) break;
     const now = Date.now();
     if (now >= deadline) break;
     const failures = getScriptLoadFailures?.() ?? [];
-    if (failures.length > 0 && now - start >= scriptFailureGraceMs) {
+    const errors = getPageErrors?.() ?? [];
+    const failed = failures.length > 0 ? failures : errors;
+    const graceMs = failures.length > 0 ? scriptFailureGraceMs : scriptErrorGraceMs;
+    if (failed.length > 0) errorSeenAt ??= now;
+    const sinceFailure = failures.length > 0 ? now - start : now - (errorSeenAt ?? now);
+    if (failed.length > 0 && sinceFailure >= graceMs) {
       scriptFailureBail = true;
       console.warn(
-        `[FrameCapture] Sub-composition timeline wait cut short after ${now - start}ms: script resource(s) failed to load (${failures.join(", ")}), so the timeline registration they carry can never arrive. Fix the script reference; the render proceeds without those animations.`
+        `[FrameCapture] Sub-composition timeline wait cut short after ${now - start}ms: script(s) failed (${failed.join(", ")}), so the timeline registration they carry can never arrive. Fix the script.`
       );
       break;
     }
@@ -5794,7 +5874,7 @@ async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
     return Boolean(
       await page.evaluate((skipIdList) => {
         const skip = new Set(skipIdList);
-        const vids = Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id));
+        const vids = Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id)).filter((v) => !v.closest("[data-hidden]"));
         return vids.length === 0 || vids.every((v) => {
           const ve = v;
           if (ve.readyState >= 2) return true;
@@ -5908,15 +5988,31 @@ function recordCaptureWarnings(session, warnings) {
 function recordSubTimelineWarning(session, timeoutMs) {
   const outcome = session.subTimelineWaitOutcome;
   if (outcome === "ready" || !outcome) return;
-  const threwThenTimedOut = outcome === "timeout" && session.pageErrors.length > 0;
-  const scriptFailure = outcome === "script_failure" || threwThenTimedOut;
+  const threwThenTimedOut = session.pageErrors.length > 0 && session.scriptLoadFailures.length === 0;
+  const scriptFailure = isScriptFailure(session);
   const sources = [...session.scriptLoadFailures, ...session.pageErrors];
   const pending = session.pendingTimelineIds ?? [];
   const pendingSuffix = pending.length > 0 ? ` (still unregistered: ${pending.join(", ")})` : "";
+  const isolated = session.isolatedCompositions ?? [];
+  if (isolated.length > 0) {
+    recordCaptureWarnings(session, [
+      {
+        code: "script_error_isolated",
+        message: `A composition script failed, so its animation was skipped and the render went on: ${isolated.map((c) => c.elementId ?? c.compositionId).join(", ")} (${sources.join(", ")}).`,
+        details: {
+          sources,
+          pendingCompositionIds: [...pending],
+          isolatedElements: isolated,
+          failureOwner: "user"
+        }
+      }
+    ]);
+    return;
+  }
   recordCaptureWarnings(session, [
     {
       code: scriptFailure ? "sub_timeline_script_failure" : "sub_timeline_readiness_timeout",
-      message: threwThenTimedOut ? `A composition script threw and a timeline did not register within ${timeoutMs}ms${pendingSuffix} (${sources.join(", ")}). Fix the error; a composition animated by CSS or rAF rather than a GSAP timeline must mark its host with data-no-timeline.` : scriptFailure ? `A sub-composition timeline script failed to load (${sources.join(", ")})` : `Sub-composition timelines did not become ready within ${timeoutMs}ms${pendingSuffix}. This can be intentional: a composition driven by CSS animations or rAF never registers window.__timelines[id], and marking its host with data-no-timeline skips the wait entirely. Otherwise, a composition that sets up asynchronously must register window.__timelines[id] once setup completes.`,
+      message: threwThenTimedOut ? `A composition script threw before its timeline registered${pendingSuffix} (${sources.join(", ")}). Fix the error; a composition animated by CSS or rAF rather than a GSAP timeline must mark its host with data-no-timeline.` : scriptFailure ? `A sub-composition timeline script failed to load (${sources.join(", ")})` : `Sub-composition timelines did not become ready within ${timeoutMs}ms${pendingSuffix}. This can be intentional: a composition driven by CSS animations or rAF never registers window.__timelines[id], and marking its host with data-no-timeline skips the wait entirely. Otherwise, a composition that sets up asynchronously must register window.__timelines[id] once setup completes.`,
       details: {
         timeoutMs,
         sources,
@@ -6192,7 +6288,7 @@ async function initializeSession(session) {
     if (!videosReady) {
       const failedVideos = await page.evaluate((skipIdList) => {
         const skip = new Set(skipIdList);
-        return Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id)).filter((v) => v.readyState < 2 && !v.error).map((v) => v.src || v.getAttribute("src") || "(no src)").join(", ");
+        return Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id)).filter((v) => !v.closest("[data-hidden]")).filter((v) => v.readyState < 2 && !v.error).map((v) => v.src || v.getAttribute("src") || "(no src)").join(", ");
       }, skipVideoIds);
       console.warn(
         `[FrameCapture] Some video elements did not decode within ${pageReadyTimeout}ms: ${failedVideos}. Continuing render. Affected videos will appear as blank/black frames.`
@@ -6288,7 +6384,7 @@ async function initializeSession(session) {
     if (!bfVideosReady) {
       const failedVideos = await page.evaluate((skipIdList) => {
         const skip = new Set(skipIdList);
-        return Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id)).filter((v) => v.readyState < 2 && !v.error).map((v) => v.src || v.getAttribute("src") || "(no src)").join(", ");
+        return Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id)).filter((v) => !v.closest("[data-hidden]")).filter((v) => v.readyState < 2 && !v.error).map((v) => v.src || v.getAttribute("src") || "(no src)").join(", ");
       }, bfSkipVideoIds);
       console.warn(
         `[FrameCapture] Some video elements did not decode within ${pageReadyTimeout}ms: ${failedVideos}. Continuing render. Affected videos will appear as blank/black frames.`
@@ -7001,6 +7097,44 @@ function resolveSessionMotionBlur(session) {
   }
   return plan;
 }
+async function judgeSmallDrawElementFrame(session, frameIndex, buffer, redraw) {
+  const sizes = session.deFrameSizes ??= [];
+  const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
+  const median = sorted ? sorted[sorted.length >> 1] ?? 0 : 0;
+  const floor = Math.max(session.deAbsFloor ?? 2e4, median * 0.12);
+  let kept = buffer;
+  if (buffer.length < floor && !session.deAcceptedSmall?.equals(buffer)) {
+    const suspect = () => new DrawElementCaptureError(
+      frameIndex,
+      `suspect small frame (${buffer.length}B < ${Math.round(floor)}B)`
+    );
+    if (session.beginFrameTimeTicks > 0) throw suspect();
+    const retry = await redraw();
+    if (retry.equals(buffer)) {
+      session.deAbsFloor = Math.min(session.deAbsFloor ?? 2e4, Math.floor(buffer.length / 2));
+      session.deAcceptedSmall = buffer;
+    } else if (retry.length < floor) {
+      throw suspect();
+    } else {
+      kept = retry;
+    }
+  }
+  if (sizes.length >= 60) sizes.shift();
+  sizes.push(kept.length);
+  return kept;
+}
+async function redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime) {
+  const { page, options } = session;
+  await prepareFrameForCapture(session, frameIndex, time, seekOptions, heldVideoTime);
+  return captureDrawElementFrame(
+    page,
+    options.width,
+    options.height,
+    options.format ?? "jpeg",
+    options.quality ?? 80,
+    true
+  );
+}
 async function captureFrameSurface(session, frameIndex, time, seekOptions, heldVideoTime) {
   const { page, options } = session;
   const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
@@ -7060,19 +7194,12 @@ async function captureFrameSurface(session, frameIndex, time, seekOptions, heldV
         session.beginFrameTimeTicks === 0
       );
       if ((options.format ?? "jpeg") !== "png" && process.env.HF_FORCE_DRAWELEMENT !== "1") {
-        const sizes = session.deFrameSizes ??= [];
-        const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
-        const median = sorted ? sorted[sorted.length >> 1] ?? 0 : 0;
-        const floor = Math.max(2e4, median * 0.12);
-        if (screenshotBuffer.length < floor) {
-          throw new DrawElementCaptureError(
-            frameIndex,
-            `suspect small frame (${screenshotBuffer.length}B < ${Math.round(floor)}B)`
-          );
-        } else {
-          if (sizes.length >= 60) sizes.shift();
-          sizes.push(screenshotBuffer.length);
-        }
+        screenshotBuffer = await judgeSmallDrawElementFrame(
+          session,
+          frameIndex,
+          screenshotBuffer,
+          () => redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime)
+        );
       }
     } catch (err) {
       if (isRecoverableDrawElementError(err)) {
@@ -8853,7 +8980,9 @@ async function extractAudioMetadata(filePath, options) {
       channels: audioStream.channels || 2,
       audioCodec,
       bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0,
-      latestStreamLeadSeconds: latestStreamLeadSeconds(output)
+      latestStreamLeadSeconds: latestStreamLeadSeconds(output),
+      audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
+      audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length
     };
   })();
   if (options?.signal) return probePromise;
@@ -14021,6 +14150,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";
@@ -15136,6 +15268,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";
@@ -15409,7 +15542,8 @@ function parseAudioElements(html) {
   return elements;
 }
 var FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE = ["-xerror"];
-async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
+var SIDECAR_WARM_UP_SECONDS = 1;
+async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config, audioSidecarUrl) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
   if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
@@ -15423,18 +15557,21 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
   const inputSeek = mediaStart >= (metadata?.latestStreamLeadSeconds ?? 0);
   const start = formatFilterNumber(mediaStart);
   const timestampTrim = inputSeek ? null : `atrim=start=${start}:end=${formatFilterNumber(mediaStart + sourceDuration)},asetpts=PTS-${start}/TB,aresample=async=1:first_pts=0`;
+  const fromSidecar = audioSidecarUrl !== void 0 && inputSeek && normalizedPlaybackRate === 1;
+  const warmUp = fromSidecar ? Math.min(SIDECAR_WARM_UP_SECONDS, mediaStart) : 0;
   const outputArgs = preparedAudioOutputArgs(
     metadata,
     normalizedPlaybackRate,
     duration,
-    timestampTrim
+    warmUp > 0 ? `atrim=start=${warmUp},asetpts=PTS-STARTPTS` : timestampTrim
   );
+  const readFrom = fromSidecar ? audioSidecarUrl : srcPath;
   const args = [
     ...readsUrl ? FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE : [],
-    ...urlInputArgs(srcPath),
-    ...inputSeek ? ["-ss", String(mediaStart), "-t", String(sourceDuration)] : [],
+    ...urlInputArgs(readFrom),
+    ...inputSeek ? ["-ss", String(mediaStart - warmUp), "-t", String(sourceDuration + warmUp)] : [],
     "-i",
-    srcPath
+    readFrom
   ];
   args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
   if (normalizedPlaybackRate !== 1) args.push("-t", String(duration));
@@ -15862,216 +15999,223 @@ 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)) {
-          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)) {
+    elements.map(
+      (element, index) => inPrepareSlot(async () => {
+        if (effectiveSignal.aborted) {
           failures.push({
-            stage: "source",
-            reason: "invalid_media",
+            stage: "cancelled",
+            reason: "cancelled",
             owner: "user",
             retryable: false,
             elementId: element.id,
-            detail: boundedDetail(
-              `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`
-            )
+            detail: boundedDetail(`Cancelled audio element ${element.id}`)
           });
           return;
         }
-        if (element.end - element.start <= 0) {
-          let metadata;
-          try {
-            metadata = await extractAudioMetadata(
+        try {
+          let srcPath = element.src;
+          let readInPlace = false;
+          let audioSidecarUrl;
+          if (!isHttpUrl(srcPath)) {
+            srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
+            const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
+            if (remoteUrl) {
+              audioSidecarUrl = config?.audioSidecarUrlByLocalPath?.get(srcPath);
+              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,
+              audioSidecarUrl
             );
-          } 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 {
@@ -16254,7 +16398,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";
@@ -16369,7 +16513,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({
@@ -16409,7 +16553,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(
@@ -16964,7 +17108,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)