@hyperframes/producer 0.5.0-alpha.13 → 0.5.0-alpha.14

package/dist/index.js

@@ -98670,7 +98670,8 @@ var DEFAULT_CONFIG = {
   forceScreenshot: false,
   enableChunkedEncode: false,
   chunkSizeFrames: 360,
-  enableStreamingEncode: false,
+  enableStreamingEncode: true,
+  streamingEncodeMaxDurationSeconds: 240,
   ffmpegEncodeTimeout: 6e5,
   ffmpegProcessTimeout: 3e5,
   ffmpegStreamingTimeout: 6e5,
@@ -98732,6 +98733,13 @@ function resolveConfig(overrides) {
       "PRODUCER_ENABLE_STREAMING_ENCODE",
       DEFAULT_CONFIG.enableStreamingEncode
     ),
+    streamingEncodeMaxDurationSeconds: Math.max(
+      0,
+      envNum(
+        "PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS",
+        DEFAULT_CONFIG.streamingEncodeMaxDurationSeconds
+      )
+    ),
     ffmpegEncodeTimeout: envNum("FFMPEG_ENCODE_TIMEOUT_MS", DEFAULT_CONFIG.ffmpegEncodeTimeout),
     ffmpegProcessTimeout: envNum("FFMPEG_PROCESS_TIMEOUT_MS", DEFAULT_CONFIG.ffmpegProcessTimeout),
     ffmpegStreamingTimeout: envNum(
@@ -101695,6 +101703,23 @@ async function applyVideoMetadataHints(page, hints) {
     [...hints]
   );
 }
+async function waitForOptionalTailwindReady(page, timeoutMs) {
+  const hasTailwindReady = await page.evaluate(
+    `(() => { const ready = window.__tailwindReady; return !!ready && typeof ready.then === "function"; })()`
+  );
+  if (!hasTailwindReady) return;
+  const ready = await Promise.race([
+    page.evaluate(
+      `Promise.resolve(window.__tailwindReady).then(() => true, () => false)`
+    ),
+    new Promise((resolve14) => setTimeout(() => resolve14(false), timeoutMs))
+  ]);
+  if (!ready) {
+    throw new Error(
+      `[FrameCapture] window.__tailwindReady not resolved after ${timeoutMs}ms. Tailwind browser runtime must finish before frame capture starts.`
+    );
+  }
+}
 async function initializeSession(session) {
   const { page, serverUrl } = session;
   page.on("console", (msg) => {
@@ -101751,6 +101776,7 @@ async function initializeSession(session) {
       );
     }
     await page.evaluate(`document.fonts?.ready`);
+    await waitForOptionalTailwindReady(page, pageReadyTimeout2);
     if (session.options.format === "png") {
       await initTransparentBackground(session.page);
     }
@@ -101816,6 +101842,7 @@ async function initializeSession(session) {
     await new Promise((r) => setTimeout(r, 100));
   }
   await page.evaluate(`document.fonts?.ready`);
+  await waitForOptionalTailwindReady(page, pageReadyTimeout);
   warmupRunning = false;
   session.beginFrameTimeTicks = (warmupTicks + 10) * session.beginFrameIntervalMs;
   if (session.options.format === "png") {
@@ -111470,6 +111497,27 @@ function createRenderJob(config2) {
 function normalizeCompositionSrcPath(srcPath) {
   return srcPath.replace(/\\/g, "/").replace(/^\.\//, "");
 }
+function createStandaloneEntryRenderClone(root, host) {
+  const hostClone = host.cloneNode(true);
+  hostClone.setAttribute("data-start", "0");
+  if (root === host) return hostClone;
+  const rootClone = root.cloneNode(false);
+  rootClone.appendChild(hostClone);
+  return rootClone;
+}
+function replaceBodyWithRenderClone(body, renderClone) {
+  while (body.firstChild) {
+    body.removeChild(body.firstChild);
+  }
+  body.appendChild(renderClone);
+}
+function shouldUseStreamingEncode(cfg, outputFormat, workerCount, durationSeconds) {
+  if (!cfg.enableStreamingEncode) return false;
+  if (outputFormat === "png-sequence") return false;
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) return false;
+  if (durationSeconds > cfg.streamingEncodeMaxDurationSeconds) return false;
+  return workerCount === 1;
+}
 function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
   const normalizedEntryFile = normalizeCompositionSrcPath(entryFile);
   const { document: document2 } = parseHTML(indexHtml);
@@ -111484,16 +111532,8 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
     (candidate) => candidate.hasAttribute("data-composition-id")
   ) ?? null;
   if (!root) return null;
-  const hostClone = host.cloneNode(true);
-  hostClone.setAttribute("data-start", "0");
-  body.innerHTML = "";
-  if (root === host) {
-    body.appendChild(hostClone);
-    return document2.toString();
-  }
-  const rootClone = root.cloneNode(false);
-  rootClone.appendChild(hostClone);
-  body.appendChild(rootClone);
+  const renderClone = createStandaloneEntryRenderClone(root, host);
+  replaceBodyWithRenderClone(body, renderClone);
   return document2.toString();
 }
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
@@ -111525,7 +111565,6 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
   }
   const enableChunkedEncode = cfg.enableChunkedEncode;
   const chunkedEncodeSize = cfg.chunkSizeFrames;
-  const enableStreamingEncode = cfg.enableStreamingEncode && !isPngSequence;
   let peakRssBytes = 0;
   let peakHeapUsedBytes = 0;
   const sampleMemory = () => {
@@ -112094,6 +112133,15 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await closeCaptureSession(probeSession);
       probeSession = null;
     }
+    let useStreamingEncode = shouldUseStreamingEncode(cfg, outputFormat, workerCount, job.duration);
+    log.info("streaming-encode gate", {
+      enabled: useStreamingEncode,
+      configFlag: cfg.enableStreamingEncode,
+      outputFormat,
+      workerCount,
+      durationSeconds: job.duration,
+      maxDurationSeconds: cfg.streamingEncodeMaxDurationSeconds
+    });
     const captureAttempts = [];
     const FORMAT_EXT = {
       mp4: ".mp4",
@@ -112633,28 +112681,47 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     } else {
       let streamingEncoder = null;
       let streamingEncoderClosed = false;
-      if (enableStreamingEncode) {
-        streamingEncoder = await spawnStreamingEncoder(
-          videoOnlyPath,
-          {
-            fps: job.config.fps,
-            width,
-            height,
-            codec: preset.codec,
-            preset: preset.preset,
-            quality: effectiveQuality,
-            bitrate: effectiveBitrate,
-            pixelFormat: preset.pixelFormat,
-            useGpu: job.config.useGpu,
-            imageFormat: captureOptions.format || "jpeg",
-            hdr: preset.hdr
-          },
-          abortSignal
-        );
-        assertNotAborted();
+      if (useStreamingEncode) {
+        try {
+          streamingEncoder = await spawnStreamingEncoder(
+            videoOnlyPath,
+            {
+              fps: job.config.fps,
+              width,
+              height,
+              codec: preset.codec,
+              preset: preset.preset,
+              quality: effectiveQuality,
+              bitrate: effectiveBitrate,
+              pixelFormat: preset.pixelFormat,
+              useGpu: job.config.useGpu,
+              imageFormat: captureOptions.format || "jpeg",
+              hdr: preset.hdr
+            },
+            abortSignal
+          );
+          assertNotAborted();
+        } catch (err) {
+          if (abortSignal?.aborted) {
+            if (streamingEncoder && !streamingEncoderClosed) {
+              await streamingEncoder.close().catch(() => {
+              });
+              streamingEncoderClosed = true;
+            }
+            throw err;
+          }
+          useStreamingEncode = false;
+          streamingEncoder = null;
+          log.warn("[Render] Streaming encoder spawn failed; falling back to disk-frame encode.", {
+            error: err instanceof Error ? err.message : String(err),
+            outputFormat,
+            workerCount,
+            durationSeconds: job.duration
+          });
+        }
       }
       try {
-        if (enableStreamingEncode && streamingEncoder) {
+        if (useStreamingEncode && streamingEncoder) {
           const reorderBuffer = createFrameReorderBuffer(0, totalFrames);
           const currentEncoder = streamingEncoder;
           if (workerCount > 1) {