hyperframes 0.8.139 → 0.8.141

package/dist/{chunk-QXOFUKBF.js → chunk-E6SDW5FV.js}

@@ -4,6 +4,11 @@ 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 {
+  LOW_MEMORY_TOTAL_MB_THRESHOLD,
+  getSystemTotalMb,
+  isLowMemorySystem
+} from "./chunk-USDEMXXL.js";
 import {
   MEDIA_VISUAL_STYLE_PROPERTIES,
   RENDER_FRAME_ID_PREFIX,
@@ -18,11 +23,10 @@ import {
   parseFirstFrameColour,
   quantizeSeekTime,
   quantizeTimeToFrame,
-  redactTelemetryString,
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-EJ7OWYF2.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -33,11 +37,9 @@ import {
   MEDIA_DURATION_CLAMP_EPSILON_SECONDS,
   MEDIA_RENDER_ID_ATTR,
   VOLUME_TARGET,
-  clampAudioGain,
   enabledAudioFxNodes,
   fxAutomationTarget,
   injectScriptsIntoHtml,
-  isAudibleVideoElement,
   normalizeAudioFxParams,
   normalizePlaybackRate,
   normalizeRateSpec,
@@ -53,7 +55,14 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-HYYSJI5D.js";
+} from "./chunk-SYKKFAUW.js";
+import {
+  clampAudioGain,
+  isAudibleVideoElement
+} from "./chunk-YA62XGXS.js";
+import {
+  redactTelemetryString
+} from "./chunk-T76PLPD6.js";
 import {
   chromeMajorCeiling,
   exceedsChromeCeiling
@@ -61,7 +70,7 @@ import {
 import {
   isWithinProjectRoot,
   resolveProjectRelativeSrc
-} from "./chunk-STA43FMY.js";
+} from "./chunk-JFKL3WAE.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -79,103 +88,6 @@ import {
 import { tmpdir } from "os";
 import { join } from "path";
 
-// ../engine/src/services/systemMemory.ts
-import { readFileSync } from "fs";
-import { totalmem } from "os";
-var BYTES_PER_MIB = 1024 * 1024;
-var BYTES_PER_MIB_BIGINT = BigInt(BYTES_PER_MIB);
-var CGROUP_V2_MEMORY_MAX_PATH = "/sys/fs/cgroup/memory.max";
-var CGROUP_V1_MEMORY_LIMIT_PATH = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
-var CGROUP_V1_NO_LIMIT_CUTOFF_BYTES = 2n ** 60n;
-var _cachedCgroupLimitMb;
-var _warnedCgroupReadFailure = false;
-function parseCgroupLimitMb(v2Content, v1Content) {
-  if (v2Content !== null) {
-    return parseCgroupV2LimitMb(v2Content);
-  }
-  return parseCgroupV1LimitMb(v1Content);
-}
-function parseCgroupV2LimitMb(content) {
-  const trimmed = content.trim();
-  if (trimmed === "max") {
-    return null;
-  }
-  return parsePositiveByteLimitMb(trimmed);
-}
-function parseCgroupV1LimitMb(content) {
-  if (content === null) {
-    return null;
-  }
-  return parsePositiveByteLimitMb(content.trim(), CGROUP_V1_NO_LIMIT_CUTOFF_BYTES);
-}
-function parsePositiveByteLimitMb(content, noLimitCutoffBytes) {
-  if (!/^\d+$/.test(content)) {
-    return null;
-  }
-  const bytes = BigInt(content);
-  if (bytes <= 0n) {
-    return null;
-  }
-  if (noLimitCutoffBytes !== void 0 && bytes >= noLimitCutoffBytes) {
-    return null;
-  }
-  return Number(bytes / BYTES_PER_MIB_BIGINT);
-}
-function getCgroupMemoryLimitMb() {
-  if (_cachedCgroupLimitMb !== void 0) return _cachedCgroupLimitMb;
-  if (process.platform !== "linux") {
-    _cachedCgroupLimitMb = null;
-    return null;
-  }
-  const v2Content = readCgroupFile(CGROUP_V2_MEMORY_MAX_PATH);
-  const v1Content = v2Content === null ? readCgroupFile(CGROUP_V1_MEMORY_LIMIT_PATH) : null;
-  _cachedCgroupLimitMb = parseCgroupLimitMb(v2Content, v1Content);
-  if (_cachedCgroupLimitMb !== null) {
-    console.warn(
-      `[SystemMemory] cgroup memory limit detected: ${_cachedCgroupLimitMb} MiB \u2014 it governs memory-adaptive render behaviour instead of host RAM.`
-    );
-  }
-  return _cachedCgroupLimitMb;
-}
-function readCgroupFile(path) {
-  try {
-    return readFileSync(path, "utf8");
-  } catch (error) {
-    const code = getErrorCode(error);
-    if (code !== "ENOENT" && code !== "ENOTDIR") {
-      warnCgroupReadFailure(path, error);
-    }
-    return null;
-  }
-}
-function getErrorCode(error) {
-  if (typeof error !== "object" || error === null || !("code" in error)) {
-    return void 0;
-  }
-  return typeof error.code === "string" ? error.code : void 0;
-}
-function formatCgroupReadError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const code = getErrorCode(error);
-  return code ? `${code}: ${message}` : message;
-}
-function warnCgroupReadFailure(path, error) {
-  if (_warnedCgroupReadFailure) return;
-  _warnedCgroupReadFailure = true;
-  console.warn(
-    `[SystemMemory] Unable to read cgroup memory limit at ${path} (${formatCgroupReadError(error)}); falling back to host RAM.`
-  );
-}
-function getSystemTotalMb() {
-  const hostTotalMb = Math.floor(totalmem() / BYTES_PER_MIB);
-  const cgroupLimitMb = getCgroupMemoryLimitMb();
-  return cgroupLimitMb === null ? hostTotalMb : Math.min(hostTotalMb, cgroupLimitMb);
-}
-var LOW_MEMORY_TOTAL_MB_THRESHOLD = 8192;
-function isLowMemorySystem(totalMb = getSystemTotalMb()) {
-  return totalMb <= LOW_MEMORY_TOTAL_MB_THRESHOLD;
-}
-
 // ../engine/src/services/vp9Options.ts
 var DEFAULT_VP9_CPU_USED = 4;
 var MIN_VP9_CPU_USED = -8;
@@ -201,6 +113,7 @@ var DEFAULT_CONFIG = {
   largeRenderThreshold: 1e3,
   disableGpu: false,
   browserGpuMode: "software",
+  allowSoftwareWebGpu: false,
   enableBrowserPool: true,
   browserTimeout: 12e4,
   protocolTimeout: 3e5,
@@ -244,6 +157,7 @@ var OPTIONAL_ENGINE_CONFIG_FIELDS = [
 ];
 var BOOLEAN_ENGINE_CONFIG_FIELDS = [
   "disableGpu",
+  "allowSoftwareWebGpu",
   "enableBrowserPool",
   "forceScreenshot",
   "staticFrameDedup",
@@ -495,6 +409,10 @@ function resolveConfig(overrides) {
     chromePath: env("PRODUCER_HEADLESS_SHELL_PATH"),
     disableGpu: envBool("PRODUCER_DISABLE_GPU", DEFAULT_CONFIG.disableGpu),
     browserGpuMode: envBrowserGpuMode(),
+    allowSoftwareWebGpu: envBool(
+      "PRODUCER_ALLOW_SOFTWARE_WEBGPU",
+      DEFAULT_CONFIG.allowSoftwareWebGpu
+    ),
     enableBrowserPool: envBool("PRODUCER_ENABLE_BROWSER_POOL", DEFAULT_CONFIG.enableBrowserPool),
     browserTimeout: envNum("PRODUCER_PUPPETEER_LAUNCH_TIMEOUT_MS", DEFAULT_CONFIG.browserTimeout),
     protocolTimeout: envNum(
@@ -1358,15 +1276,19 @@ function getLowMemoryFlags() {
 }
 var CANVAS_DRAW_ELEMENT_FEATURE_FLAG = "--enable-features=CanvasDrawElement";
 var WEBGPU_FLAG = "--enable-unsafe-webgpu";
+function usesSoftwareWebGpu(requiresWebGpu, config) {
+  return !!requiresWebGpu && !!config?.allowSoftwareWebGpu && !(config.disableGpu ?? DEFAULT_CONFIG.disableGpu) && (config.browserGpuMode ?? DEFAULT_CONFIG.browserGpuMode) === "software";
+}
 function buildChromeArgs(options, config) {
   const platform = options.platform ?? process.platform;
   const gpuDisabled = config?.disableGpu ?? DEFAULT_CONFIG.disableGpu;
   const browserGpuMode = gpuDisabled ? "software" : config?.browserGpuMode ?? DEFAULT_CONFIG.browserGpuMode;
+  const softwareWebGpu = usesSoftwareWebGpu(options.requiresWebGpu, config);
   const chromeArgs = [
     "--no-sandbox",
     "--disable-setuid-sandbox",
     "--disable-dev-shm-usage",
-    CANVAS_DRAW_ELEMENT_FEATURE_FLAG,
+    softwareWebGpu ? `${CANVAS_DRAW_ELEMENT_FEATURE_FLAG},Vulkan` : CANVAS_DRAW_ELEMENT_FEATURE_FLAG,
     "--enable-webgl",
     "--ignore-gpu-blocklist",
     ...getBrowserGpuArgs(browserGpuMode, platform),
@@ -1410,7 +1332,8 @@ function buildChromeArgs(options, config) {
   if (browserGpuMode !== "software" || options.requiresWebGpu) {
     chromeArgs.push(WEBGPU_FLAG);
   }
-  if (browserGpuMode === "software") {
+  if (softwareWebGpu) chromeArgs.push("--use-vulkan=swiftshader");
+  if (browserGpuMode === "software" && !softwareWebGpu) {
     chromeArgs.push("--disable-gpu-compositing");
   }
   if (options.captureMode !== "screenshot") {
@@ -1440,26 +1363,30 @@ function compositionRequiresWebGpu(html) {
 var WebGpuUnavailableError = class extends Error {
   constructor() {
     super(
-      "This composition declares data-requires-webgpu, but no hardware WebGPU adapter could be obtained on this browser launch (a software fallback adapter such as swiftshader reports one but cannot render it). Run on a host with a GPU, or remove data-requires-webgpu."
+      "This composition declares data-requires-webgpu, but no hardware WebGPU adapter could be obtained on this browser launch. Run on a host with a GPU, set PRODUCER_ALLOW_SOFTWARE_WEBGPU=true to render it on SwiftShader (slow), or remove data-requires-webgpu."
     );
     this.name = "WebGpuUnavailableError";
   }
 };
 var WEBGPU_ADAPTER_PROBE_TIMEOUT_MS = 1e4;
-async function assertWebGpuAdapterAvailable(page, requiresWebGpu) {
+async function assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu = false) {
   if (!requiresWebGpu) return;
-  const hasUsableAdapter = await page.evaluate(async (timeoutMs) => {
-    if (typeof navigator === "undefined" || !navigator.gpu) return false;
-    try {
-      const adapter = await Promise.race([
-        navigator.gpu.requestAdapter(),
-        new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
-      ]);
-      return !!adapter && !adapter.info.isFallbackAdapter;
-    } catch {
-      return false;
-    }
-  }, WEBGPU_ADAPTER_PROBE_TIMEOUT_MS);
+  const hasUsableAdapter = await page.evaluate(
+    async (timeoutMs, acceptFallback) => {
+      if (typeof navigator === "undefined" || !navigator.gpu) return false;
+      try {
+        const adapter = await Promise.race([
+          navigator.gpu.requestAdapter(),
+          new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+        ]);
+        return !!adapter && (acceptFallback || !adapter.info.isFallbackAdapter);
+      } catch {
+        return false;
+      }
+    },
+    WEBGPU_ADAPTER_PROBE_TIMEOUT_MS,
+    softwareWebGpu
+  );
   if (!hasUsableAdapter) throw new WebGpuUnavailableError();
 }
 function getBrowserGpuArgs(mode, platform) {
@@ -5105,9 +5032,10 @@ async function createCaptureSession(serverUrl, outputDir, options, onBeforeCaptu
   );
   const preMode = headlessShell && isLinux && !effectiveForceScreenshot && !supersampling && !drawElementTransparent ? "beginframe" : "screenshot";
   const requiresWebGpu = options.requiresWebGpu ?? await fetch(`${serverUrl}/index.html`, { signal: AbortSignal.timeout(5e3) }).then((res) => res.text()).then(compositionRequiresWebGpu).catch(() => false);
+  const gpuConfig = { ...config, browserGpuMode: resolvedGpuMode };
   const chromeArgs = buildChromeArgs(
     { width: options.width, height: options.height, captureMode: preMode, requiresWebGpu },
-    { ...config, browserGpuMode: resolvedGpuMode }
+    gpuConfig
   );
   const browserLease = await acquireBrowser(chromeArgs, config);
   return constructCaptureSessionWithRollback({
@@ -5118,7 +5046,8 @@ async function createCaptureSession(serverUrl, outputDir, options, onBeforeCaptu
     onBeforeCapture,
     config,
     useDrawElement,
-    requiresWebGpu
+    requiresWebGpu,
+    softwareWebGpu: usesSoftwareWebGpu(requiresWebGpu, gpuConfig)
   });
 }
 async function constructCaptureSessionWithRollback(input) {
@@ -5168,6 +5097,7 @@ async function constructCaptureSession(input) {
     config,
     useDrawElement,
     requiresWebGpu,
+    softwareWebGpu,
     onPageCreated
   } = input;
   const { browser, captureMode } = browserLease;
@@ -5231,6 +5161,7 @@ async function constructCaptureSession(input) {
     outputDir,
     onBeforeCapture,
     requiresWebGpu,
+    softwareWebGpu,
     isInitialized: false,
     browserConsoleBuffer: [],
     scriptLoadFailures: [],
@@ -5790,7 +5721,11 @@ async function initializeSession(session) {
       );
       throw error;
     }
-    await assertWebGpuAdapterAvailable(page, session.requiresWebGpu ?? false);
+    await assertWebGpuAdapterAvailable(
+      page,
+      session.requiresWebGpu ?? false,
+      session.softwareWebGpu
+    );
   };
   if (session.captureMode === "screenshot") {
     await gotoEntryPage();
@@ -6036,7 +5971,7 @@ async function seekPageTimeline(page, time, seekOptions) {
     seekOptions
   );
 }
-async function prepareFrameForCapture(session, frameIndex, time, seekOptions) {
+async function prepareFrameForCapture(session, frameIndex, time, seekOptions, heldVideoTime) {
   const { page, options } = session;
   if (!session.isInitialized) {
     throw new Error("[FrameCapture] Session not initialized");
@@ -6053,7 +5988,7 @@ async function prepareFrameForCapture(session, frameIndex, time, seekOptions) {
   const seekMs = Date.now() - seekStart;
   const beforeCaptureStart = Date.now();
   if (session.onBeforeCapture) {
-    await session.onBeforeCapture(page, quantizedTime);
+    await session.onBeforeCapture(page, quantizedTime, heldVideoTime);
   }
   await waitForPendingSeekCompletion(page);
   await page.evaluate(async () => {
@@ -6157,6 +6092,8 @@ async function computeStaticFrameSet(page, fps) {
     }
     const hasVideo2 = !!document.querySelector("video");
     const hasCanvas2 = !!document.querySelector("canvas");
+    const hasFrameSources2 = w.__hfHasFrameSources?.() ?? false;
+    const hasIframe2 = !!document.querySelector("iframe");
     const hasUnresolvableClipStart2 = Array.from(document.querySelectorAll("[data-start]")).some(
       (el) => {
         const v = el.dataset.start;
@@ -6181,6 +6118,8 @@ async function computeStaticFrameSet(page, fps) {
       duration: w.__hf?.duration ?? 0,
       hasVideo: hasVideo2,
       hasCanvas: hasCanvas2,
+      hasFrameSources: hasFrameSources2,
+      hasIframe: hasIframe2,
       hasNonGsapAnim: hasNonGsapAnim2,
       hasUnresolvableClipStart: hasUnresolvableClipStart2,
       hasTimelineCall: hasTimelineCall2
@@ -6192,6 +6131,8 @@ async function computeStaticFrameSet(page, fps) {
     duration,
     hasVideo,
     hasCanvas,
+    hasFrameSources,
+    hasIframe,
     hasNonGsapAnim,
     hasUnresolvableClipStart,
     hasTimelineCall
@@ -6225,6 +6166,8 @@ async function computeStaticFrameSet(page, fps) {
   if (!(duration > 0)) reasons.push("unknown/zero duration");
   if (hasVideo) reasons.push("video");
   if (hasCanvas) reasons.push("canvas/webgl");
+  if (hasFrameSources) reasons.push("registered frame source");
+  if (hasIframe) reasons.push("iframe");
   if (tweenCount === 0) reasons.push("no GSAP tweens (non-GSAP animation)");
   if (hasNonGsapAnim) reasons.push("running CSS/WAAPI animation");
   if (hasTimelineCall) reasons.push("tl.call() side effect (not seek-safe)");
@@ -6651,20 +6594,16 @@ function resolveSessionMotionBlur(session) {
       `[MotionBlur] sub-frame motion blur requires format "png", got "${session.options.format ?? "jpeg"}"`
     );
   }
-  if (session.onBeforeCapture) {
-    throw new Error(
-      "[MotionBlur] sub-frame motion blur cannot run with injected video frames: video content is extracted per output frame and does not follow a sub-frame seek"
-    );
-  }
   return plan;
 }
-async function captureFrameSurface(session, frameIndex, time, seekOptions) {
+async function captureFrameSurface(session, frameIndex, time, seekOptions, heldVideoTime) {
   const { page, options } = session;
   const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
     session,
     frameIndex,
     time,
-    seekOptions
+    seekOptions,
+    heldVideoTime
   );
   const screenshotStart = Date.now();
   let screenshotBuffer;
@@ -6781,7 +6720,7 @@ function startChromeMemorySampler(session) {
   session.chromeMemory = sampler;
   sampler.start();
 }
-async function resolveAdaptiveSampleCount(session, frameIndex, absFrameIndex, plan, fps, sampleSeek) {
+async function resolveAdaptiveSampleCount(session, frameIndex, absFrameIndex, plan, fps, sampleSeek, frameTime) {
   if (session.motionBlurNonSpatialFrames?.has(absFrameIndex)) {
     return {
       samplesPerFrame: DEFAULT_SAMPLES_PER_FRAME,
@@ -6791,8 +6730,8 @@ async function resolveAdaptiveSampleCount(session, frameIndex, absFrameIndex, pl
     };
   }
   const { windowStart, windowEnd } = motionBlurProbeTimes(plan, absFrameIndex, fps);
-  const probeA = await captureFrameSurface(session, frameIndex, windowStart, sampleSeek);
-  const probeB = await captureFrameSurface(session, frameIndex, windowEnd, sampleSeek);
+  const probeA = await captureFrameSurface(session, frameIndex, windowStart, sampleSeek, frameTime);
+  const probeB = await captureFrameSurface(session, frameIndex, windowEnd, sampleSeek, frameTime);
   return {
     samplesPerFrame: adaptiveSampleCount(probeDiffMagnitude(probeA.buffer, probeB.buffer)),
     seekMs: probeA.seekMs + probeB.seekMs,
@@ -6806,6 +6745,11 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan)
   const eventfulSeekStart = Date.now();
   await seekPageTimeline(session.page, frameTime, void 0);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
+  if (session.onBeforeCapture) {
+    const injectStart = Date.now();
+    await session.onBeforeCapture(session.page, frameTime, frameTime);
+    totals.beforeCaptureMs += Date.now() - injectStart;
+  }
   const sampleSeek = {
     suppressEvents: true,
     subFrameDivisions: plan.subFrameDivisions
@@ -6818,7 +6762,8 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan)
       absFrameIndex,
       plan,
       fps,
-      sampleSeek
+      sampleSeek,
+      frameTime
     );
     samplesPerFrame = chosen.samplesPerFrame;
     totals.seekMs += chosen.seekMs;
@@ -6827,7 +6772,13 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan)
   }
   const accumulator = new MotionBlurAccumulator(plan.blend);
   for (const sampleTime of motionBlurSampleTimes(plan, absFrameIndex, fps, samplesPerFrame)) {
-    const sample = await captureFrameSurface(session, frameIndex, sampleTime, sampleSeek);
+    const sample = await captureFrameSurface(
+      session,
+      frameIndex,
+      sampleTime,
+      sampleSeek,
+      frameTime
+    );
     totals.seekMs += sample.seekMs;
     totals.beforeCaptureMs += sample.beforeCaptureMs;
     totals.screenshotMs += sample.screenshotMs;
@@ -7274,7 +7225,7 @@ import {
   mkdirSync as mkdirSync2,
   mkdtempSync,
   openSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2,
@@ -7722,6 +7673,22 @@ function isExternalFfmpegInterruption(result) {
   if (result.signal === "SIGTERM") return true;
   return result.exitCode === 255 && FFMPEG_SIGTERM_EXIT_LINE.test(result.stderr);
 }
+function ffmpegStatsReader(onStats) {
+  let rest = "";
+  return (chunk) => {
+    const lines = (rest + chunk).split(/[\r\n]/);
+    rest = lines.pop() ?? "";
+    for (const line of lines) {
+      const frame = /frame=\s*(\d+)/.exec(line)?.[1];
+      const time = /time=\s*(\d+):(\d+):(\d+(?:\.\d+)?)/.exec(line);
+      if (frame === void 0 && !time) continue;
+      onStats({
+        frames: frame === void 0 ? void 0 : Number(frame),
+        seconds: time ? Math.round((Number(time[1]) * 3600 + Number(time[2]) * 60 + Number(time[3])) * 100) / 100 : void 0
+      });
+    }
+  };
+}
 var DEFAULT_TIMEOUT = 3e5;
 var DEFAULT_STDERR_TAIL_LINES = 15;
 function formatWindowsFfmpegExit(exitCode) {
@@ -7816,7 +7783,7 @@ async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
-import { createReadStream, readFileSync as readFileSync2, statSync } from "fs";
+import { createReadStream, readFileSync, statSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { basename } from "path";
 var FFPROBE_STDERR_MAX_BYTES = 8 * 1024;
@@ -8129,7 +8096,7 @@ function pixelFormatHasAlpha(pixelFormat) {
 }
 function extractStillImageMetadata(filePath) {
   try {
-    return extractPngMetadataFromBuffer(readFileSync2(filePath));
+    return extractPngMetadataFromBuffer(readFileSync(filePath));
   } catch {
     return null;
   }
@@ -8438,7 +8405,7 @@ async function analyzeKeyframeIntervalsUncached(filePath, videoStreamStartSecond
 }
 
 // ../engine/src/utils/renderProvenance.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join4 } from "path";
 import { fileURLToPath } from "url";
 var PROVENANCE_RENDERER_TAG = "hyperframes_renderer";
@@ -8453,7 +8420,7 @@ function resolveOwnVersionFrom(startDir) {
     const candidate = join4(dir, "package.json");
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync3(candidate, "utf8"));
+      pkg = JSON.parse(readFileSync2(candidate, "utf8"));
     } catch {
       pkg = void 0;
     }
@@ -8758,7 +8725,9 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
   args.push("-y", outputPath);
   return args;
 }
-async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config) {
+var framesReader = (onFrames) => onFrames && ffmpegStatsReader(({ frames }) => frames !== void 0 && onFrames(frames));
+var secondsReader = (onSeconds) => onSeconds && ffmpegStatsReader(({ seconds }) => seconds !== void 0 && onSeconds(seconds));
+async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config, onFramesEncoded) {
   const startTime = Date.now();
   const outputDir = dirname2(outputPath);
   if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
@@ -8782,7 +8751,11 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   const inputArgs = ["-framerate", fpsToFfmpegArg(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
-  const result = await runFfmpeg(args, { signal, timeout: encodeTimeout });
+  const result = await runFfmpeg(args, {
+    signal,
+    timeout: encodeTimeout,
+    onStderr: framesReader(onFramesEncoded)
+  });
   if (result.terminationReason === "abort") {
     return {
       success: false,
@@ -8854,7 +8827,7 @@ async function concatVideoFiles(inputPaths, outputPath, signal, config) {
     externalInterruption: isExternalFfmpegInterruption(result)
   };
 }
-async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, options, chunkSizeFrames, signal, config) {
+async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, options, chunkSizeFrames, signal, config, onFramesEncoded) {
   const start = Date.now();
   const files = readdirSync2(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i)).sort();
   if (files.length === 0) {
@@ -8902,7 +8875,13 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
     const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
-    const processResult = await runFfmpeg(args, { signal, timeout: encodeTimeout });
+    const processResult = await runFfmpeg(args, {
+      signal,
+      timeout: encodeTimeout,
+      onStderr: framesReader(
+        onFramesEncoded && ((frames) => onFramesEncoded(startNumber + frames))
+      )
+    });
     const chunkResult = {
       success: processResult.success,
       error: processResult.success ? void 0 : appendEncodeTimeoutMessage(
@@ -8945,7 +8924,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     fileSize
   };
 }
-async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config, fps) {
+async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config, fps, onSecondsWritten) {
   const outputDir = dirname2(outputPath);
   if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
@@ -8973,7 +8952,11 @@ async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, confi
   }
   args.push("-y", outputPath);
   const processTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const result = await runFfmpeg(args, { signal, timeout: processTimeout });
+  const result = await runFfmpeg(args, {
+    signal,
+    timeout: processTimeout,
+    onStderr: secondsReader(onSecondsWritten)
+  });
   if (signal?.aborted) {
     return {
       success: false,
@@ -9066,7 +9049,7 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
     }
     if (master !== void 0) {
       try {
-        const stripped = stripAudioOnlyVariants(readFileSync4(master, "utf-8"));
+        const stripped = stripAudioOnlyVariants(readFileSync3(master, "utf-8"));
         ftruncateSync(master, 0);
         writeSync(master, stripped, 0, "utf-8");
       } finally {
@@ -9082,7 +9065,7 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
     failureReason: result.failureReason
   };
 }
-async function applyFaststart(inputPath, outputPath, signal, config, fps) {
+async function applyFaststart(inputPath, outputPath, signal, config, fps, onSecondsWritten) {
   if (outputPath.endsWith(".webm") || outputPath.endsWith(".mov")) {
     if (inputPath !== outputPath) copyFileSync(inputPath, outputPath);
     return { success: true, outputPath, durationMs: 0 };
@@ -9094,7 +9077,11 @@ async function applyFaststart(inputPath, outputPath, signal, config, fps) {
   }
   args.push("-y", outputPath);
   const processTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const result = await runFfmpeg(args, { signal, timeout: processTimeout });
+  const result = await runFfmpeg(args, {
+    signal,
+    timeout: processTimeout,
+    onStderr: secondsReader(onSecondsWritten)
+  });
   if (signal?.aborted) {
     return {
       success: false,
@@ -9416,9 +9403,16 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
   ffmpeg.stdout?.on("error", () => {
   });
   const streamingTimeout = config?.ffmpegStreamingTimeout ?? DEFAULT_CONFIG.ffmpegStreamingTimeout;
+  let framesEncoded = 0;
+  let onFramesEncoded;
   const managed = new ManagedChildProcess(ffmpeg, {
     signal,
-    inactivityTimeoutMs: streamingTimeout
+    inactivityTimeoutMs: streamingTimeout,
+    onStderr: ffmpegStatsReader(({ frames }) => {
+      if (frames === void 0) return;
+      framesEncoded = frames;
+      onFramesEncoded?.(frames);
+    })
   });
   const exitPromise = managed.wait().then((outcome) => {
     exitCode = outcome.exitCode;
@@ -9481,7 +9475,11 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
       managed.markActivity();
       return true;
     },
-    close: async () => {
+    close: async (onEncoded) => {
+      if (onEncoded && exitStatus === "running") {
+        onFramesEncoded = onEncoded;
+        onEncoded(framesEncoded);
+      }
       const stdin = ffmpeg.stdin;
       if (stdin && !stdin.destroyed) {
         await new Promise((resolve) => {
@@ -9666,7 +9664,7 @@ function isKnownInactiveTimelineWindow(element, resolvedStart) {
 }
 
 // ../engine/src/utils/alphaPlaneProbe.ts
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync5, rmSync } from "fs";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync4, rmSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join6 } from "path";
 var BYTES_PER_SAMPLE_FRAME = 8 * 8 * 4;
@@ -9706,7 +9704,7 @@ async function probeInputAlphaPlane(videoPath, decoder, signal) {
       { timeout: 3e4, signal }
     );
     if (!result.success) return void 0;
-    return sampledRgbaAlphaIsFullyOpaque(readFileSync5(samplePath));
+    return sampledRgbaAlphaIsFullyOpaque(readFileSync4(samplePath));
   } catch {
     return void 0;
   } finally {
@@ -12763,9 +12761,14 @@ function createVideoFrameInjector(frameLookup, config) {
     touchCacheDir(cacheDir);
     lastCacheTouchByDir.set(cacheDir, now);
   }
-  return async (page, time) => {
+  return async (page, time, heldVideoTime) => {
     for (const cacheDir of frameLookup.frameDirs()) renewCacheLease(cacheDir);
     const activePayloads = frameLookup.getActiveFramePayloads(time);
+    if (heldVideoTime !== void 0) {
+      for (const [videoId, payload] of frameLookup.getActiveFramePayloads(heldVideoTime)) {
+        if (activePayloads.has(videoId)) activePayloads.set(videoId, payload);
+      }
+    }
     const updates = [];
     const activeIds = /* @__PURE__ */ new Set();
     if (activePayloads.size > 0) {
@@ -13215,7 +13218,7 @@ function clampFadesToDuration(fades, duration) {
 }
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
+import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, 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
@@ -13338,7 +13341,7 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   if (!gainAt) return false;
   let stagingDir;
   try {
-    const buffer = readFileSync6(wavPath);
+    const buffer = readFileSync5(wavPath);
     const layout = parseWavLayout(buffer);
     if (!layout) return false;
     scaleSamples(buffer, layout, gainAt);
@@ -13414,7 +13417,7 @@ function chainTailSeconds(chain, automation) {
 }
 
 // ../engine/src/services/audioFxRender.ts
-import { existsSync as existsSync9, mkdtempSync as mkdtempSync5, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdtempSync as mkdtempSync5, readFileSync as readFileSync6, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join12 } from "path";
 import { pathToFileURL } from "url";
@@ -13451,7 +13454,7 @@ function readWavChunks(buf) {
   return { ...head, data };
 }
 function readWav(path) {
-  const buf = readFileSync7(path);
+  const buf = readFileSync6(path);
   if (buf.length < 44 || buf.toString("ascii", 0, 4) !== "RIFF") {
     throw new AudioFxRenderError(`Not a WAV file: ${path}`);
   }
@@ -14939,6 +14942,10 @@ function computeWorkerSizing(totalFrames, requested, config) {
       boundBy = "contention";
     }
   }
+  if (finalWorkers > heapBasedWorkers) {
+    finalWorkers = heapBasedWorkers;
+    boundBy = "heap";
+  }
   return finish(finalWorkers, boundBy, effectiveMaxWorkers);
 }
 function calculateOptimalWorkers(totalFrames, requested, config) {
@@ -15437,7 +15444,7 @@ function getSystemResources() {
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync8, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants } from "fs";
+import { readFileSync as readFileSync7, 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",
@@ -15479,7 +15486,7 @@ function readRegularFile(filePath) {
   }
   try {
     if (!fstatSync(fd).isFile()) return null;
-    return readFileSync8(fd);
+    return readFileSync7(fd);
   } finally {
     closeSync4(fd);
   }
@@ -15888,10 +15895,6 @@ function buildHdrChromeArgs(width, height) {
 }
 
 export {
-  getCgroupMemoryLimitMb,
-  getSystemTotalMb,
-  LOW_MEMORY_TOTAL_MB_THRESHOLD,
-  isLowMemorySystem,
   DEFAULT_VP9_CPU_USED,
   MIN_VP9_CPU_USED,
   MAX_VP9_CPU_USED,