hyperframes 0.8.188 → 0.8.189

package/dist/{chunk-JYC53CW4.js → chunk-E676Y7AY.js}

@@ -4,22 +4,22 @@ import { dirname as __hf_dirname } from "node:path";
 var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
+import {
+  ambiguousIssue,
+  loadBrowserScript
+} from "./chunk-TPTQHOXU.js";
 import {
   auditClipDurations,
   shouldIgnoreHttpError,
   shouldIgnoreRequestFailure
-} from "./chunk-FOLMMQF3.js";
-import {
-  checkSnapshotDirectory,
-  rectToBbox
-} from "./chunk-KANNRHY7.js";
-import {
-  ambiguousIssue,
-  loadBrowserScript
-} from "./chunk-2DHCCBCN.js";
+} from "./chunk-JIPUWKLA.js";
 import {
   serveStaticProjectHtml
-} from "./chunk-XPVN4R66.js";
+} from "./chunk-CSYSEPWL.js";
+import {
+  artifactDirectory,
+  finishSnapshotRun
+} from "./chunk-TMBUBLZB.js";
 import {
   FfmpegUnavailableError,
   decideMediaProxyEligibility,
@@ -27,7 +27,7 @@ import {
   proxyVariantFor,
   resolveProxies,
   scanProjectMediaCodecMap
-} from "./chunk-LWYZN7HS.js";
+} from "./chunk-BZQLTNMB.js";
 import {
   AUDIT_SEEK_OPTIONS,
   DEFAULT_ZOOM_PADDING_PX,
@@ -41,14 +41,17 @@ import {
   seekCompositionTimeline,
   seekInPage,
   waitForPreferredSeekTarget
-} from "./chunk-KDBPZOXK.js";
+} from "./chunk-TREMHDWT.js";
 import {
   BrowserCleanupError,
   closeManagedBrowser
-} from "./chunk-MXXX6WVC.js";
+} from "./chunk-HNMDLKA4.js";
+import {
+  findStageProxyBox
+} from "./chunk-SGFMCNLY.js";
 import {
   resolveAutoProxy
-} from "./chunk-DG4ME554.js";
+} from "./chunk-Z2BW2WJS.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -132,10 +135,41 @@ function dropMotionBlurConsoleEcho(drafts, found) {
   );
 }
 
+// src/utils/checkSnapshotDirectory.ts
+import { resolve } from "path";
+var runDirectories = /* @__PURE__ */ new Map();
+var activeChecks = /* @__PURE__ */ new Map();
+function beginCheckSnapshots(projectDir) {
+  const project = resolve(projectDir);
+  activeChecks.set(project, (activeChecks.get(project) ?? 0) + 1);
+}
+function checkSnapshotDirectory(projectDir) {
+  const project = resolve(projectDir);
+  let directory = runDirectories.get(project);
+  if (!directory) {
+    directory = artifactDirectory(project, "snapshots");
+    runDirectories.set(project, directory);
+  }
+  return directory;
+}
+async function finishCheckSnapshots(projectDir) {
+  const project = resolve(projectDir);
+  const remaining = Math.max(0, (activeChecks.get(project) ?? 1) - 1);
+  if (remaining > 0) {
+    activeChecks.set(project, remaining);
+    return;
+  }
+  activeChecks.delete(project);
+  const path = runDirectories.get(project);
+  if (!path) return;
+  runDirectories.delete(project);
+  await finishSnapshotRun(project, path);
+}
+
 // src/utils/checkBrowser.ts
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import os from "os";
-import { join, resolve } from "path";
+import { join, resolve as resolve2 } from "path";
 
 // src/utils/gsapTweenTails.ts
 var TWEEN_TAIL_WINDOW = 0.25;
@@ -247,9 +281,14 @@ function collectTweenRecords() {
   );
 }
 
+// src/utils/checkTypes.ts
+function rectToBbox(rect) {
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+
 // src/utils/checkBrowser.ts
 async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride) {
-  const none = { findings: [], failedPaths: /* @__PURE__ */ new Set() };
+  const none = { findings: [], failedPaths: /* @__PURE__ */ new Set(), files: [] };
   if (!resolveAutoProxy(projectDir, autoProxyOverride)) return none;
   let codecMap;
   try {
@@ -265,17 +304,20 @@ async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride
   );
   if (hostileEntries.length === 0) return none;
   const startedAt = Date.now();
+  const stageBox = findStageProxyBox(html);
   const sources = hostileEntries.map(([pathname, facts]) => {
     const file = pathname.replace(/^\/+/, "");
     return {
       pathname,
       file,
-      sourcePath: resolve(projectDir, file),
-      variant: proxyVariantFor(facts)
+      sourcePath: resolve2(projectDir, file),
+      variant: proxyVariantFor(facts),
+      box: stageBox
     };
   });
   const total = hostileEntries.length;
-  const toMake = sources.filter((source) => !proxyCached(projectDir, source)).length;
+  const cached = sources.map((source) => proxyCached(projectDir, source));
+  const toMake = cached.filter((isCached) => !isCached).length;
   if (toMake > 0) {
     console.error(
       `[hyperframes] Making browser-playable copies of ${toMake} video${toMake === 1 ? "" : "s"} Chrome cannot decode. Only the first check of these files waits for this; later checks reuse the copies.`
@@ -306,11 +348,18 @@ async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride
       )
     );
   }
-  return { findings, failedPaths: new Set(failures.map(({ pathname }) => pathname)) };
+  const files = sources.map(({ file }, index) => {
+    const result = results[index];
+    if (result.status === "rejected") {
+      return { file, state: "failed", reason: normalizeErrorMessage(result.reason) };
+    }
+    return { file, state: cached[index] ? "cached" : "ready" };
+  });
+  return { findings, failedPaths: new Set(failures.map(({ pathname }) => pathname)), files };
 }
 function proxyCached(projectDir, source) {
   try {
-    return existsSync(getProxyCachePath(projectDir, source.sourcePath, source.variant));
+    return existsSync(getProxyCachePath(projectDir, source.sourcePath, source.variant, source.box));
   } catch {
     return false;
   }
@@ -319,7 +368,7 @@ function proxyFailedDraft(message) {
   return { code: "media_proxy_failed", severity: "warning", message, time: 0 };
 }
 async function runBrowserCheck(project, options, motion, runGrid, deadline, prelaunched) {
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-3QG722YD.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-EDD2XDS2.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   deadline?.enter("copies");
   const { findings: drafts, failedPaths } = await preResolveHostileMediaProxies(
@@ -366,7 +415,7 @@ async function runBrowserCheck(project, options, motion, runGrid, deadline, prel
     await waitForPreferredSeekTarget(page);
     const rootAnchor = await resolveRootAnchor(page);
     const launchSettleMs = Date.now() - launchSettleStart;
-    const { analyzeClipMediaFit } = await import("./src-ZPIV4PGX.js");
+    const { analyzeClipMediaFit } = await import("./src-YNXBU4ZQ.js");
     for (const entry of await auditClipDurations(page, analyzeClipMediaFit, options.timeout)) {
       drafts.push({ code: "clip_media_fit", severity: entry.level, message: entry.text, time: 0 });
     }
@@ -475,7 +524,7 @@ function mergeHelperDrafts(primary, helper) {
 }
 async function captureFindingCrops(project, options, requests, deadline) {
   if (requests.length === 0) return [];
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-3QG722YD.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-EDD2XDS2.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   const server = await serveStaticProjectHtml(
     project.dir,
@@ -651,11 +700,11 @@ async function abortedImagesStillBroken(page, drafts) {
   if (urls.length === 0) return /* @__PURE__ */ new Set();
   const broken = await page.evaluate(
     async (candidates, capMs) => {
-      const fails = (img) => new Promise((resolve2) => {
-        const cap = setTimeout(() => resolve2(false), capMs);
+      const fails = (img) => new Promise((resolve3) => {
+        const cap = setTimeout(() => resolve3(false), capMs);
         img.decode().then(
-          () => resolve2(false),
-          () => resolve2(true)
+          () => resolve3(false),
+          () => resolve3(true)
         ).finally(() => clearTimeout(cap));
       });
       const stillBroken = await Promise.all(
@@ -1680,6 +1729,10 @@ function matchComponentFindings({
 }
 
 export {
+  beginCheckSnapshots,
+  checkSnapshotDirectory,
+  finishCheckSnapshots,
+  rectToBbox,
   preResolveHostileMediaProxies,
   runBrowserCheck,
   samplingBrowserCount,

package/dist/{chunk-5OZI55AC.js → chunk-E7TI5PAQ.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-WIX4JM2K.js");
+        const { trackCommandFailure } = await import("./events-GUIOSBIB.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-BWEZDN6U.js → chunk-F45HHA3M.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   shouldTrack
-} from "./chunk-PMXR3IUH.js";
+} from "./chunk-T37XXYRK.js";
 
 // src/telemetry/renderObservability.ts
 function renderObservabilityTelemetryPayload(observability) {

package/dist/{chunk-DA4TQFSF.js → chunk-FJF5JBYU.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-YCW345M4.js";
+} from "./chunk-HXM2ISEK.js";
 import {
   DOMParser,
   parseHTML

package/dist/{chunk-NFHRGHCJ.js → chunk-GBT7P3OQ.js}

@@ -14,17 +14,17 @@ import {
 } from "./chunk-6JR2XUEE.js";
 import {
   readCompositionFps
-} from "./chunk-B2P4JRUJ.js";
+} from "./chunk-HUG47UEE.js";
 import {
   HF_AUDIO_GROUP_ATTR,
   extractAudioMetadata,
   extractMediaMetadata
-} from "./chunk-YCW345M4.js";
+} from "./chunk-HXM2ISEK.js";
 import {
   byStart,
   fpsToNumber,
   parseFpsWithDefault
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-WYCFMNU3.js";
 import {
   HF_AUDIO_AUTOMATION_ATTR,
   HF_AUDIO_FX_ATTR,

package/dist/{chunk-UF6RCYA5.js → chunk-GWYMAII7.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   sherpaParakeetInstalled,
   sherpaUnsupportedReason
-} from "./chunk-FWVILDOZ.js";
+} from "./chunk-M6FHSQZ3.js";
 import {
   findParakeet
 } from "./chunk-JZIEZCQM.js";

package/dist/{chunk-MXXX6WVC.js → chunk-HNMDLKA4.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-DKPNNYBZ.js";
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-T3OXKSRG.js";
+} from "./chunk-B52BJM5K.js";
 import {
   requestCliExit
 } from "./chunk-JVBRJMOP.js";

package/dist/{chunk-GYBPAKBM.js → chunk-HQIFMCQN.js}

@@ -8,7 +8,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-2WUDFZCR.js";
+} from "./chunk-XJVXROOL.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -41,6 +41,7 @@ import {
   analyzeCompositionHdr,
   analyzeKeyframeIntervals,
   appendRenderProvenanceArgs,
+  appendSoftwareEncoderThreadsArg,
   applyConcreteGpuScreenshotClamp,
   applyDomLayerMask,
   applyFaststart,
@@ -155,7 +156,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-YCW345M4.js";
+} from "./chunk-HXM2ISEK.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
@@ -170,7 +171,7 @@ import {
   parseVfxChain,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-WYCFMNU3.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -15499,7 +15500,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-ZPIV4PGX.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-YNXBU4ZQ.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -17148,7 +17149,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-ZPIV4PGX.js");
+    const { drainBrowserPool } = await import("./src-YNXBU4ZQ.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -18193,10 +18194,9 @@ function readAssemblePlan(planDir, chunkPaths) {
 function videoInputArgs(ctx, videoSources) {
   return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
 }
-async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join39(ctx.workDir, `cfr.${ctx.format}`);
-  const cfrArgs = [
-    ...videoInputArgs(ctx, chunkPaths),
+function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
+  const args = [
+    ...inputArgs,
     "-c:v",
     "libx264",
     ...cfrRateControlArgs(encoder),
@@ -18205,8 +18205,14 @@ async function reencodeCfr(ctx, chunkPaths, encoder) {
     "-fps_mode",
     "cfr",
     "-r",
-    ctx.fpsArg
+    fpsArg
   ];
+  appendSoftwareEncoderThreadsArg(args);
+  return args;
+}
+async function reencodeCfr(ctx, chunkPaths, encoder) {
+  const cfrOutputPath = join39(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
   await ctx.timed(

package/dist/{chunk-B2P4JRUJ.js → chunk-HUG47UEE.js}

@@ -10,7 +10,7 @@ import {
 import {
   DISTRIBUTED_FPS,
   isDistributedFps
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-WYCFMNU3.js";
 import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";

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

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-WYCFMNU3.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -8993,6 +8993,12 @@ 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))));
+}
+
 // ../engine/src/utils/renderProvenance.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join5 } from "path";
@@ -9217,6 +9223,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
+      appendSoftwareEncoderThreadsArg(args);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const gop = resolveLockedGopSize(options);
@@ -9921,6 +9928,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
+      appendSoftwareEncoderThreadsArg(args);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const lockedGop = resolveLockedGopSize(options);
@@ -12472,6 +12480,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 +12488,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";
 }
@@ -15239,7 +15249,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 +15314,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 +15511,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 +15637,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 +15723,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);
@@ -17396,6 +17506,7 @@ export {
   extractVideoMetadata,
   extractAudioMetadata,
   analyzeKeyframeIntervals,
+  appendSoftwareEncoderThreadsArg,
   PROVENANCE_RENDERER_TAG,
   PROVENANCE_VERSION_TAG,
   PROVENANCE_RENDERER_NAME,

package/dist/{chunk-OJOZXWLC.js → chunk-IFXOMIBP.js}

@@ -15,13 +15,13 @@ import {
   findFFmpeg,
   findFFprobe,
   getFFmpegInstallHint
-} from "./chunk-NMOTNNP2.js";
+} from "./chunk-3OLOVRWS.js";
 import {
   DEFAULT_VP9_CPU_USED,
   SDR_RGB_TO_BT709_FILTER,
   SDR_RGB_TO_TAGGED_BT709_FILTER,
   renderProvenanceArgs
-} from "./chunk-YCW345M4.js";
+} from "./chunk-HXM2ISEK.js";
 
 // src/background-removal/pipeline.ts
 import { spawn } from "child_process";
@@ -262,7 +262,7 @@ function inferInputKind(inputPath) {
 }
 async function probeMedia(inputPath) {
   const isImage = inferInputKind(inputPath) === "image";
-  const engine = await import("./src-ZPIV4PGX.js");
+  const engine = await import("./src-YNXBU4ZQ.js");
   const meta = await engine.extractMediaMetadata(inputPath);
   if (isImage) {
     return { width: meta.width, height: meta.height, fps: 0, frameCount: 1 };

package/dist/{chunk-6Q5CFUAP.js → chunk-IPEP346Y.js}

@@ -8,7 +8,7 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-PMXR3IUH.js";
+} from "./chunk-T37XXYRK.js";
 import {
   CliRuntimeError
 } from "./chunk-JVBRJMOP.js";