@hyperframes/producer 0.8.200 → 0.8.202

package/README.md

@@ -61,13 +61,13 @@ are rejected before a render starts. This is separate from engine sub-frame
 
 The producer can render HTML compositions to formats that carry a **true alpha channel** — not chroma key. The same composition that renders an opaque MP4 renders a layerable overlay when you set `format`.
 
-| `format`          | Codec / pixel format              | Alpha                   | Audio               | Use case                                                                                |
-| ----------------- | --------------------------------- | ----------------------- | ------------------- | --------------------------------------------------------------------------------------- |
-| `"mp4"` (default) | H.264 (yuv420p) or H.265 + HDR10  | No                      | AAC                 | Streaming, social, default deliverable                                                  |
-| `"webm"`          | VP9 + yuva420p                    | **True alpha**          | Opus                | Web playback as overlay (`<video>` over background); supported in Chrome, Edge, Firefox |
-| `"mov"`           | ProRes 4444 + yuva444p10le        | **True alpha + 10-bit** | AAC                 | Editor ingest (Premiere, Final Cut Pro, DaVinci Resolve)                                |
-| `"png-sequence"`  | Numbered RGBA PNGs in a directory | **Lossless alpha**      | Sidecar `audio.m4a` | After Effects / Nuke / Fusion, or pipelines that post-process frames before encoding    |
-| `"hls"`           | H.264 (yuv420p) in MPEG-TS        | No                      | AAC rendition       | VOD streaming — see [HLS Output](#hls-output)                                           |
+| `format`          | Codec / pixel format              | Alpha              | Audio               | Use case                                                                                |
+| ----------------- | --------------------------------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
+| `"mp4"` (default) | H.264 (yuv420p) or H.265 + HDR10  | No                 | AAC                 | Streaming, social, default deliverable                                                  |
+| `"webm"`          | VP9 + yuva420p                    | **True alpha**     | Opus                | Web playback as overlay (`<video>` over background); supported in Chrome, Edge, Firefox |
+| `"mov"`           | ProRes 4444 + yuva444p10le        | **True alpha**     | AAC                 | Editor ingest (Premiere, Final Cut Pro, DaVinci Resolve)                                |
+| `"png-sequence"`  | Numbered RGBA PNGs in a directory | **Lossless alpha** | Sidecar `audio.m4a` | After Effects / Nuke / Fusion, or pipelines that post-process frames before encoding    |
+| `"hls"`           | H.264 (yuv420p) in MPEG-TS        | No                 | AAC rendition       | VOD streaming — see [HLS Output](#hls-output)                                           |
 
 ### Example
 
@@ -88,7 +88,7 @@ await executeRenderJob(job, "./my-project", "./output.webm");
 The producer captures Chrome screenshots with the page background forced transparent (`html, body, [data-composition-id] { background: transparent !important }`) and the CDP default background override set to RGBA 0,0,0,0. The captured PNGs carry a real alpha channel and that channel is preserved end-to-end:
 
 - VP9 (`webm`) is encoded with `-pix_fmt yuva420p`, `-auto-alt-ref 0`, `-cpu-used 4` by default, and `alpha_mode=1` metadata. Tune the speed/quality tradeoff with `PRODUCER_VP9_CPU_USED` (`-8` to `8`) or local CLI `--vp9-cpu-used`.
-- ProRes 4444 (`mov`) is encoded with `-pix_fmt yuva444p10le`.
+- ProRes 4444 (`mov`) uses `-pix_fmt yuva444p10le` and carries a separate alpha plane. Chrome's RGBA capture, including alpha, is 8 bits per channel; the 10-bit pixel format adds no capture precision.
 - PNG sequences are written without re-encoding (zero-padded `frame_NNNNNN.png`).
 
 This is not chroma keying. There is no green/blue background to remove and no "key" tolerance to tune — pixels that were transparent in the browser are transparent in the output.

package/dist/distributed.js

@@ -96,6 +96,7 @@ import {
   createVideoFrameInjector,
   getEncoderPreset as getEncoderPreset3,
   distributeFrames as distributeFrames2,
+  distributeFramesInterleaved as distributeFramesInterleaved2,
   executeParallelCapture as executeParallelCapture2,
   mergeWorkerFrames,
   getSystemTotalMb,
@@ -1540,6 +1541,7 @@ import {
   parseVideoElements,
   parseImageElements,
   parseAudioElements,
+  isSelfOrAncestorHidden,
   resolveReferencedStart
 } from "@hyperframes/engine";
 function resolveHostEnd(host, hostStart) {
@@ -1600,6 +1602,15 @@ function collectHostWindows(html) {
   }
   return windows;
 }
+function collectHiddenVideoIds(html) {
+  const { document: document2 } = parseHTML2(html);
+  const hidden = /* @__PURE__ */ new Set();
+  for (const element of document2.querySelectorAll("video")) {
+    const id = element.getAttribute(MEDIA_RENDER_ID_ATTR) || element.getAttribute("id");
+    if (id && isSelfOrAncestorHidden(element)) hidden.add(id);
+  }
+  return hidden;
+}
 function toAbsoluteWindow(start, end, window2) {
   const absoluteStart = resolveAbsoluteMediaStartSeconds({
     authoredStart: start,
@@ -1633,8 +1644,13 @@ function collectRenderMedia(html) {
   const windows = collectHostWindows(html);
   const windowFor = (id) => windows.get(id) ?? ROOT_WINDOW;
   const droppedMediaIds = /* @__PURE__ */ new Set();
+  const hiddenIds = collectHiddenVideoIds(html);
   const videos = [];
   for (const video of parseVideoElements(html)) {
+    if (hiddenIds.has(video.id)) {
+      droppedMediaIds.add(video.id);
+      continue;
+    }
     const absolute = toAbsoluteWindow(video.start, video.end, windowFor(video.id));
     if (!absolute) {
       droppedMediaIds.add(video.id);
@@ -1844,7 +1860,7 @@ async function runAnimatedGifTranscode(request) {
       failureReason: result.failureReason
     });
   }
-  if (result.terminationReason === "deadline") {
+  if (result.terminationReason === "inactivity") {
     throw new Error(`Animated GIF transcode timed out after ${timeout}ms`);
   }
   throw result.error ?? new Error(`Animated GIF transcode failed (${result.exitCode}): ${result.stderr.slice(-500)}`);
@@ -2463,8 +2479,9 @@ async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocal
   const markedStaticHtml = markInferredVariableMediaDurations(staticCompiled, mediaUnresolved);
   let compiledHtml = resolutions.length > 0 ? injectDurations(markedStaticHtml, resolutions) : markedStaticHtml;
   const preResolved = extractResolvedMedia(compiledHtml);
+  const hiddenVideoIds = collectHiddenVideoIds(compiledHtml);
   const clampResults = await Promise.all(
-    preResolved.filter((el) => !!el.src && !el.loop).map(async (el) => {
+    preResolved.filter((el) => !!el.src && !el.loop && !hiddenVideoIds.has(el.id)).map(async (el) => {
       const { duration: maxDuration } = await resolveMediaDuration(
         el.src,
         el.mediaStart,
@@ -4135,6 +4152,7 @@ async function runProbeStage(input) {
         height,
         fps: job.config.fps,
         format: captureFormat,
+        transparent: needsAlpha,
         quality: captureFormat === "png" ? void 0 : resolveCaptureJpegQuality(job.config.quality),
         variables: job.config.variables,
         deviceScaleFactor,
@@ -5772,6 +5790,7 @@ async function runCaptureStage(input) {
       createBeforeCaptureHook: createRenderVideoFrameInjector,
       abortSignal,
       frameRangeStart: frameRange?.startFrame,
+      interleaveFrames: input.interleaveFrames,
       dedupPerfs,
       pageErrorLines: workerPageErrors,
       onProgress: (progress) => {
@@ -6349,9 +6368,6 @@ async function runEncodeStage(input) {
     return { encodeMs: Date.now() - stage5Start };
   }
   const onFramesEncoded = startEncodeProgress(job, "Encoding video", onProgress);
-  const baseScaledEncodeTimeout = Math.ceil((job.duration ?? 0) * 4e3);
-  const scaledEncodeTimeout = baseScaledEncodeTimeout * (job.config.quality === "high" ? 6 : 1);
-  const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
   const frameExt = frameFileExtension2(input.captureImageFormat);
   const framePattern = `frame_%06d.${frameExt}`;
   const encoderOpts = videoEncoderOptions(input, engineCfg);
@@ -6362,7 +6378,7 @@ async function runEncodeStage(input) {
     encoderOpts,
     chunkedEncodeSize,
     abortSignal,
-    videoEngineCfg,
+    engineCfg,
     onFramesEncoded
   ) : await encodeFramesFromDir(
     framesDir,
@@ -6370,7 +6386,7 @@ async function runEncodeStage(input) {
     videoOnlyPath,
     encoderOpts,
     abortSignal,
-    videoEngineCfg,
+    engineCfg,
     onFramesEncoded
   );
   assertNotAborted();
@@ -6498,16 +6514,42 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   }
   return ranges;
 }
-function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0) {
+function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0, stride = 1) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
+  const outputDirFor = (batchIndex, workerId) => join13(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  if (stride > 1) {
+    const spans = /* @__PURE__ */ new Map();
+    for (const range of ranges) {
+      for (let frame = range.startFrame; frame < range.endFrame; frame++) {
+        const span = spans.get(frame % stride);
+        if (span) span.last = frame;
+        else spans.set(frame % stride, { first: frame, last: frame });
+      }
+    }
+    const strided = [...spans.values()];
+    for (let i = 0; i < strided.length; i += workersPerBatch) {
+      const batchIndex = batches.length;
+      batches.push(
+        strided.slice(i, i + workersPerBatch).map(({ first, last }, workerId) => ({
+          workerId,
+          startFrame: rangeStart + first,
+          endFrame: rangeStart + last + 1,
+          frameStride: stride,
+          outputDir: outputDirFor(batchIndex, workerId),
+          outputFrameOffset: rangeStart
+        }))
+      );
+    }
+    return batches;
+  }
   for (let i = 0; i < ranges.length; i += workersPerBatch) {
     const batchIndex = batches.length;
     const batch = ranges.slice(i, i + workersPerBatch).map((range, workerId) => ({
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join13(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: outputDirFor(batchIndex, workerId),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -6565,8 +6607,16 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       currentWorkers,
       attemptWorkDir,
       attempt,
-      rangeStart
-    ) : [distributeFrames2(options.totalFrames, currentWorkers, attemptWorkDir, rangeStart)];
+      rangeStart,
+      options.interleaveFrames ? options.initialWorkerCount : 1
+    ) : [
+      (options.interleaveFrames ? distributeFramesInterleaved2 : distributeFrames2)(
+        options.totalFrames,
+        currentWorkers,
+        attemptWorkDir,
+        rangeStart
+      )
+    ];
     options.dedupPerfs.length = 0;
     try {
       for (const tasks of batches) {
@@ -11058,7 +11108,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             assertNotAborted: () => {
             },
             frameRange: range,
-            onFrameLanded: (frame) => overlap.current?.onFrameLanded(frame)
+            onFrameLanded: (frame) => overlap.current?.onFrameLanded(frame),
+            interleaveFrames: overlap.current !== null
           }).catch(async (captureError) => {
             await overlap.current?.abort();
             overlap.current = null;

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "72ff9fd22c5222e47fb7ec1b9bb2e3643440846a146df5ced666c818e2027d86",
+  "sha256": "58749315991d8ab9f1dc5f8d6968335e10241f89793d85fc83f8aada8dba5a19",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"