hyperframes 0.8.173 → 0.8.175

package/dist/{chunk-6RIH2NDU.js → chunk-KHR4IJAW.js}

@@ -4,33 +4,33 @@ 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 {
+  resolveCompositionViewportFromHtml
+} from "./chunk-FH7WODJH.js";
 import {
   gotoWhenSent,
   launchManagedBrowser,
   resolveManagedGpuMode,
   rethrowAfterBrowserCleanup
-} from "./chunk-TNHRCZT3.js";
-import {
-  resolveCompositionViewportFromHtml
-} from "./chunk-FH7WODJH.js";
+} from "./chunk-XRRDVRCY.js";
 import {
   pageNavigationTimeoutMs,
   windowsChromeCrashRemediation
-} from "./chunk-V2D4QZBC.js";
+} from "./chunk-RAZVWSU5.js";
 import {
   oneProcessOverPipe
 } from "./chunk-BRHI7EIA.js";
 import {
   resolveLocalBrowserGpuMode,
   resolveLocalWebGpu
-} from "./chunk-KR5ZHRF2.js";
+} from "./chunk-V7T7WA2K.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
-} from "./chunk-O433SZAJ.js";
+} from "./chunk-RERXOG54.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -39,13 +39,17 @@ import {
 import { spawn } from "child_process";
 var SHADER_TRANSITIONS_TIMEOUT_MS = 9e4;
 var CAPTURE_SETTLE_MS = 1500;
+var NETWORK_IDLE_MS = 100;
 var PREFERRED_SEEK_TARGET_WAIT_MS = 500;
 var DEFAULT_POST_SEEK_FONT_WAIT_MS = 500;
 var AUDIT_SEEK_OPTIONS = {
   fallbackToBridgeAndTimelines: true,
   animationFrameSettle: "double",
-  waitForFontsMs: 500,
-  settleMs: 120
+  waitForFontsMs: 500
+};
+var SCREENSHOT_SEEK_OPTIONS = {
+  ...AUDIT_SEEK_OPTIONS,
+  waitForImagesMs: 120
 };
 var DENSE_GEOMETRY_SEEK_OPTIONS = {
   ...AUDIT_SEEK_OPTIONS,
@@ -101,11 +105,41 @@ async function waitForCompositionSettle(page, options) {
   }).catch(() => {
     console.warn(`   ${c.warn("\u26A0")} Shader transitions did not finish pre-rendering`);
   });
-  await page.evaluate(() => document.fonts.ready).catch(() => {
-  });
-  await new Promise((resolveSettle) => setTimeout(resolveSettle, CAPTURE_SETTLE_MS));
+  await waitForLateSubresources(page);
   return runtimeReady;
 }
+async function waitForLateSubresources(page) {
+  let cap;
+  const deadline = Date.now() + CAPTURE_SETTLE_MS;
+  const ready = (async () => {
+    await page.waitForFunction(() => document.readyState === "complete", {
+      timeout: CAPTURE_SETTLE_MS
+    });
+    await page.waitForNetworkIdle({
+      idleTime: NETWORK_IDLE_MS,
+      timeout: Math.max(1, deadline - Date.now())
+    });
+    await page.evaluate(async () => {
+      await Promise.all(Array.from(document.images, (image) => image.decode().catch(() => {
+      })));
+      await document.fonts.ready;
+    });
+  })();
+  try {
+    await Promise.race([
+      ready,
+      new Promise((resolveCap) => {
+        cap = setTimeout(resolveCap, CAPTURE_SETTLE_MS);
+      })
+    ]);
+  } catch {
+    await new Promise((resolveCap) => setTimeout(resolveCap, Math.max(0, deadline - Date.now())));
+  } finally {
+    clearTimeout(cap);
+    ready.catch(() => {
+    });
+  }
+}
 async function installPageFunctionGuard(page) {
   await page.evaluateOnNewDocument("self.__name = self.__name || ((fn) => fn);");
 }
@@ -114,9 +148,9 @@ async function openSettledCompositionPage(html, url, options) {
   const { ensureBrowser, findSystemBrowser } = await import("./manager-HEUPD2YB.js");
   const browser = await ensureBrowser({ signal: options.signal });
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-WD5GOYON.js");
+  const { buildChromeArgs } = await import("./src-4COYCAFY.js");
   const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
-  const answer = (await import("./staticProjectServer-72JF5PPO.js")).inProcessAnswer(url);
+  const answer = (await import("./staticProjectServer-DG4VZO4G.js")).inProcessAnswer(url);
   const requiresWebGpu = compositionRequiresWebGpu(html);
   let softwareWebGpu = false;
   const launch = async (executablePath) => {
@@ -183,97 +217,96 @@ ${remediation}`,
     return rethrowAfterBrowserCleanup(chromeBrowser, err);
   }
 }
+function seekInPage(t, fallbackToBridgeAndTimelines, exactTime, skipDraws) {
+  const getProperty = (target, key) => {
+    if ((typeof target !== "object" || target === null) && typeof target !== "function") {
+      return void 0;
+    }
+    return Reflect.get(target, key);
+  };
+  const call = (fn, receiver, args) => {
+    if (typeof fn !== "function") return false;
+    Reflect.apply(fn, receiver, args);
+    return true;
+  };
+  const player = Reflect.get(window, "__player");
+  if (!player && !fallbackToBridgeAndTimelines) return;
+  const safe = Math.max(0, Number(t) || 0);
+  const renderSeek = getProperty(player, "renderSeek");
+  const playerSeek = getProperty(player, "seek");
+  const hf = Reflect.get(window, "__hf");
+  const bridgeSeek = getProperty(hf, "seek");
+  const gsap = Reflect.get(window, "gsap");
+  const ticker = getProperty(gsap, "ticker");
+  const seekTo = (time) => {
+    if (call(renderSeek, player, exactTime ? [time, { exact: true }] : [time])) {
+    } else if (fallbackToBridgeAndTimelines && call(bridgeSeek, hf, [time])) {
+    } else if (call(playerSeek, player, [time])) {
+    } else if (fallbackToBridgeAndTimelines) {
+      const timelines = Reflect.get(window, "__timelines");
+      if (typeof timelines === "object" && timelines !== null) {
+        for (const key of Object.keys(timelines)) {
+          const timeline = Reflect.get(timelines, key);
+          call(getProperty(timeline, "pause"), timeline, []);
+          call(getProperty(timeline, "seek"), timeline, [time]);
+        }
+      }
+    }
+    call(getProperty(ticker, "tick"), ticker, []);
+  };
+  const gateSlot = /* @__PURE__ */ Symbol.for("hyperframes.webglDrawGate");
+  let gate = Reflect.get(window, gateSlot);
+  if (skipDraws && !gate) {
+    const installed = { skip: false, skipped: false };
+    for (const name of ["WebGLRenderingContext", "WebGL2RenderingContext"]) {
+      const proto = getProperty(Reflect.get(window, name), "prototype");
+      if (!proto) continue;
+      for (const method of [
+        "clear",
+        "drawArrays",
+        "drawElements",
+        "drawArraysInstanced",
+        "drawElementsInstanced",
+        "drawRangeElements",
+        "blitFramebuffer"
+      ]) {
+        const draw = getProperty(proto, method);
+        if (typeof draw !== "function") continue;
+        Reflect.set(proto, method, function(...args) {
+          if (!installed.skip) return Reflect.apply(draw, this, args);
+          installed.skipped = true;
+          return void 0;
+        });
+      }
+    }
+    Reflect.set(window, gateSlot, installed);
+    gate = installed;
+  }
+  const seekWithoutDraws = (time) => {
+    if (!gate) return seekTo(time);
+    gate.skip = true;
+    try {
+      seekTo(time);
+    } finally {
+      gate.skip = false;
+    }
+  };
+  if (skipDraws) {
+    seekWithoutDraws(safe);
+    return;
+  }
+  if (gate?.skipped) {
+    seekWithoutDraws(safe >= 1e-3 ? safe - 1e-3 : safe + 1e-3);
+    gate.skipped = false;
+  }
+  seekTo(safe);
+}
 async function seekCompositionTimeline(page, timeSeconds, options = {}) {
   if (options.waitForPreferredSeekTargetMs !== void 0) {
     await waitForPreferredSeekTarget(page, options.waitForPreferredSeekTargetMs);
   }
   await page.evaluate(
-    // Serialized into the page; the seek-target cascade must stay one function.
-    // fallow-ignore-next-line complexity
-    (t, fallbackToBridgeAndTimelines, exactTime, skipDraws) => {
-      const getProperty = (target, key) => {
-        if ((typeof target !== "object" || target === null) && typeof target !== "function") {
-          return void 0;
-        }
-        return Reflect.get(target, key);
-      };
-      const call = (fn, receiver, args) => {
-        if (typeof fn !== "function") return false;
-        Reflect.apply(fn, receiver, args);
-        return true;
-      };
-      const player = Reflect.get(window, "__player");
-      if (!player && !fallbackToBridgeAndTimelines) return;
-      const safe = Math.max(0, Number(t) || 0);
-      const renderSeek = getProperty(player, "renderSeek");
-      const playerSeek = getProperty(player, "seek");
-      const hf = Reflect.get(window, "__hf");
-      const bridgeSeek = getProperty(hf, "seek");
-      const gsap = Reflect.get(window, "gsap");
-      const ticker = getProperty(gsap, "ticker");
-      const seekTo = (time) => {
-        if (call(renderSeek, player, exactTime ? [time, { exact: true }] : [time])) {
-        } else if (fallbackToBridgeAndTimelines && call(bridgeSeek, hf, [time])) {
-        } else if (call(playerSeek, player, [time])) {
-        } else if (fallbackToBridgeAndTimelines) {
-          const timelines = Reflect.get(window, "__timelines");
-          if (typeof timelines === "object" && timelines !== null) {
-            for (const key of Object.keys(timelines)) {
-              const timeline = Reflect.get(timelines, key);
-              call(getProperty(timeline, "pause"), timeline, []);
-              call(getProperty(timeline, "seek"), timeline, [time]);
-            }
-          }
-        }
-        call(getProperty(ticker, "tick"), ticker, []);
-      };
-      const gateSlot = /* @__PURE__ */ Symbol.for("hyperframes.webglDrawGate");
-      let gate = Reflect.get(window, gateSlot);
-      if (skipDraws && !gate) {
-        const installed = { skip: false, skipped: false };
-        for (const name of ["WebGLRenderingContext", "WebGL2RenderingContext"]) {
-          const proto = getProperty(Reflect.get(window, name), "prototype");
-          if (!proto) continue;
-          for (const method of [
-            "clear",
-            "drawArrays",
-            "drawElements",
-            "drawArraysInstanced",
-            "drawElementsInstanced",
-            "drawRangeElements",
-            "blitFramebuffer"
-          ]) {
-            const draw = getProperty(proto, method);
-            if (typeof draw !== "function") continue;
-            Reflect.set(proto, method, function(...args) {
-              if (!installed.skip) return Reflect.apply(draw, this, args);
-              installed.skipped = true;
-              return void 0;
-            });
-          }
-        }
-        Reflect.set(window, gateSlot, installed);
-        gate = installed;
-      }
-      const seekWithoutDraws = (time) => {
-        if (!gate) return seekTo(time);
-        gate.skip = true;
-        try {
-          seekTo(time);
-        } finally {
-          gate.skip = false;
-        }
-      };
-      if (skipDraws) {
-        seekWithoutDraws(safe);
-        return;
-      }
-      if (gate?.skipped) {
-        seekWithoutDraws(safe >= 1e-3 ? safe - 1e-3 : safe + 1e-3);
-        gate.skipped = false;
-      }
-      seekTo(safe);
-    },
+    seekInPage,
     timeSeconds,
     options.fallbackToBridgeAndTimelines === true,
     options.exactTime === true,
@@ -289,6 +322,7 @@ async function seekCompositionTimeline(page, timeSeconds, options = {}) {
     { videoFrames: options.waitForVideoFrames !== false }
   );
   const animationFrameSettle = options.animationFrameSettle ?? "race";
+  const waitForFontsMs = options.waitForFontsMs ?? DEFAULT_POST_SEEK_FONT_WAIT_MS;
   if (animationFrameSettle === "race") {
     await page.evaluate(`new Promise(function(r) {
       var settled = false;
@@ -296,17 +330,17 @@ async function seekCompositionTimeline(page, timeSeconds, options = {}) {
       window.setTimeout(finish, 100);
       requestAnimationFrame(function() { requestAnimationFrame(finish); });
     })`);
-  } else if (animationFrameSettle === "double") {
+  } else if (animationFrameSettle === "double" && !(waitForFontsMs > 0)) {
     await page.evaluate(
       () => new Promise(
         (resolveFrame) => requestAnimationFrame(() => requestAnimationFrame(() => resolveFrame()))
       )
     );
   }
-  const waitForFontsMs = options.waitForFontsMs ?? DEFAULT_POST_SEEK_FONT_WAIT_MS;
   if (waitForFontsMs > 0) {
-    await waitForCompositionFonts(page, waitForFontsMs);
+    await waitForCompositionFonts(page, waitForFontsMs, animationFrameSettle === "double" ? 2 : 1);
   }
+  if (options.waitForImagesMs) await waitForCompositionImages(page, options.waitForImagesMs);
   if (options.settleMs !== void 0) {
     const settleMs = Math.max(0, options.settleMs);
     await new Promise((resolveSettle) => setTimeout(resolveSettle, settleMs));
@@ -328,28 +362,48 @@ async function waitForPreferredSeekTarget(page, timeoutMs = PREFERRED_SEEK_TARGE
   } catch {
   }
 }
-async function waitForCompositionFonts(page, timeoutMs) {
-  await page.evaluate((ms) => {
-    const fonts = Reflect.get(document, "fonts");
-    if (typeof fonts !== "object" || fonts === null) return Promise.resolve();
-    void document.body?.offsetHeight;
-    return new Promise((resolveWait) => {
+async function waitForCompositionImages(page, timeoutMs) {
+  await page.evaluate(
+    (ms) => new Promise((resolveWait) => {
       const deadline = setTimeout(resolveWait, ms);
-      requestAnimationFrame(() => {
-        const status = Reflect.get(fonts, "status");
-        const ready = Reflect.get(fonts, "ready");
-        if (status !== "loading" || !ready) {
-          clearTimeout(deadline);
-          resolveWait();
-          return;
-        }
-        Promise.resolve(ready).then(() => {
-          clearTimeout(deadline);
-          resolveWait();
+      void Promise.all(
+        Array.from(document.images, (image) => image.decode().catch(() => {
+        }))
+      ).then(() => {
+        clearTimeout(deadline);
+        resolveWait();
+      });
+    }),
+    timeoutMs
+  );
+}
+async function waitForCompositionFonts(page, timeoutMs, frames = 1) {
+  await page.evaluate(
+    ({ ms, frames: count }) => {
+      const fonts = Reflect.get(document, "fonts");
+      void document.body?.offsetHeight;
+      const afterFrames = (left, then) => {
+        requestAnimationFrame(() => left > 1 ? afterFrames(left - 1, then) : then());
+      };
+      return new Promise((resolveWait) => {
+        const deadline = setTimeout(resolveWait, ms);
+        afterFrames(count, () => {
+          const status = fonts ? Reflect.get(fonts, "status") : void 0;
+          const ready = fonts ? Reflect.get(fonts, "ready") : void 0;
+          if (status !== "loading" || !ready) {
+            clearTimeout(deadline);
+            resolveWait();
+            return;
+          }
+          Promise.resolve(ready).then(() => {
+            clearTimeout(deadline);
+            resolveWait();
+          });
         });
       });
-    });
-  }, timeoutMs).catch(() => {
+    },
+    { ms: timeoutMs, frames }
+  ).catch(() => {
   });
 }
 var ZOOM_REGION_PATTERN = /^-?\d+(?:\.\d+)?(?:,-?\d+(?:\.\d+)?){3}$/;
@@ -446,11 +500,13 @@ async function answerPageInProcess(page, url, answer) {
 
 export {
   AUDIT_SEEK_OPTIONS,
+  SCREENSHOT_SEEK_OPTIONS,
   DENSE_GEOMETRY_SEEK_OPTIONS,
   resolveCliChromeGpuMode,
   waitForRuntimeReady,
   installPageFunctionGuard,
   openSettledCompositionPage,
+  seekInPage,
   seekCompositionTimeline,
   waitForPreferredSeekTarget,
   waitForCompositionFonts,

package/dist/{chunk-WIAO42MD.js → chunk-KZHYAGC3.js}

@@ -7,13 +7,13 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-BYRHCRU3.js";
+} from "./chunk-PBKOURSI.js";
 import {
   shouldTrack
-} from "./chunk-ETPPGNJB.js";
+} from "./chunk-W5USVP6Z.js";
 import {
   detectAgentRuntime
-} from "./chunk-QWQ6GQTI.js";
+} from "./chunk-T6AGUTZJ.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -83,8 +83,8 @@ async function maybePromptRenderFeedback(opts) {
 async function getDoctorSummary() {
   try {
     const [{ getSystemMeta }, { findFFmpeg }] = await Promise.all([
-      import("./system-VRXC6S4A.js"),
-      import("./ffmpeg-7BYARPLM.js")
+      import("./system-7F3UEHQT.js"),
+      import("./ffmpeg-QIYSAPHO.js")
     ]);
     const sys = getSystemMeta();
     const parts = [