@hyperframes/producer 0.4.15 → 0.4.16

package/dist/public-server.js

@@ -57866,7 +57866,7 @@ var require_util2 = __commonJS({
         }
         path12 = url.path;
       }
-      var isAbsolute3 = exports.isAbsolute(path12);
+      var isAbsolute5 = exports.isAbsolute(path12);
       var parts = path12.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
@@ -57886,7 +57886,7 @@ var require_util2 = __commonJS({
       }
       path12 = parts.join("/");
       if (path12 === "") {
-        path12 = isAbsolute3 ? "/" : ".";
+        path12 = isAbsolute5 ? "/" : ".";
       }
       if (url) {
         url.path = path12;
@@ -104407,6 +104407,34 @@ function getGpuEncoderName(encoder, codec) {
       return codec === "h264" ? "libx264" : "libx265";
   }
 }
+var NVENC_PRESET_MAP = {
+  ultrafast: "p1",
+  superfast: "p1",
+  veryfast: "p2",
+  faster: "p3",
+  fast: "p4",
+  medium: "p4",
+  slow: "p5",
+  slower: "p6",
+  veryslow: "p7",
+  placebo: "p7"
+};
+var QSV_PRESET_MAP = {
+  ultrafast: "veryfast",
+  superfast: "veryfast",
+  placebo: "veryslow"
+};
+function mapPresetForGpuEncoder(encoder, preset) {
+  switch (encoder) {
+    case "nvenc":
+      if (/^p[1-7]$/.test(preset)) return preset;
+      return NVENC_PRESET_MAP[preset] ?? "p4";
+    case "qsv":
+      return QSV_PRESET_MAP[preset] ?? preset;
+    default:
+      return preset;
+  }
+}
 
 // ../engine/src/utils/hdr.ts
 function isHdrColorSpace(cs) {
@@ -104450,6 +104478,16 @@ function analyzeCompositionHdr(colorSpaces) {
 // ../engine/src/utils/runFfmpeg.ts
 import { spawn as spawn4 } from "child_process";
 var DEFAULT_TIMEOUT2 = 3e5;
+var DEFAULT_STDERR_TAIL_LINES = 15;
+function formatFfmpegError(exitCode, stderr, tailLines = DEFAULT_STDERR_TAIL_LINES) {
+  const tail = (stderr ?? "").split(/\r?\n/).filter((line) => line.length > 0).slice(-tailLines).join("\n");
+  if (exitCode === null) {
+    return tail ? `[FFmpeg] ${tail}` : "[FFmpeg] process error";
+  }
+  return tail ? `FFmpeg exited with code ${exitCode}
+ffmpeg stderr (tail):
+${tail}` : `FFmpeg exited with code ${exitCode}`;
+}
 async function runFfmpeg(args, opts) {
   const startMs = Date.now();
   const signal = opts?.signal;
@@ -104560,7 +104598,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
       args.push("-c:v", encoderName);
       switch (gpuEncoder) {
         case "nvenc":
-          args.push("-preset", preset);
+          args.push("-preset", mapPresetForGpuEncoder("nvenc", preset));
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-cq", String(quality));
           break;
@@ -104579,7 +104617,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
           else args.push("-qp", String(quality));
           break;
         case "qsv":
-          args.push("-preset", preset);
+          args.push("-preset", mapPresetForGpuEncoder("qsv", preset));
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-global_quality", String(quality));
           break;
@@ -104719,7 +104757,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
           durationMs,
           framesEncoded: 0,
           fileSize: 0,
-          error: `FFmpeg exited with code ${code}`
+          error: formatFfmpegError(code, stderr)
         });
         return;
       }
@@ -104889,7 +104927,7 @@ async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, confi
     success: result.success,
     outputPath,
     durationMs: result.durationMs,
-    error: !result.success ? result.exitCode !== null ? `FFmpeg exited with code ${result.exitCode}` : `[FFmpeg] ${result.stderr}` : void 0
+    error: !result.success ? formatFfmpegError(result.exitCode, result.stderr) : void 0
   };
 }
 async function applyFaststart(inputPath, outputPath, signal, config2) {
@@ -104912,7 +104950,7 @@ async function applyFaststart(inputPath, outputPath, signal, config2) {
     success: result.success,
     outputPath,
     durationMs: result.durationMs,
-    error: !result.success ? result.exitCode !== null ? `FFmpeg exited with code ${result.exitCode}` : `[FFmpeg] ${result.stderr}` : void 0
+    error: !result.success ? formatFfmpegError(result.exitCode, result.stderr) : void 0
   };
 }
 
@@ -105005,7 +105043,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
       args.push("-c:v", encoderName);
       switch (gpuEncoder) {
         case "nvenc":
-          args.push("-preset", preset);
+          args.push("-preset", mapPresetForGpuEncoder("nvenc", preset));
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-cq", String(quality));
           break;
@@ -105024,7 +105062,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
           else args.push("-qp", String(quality));
           break;
         case "qsv":
-          args.push("-preset", preset);
+          args.push("-preset", mapPresetForGpuEncoder("qsv", preset));
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-global_quality", String(quality));
           break;
@@ -105180,7 +105218,7 @@ Process error: ${err.message}`;
           success: false,
           durationMs,
           fileSize: 0,
-          error: `FFmpeg exited with code ${exitCode}`
+          error: formatFfmpegError(exitCode, stderr)
         };
       }
       const fileSize = existsSync6(outputPath) ? statSync4(outputPath).size : 0;
@@ -105194,7 +105232,7 @@ Process error: ${err.message}`;
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn8 } from "child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync4, rmSync } from "fs";
-import { join as join8 } from "path";
+import { isAbsolute as isAbsolute2, join as join8 } from "path";
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn7 } from "child_process";
@@ -105309,7 +105347,7 @@ function parseFrameRate(frameRateStr) {
   }
   return parseFloat(frameRateStr) || 0;
 }
-async function extractVideoMetadata(filePath) {
+async function extractMediaMetadata(filePath) {
   const cached = videoMetadataCache.get(filePath);
   if (cached) return cached;
   const probePromise = (async () => {
@@ -105595,7 +105633,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const { fps, outputDir, quality = 95, format: format3 = "jpg" } = options;
   const videoOutputDir = join8(outputDir, videoId);
   if (!existsSync8(videoOutputDir)) mkdirSync5(videoOutputDir, { recursive: true });
-  const metadata = await extractVideoMetadata(videoPath);
+  const metadata = await extractMediaMetadata(videoPath);
   const framePattern = `frame_%05d.${format3}`;
   const outputPattern = join8(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
@@ -105744,7 +105782,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
     if (signal?.aborted) break;
     try {
       let videoPath = video.src;
-      if (!videoPath.startsWith("/") && !isHttpUrl(videoPath)) {
+      if (!isAbsolute2(videoPath) && !isHttpUrl(videoPath)) {
         const fromCompiled = compiledDir ? join8(compiledDir, videoPath) : null;
         videoPath = fromCompiled && existsSync8(fromCompiled) ? fromCompiled : join8(baseDir, videoPath);
       }
@@ -105764,7 +105802,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
   }
   const videoColorSpaces = await Promise.all(
     resolvedVideos.map(async ({ videoPath }) => {
-      const metadata = await extractVideoMetadata(videoPath);
+      const metadata = await extractMediaMetadata(videoPath);
       return metadata.colorSpace;
     })
   );
@@ -105797,7 +105835,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
     if (signal?.aborted) break;
     const entry = resolvedVideos[i];
     if (!entry) continue;
-    const metadata = await extractVideoMetadata(entry.videoPath);
+    const metadata = await extractMediaMetadata(entry.videoPath);
     if (!metadata.isVFR) continue;
     let segDuration = entry.video.end - entry.video.start;
     if (!Number.isFinite(segDuration) || segDuration <= 0) {
@@ -105833,7 +105871,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       try {
         let videoDuration = video.end - video.start;
         if (!Number.isFinite(videoDuration) || videoDuration <= 0) {
-          const metadata = await extractVideoMetadata(videoPath);
+          const metadata = await extractMediaMetadata(videoPath);
           const sourceDuration = metadata.durationSeconds - video.mediaStart;
           videoDuration = sourceDuration > 0 ? sourceDuration : metadata.durationSeconds;
           video.end = video.start + videoDuration;
@@ -106208,7 +106246,7 @@ async function queryElementStacking(page, nativeHdrIds) {
 
 // ../engine/src/services/audioMixer.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
-import { join as join9, dirname as dirname7 } from "path";
+import { isAbsolute as isAbsolute3, join as join9, dirname as dirname7 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(html);
@@ -106435,7 +106473,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       }
       try {
         let srcPath = element.src;
-        if (!srcPath.startsWith("/") && !isHttpUrl(srcPath)) {
+        if (!isAbsolute3(srcPath) && !isHttpUrl(srcPath)) {
           const fromCompiled = compiledDir ? join9(compiledDir, srcPath) : null;
           srcPath = fromCompiled && existsSync9(fromCompiled) ? fromCompiled : join9(baseDir, srcPath);
         }
@@ -107161,13 +107199,51 @@ function normalizeObjectFit(value) {
 }
 function parseTransformMatrix(css) {
   if (!css || css === "none") return null;
-  const match2 = css.match(
+  const match2d = css.match(
     /^matrix\(\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,)]+)\s*\)$/
   );
-  if (!match2) return null;
-  const values = match2.slice(1, 7).map(Number);
-  if (!values.every(Number.isFinite)) return null;
-  return values;
+  if (match2d) {
+    const values = match2d.slice(1, 7).map(Number);
+    if (!values.every(Number.isFinite)) return null;
+    return values;
+  }
+  const match3d = css.match(/^matrix3d\(\s*([^)]+)\)$/);
+  if (match3d) {
+    const raw2 = match3d[1];
+    if (!raw2) return null;
+    const parts = raw2.split(",").map((s) => Number(s.trim()));
+    if (parts.length !== 16 || !parts.every(Number.isFinite)) return null;
+    warnIfZSignificant(parts);
+    return [
+      parts[0],
+      parts[1],
+      parts[4],
+      parts[5],
+      parts[12],
+      parts[13]
+    ];
+  }
+  return null;
+}
+var warnedZSignificant = false;
+var Z_EPSILON = 1e-6;
+function warnIfZSignificant(parts) {
+  if (warnedZSignificant) return;
+  const a3 = parts[8] ?? 0;
+  const b3 = parts[9] ?? 0;
+  const c1 = parts[2] ?? 0;
+  const c2 = parts[6] ?? 0;
+  const c3 = parts[10] ?? 1;
+  const d1 = parts[3] ?? 0;
+  const d2 = parts[7] ?? 0;
+  const d3 = parts[11] ?? 0;
+  const d4 = parts[15] ?? 1;
+  if (Math.abs(a3) > Z_EPSILON || Math.abs(b3) > Z_EPSILON || Math.abs(c1) > Z_EPSILON || Math.abs(c2) > Z_EPSILON || Math.abs(c3 - 1) > Z_EPSILON || Math.abs(d1) > Z_EPSILON || Math.abs(d2) > Z_EPSILON || Math.abs(d3) > Z_EPSILON || Math.abs(d4 - 1) > Z_EPSILON) {
+    warnedZSignificant = true;
+    console.warn(
+      `[alphaBlit] parseTransformMatrix received a matrix3d with non-trivial 3D components (a3=${a3}, b3=${b3}, c1=${c1}, c2=${c2}, c3=${c3}, d1=${d1}, d2=${d2}, d3=${d3}, d4=${d4}). The engine projects 3D transforms to 2D (m11, m12, m21, m22, m41, m42) and silently discards perspective and out-of-plane rotation. If your composition uses real 3D (rotateX/Y, perspective), the rendered output will not match the studio preview. Z translation (translateZ) is dropped by design and does not trigger this warning. This warning is emitted once per process.`
+    );
+  }
 }
 
 // ../engine/src/utils/layerCompositor.ts
@@ -108371,14 +108447,14 @@ import { join as join14, dirname as dirname9, resolve as resolve10 } from "path"
 import postcss from "postcss";
 
 // src/utils/paths.ts
-import { resolve as resolve9, basename as basename2, join as join12, relative as relative2, isAbsolute as isAbsolute2 } from "node:path";
+import { resolve as resolve9, basename as basename2, join as join12, relative as relative2, isAbsolute as isAbsolute4 } from "node:path";
 var DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve9(new URL(import.meta.url).pathname, "../../..", "renders");
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve9(childPath);
   const absParent = resolve9(parentPath);
   if (absChild === absParent) return true;
   const rel = relative2(absParent, absChild);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute4(rel);
 }
 function toExternalAssetKey(absPath) {
   if (absPath.startsWith("hf-ext/")) return absPath;
@@ -108841,7 +108917,7 @@ async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagNa
   if (!existsSync14(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
-  const metadata = tagName19 === "video" ? await extractVideoMetadata(filePath) : await extractAudioMetadata(filePath);
+  const metadata = tagName19 === "video" ? await extractMediaMetadata(filePath) : await extractAudioMetadata(filePath);
   const fileDuration = metadata.durationSeconds;
   const effectiveDuration = fileDuration - mediaStart;
   const duration = effectiveDuration > 0 ? effectiveDuration : fileDuration;
@@ -109424,7 +109500,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir) {
     if (isHttpUrl(video.src)) continue;
     const videoPath = resolve10(projectDir, video.src);
     const reencode = `ffmpeg -i "${video.src}" -c:v libx264 -r 30 -g 30 -keyint_min 30 -movflags +faststart -c:a copy output.mp4`;
-    Promise.all([analyzeKeyframeIntervals(videoPath), extractVideoMetadata(videoPath)]).then(([analysis, metadata]) => {
+    Promise.all([analyzeKeyframeIntervals(videoPath), extractMediaMetadata(videoPath)]).then(([analysis, metadata]) => {
       if (analysis.isProblematic) {
         console.warn(
           `[Compiler] WARNING: Video "${video.id}" has sparse keyframes (max interval: ${analysis.maxIntervalSeconds}s). This causes seek failures and frame freezing. Re-encode with: ${reencode}`
@@ -109623,6 +109699,21 @@ function getMaxFrameIndex(frameDir) {
   frameDirMaxIndexCache.set(frameDir, max);
   return max;
 }
+function countNonZeroAlpha(rgba) {
+  let n = 0;
+  for (let p = 3; p < rgba.length; p += 4) {
+    if (rgba[p] !== 0) n++;
+  }
+  return n;
+}
+function countNonZeroRgb48(buf) {
+  let n = 0;
+  for (let p = 0; p < buf.length; p += 6) {
+    if (buf[p] !== 0 || buf[p + 1] !== 0 || buf[p + 2] !== 0 || buf[p + 3] !== 0 || buf[p + 4] !== 0 || buf[p + 5] !== 0)
+      n++;
+  }
+  return n;
+}
 var RenderCancelledError = class extends Error {
   reason;
   constructor(message = "render_cancelled", reason = "aborted") {
@@ -109830,6 +109921,165 @@ function blitHdrImageLayer(canvas, el, hdrImageBuffers, width, height, log, sour
     }
   }
 }
+async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter, debugFrameIndex = -1) {
+  const {
+    log,
+    domSession,
+    beforeCaptureHook,
+    width,
+    height,
+    fps,
+    effectiveHdr,
+    nativeHdrImageIds,
+    hdrImageBuffers,
+    hdrFrameDirs,
+    hdrVideoStartTimes,
+    imageTransfers,
+    videoTransfers,
+    debugDumpEnabled,
+    debugDumpDir
+  } = ctx;
+  const filteredStacking = elementFilter ? fullStacking.filter((e) => elementFilter.has(e.id)) : fullStacking;
+  const layers = groupIntoLayers(filteredStacking);
+  const shouldLog = debugDumpEnabled && debugFrameIndex >= 0;
+  if (shouldLog) {
+    log.info("[diag] compositeToBuffer plan", {
+      frame: debugFrameIndex,
+      time: time.toFixed(3),
+      filterSize: elementFilter?.size,
+      fullStackingCount: fullStacking.length,
+      filteredCount: filteredStacking.length,
+      layerCount: layers.length,
+      layers: layers.map(
+        (l) => l.type === "hdr" ? {
+          type: "hdr",
+          id: l.element.id,
+          z: l.element.zIndex,
+          visible: l.element.visible,
+          opacity: l.element.opacity,
+          bounds: `${Math.round(l.element.x)},${Math.round(l.element.y)} ${Math.round(l.element.width)}x${Math.round(l.element.height)}`
+        } : { type: "dom", ids: l.elementIds }
+      )
+    });
+  }
+  for (const [layerIdx, layer] of layers.entries()) {
+    if (layer.type === "hdr") {
+      const before2 = shouldLog ? countNonZeroRgb48(canvas) : 0;
+      const isHdrImage = nativeHdrImageIds.has(layer.element.id);
+      if (isHdrImage) {
+        blitHdrImageLayer(
+          canvas,
+          layer.element,
+          hdrImageBuffers,
+          width,
+          height,
+          log,
+          imageTransfers.get(layer.element.id),
+          effectiveHdr.transfer
+        );
+      } else {
+        blitHdrVideoLayer(
+          canvas,
+          layer.element,
+          time,
+          fps,
+          hdrFrameDirs,
+          hdrVideoStartTimes,
+          width,
+          height,
+          log,
+          videoTransfers.get(layer.element.id),
+          effectiveHdr.transfer
+        );
+      }
+      if (shouldLog) {
+        const after2 = countNonZeroRgb48(canvas);
+        if (isHdrImage) {
+          const buf = hdrImageBuffers.get(layer.element.id);
+          log.info("[diag] hdr layer blit", {
+            frame: debugFrameIndex,
+            layerIdx,
+            id: layer.element.id,
+            kind: "image",
+            pixelsAdded: after2 - before2,
+            totalNonZero: after2,
+            bufferDecoded: !!buf,
+            bufferDims: buf ? `${buf.width}x${buf.height}` : null
+          });
+        } else {
+          const frameDir = hdrFrameDirs.get(layer.element.id);
+          const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
+          const localTime = time - startTime;
+          const frameNum = Math.floor(localTime * fps) + 1;
+          const expectedFrame = frameDir ? join15(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
+          log.info("[diag] hdr layer blit", {
+            frame: debugFrameIndex,
+            layerIdx,
+            id: layer.element.id,
+            kind: "video",
+            pixelsAdded: after2 - before2,
+            totalNonZero: after2,
+            startTime,
+            localTime: localTime.toFixed(3),
+            hdrFrameNum: frameNum,
+            expectedFrame,
+            expectedFrameExists: expectedFrame ? existsSync15(expectedFrame) : false
+          });
+        }
+      }
+    } else {
+      const allElementIds = fullStacking.map((e) => e.id);
+      const layerIds = new Set(layer.elementIds);
+      const hideIds = allElementIds.filter((id) => !layerIds.has(id));
+      await domSession.page.evaluate((t) => {
+        if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t);
+      }, time);
+      if (beforeCaptureHook) {
+        await beforeCaptureHook(domSession.page, time);
+      }
+      await applyDomLayerMask(domSession.page, layer.elementIds, hideIds);
+      const domPng = await captureAlphaPng(domSession.page, width, height);
+      await removeDomLayerMask(domSession.page, hideIds);
+      try {
+        const { data: domRgba } = decodePng(domPng);
+        const before2 = shouldLog ? countNonZeroRgb48(canvas) : 0;
+        const alphaPixels = shouldLog ? countNonZeroAlpha(domRgba) : 0;
+        blitRgba8OverRgb48le(domRgba, canvas, width, height, effectiveHdr.transfer);
+        if (shouldLog && debugDumpDir) {
+          const after2 = countNonZeroRgb48(canvas);
+          const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
+          const dumpPath = join15(debugDumpDir, dumpName);
+          writeFileSync4(dumpPath, domPng);
+          log.info("[diag] dom layer blit", {
+            frame: debugFrameIndex,
+            layerIdx,
+            layerIds: layer.elementIds,
+            hideCount: hideIds.length,
+            pngBytes: domPng.length,
+            alphaPixels,
+            pixelsAdded: after2 - before2,
+            totalNonZero: after2,
+            dumpPath
+          });
+        }
+      } catch (err) {
+        log.warn("DOM layer decode/blit failed; skipping overlay", {
+          layerIds: layer.elementIds,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  if (shouldLog && debugDumpDir) {
+    const finalNonZero = countNonZeroRgb48(canvas);
+    log.info("[diag] compositeToBuffer end", {
+      frame: debugFrameIndex,
+      finalNonZeroPixels: finalNonZero,
+      totalPixels: width * height,
+      coverage: (finalNonZero / (width * height) * 100).toFixed(1) + "%"
+    });
+  }
+}
 function createRenderJob(config2) {
   return {
     id: randomUUID(),
@@ -110174,7 +110424,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             videoPath = fromCompiled;
           }
           if (!existsSync15(videoPath)) return;
-          const meta = await extractVideoMetadata(videoPath);
+          const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
             videoTransfers.set(v.id, detectTransfer(meta.colorSpace));
@@ -110195,7 +110445,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             imgPath = fromCompiled;
           }
           if (!existsSync15(imgPath)) return null;
-          const meta = await extractVideoMetadata(imgPath);
+          const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
             imageTransfers.set(img.id, detectTransfer(meta.colorSpace));
@@ -110307,6 +110557,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       format: needsAlpha ? "png" : "jpeg",
       quality: needsAlpha ? void 0 : job.config.quality === "draft" ? 80 : 95
     };
+    const buildHdrCaptureOptions = () => ({
+      ...captureOptions,
+      skipReadinessVideoIds: Array.from(nativeHdrVideoIds)
+    });
     const workerCount = calculateOptimalWorkers(totalFrames, job.config.workers, cfg);
     const FORMAT_EXT = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
@@ -110341,7 +110595,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       const domSession = await createCaptureSession(
         fileServer.url,
         framesDir,
-        { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+        buildHdrCaptureOptions(),
         createVideoFrameInjector(frameLookup),
         cfg
       );
@@ -110437,6 +110691,29 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
         }
+        for (const [imageId, startTime] of hdrImageStartTimes) {
+          if (hdrExtractionDims.has(imageId)) continue;
+          const img = composition.images.find((i) => i.id === imageId);
+          if (!img) continue;
+          const duration = img.end - img.start;
+          const retryTime = startTime + Math.min(0.5, duration * 0.1);
+          await domSession.page.evaluate((t) => {
+            if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t);
+          }, retryTime);
+          if (domSession.onBeforeCapture) {
+            await domSession.onBeforeCapture(domSession.page, retryTime);
+          }
+          const retryStacking = await queryElementStacking(domSession.page, nativeHdrIds);
+          for (const el of retryStacking) {
+            if (el.id === imageId && el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0) {
+              hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+              if (!hdrImageFitInfo.has(el.id)) {
+                hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
+              }
+              break;
+            }
+          }
+        }
         for (const [videoId, srcPath] of hdrVideoSrcPaths) {
           const video = composition.videos.find((v) => v.id === videoId);
           if (!video) continue;
@@ -110519,21 +110796,6 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         }
         assertNotAborted();
         try {
-          let countNonZeroAlpha2 = function(rgba) {
-            let n = 0;
-            for (let p = 3; p < rgba.length; p += 4) {
-              if (rgba[p] !== 0) n++;
-            }
-            return n;
-          }, countNonZeroRgb482 = function(buf) {
-            let n = 0;
-            for (let p = 0; p < buf.length; p += 6) {
-              if (buf[p] !== 0 || buf[p + 1] !== 0 || buf[p + 2] !== 0 || buf[p + 3] !== 0 || buf[p + 4] !== 0 || buf[p + 5] !== 0)
-                n++;
-            }
-            return n;
-          };
-          var countNonZeroAlpha = countNonZeroAlpha2, countNonZeroRgb48 = countNonZeroRgb482;
           const beforeCaptureHook = domSession.onBeforeCapture;
           const cleanedUpVideos = /* @__PURE__ */ new Set();
           const hdrVideoEndTimes = /* @__PURE__ */ new Map();
@@ -110547,153 +110809,28 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           if (debugDumpDir && !existsSync15(debugDumpDir)) {
             mkdirSync10(debugDumpDir, { recursive: true });
           }
-          async function compositeToBuffer(canvas, time, fullStacking, elementFilter, debugFrameIndex = -1) {
-            const filteredStacking = elementFilter ? fullStacking.filter((e) => elementFilter.has(e.id)) : fullStacking;
-            const layers = groupIntoLayers(filteredStacking);
-            const shouldLog = debugDumpEnabled && debugFrameIndex >= 0;
-            if (shouldLog) {
-              log.info("[diag] compositeToBuffer plan", {
-                frame: debugFrameIndex,
-                time: time.toFixed(3),
-                filterSize: elementFilter?.size,
-                fullStackingCount: fullStacking.length,
-                filteredCount: filteredStacking.length,
-                layerCount: layers.length,
-                layers: layers.map(
-                  (l) => l.type === "hdr" ? {
-                    type: "hdr",
-                    id: l.element.id,
-                    z: l.element.zIndex,
-                    visible: l.element.visible,
-                    opacity: l.element.opacity,
-                    bounds: `${Math.round(l.element.x)},${Math.round(l.element.y)} ${Math.round(l.element.width)}x${Math.round(l.element.height)}`
-                  } : { type: "dom", ids: l.elementIds }
-                )
-              });
-            }
-            for (const [layerIdx, layer] of layers.entries()) {
-              if (layer.type === "hdr") {
-                const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
-                const isHdrImage = nativeHdrImageIds.has(layer.element.id);
-                if (isHdrImage) {
-                  blitHdrImageLayer(
-                    canvas,
-                    layer.element,
-                    hdrImageBuffers,
-                    width,
-                    height,
-                    log,
-                    imageTransfers.get(layer.element.id),
-                    effectiveHdr?.transfer
-                  );
-                } else {
-                  blitHdrVideoLayer(
-                    canvas,
-                    layer.element,
-                    time,
-                    job.config.fps,
-                    hdrFrameDirs,
-                    hdrVideoStartTimes,
-                    width,
-                    height,
-                    log,
-                    videoTransfers.get(layer.element.id),
-                    effectiveHdr?.transfer
-                  );
-                }
-                if (shouldLog) {
-                  const after2 = countNonZeroRgb482(canvas);
-                  if (isHdrImage) {
-                    const buf = hdrImageBuffers.get(layer.element.id);
-                    log.info("[diag] hdr layer blit", {
-                      frame: debugFrameIndex,
-                      layerIdx,
-                      id: layer.element.id,
-                      kind: "image",
-                      pixelsAdded: after2 - before2,
-                      totalNonZero: after2,
-                      bufferDecoded: !!buf,
-                      bufferDims: buf ? `${buf.width}x${buf.height}` : null
-                    });
-                  } else {
-                    const frameDir = hdrFrameDirs.get(layer.element.id);
-                    const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
-                    const localTime = time - startTime;
-                    const frameNum = Math.floor(localTime * job.config.fps) + 1;
-                    const expectedFrame = frameDir ? join15(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
-                    log.info("[diag] hdr layer blit", {
-                      frame: debugFrameIndex,
-                      layerIdx,
-                      id: layer.element.id,
-                      kind: "video",
-                      pixelsAdded: after2 - before2,
-                      totalNonZero: after2,
-                      startTime,
-                      localTime: localTime.toFixed(3),
-                      hdrFrameNum: frameNum,
-                      expectedFrame,
-                      expectedFrameExists: expectedFrame ? existsSync15(expectedFrame) : false
-                    });
-                  }
-                }
-              } else {
-                const allElementIds = fullStacking.map((e) => e.id);
-                const layerIds = new Set(layer.elementIds);
-                const hideIds = allElementIds.filter((id) => !layerIds.has(id));
-                await domSession.page.evaluate((t) => {
-                  if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t);
-                }, time);
-                if (beforeCaptureHook) {
-                  await beforeCaptureHook(domSession.page, time);
-                }
-                await applyDomLayerMask(domSession.page, layer.elementIds, hideIds);
-                const domPng = await captureAlphaPng(domSession.page, width, height);
-                await removeDomLayerMask(domSession.page, hideIds);
-                try {
-                  const { data: domRgba } = decodePng(domPng);
-                  if (!effectiveHdr) {
-                    throw new Error(
-                      "Invariant violation: effectiveHdr is undefined inside HDR layer branch"
-                    );
-                  }
-                  const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
-                  const alphaPixels = shouldLog ? countNonZeroAlpha2(domRgba) : 0;
-                  blitRgba8OverRgb48le(domRgba, canvas, width, height, effectiveHdr.transfer);
-                  if (shouldLog && debugDumpDir) {
-                    const after2 = countNonZeroRgb482(canvas);
-                    const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-                    const dumpPath = join15(debugDumpDir, dumpName);
-                    writeFileSync4(dumpPath, domPng);
-                    log.info("[diag] dom layer blit", {
-                      frame: debugFrameIndex,
-                      layerIdx,
-                      layerIds: layer.elementIds,
-                      hideCount: hideIds.length,
-                      pngBytes: domPng.length,
-                      alphaPixels,
-                      pixelsAdded: after2 - before2,
-                      totalNonZero: after2,
-                      dumpPath
-                    });
-                  }
-                } catch (err) {
-                  log.warn("DOM layer decode/blit failed; skipping overlay", {
-                    layerIds: layer.elementIds,
-                    error: err instanceof Error ? err.message : String(err)
-                  });
-                }
-              }
-            }
-            if (shouldLog && debugDumpDir) {
-              const finalNonZero = countNonZeroRgb482(canvas);
-              log.info("[diag] compositeToBuffer end", {
-                frame: debugFrameIndex,
-                finalNonZeroPixels: finalNonZero,
-                totalPixels: width * height,
-                coverage: (finalNonZero / (width * height) * 100).toFixed(1) + "%"
-              });
-            }
+          if (!effectiveHdr) {
+            throw new Error(
+              "Internal: HDR render path entered without effectiveHdr \u2014 this is a bug."
+            );
           }
+          const hdrCompositeCtx = {
+            log,
+            domSession,
+            beforeCaptureHook,
+            width,
+            height,
+            fps: job.config.fps,
+            effectiveHdr,
+            nativeHdrImageIds,
+            hdrImageBuffers,
+            hdrFrameDirs,
+            hdrVideoStartTimes,
+            imageTransfers,
+            videoTransfers,
+            debugDumpEnabled,
+            debugDumpDir
+          };
           const bufSize = width * height * 6;
           const hasTransitions = transitionRanges.length > 0;
           const transBufferA = hasTransitions ? Buffer.alloc(bufSize) : null;
@@ -110801,7 +110938,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
               hdrEncoder.writeFrame(transOutput);
             } else {
               normalCanvas.fill(0);
-              await compositeToBuffer(normalCanvas, time, stackingInfo, void 0, i);
+              await compositeHdrFrame(
+                hdrCompositeCtx,
+                normalCanvas,
+                time,
+                stackingInfo,
+                void 0,
+                i
+              );
               if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
                 const previewPath = join15(
                   debugDumpDir,
@@ -110920,7 +111064,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
               fileServer.url,
               workDir,
               tasks,
-              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              buildHdrCaptureOptions(),
               () => createVideoFrameInjector(frameLookup),
               abortSignal,
               (progress) => {
@@ -110950,7 +111094,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             const session = probeSession ?? await createCaptureSession(
               fileServer.url,
               framesDir,
-              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              buildHdrCaptureOptions(),
               videoInjector,
               cfg
             );
@@ -111002,7 +111146,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
               fileServer.url,
               workDir,
               tasks,
-              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              buildHdrCaptureOptions(),
               () => createVideoFrameInjector(frameLookup),
               abortSignal,
               (progress) => {
@@ -111033,7 +111177,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             const session = probeSession ?? await createCaptureSession(
               fileServer.url,
               framesDir,
-              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              buildHdrCaptureOptions(),
               videoInjector,
               cfg
             );