hyperframes 0.8.189 → 0.8.190-hdr.1

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

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-WYCFMNU3.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);
   }
@@ -8995,8 +9022,10 @@ async function analyzeKeyframeIntervalsUncached(filePath, videoStreamStartSecond
 
 // ../engine/src/services/softwareEncoderThreads.ts
 import { availableParallelism } from "os";
-function appendSoftwareEncoderThreadsArg(args, parallelism = availableParallelism()) {
-  args.push("-threads", String(Math.max(1, Math.floor(parallelism))));
+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
@@ -9223,7 +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);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const gop = resolveLockedGopSize(options);
@@ -9928,7 +9957,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
-      appendSoftwareEncoderThreadsArg(args);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const lockedGop = resolveLockedGopSize(options);
@@ -14021,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";
@@ -15136,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";
@@ -15862,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 {
@@ -16254,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";
@@ -16369,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({
@@ -16409,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(
@@ -16964,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)

package/dist/{chunk-R5FS7GFU.js → chunk-4TFBD773.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   updateNoticesSuppressed
-} from "./chunk-OHXHBMF4.js";
+} from "./chunk-LJKMM3XW.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";

package/dist/{chunk-WYCFMNU3.js → chunk-56IOFIYB.js}

@@ -9,7 +9,7 @@ import {
   parseStrictFiniteTimingNumber,
   resolveNaturalMediaTimelineDuration,
   resolveTimedImageDurationSeconds
-} from "./chunk-BPX7LZG6.js";
+} from "./chunk-DIV37NUE.js";
 import {
   CANVAS_DIMENSIONS,
   isCompositionElement,

package/dist/{chunk-NSJ5HD6A.js → chunk-5XD6QAMF.js}

@@ -6,26 +6,26 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   parakeetRunner
-} from "./chunk-GWYMAII7.js";
+} from "./chunk-UQMPHIOA.js";
 import {
   DecodeCancelled,
   prepareSherpaWav,
   sherpaUnsupportedReason,
   transcribeWithSherpa
-} from "./chunk-M6FHSQZ3.js";
+} from "./chunk-7DJCW4YE.js";
 import {
   initialModelForLanguage,
   transcribe
-} from "./chunk-74Y43RJZ.js";
+} from "./chunk-3B35XAD2.js";
 import {
   createRenderCancellationScope,
   stoppedByCancelSignal
-} from "./chunk-TFUAKV6O.js";
+} from "./chunk-AGUVIOZR.js";
 import {
   DEFAULT_MODEL,
   findWhisper,
   isWhisperUnavailable
-} from "./chunk-6RA4TWGV.js";
+} from "./chunk-6TBDO6H6.js";
 import {
   formatSrt,
   formatVtt,