hyperframes 0.8.35 → 0.8.37

package/dist/fontLocalizeCli.js

@@ -55006,7 +55006,6 @@ async function syncVideoFrameVisibility(page, activeVideoIds) {
             img.style.visibility = "visible";
           }
         } else {
-          video.style.removeProperty("display");
           video.style.setProperty("visibility", "hidden", "important");
           video.style.setProperty("pointer-events", "none", "important");
           if (hasImg) {
@@ -74471,6 +74470,7 @@ function declarerVariableRules(document2, layerFor) {
   }
   return rules;
 }
+var MAX_INLINE_ASSET_BYTES;
 var init_htmlBundler = __esm({
   "../core/dist/compiler/htmlBundler.js"() {
     "use strict";
@@ -74491,6 +74491,7 @@ var init_htmlBundler = __esm({
     init_cssSelector();
     init_safePath();
     init_colorGrading();
+    MAX_INLINE_ASSET_BYTES = 2 * 1024 * 1024;
   }
 });
 
@@ -86803,6 +86804,17 @@ var ArtifactTransaction = class {
 };
 
 // ../producer/src/services/render/capturePlan.ts
+function drawElementVerificationFailure(plan2, hasDiskFallbackHeadroom) {
+  const { routing } = plan2;
+  const needsHeadroom = routing.kind !== "default" && routing.fallback.kind === "sdr_disk" && routing.memoryExhaustionFallback.kind === "sdr_streaming";
+  return {
+    kind: "draw_element_verification",
+    diskFallbackAvailable: needsHeadroom ? hasDiskFallbackHeadroom() : void 0
+  };
+}
+function streamingCaptureFailure(plan2, classification, hasDiskFallbackHeadroom) {
+  return classification.isVerifyError ? drawElementVerificationFailure(plan2, hasDiskFallbackHeadroom) : { kind: "capture_failure", memoryExhaustion: classification.isMemoryExhaustion };
+}
 function assertWorkerCount(workerCount) {
   if (!Number.isInteger(workerCount) || workerCount < 1) {
     throw new Error(`CapturePlan workerCount must be a positive integer; got ${workerCount}`);
@@ -86873,11 +86885,12 @@ function replanAfterFailure(plan2, failure) {
     });
   }
   const isMemoryExhaustion = failure.kind === "capture_failure" && failure.memoryExhaustion;
+  const diskFallbackUnavailable = failure.kind === "draw_element_verification" && failure.diskFallbackAvailable === false;
   const fallback = plan2.routing.kind === "default" ? {
     kind: plan2.kind,
     workerCount: isMemoryExhaustion ? 1 : plan2.workerCount,
     forceParallelStream: false
-  } : isMemoryExhaustion ? plan2.routing.memoryExhaustionFallback : plan2.routing.fallback;
+  } : isMemoryExhaustion || diskFallbackUnavailable ? plan2.routing.memoryExhaustionFallback : plan2.routing.fallback;
   return createCapturePlan({
     ...plan2,
     workerCount: fallback.workerCount,
@@ -92793,7 +92806,7 @@ function estimateDiskCaptureBytes(totalFrames, captureOptions) {
   const outputHeight = Math.ceil(captureOptions.height * scale);
   return Math.ceil(totalFrames) * outputWidth * outputHeight * 4;
 }
-function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes = (path) => {
+function inspectDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes = (path) => {
   try {
     const stat = statfsSync(path);
     return stat.bavail * stat.bsize;
@@ -92802,11 +92815,22 @@ function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeD
   }
 }) {
   const freeBytes = freeDiskBytes(framesDir);
-  if (freeBytes === null) return;
   const estimatedBytes = estimateDiskCaptureBytes(totalFrames, captureOptions);
-  if (estimatedBytes <= freeBytes * 0.9) return;
+  if (freeBytes === null || estimatedBytes <= freeBytes * 0.9) {
+    return { available: true, estimatedBytes, freeBytes };
+  }
+  return { available: false, estimatedBytes, freeBytes };
+}
+function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes) {
+  const headroom = inspectDiskCaptureHeadroom(
+    framesDir,
+    totalFrames,
+    captureOptions,
+    freeDiskBytes
+  );
+  if (headroom.available) return;
   throw new Error(
-    `Disk capture may need ~${(estimatedBytes / 1e6).toFixed(1)} MB of temporary frame storage, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Re-run with --low-memory-mode to stream frames, raise PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS if streaming is supported, or free up disk space.`
+    `Disk capture may need ~${(headroom.estimatedBytes / 1e6).toFixed(1)} MB of temporary frame storage, but only ${(headroom.freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Re-run with --low-memory-mode to stream frames, raise PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS if streaming is supported, or free up disk space.`
   );
 }
 async function runCaptureStage(input) {
@@ -95780,6 +95804,7 @@ import { mkdtempSync as mkdtempSync10, renameSync as renameSync6, rmSync as rmSy
 import { dirname as dirname17, join as join42 } from "path";
 var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
 var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
+var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
 var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
 function buildAacTruePeakCorrectionArgs(inputPath, outputPath, targetDurationSeconds, attenuationDb) {
   return [
@@ -95979,10 +96004,15 @@ async function enforceAacTruePeak(input) {
   try {
     scratchDir = mkdtempSync10(join42(dirname17(input.audioPath), ".true-peak-"));
     const correctedPath = join42(scratchDir, "audio.m4a");
+    const correctionTargetDbfs = AAC_DELIVERY_TRUE_PEAK_DBFS - AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB;
+    const measurements = [];
     let attenuationDb = 0;
     let measuredPath = input.audioPath;
     for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
       const truePeakDbfs = await input.probeTruePeak(measuredPath, input.signal);
+      measurements.push(
+        `pass ${pass}: ${truePeakDbfs.toFixed(3)} dBFS at ${attenuationDb.toFixed(3)} dB attenuation`
+      );
       if (Number.isNaN(truePeakDbfs) || truePeakDbfs === Number.POSITIVE_INFINITY) {
         return { success: false, error: "audioPadTrim: FFmpeg reported an invalid true peak" };
       }
@@ -95991,7 +96021,7 @@ async function enforceAacTruePeak(input) {
         return { success: true };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
-      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - truePeakDbfs;
+      attenuationDb += correctionTargetDbfs - truePeakDbfs;
       const result = await input.runner(
         buildAacTruePeakCorrectionArgs(
           input.audioPath,
@@ -96014,7 +96044,7 @@ async function enforceAacTruePeak(input) {
     }
     return {
       success: false,
-      error: `audioPadTrim: AAC true peak remained above ${AAC_DELIVERY_TRUE_PEAK_DBFS} dBFS after ${MAX_TRUE_PEAK_CORRECTION_PASSES} correction passes`
+      error: `audioPadTrim: AAC true peak remained above ${AAC_DELIVERY_TRUE_PEAK_DBFS} dBFS after ${MAX_TRUE_PEAK_CORRECTION_PASSES} correction passes; ${measurements.join("; ")}`
     };
   } catch (err) {
     return {
@@ -97923,10 +97953,12 @@ async function executeRenderPipeline(input) {
             isVerifyError ? "drawElement self-verify failed; retrying with forceScreenshot" : isDeStall ? "drawElement renderer stalled; retrying with forceScreenshot" : isSequentialStall ? "sequential capture stalled; retrying with a fresh screenshot session" : "capture failed; retrying with a fresh screenshot session"
           );
           const failedRouting = capturePlan.routing.kind;
-          capturePlan = replanAfterFailure(
+          const failure = streamingCaptureFailure(
             capturePlan,
-            isVerifyError ? { kind: "draw_element_verification" } : { kind: "capture_failure", memoryExhaustion: isMemoryExhaustion }
+            { isVerifyError, isMemoryExhaustion },
+            () => inspectDiskCaptureHeadroom(framesDir, totalFrames, buildCaptureOptions()).available
           );
+          capturePlan = replanAfterFailure(capturePlan, failure);
           syncCapturePlan();
           updateCaptureObservability({
             forceScreenshot: capturePlan.forceScreenshot,
@@ -97946,13 +97978,11 @@ async function executeRenderPipeline(input) {
             probeSession = null;
             await closeOrphanedProbeForRetry(orphaned, closeCaptureSession, log, "streaming");
           }
-          if (failedRouting === "worker_inversion") {
-            log.info(
-              `[Render] Reverting worker inversion for the retry: ${capturePlan.workerCount} workers, plan=${capturePlan.kind}.`
-            );
-          } else if (failedRouting === "parallel_router") {
+          if (failedRouting !== "default") {
+            const route = failedRouting === "worker_inversion" ? "worker inversion" : "parallel router";
+            const diskFallbackLacksHeadroom = failure.kind === "draw_element_verification" && failure.diskFallbackAvailable === false;
             log.info(
-              `[Render] Reverting parallel router for the retry: ${capturePlan.workerCount} workers, plan=${capturePlan.kind}.`
+              diskFallbackLacksHeadroom ? `[Render] ${route} disk fallback lacks headroom; retrying with ${capturePlan.workerCount}-worker screenshot streaming.` : `[Render] Reverting ${route} for the retry: ${capturePlan.workerCount} workers, plan=${capturePlan.kind}.`
             );
           }
           if (capturePlan.kind === "sdr_streaming") {
@@ -99626,8 +99656,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.35" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.35" : "0.0.0-dev";
+var VERSION = true ? "0.8.37" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.37" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {