hyperframes 0.8.111 → 0.8.112

package/dist/{chunk-OF3RKOPU.js → chunk-P74PW7KR.js}

@@ -22,7 +22,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-B25H4M4V.js";
+} from "./chunk-C4JINRJK.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -52,7 +52,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-YLVI7VL5.js";
+} from "./chunk-S6TH5G6Z.js";
 import {
   chromeMajorCeiling,
   exceedsChromeCeiling
@@ -60,7 +60,7 @@ import {
 import {
   isWithinProjectRoot,
   resolveProjectRelativeSrc
-} from "./chunk-BAVM2XBR.js";
+} from "./chunk-YAFO7V4A.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -1329,7 +1329,8 @@ function probeNvidiaVramMb() {
     const out = execSync("nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits", {
       timeout: 3e3,
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
     }).trim();
     const mb = parseInt(out.split("\n")[0] ?? "", 10);
     if (Number.isFinite(mb) && mb > 0) {
@@ -1370,6 +1371,7 @@ function buildChromeArgs(options, config) {
     ...getBrowserGpuArgs(browserGpuMode, platform),
     "--font-render-hinting=none",
     "--force-color-profile=srgb",
+    "--force-device-scale-factor=1",
     `--window-size=${options.width},${options.height}`,
     // Prevent Chrome from throttling background tabs/timers — critical when the
     // page is offscreen during headless capture
@@ -2507,18 +2509,25 @@ async function captureScreenshotWithAlpha(page, width, height) {
   }
 }
 var TRANSPARENT_BG_STYLE_ID = "__hf_transparent_bg__";
-async function initTransparentBackground(page) {
+async function initTransparentBackground(page, { clearCompositionRoot = false } = {}) {
   const client = await getCdpSession(page);
   await client.send("Emulation.setDefaultBackgroundColorOverride", {
     color: { r: 0, g: 0, b: 0, a: 0 }
   });
-  await page.evaluate((styleId) => {
-    if (document.getElementById(styleId)) return;
-    const style = document.createElement("style");
-    style.id = styleId;
-    style.textContent = "html,body,[data-composition-id]{background:transparent !important;background-color:transparent !important;background-image:none !important;}";
-    document.head.appendChild(style);
-  }, TRANSPARENT_BG_STYLE_ID);
+  await page.evaluate(
+    (styleId, clearCompositionRoot2) => {
+      const selector = clearCompositionRoot2 ? "html,body,[data-composition-id]" : "html,body";
+      let style = document.getElementById(styleId);
+      if (!style) {
+        style = document.createElement("style");
+        style.id = styleId;
+        document.head.appendChild(style);
+      }
+      style.textContent = `${selector}{background:transparent !important;background-color:transparent !important;background-image:none !important;}`;
+    },
+    TRANSPARENT_BG_STYLE_ID,
+    clearCompositionRoot
+  );
 }
 async function captureAlphaPng(page, width, height) {
   const client = await getCdpSession(page);
@@ -4281,7 +4290,8 @@ async function listFilters() {
   try {
     const { stdout } = await execFileP(getFfmpegBinary(), ["-hide_banner", "-filters"], {
       maxBuffer: 4 * 1024 * 1024,
-      timeout: 5e3
+      timeout: 5e3,
+      windowsHide: true
     });
     return stdout;
   } catch {
@@ -9534,8 +9544,8 @@ function isMemberGroupHidden(groupsById, el) {
 }
 
 // ../engine/src/services/videoFrameExtractor.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync3 } from "fs";
-import { join as join9 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync8, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
+import { join as join10 } from "path";
 
 // ../engine/src/services/referenceResolver.ts
 function findReferenceTargetEl(doc, refId) {
@@ -9591,6 +9601,59 @@ function isKnownInactiveTimelineWindow(element, resolvedStart) {
   return end != null && end <= resolvedStart;
 }
 
+// ../engine/src/utils/alphaPlaneProbe.ts
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync5, rmSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join6 } from "path";
+var BYTES_PER_SAMPLE_FRAME = 8 * 8 * 4;
+var MAX_SAMPLE_BYTES = BYTES_PER_SAMPLE_FRAME * 3;
+function sampledRgbaAlphaIsFullyOpaque(buf) {
+  if (buf.length === 0 || buf.length > MAX_SAMPLE_BYTES || buf.length % BYTES_PER_SAMPLE_FRAME !== 0) {
+    return void 0;
+  }
+  for (let i = 3; i < buf.length; i += 4) {
+    if (buf[i] !== 255) return false;
+  }
+  return true;
+}
+async function probeInputAlphaPlane(videoPath, decoder, signal) {
+  let probeDir;
+  try {
+    probeDir = mkdtempSync2(join6(tmpdir2(), "hf-alpha-probe-"));
+    const samplePath = join6(probeDir, "alpha.raw");
+    const result = await runFfmpeg(
+      [
+        "-v",
+        "error",
+        "-c:v",
+        decoder,
+        "-i",
+        videoPath,
+        "-frames:v",
+        "3",
+        "-vf",
+        "scale=8:8",
+        "-pix_fmt",
+        "rgba",
+        "-f",
+        "rawvideo",
+        samplePath
+      ],
+      { timeout: 3e4, signal }
+    );
+    if (!result.success) return void 0;
+    return sampledRgbaAlphaIsFullyOpaque(readFileSync5(samplePath));
+  } catch {
+    return void 0;
+  } finally {
+    if (probeDir) rmSync(probeDir, { recursive: true, force: true });
+  }
+}
+function inputAlphaOpaqueWarning(src) {
+  return `[hyperframes:render] WARNING: video src="${src}" declares an alpha channel but its first frames decode fully opaque. If it should be transparent, re-export it with an alpha pixel format and avoid remuxing afterward, which can drop the alpha while keeping the tag.
+`;
+}
+
 // ../engine/src/utils/urlDownloader.ts
 import {
   closeSync as closeSync2,
@@ -9599,19 +9662,19 @@ import {
   existsSync as existsSync6,
   fsyncSync,
   linkSync,
-  mkdtempSync as mkdtempSync2,
+  mkdtempSync as mkdtempSync3,
   mkdirSync as mkdirSync4,
   lstatSync,
   openSync as openSync2,
   readdirSync as readdirSync3,
   rmdirSync,
-  rmSync,
+  rmSync as rmSync2,
   statSync as statSync4,
   unlinkSync
 } from "fs";
 import { createHash, randomUUID } from "crypto";
 import { BlockList, isIP } from "net";
-import { dirname as dirname4, extname as extname2, join as join6 } from "path";
+import { dirname as dirname4, extname as extname2, join as join7 } from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 var inFlightDownloads = /* @__PURE__ */ new Map();
@@ -9803,7 +9866,7 @@ function removeCacheLockDirectoryIfEmpty(lockPath) {
 }
 function releaseOwnedCachePathLock(lockPath, owner) {
   try {
-    rmdirSync(join6(lockPath, owner));
+    rmdirSync(join7(lockPath, owner));
   } catch (error) {
     if (error.code === "ENOENT") return;
     throw error;
@@ -9844,12 +9907,12 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
     if (createdLock) {
       const owner = `${CACHE_LOCK_OWNER_PREFIX}${randomUUID()}`;
       try {
-        mkdirSync4(join6(lockPath, owner));
+        mkdirSync4(join7(lockPath, owner));
         const entries = readdirSync3(lockPath);
         if (entries.length === 1 && entries[0] === owner) {
           return () => releaseOwnedCachePathLock(lockPath, owner);
         }
-        rmdirSync(join6(lockPath, owner));
+        rmdirSync(join7(lockPath, owner));
         removeCacheLockDirectoryIfEmpty(lockPath);
         continue;
       } catch (error) {
@@ -9867,7 +9930,7 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
     if (Date.now() - observedLock.stats.mtimeMs > CACHE_LOCK_STALE_MS) {
       if (observedLock.owner) {
         try {
-          rmdirSync(join6(lockPath, observedLock.owner));
+          rmdirSync(join7(lockPath, observedLock.owner));
         } catch (error) {
           if (error.code === "ENOENT") continue;
           throw error;
@@ -9875,7 +9938,7 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
         removeCacheLockDirectoryIfEmpty(lockPath);
         continue;
       }
-      const reclaimPath = join6(lockPath, CACHE_LOCK_RECLAIM_NAME);
+      const reclaimPath = join7(lockPath, CACHE_LOCK_RECLAIM_NAME);
       try {
         mkdirSync4(reclaimPath);
       } catch (error) {
@@ -10315,8 +10378,8 @@ function emitDownloadTelemetry(options, event) {
   }
 }
 async function runDownloadAttempt(url, localPath, timeoutMs, attempt, options, signal) {
-  const attemptDir = mkdtempSync2(join6(dirname4(localPath), ".hf-download-"));
-  const partialPath = join6(attemptDir, "payload");
+  const attemptDir = mkdtempSync3(join7(dirname4(localPath), ".hf-download-"));
+  const partialPath = join7(attemptDir, "payload");
   const controller = new AbortController();
   let timedOut = false;
   let callerAborted = signal?.aborted ?? false;
@@ -10418,7 +10481,7 @@ async function runDownloadAttempt(url, localPath, timeoutMs, attempt, options, s
     clearTimeout(timeoutId);
     signal?.removeEventListener("abort", onCallerAbort);
     controller.abort();
-    rmSync(attemptDir, { recursive: true, force: true });
+    rmSync2(attemptDir, { recursive: true, force: true });
   }
 }
 async function downloadWithRetry(url, localPath, timeoutMs, signal, onTransientRetry, options = {}) {
@@ -10497,7 +10560,7 @@ async function reuseOrInvalidateCachedFile(url, localPath, timeoutMs, signal, op
         throw error;
       }
       if (!before.isFile() || before.size === 0) {
-        rmSync(localPath, { recursive: before.isDirectory(), force: true });
+        rmSync2(localPath, { recursive: before.isDirectory(), force: true });
         return false;
       }
       let inspection;
@@ -10529,7 +10592,7 @@ async function reuseOrInvalidateCachedFile(url, localPath, timeoutMs, signal, op
         });
         return true;
       }
-      rmSync(localPath, { force: true });
+      rmSync2(localPath, { force: true });
       return false;
     }
     return false;
@@ -10552,7 +10615,7 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransient
     mkdirSync4(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url, validationScope);
-  const localPath = join6(destDir, filename);
+  const localPath = join7(destDir, filename);
   const downloadPromise = (async () => {
     const cacheStartedAt = Date.now();
     const reused = await reuseOrInvalidateCachedFile(
@@ -10629,16 +10692,16 @@ import {
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync5,
   renameSync,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   statSync as statSync5,
   utimesSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // ../engine/src/services/extractedFrameIndex.ts
 import { readdirSync as readdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var FRAME_FILENAME_PREFIX = "frame_";
 var ExtractedFrameSequenceError = class extends Error {
   constructor(message) {
@@ -10668,7 +10731,7 @@ function framePathsFromDirectory(outputDir, format) {
         `Duplicate extracted frame index ${index}: ${indexed.get(index)} and ${file}`
       );
     }
-    indexed.set(index, join7(outputDir, file));
+    indexed.set(index, join8(outputDir, file));
   }
   const ordered = /* @__PURE__ */ new Map();
   for (let index = 0; index < indexed.size; index += 1) {
@@ -10725,8 +10788,8 @@ function hasFrameFiles(dir) {
 }
 function lookupCacheEntry(rootDir, input) {
   const keyHash = computeCacheKey(input);
-  const dir = join8(rootDir, cacheEntryDirName(keyHash));
-  const complete = existsSync7(join8(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
+  const dir = join9(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync7(join9(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
   return { entry: { dir, keyHash }, hit: complete };
 }
 function partialCacheEntryDir(entry) {
@@ -10737,13 +10800,13 @@ function isTargetExistsRenameError(err) {
   return code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM";
 }
 function adoptPublishedWinner(entry, partialDir) {
-  if (!existsSync7(join8(entry.dir, COMPLETE_SENTINEL))) return null;
+  if (!existsSync7(join9(entry.dir, COMPLETE_SENTINEL))) return null;
   removeDir(partialDir);
   return { dir: entry.dir, published: true };
 }
 function publishCacheEntry(entry, partialDir) {
   try {
-    writeFileSync3(join8(partialDir, COMPLETE_SENTINEL), "", "utf-8");
+    writeFileSync3(join9(partialDir, COMPLETE_SENTINEL), "", "utf-8");
   } catch {
     return { dir: partialDir, published: false };
   }
@@ -10756,7 +10819,7 @@ function publishCacheEntry(entry, partialDir) {
   const winner = adoptPublishedWinner(entry, partialDir);
   if (winner) return winner;
   try {
-    rmSync2(entry.dir, { recursive: true, force: true });
+    rmSync3(entry.dir, { recursive: true, force: true });
   } catch {
     return { dir: partialDir, published: false };
   }
@@ -10774,7 +10837,7 @@ function touchCacheDir(dir) {
   } catch {
   }
   try {
-    utimesSync(join8(dir, COMPLETE_SENTINEL), now, now);
+    utimesSync(join9(dir, COMPLETE_SENTINEL), now, now);
   } catch {
   }
 }
@@ -10803,7 +10866,7 @@ function directorySizeBytes(path) {
     return 0;
   }
   for (const child of children) {
-    const childPath = join8(path, child);
+    const childPath = join9(path, child);
     try {
       const stat = lstatSync2(childPath);
       if (stat.isDirectory()) {
@@ -10818,7 +10881,7 @@ function directorySizeBytes(path) {
 }
 function removeDir(path) {
   try {
-    rmSync2(path, { recursive: true, force: true });
+    rmSync3(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -10832,7 +10895,7 @@ function collectGcEntry(dir, name, now, minAgeMs, stats, remove) {
     }
     let lastUseMs = dirStat.mtimeMs;
     try {
-      lastUseMs = statSync5(join8(dir, COMPLETE_SENTINEL)).mtimeMs;
+      lastUseMs = statSync5(join9(dir, COMPLETE_SENTINEL)).mtimeMs;
     } catch {
     }
     return { dir, size: directorySizeBytes(dir), lastUseMs, ageMs: now - lastUseMs };
@@ -10842,14 +10905,14 @@ function collectGcEntry(dir, name, now, minAgeMs, stats, remove) {
 }
 function gcSweepDue(rootDir, maxAgeMs) {
   try {
-    return Date.now() - statSync5(join8(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
+    return Date.now() - statSync5(join9(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
   } catch {
     return true;
   }
 }
 function markGcSweep(rootDir) {
   try {
-    writeFileSync3(join8(rootDir, GC_MARKER), "", "utf-8");
+    writeFileSync3(join9(rootDir, GC_MARKER), "", "utf-8");
   } catch {
   }
 }
@@ -10864,7 +10927,7 @@ function gcExtractionCache(rootDir, opts) {
     for (const child of readdirSync5(rootDir, { withFileTypes: true })) {
       if (!child.isDirectory() || !isCacheLikeChild(child.name)) continue;
       const entry = collectGcEntry(
-        join8(rootDir, child.name),
+        join9(rootDir, child.name),
         child.name,
         now,
         opts.minAgeMs,
@@ -11346,7 +11409,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const normalizedFps = toFps(options.fps);
   const fps = fpsToNumber(normalizedFps);
   const ffmpegFps = fpsToFfmpegArg(normalizedFps);
-  const videoOutputDir = outputDirOverride ?? join9(outputDir, videoId);
+  const videoOutputDir = outputDirOverride ?? join10(outputDir, videoId);
   if (!existsSync8(videoOutputDir)) mkdirSync6(videoOutputDir, { recursive: true });
   let metadata;
   try {
@@ -11373,7 +11436,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   }
   const format = resolveFrameFormat(metadata, options.format);
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
-  const outputPattern = join9(videoOutputDir, framePattern);
+  const outputPattern = join10(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const toneMappedToSdr = options.toneMapHdrToSdr === true && isHdr && await toneMapsWithZscale();
@@ -11832,7 +11895,7 @@ function planSupersetGroups(misses, fps) {
 }
 function sliceSupersetMember(member, superset, outputDir, fps, configuredFps) {
   const { work } = member.miss;
-  rmSync3(outputDir, { recursive: true, force: true });
+  rmSync4(outputDir, { recursive: true, force: true });
   mkdirSync6(outputDir, { recursive: true });
   const requestedFrames = extractionFrameCountForDuration(
     work.videoDuration,
@@ -11844,7 +11907,7 @@ function sliceSupersetMember(member, superset, outputDir, fps, configuredFps) {
   for (let i = 0; i < frameCount; i += 1) {
     const sourceFrame = superset.framePaths.get(member.offsetFrames + i);
     if (!sourceFrame) throw new Error(`superset frame ${member.offsetFrames + i} missing`);
-    linkOrCopyFrame(sourceFrame, join9(outputDir, frameFileName(i + 1, work.format)));
+    linkOrCopyFrame(sourceFrame, join10(outputDir, frameFileName(i + 1, work.format)));
   }
   return extractedFramesFromDirectory(work, outputDir, work.videoPath, fps);
 }
@@ -11893,7 +11956,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         videoPath = resolveProjectRelativeSrc(video.src, baseDir, compiledDir);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join9(options.outputDir, "_downloads");
+        const downloadDir = join10(options.outputDir, "_downloads");
         mkdirSync6(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(
           videoPath,
@@ -11980,6 +12043,21 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   const videoColorSpaces = videoMetadata.map((m) => m.colorSpace);
   const sdrToHdrTransfers = resolvedVideos.map(() => void 0);
   breakdown.hdrProbeMs = Date.now() - phase2ProbeStart;
+  const alphaWarnedSrcs = /* @__PURE__ */ new Set();
+  if (resolvedVideos.length > 0) {
+    await Promise.all(
+      resolvedVideos.map(async ({ video, videoPath }, index) => {
+        if (signal?.aborted) return;
+        const metadata = videoMetadata[index];
+        if (!metadata?.hasAlpha || !codecMayHaveAlpha(metadata.videoCodec)) return;
+        if (alphaWarnedSrcs.has(video.src)) return;
+        alphaWarnedSrcs.add(video.src);
+        const decoder = decoderForCodec(metadata.videoCodec);
+        if (await probeInputAlphaPlane(videoPath, decoder, signal) !== true) return;
+        process.stderr.write(inputAlphaOpaqueWarning(video.src));
+      })
+    );
+  }
   const hdrPreflightStart = Date.now();
   const hdrInfo = analyzeCompositionHdr(videoColorSpaces);
   const hdrSkippedIndices = /* @__PURE__ */ new Set();
@@ -12104,7 +12182,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   async function extractDirectMiss(miss, maxTransientRetries = options.maxTransientRetries ?? 0) {
     const { work, cacheTarget } = miss;
     if (!cacheTarget) {
-      const outputDir = join9(options.outputDir, work.video.id);
+      const outputDir = join10(options.outputDir, work.video.id);
       const attempted2 = await runVideoExtractionWithRetry(
         () => extractVideoFramesRange(
           work.videoPath,
@@ -12120,14 +12198,14 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
           maxTransientRetries,
           onRetry: () => {
             recordTransientRetries(1);
-            rmSync3(outputDir, { recursive: true, force: true });
+            rmSync4(outputDir, { recursive: true, force: true });
           }
         }
       );
       return attempted2.result;
     }
     const partialDir = partialCacheEntryDir(cacheTarget.entry);
-    rmSync3(partialDir, { recursive: true, force: true });
+    rmSync4(partialDir, { recursive: true, force: true });
     mkdirSync6(partialDir, { recursive: true });
     const attempted = await runVideoExtractionWithRetry(
       () => extractVideoFramesRange(
@@ -12145,7 +12223,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         maxTransientRetries,
         onRetry: () => {
           recordTransientRetries(1);
-          rmSync3(partialDir, { recursive: true, force: true });
+          rmSync4(partialDir, { recursive: true, force: true });
           mkdirSync6(partialDir, { recursive: true });
         }
       }
@@ -12172,7 +12250,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       return sliceSupersetMember(
         member,
         superset,
-        join9(options.outputDir, work.video.id),
+        join10(options.outputDir, work.video.id),
         fps,
         configuredFps
       );
@@ -12189,9 +12267,9 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   async function executeSupersetGroup(group) {
     const first = group.members[0]?.miss.work;
     if (!first) return [];
-    const tempDir = cacheRootDir ? join9(cacheRootDir, `${group.groupId}.partial-${process.pid}`) : join9(options.outputDir, group.groupId);
+    const tempDir = cacheRootDir ? join10(cacheRootDir, `${group.groupId}.partial-${process.pid}`) : join10(options.outputDir, group.groupId);
     try {
-      rmSync3(tempDir, { recursive: true, force: true });
+      rmSync4(tempDir, { recursive: true, force: true });
       const superset = await extractVideoFramesRange(
         first.videoPath,
         group.groupId,
@@ -12224,7 +12302,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       );
       return fallback;
     } finally {
-      rmSync3(tempDir, { recursive: true, force: true });
+      rmSync4(tempDir, { recursive: true, force: true });
     }
   }
   const preparedExtractions = await Promise.all(
@@ -12510,7 +12588,7 @@ var FrameLookupTable = class {
     for (const video of this.videos.values()) {
       if (video.extracted.ownedByLookup) continue;
       if (existsSync8(video.extracted.outputDir)) {
-        rmSync3(video.extracted.outputDir, { recursive: true, force: true });
+        rmSync4(video.extracted.outputDir, { recursive: true, force: true });
       }
     }
     this.videos.clear();
@@ -12957,8 +13035,8 @@ async function queryElementStacking(page, nativeHdrIds) {
 }
 
 // ../engine/src/services/audioMixer.ts
-import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync5, openSync as openSync3, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12, dirname as dirname6, isAbsolute, relative } from "path";
+import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync6, openSync as openSync3, rmSync as rmSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13, dirname as dirname6, isAbsolute, relative } from "path";
 
 // ../engine/src/utils/notMediaPayload.ts
 import { createHash as createHash3 } from "crypto";
@@ -13073,8 +13151,8 @@ function clampFadesToDuration(fades, duration) {
 }
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
+import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
 
 // ../core/dist/runtime/mediaVolumeEnvelope.js
 function normaliseEnvelope(keyframes, trackStart, baseVolume) {
@@ -13196,12 +13274,12 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   if (!gainAt) return false;
   let stagingDir;
   try {
-    const buffer = readFileSync5(wavPath);
+    const buffer = readFileSync6(wavPath);
     const layout = parseWavLayout(buffer);
     if (!layout) return false;
     scaleSamples(buffer, layout, gainAt);
-    stagingDir = mkdtempSync3(join10(dirname5(wavPath), ".hf-volume-"));
-    const tempPath = join10(stagingDir, "audio.wav");
+    stagingDir = mkdtempSync4(join11(dirname5(wavPath), ".hf-volume-"));
+    const tempPath = join11(stagingDir, "audio.wav");
     writeFileSync4(tempPath, buffer, { flag: "wx" });
     renameSync2(tempPath, wavPath);
     return true;
@@ -13210,7 +13288,7 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   } finally {
     if (stagingDir) {
       try {
-        rmSync4(stagingDir, { recursive: true, force: true });
+        rmSync5(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -13272,9 +13350,9 @@ function chainTailSeconds(chain, automation) {
 }
 
 // ../engine/src/services/audioFxRender.ts
-import { existsSync as existsSync9, mkdtempSync as mkdtempSync4, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, mkdtempSync as mkdtempSync5, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join12 } from "path";
 import { pathToFileURL } from "url";
 
 // ../core/dist/generated/audio-fx-runtime-inline.js
@@ -13309,7 +13387,7 @@ function readWavChunks(buf) {
   return { ...head, data };
 }
 function readWav(path) {
-  const buf = readFileSync6(path);
+  const buf = readFileSync7(path);
   if (buf.length < 44 || buf.toString("ascii", 0, 4) !== "RIFF") {
     throw new AudioFxRenderError(`Not a WAV file: ${path}`);
   }
@@ -13404,7 +13482,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
   const { samples, sampleRate, channels, float } = readWav(inputWav);
   const planes = deinterleave(samples, channels);
   if ((planes[0]?.length ?? 0) === 0) return { path: inputWav, envelopeBaked: false };
-  const hostDir = mkdtempSync4(join11(tmpdir2(), "hf-fx-host-"));
+  const hostDir = mkdtempSync5(join12(tmpdir3(), "hf-fx-host-"));
   let lease = null;
   try {
     if (options.signal?.aborted) {
@@ -13413,7 +13491,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
     lease = await acquireBrowser(["--no-sandbox", "--autoplay-policy=no-user-gesture-required"]);
     const page = await lease.browser.newPage();
     try {
-      const hostPage = join11(hostDir, "audio-fx.html");
+      const hostPage = join12(hostDir, "audio-fx.html");
       writeFileSync5(hostPage, "<!doctype html><meta charset=utf-8><title>audio fx</title>");
       await page.goto(pathToFileURL(hostPage).href, { waitUntil: "domcontentloaded" });
       await page.addScriptTag({ content: getAudioFxRuntimeScript() });
@@ -13441,7 +13519,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
       `Audio FX failed for track ${options.trackId}: ${err.message}`
     );
   } finally {
-    rmSync5(hostDir, { recursive: true, force: true });
+    rmSync6(hostDir, { recursive: true, force: true });
     await lease?.release().catch(() => void 0);
   }
 }
@@ -14047,8 +14125,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
   const runMix = async (ignoreAutomation) => {
     const inputs = [];
     tracks.forEach((track) => inputs.push("-i", track.srcPath));
-    const scriptDir = mkdtempSync5(join12(outputDir, ".filter-complex-"));
-    const scriptPath = join12(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync6(join13(outputDir, ".filter-complex-"));
+    const scriptPath = join13(scriptDir, "graph.txt");
     const fd = openSync3(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, buildFilterComplex(ignoreAutomation));
@@ -14079,7 +14157,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       currentArgs[currentArgs.indexOf("-filter_complex_script")] = "-/filter_complex";
       return await runFfmpeg(currentArgs, { signal, timeout: ffmpegProcessTimeout });
     } finally {
-      rmSync6(scriptDir, { recursive: true, force: true });
+      rmSync7(scriptDir, { recursive: true, force: true });
     }
   };
   let result = await runMix(false);
@@ -14152,8 +14230,8 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
       `${mixInputs}amix=inputs=${memberTracks.length}:duration=longest:dropout_transition=0[mixed];[mixed]volume=${formatFilterNumber(memberTracks.length)}[out]`
     );
     const filterComplex = [...inputFilters, mixFilter].join(";");
-    const scriptDir = mkdtempSync5(join12(outputDir, ".group-filter-complex-"));
-    const scriptPath = join12(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync6(join13(outputDir, ".group-filter-complex-"));
+    const scriptPath = join13(scriptDir, "graph.txt");
     const fd = openSync3(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, filterComplex);
@@ -14193,7 +14271,7 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
       currentArgs[currentArgs.indexOf("-filter_complex_script")] = "-/filter_complex";
       return await runFfmpeg(currentArgs, { signal, timeout: ffmpegProcessTimeout });
     } finally {
-      rmSync6(scriptDir, { recursive: true, force: true });
+      rmSync7(scriptDir, { recursive: true, force: true });
     }
   };
   let useNormalize = true;
@@ -14306,7 +14384,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join12(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join13(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -14333,7 +14411,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join12(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join13(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -14377,7 +14455,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           const fxResult = await applyAudioFxChain(
             audioSrcPath,
             chain,
-            join12(workDir, `${element.id}-fx.wav`),
+            join13(workDir, `${element.id}-fx.wav`),
             {
               trackId: element.id,
               signal: effectiveSignal,
@@ -14441,14 +14519,14 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   ).catch((err) => {
     internalController.abort();
     try {
-      rmSync6(workDir, { recursive: true, force: true });
+      rmSync7(workDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
   });
   const bail = () => {
     try {
-      rmSync6(workDir, { recursive: true, force: true });
+      rmSync7(workDir, { recursive: true, force: true });
     } catch {
     }
     return {
@@ -14470,7 +14548,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     const meta = groupMeta.get(groupId);
     if (!meta) continue;
     const pathId = safePathSegment(groupId, groupIndex);
-    const groupWavPath = join12(workDir, `group-${pathId}.wav`);
+    const groupWavPath = join13(workDir, `group-${pathId}.wav`);
     try {
       const subMix = await mixGroupMembers(
         memberTracks,
@@ -14506,7 +14584,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         const fxResult = await applyAudioFxChain(
           groupSrcPath,
           chain,
-          join12(workDir, `group-${pathId}-fx.wav`),
+          join13(workDir, `group-${pathId}-fx.wav`),
           {
             trackId: groupId,
             signal: effectiveSignal,
@@ -14555,7 +14633,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   if (failures.length > 0) return bail();
   const mixResult = await mixAudioTracks(tracks, outputPath, totalDuration, signal, config);
   try {
-    rmSync6(workDir, { recursive: true, force: true });
+    rmSync7(workDir, { recursive: true, force: true });
   } catch {
   }
   const degradedNote = groupsDegradedAutomation.length > 0 ? `Volume automation exceeded this ffmpeg build's expression limits in group(s) ${groupsDegradedAutomation.join(", ")}; rendered at base volume` : void 0;
@@ -14574,26 +14652,26 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 import { cpus, freemem } from "os";
 import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { getHeapStatistics } from "v8";
 
 // ../engine/src/utils/psnr.ts
 import { execFile as execFile3 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join13 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join14 } from "path";
 import { promisify as promisify3 } from "util";
 async function psnrDb(a, b) {
   const execFileP = promisify3(execFile3);
-  const dir = await mkdtemp(join13(tmpdir3(), "hf-de-verify-"));
+  const dir = await mkdtemp(join14(tmpdir4(), "hf-de-verify-"));
   try {
-    const pa = join13(dir, "a.jpg");
-    const pb = join13(dir, "b.jpg");
+    const pa = join14(dir, "a.jpg");
+    const pb = join14(dir, "b.jpg");
     await Promise.all([writeFile(pa, a), writeFile(pb, b)]);
     const { stderr } = await execFileP(
       getFfmpegBinary(),
       ["-hide_banner", "-i", pa, "-i", pb, "-lavfi", "psnr", "-f", "null", "-"],
-      { maxBuffer: 4 * 1024 * 1024 }
+      { maxBuffer: 4 * 1024 * 1024, windowsHide: true }
     );
     const m = /average:(inf|[\d.]+)/.exec(stderr);
     if (!m) throw new Error(`psnr parse failed: ${stderr.slice(-300)}`);
@@ -14813,7 +14891,7 @@ function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join14(workDir, `worker-${i}`),
+      outputDir: join15(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -14827,7 +14905,7 @@ function distributeFramesInterleaved(totalFrames, workerCount, workDir, rangeSta
       startFrame: rangeStart + i,
       endFrame: rangeStart + totalFrames,
       frameStride: workerCount,
-      outputDir: join14(workDir, `worker-${i}`),
+      outputDir: join15(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -15027,7 +15105,7 @@ async function verifyDiskDrawElementSamples(session, task, streaming) {
   for (const idx of selectVerifySampleIndicesForTask(truths.keys(), task)) {
     const truth = truths.get(idx);
     if (!truth) continue;
-    const framePath = join14(task.outputDir, `frame_${String(idx - offset).padStart(6, "0")}.${ext}`);
+    const framePath = join15(task.outputDir, `frame_${String(idx - offset).padStart(6, "0")}.${ext}`);
     const db = await psnrForDiskSample(framePath, truth, task.workerId, idx);
     if (db === null) continue;
     assertDiskSampleAboveFloor(db, verifyMinDb, idx, task.workerId);
@@ -15270,8 +15348,8 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
     }
     const files = readdirSync6(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join14(task.outputDir, file);
-      const targetPath = join14(outputDir, file);
+      const sourcePath = join15(task.outputDir, file);
+      const targetPath = join15(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -15295,8 +15373,8 @@ function getSystemResources() {
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync7, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants } from "fs";
-import { join as join15, extname as extname3 } from "path";
+import { readFileSync as readFileSync8, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants } from "fs";
+import { join as join16, extname as extname3 } from "path";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -15337,16 +15415,16 @@ function readRegularFile(filePath) {
   }
   try {
     if (!fstatSync(fd).isFile()) return null;
-    return readFileSync7(fd);
+    return readFileSync8(fd);
   } finally {
     closeSync4(fd);
   }
 }
 function resolveContainedPaths(projectDir, compiledDir, relativePath) {
-  const projectPath = join15(projectDir, relativePath);
+  const projectPath = join16(projectDir, relativePath);
   if (!isWithinProjectRoot(projectDir, projectPath)) return null;
   if (!compiledDir) return { projectPath, compiledPath: null };
-  const compiledPath = join15(compiledDir, relativePath);
+  const compiledPath = join16(compiledDir, relativePath);
   if (!isWithinProjectRoot(compiledDir, compiledPath)) return null;
   return { projectPath, compiledPath };
 }
@@ -15539,7 +15617,7 @@ function verifyGpuParity(a, b, options = {}) {
 
 // ../engine/src/services/hdrCapture.ts
 import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { homedir as homedir2 } from "os";
 var PQ_M1 = 0.1593017578125;
 var PQ_M2 = 78.84375;
@@ -15662,12 +15740,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join16(homedir2(), ".cache", "puppeteer", "chrome");
+  const baseDir = join17(homedir2(), ".cache", "puppeteer", "chrome");
   if (!existsSync12(baseDir)) return void 0;
   const versions = readdirSync7(baseDir).sort().reverse();
   for (const version of versions) {
     const candidates = [
-      join16(
+      join17(
         baseDir,
         version,
         "chrome-mac-arm64",
@@ -15676,7 +15754,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join16(
+      join17(
         baseDir,
         version,
         "chrome-mac-x64",
@@ -15685,8 +15763,8 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join16(baseDir, version, "chrome-linux64", "chrome"),
-      join16(baseDir, version, "chrome-win64", "chrome.exe")
+      join17(baseDir, version, "chrome-linux64", "chrome"),
+      join17(baseDir, version, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
       if (existsSync12(binary)) return binary;