hyperframes 0.8.181 → 0.8.184

package/dist/{check-DJCUOUDI.js → chunk-GDEV42FA.js}

@@ -9,17 +9,24 @@ import {
   reportArtifacts,
   withProjectLock
 } from "./chunk-57GN6KWT.js";
+import {
+  captureArtifactRevision
+} from "./chunk-VDM3FEDP.js";
+import {
+  loadProducer
+} from "./chunk-BCHSTE7U.js";
 import {
   trackLintRun
-} from "./chunk-N5SXQCJL.js";
+} from "./chunk-Q33P4EAC.js";
 import {
   beginCheckSnapshots,
   checkSnapshotDirectory,
   finishCheckSnapshots,
   rectToBbox
-} from "./chunk-RHWJKSGH.js";
+} from "./chunk-KANNRHY7.js";
 import {
   CONTENT_OVERLAP_HELD_ERROR_MS,
+  DEFAULT_MAX_STATIC_SEC,
   assertionTargets,
   buildLayoutSampleTimes,
   buildTransitionSampleTimes,
@@ -31,77 +38,37 @@ import {
   findingElementKey,
   formatFindingTimes,
   formatLayoutIssue,
+  frozenSpans,
   groupSampledFindings,
   limitLayoutIssues,
   longestContiguousRunMs,
   mergeSampleTimes,
   parseAt,
   readMotionSpec
-} from "./chunk-O5AE7HOP.js";
-import {
-  captureArtifactRevision
-} from "./chunk-PF7OWVTL.js";
-import "./chunk-JMFJI26U.js";
-import "./chunk-X7MTZ4T2.js";
-import {
-  loadProducer
-} from "./chunk-ZUOSILUE.js";
+} from "./chunk-QL2PNIXC.js";
 import {
   resolveProject
-} from "./chunk-OJDXABUF.js";
-import "./chunk-IZM562YJ.js";
-import "./chunk-UVEQLDKB.js";
-import "./chunk-X7MTZ4T2.js";
-import "./chunk-XUHOIDKG.js";
-import "./chunk-JBCU6NR5.js";
-import "./chunk-IWTRHPTP.js";
-import "./chunk-TTVHYD5R.js";
-import "./chunk-6JR2XUEE.js";
-import "./chunk-KIO3R4QN.js";
+} from "./chunk-LRGYPXHF.js";
 import {
   recordArtifacts
-} from "./chunk-ICMXC3MI.js";
-import "./chunk-ALVXFXUG.js";
-import "./chunk-V2UNZ7QP.js";
-import "./chunk-FH7WODJH.js";
+} from "./chunk-U6RXZNZE.js";
 import {
   BrowserCleanupError,
   closeManagedBrowser
-} from "./chunk-IL3GTCQY.js";
-import "./chunk-XSRUVMXK.js";
-import "./chunk-BRHI7EIA.js";
-import "./chunk-S3RYRF3W.js";
-import "./chunk-K2FLNJVB.js";
-import "./chunk-DQBY7FRR.js";
-import {
-  resolveLocalBrowserGpuMode
-} from "./chunk-4OT3FWVV.js";
-import "./chunk-442JNXRM.js";
+} from "./chunk-KN46TGHV.js";
 import {
   withRemainingBudget
-} from "./chunk-RGHQID2E.js";
-import "./chunk-XH262OWN.js";
-import "./chunk-XT7X6QCP.js";
-import "./chunk-4YYJOFKS.js";
-import "./chunk-HVW7ABXD.js";
-import "./chunk-WUQUR33W.js";
-import "./chunk-JHOCK3DG.js";
-import "./chunk-OFY6JTZC.js";
-import "./chunk-TO6JNTML.js";
-import "./chunk-AWDFDFI3.js";
-import "./chunk-P6LJ4Y32.js";
-import "./chunk-GMECXFAN.js";
-import "./chunk-5CS4T6C6.js";
+} from "./chunk-EHSBBBR2.js";
+import {
+  resolveLocalBrowserGpuMode
+} from "./chunk-UNNXFKVG.js";
 import {
   trackCheckReport,
   trackCommandFailure
-} from "./chunk-5E5EYPZO.js";
-import "./chunk-K26FR4SM.js";
-import "./chunk-VWG7OQKU.js";
-import "./chunk-T6AGUTZJ.js";
+} from "./chunk-JIUTXKWA.js";
 import {
   swallowedFlagUsageError
-} from "./chunk-UPFUC4DB.js";
+} from "./chunk-HTIUNMTP.js";
 import {
   defineCommand,
   parseArgs
@@ -111,61 +78,27 @@ import {
 } from "./chunk-54HJ63Q2.js";
 import {
   setCommandExitCode
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
-import "./chunk-KLIKCX6Q.js";
-import "./chunk-EVMY7IPL.js";
-import "./chunk-7FMUTGOH.js";
-import "./chunk-Q5X2B5WT.js";
-import {
-  withMeta
-} from "./chunk-VAJIPSN6.js";
-import "./chunk-K4WIOZFP.js";
-import "./chunk-XUXGIA7H.js";
-import "./chunk-WERLJGIC.js";
-import "./chunk-ISN5GRYI.js";
-import "./chunk-XEWHUPFS.js";
-import "./chunk-EOVYQ3IG.js";
-import "./chunk-XT6MXC7A.js";
 import {
   extractMediaMetadata,
   findHdrAutoPromotion
-} from "./chunk-YPBIAONI.js";
-import "./chunk-4IEH6EAC.js";
-import "./chunk-W2LGJSEN.js";
-import "./chunk-LBQFLUIY.js";
-import "./chunk-BAZ5LCR3.js";
-import "./chunk-VC76R6W2.js";
-import "./chunk-UJKQWGFF.js";
-import "./chunk-YMS5FOMC.js";
-import "./chunk-OFQWTKPW.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-634HSJ3J.js";
-import "./chunk-FXMKHHPO.js";
-import "./chunk-RQVDTPGD.js";
-import "./chunk-537IYAEE.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   lintProject,
   shouldBlockRender
-} from "./chunk-GK2FIKIQ.js";
+} from "./chunk-ADDHW2FS.js";
 import {
   resolveProjectRelativeSrc
 } from "./chunk-6BNTGNGD.js";
-import "./chunk-VAS6HQX3.js";
-import "./chunk-OYLO6TYK.js";
-import "./chunk-32GKETR7.js";
-import "./chunk-BSQ7XANM.js";
-import "./chunk-SDYDNHEE.js";
-import "./chunk-TYXH3EKP.js";
-import "./chunk-IXLUTE6N.js";
+import {
+  withMeta
+} from "./chunk-ABZYYUUH.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
-import "./chunk-KGPLIH7B.js";
-import "./chunk-3GXQPCJC.js";
-import "./chunk-M2WBOQ2Q.js";
 
 // src/commands/check.ts
 import { randomUUID } from "crypto";
@@ -270,7 +203,7 @@ import { join, relative } from "path";
 
 // src/utils/hdrPromotion.ts
 async function bundleProjectHtml(projectDir) {
-  const { bundleToSingleHtml } = await import("./compiler-U3W6CJW7.js");
+  const { bundleToSingleHtml } = await import("./compiler-Q3N6QXMT.js");
   return bundleToSingleHtml(projectDir);
 }
 async function collectBundledRenderMedia(html) {
@@ -576,13 +509,8 @@ async function collectGeometryAt(driver, options, grid, canvas, time) {
   }
   return issues;
 }
-async function collectGridSamples(driver, options, grid, motion) {
-  const layoutSet = new Set(grid.layoutSamples);
-  const motionSet = new Set(motion.times);
-  const contrastSet = new Set(grid.contrastSamples);
-  const geometryEnabled = grid.captionSamples.length > 0 || grid.frameSamples.length > 0;
-  const canvas = geometryEnabled ? await driver.getCanvas() : null;
-  const collected = {
+function emptyGridSamples() {
+  return {
     layoutIssues: [],
     motionFrames: [],
     contrastEntries: [],
@@ -592,34 +520,91 @@ async function collectGridSamples(driver, options, grid, motion) {
     rotationSamples: [],
     indicatorFrames: []
   };
-  for (const time of mergeSampleTimes(grid.layoutSamples, motion.times)) {
-    await driver.seek(time, contrastSet.has(time));
-    const issuesAtTime = [];
-    if (layoutSet.has(time)) {
-      const layoutIssues = await driver.collectLayout(time, options.tolerance, options.layout);
-      collected.layoutIssues.push(...layoutIssues);
-      issuesAtTime.push(...layoutIssues);
-      collected.layoutStateSignatures.push({
-        time,
-        signature: await driver.collectLayoutGeometry(),
-        clock: await driver.collectSeekClock()
-      });
-      collected.rotationSamples.push(...await driver.collectRotationSample(time));
-      collected.indicatorFrames.push(await driver.collectOffPivotRotationSample(time));
-    }
-    if (canvas) {
-      const geometryIssues = await collectGeometryAt(driver, options, grid, canvas, time);
-      collected.layoutIssues.push(...geometryIssues);
-      issuesAtTime.push(...geometryIssues);
+}
+function appendGridSamples(into, from) {
+  into.layoutIssues.push(...from.layoutIssues);
+  into.motionFrames.push(...from.motionFrames);
+  into.contrastEntries.push(...from.contrastEntries);
+  into.screenshots.push(...from.screenshots);
+  into.contrastMs += from.contrastMs;
+  into.layoutStateSignatures.push(...from.layoutStateSignatures);
+  into.rotationSamples.push(...from.rotationSamples);
+  into.indicatorFrames.push(...from.indicatorFrames);
+}
+async function collectSampleAt(driver, options, grid, motion, sets, time) {
+  const collected = emptyGridSamples();
+  await driver.seek(time, sets.contrast.has(time));
+  const issuesAtTime = [];
+  if (sets.layout.has(time)) {
+    const layoutIssues = await driver.collectLayout(time, options.tolerance, options.layout);
+    collected.layoutIssues.push(...layoutIssues);
+    issuesAtTime.push(...layoutIssues);
+    collected.layoutStateSignatures.push({
+      time,
+      signature: await driver.collectLayoutGeometry(),
+      clock: await driver.collectSeekClock()
+    });
+    collected.rotationSamples.push(...await driver.collectRotationSample(time));
+    collected.indicatorFrames.push(await driver.collectOffPivotRotationSample(time));
+  }
+  if (sets.canvas) {
+    const geometryIssues = await collectGeometryAt(driver, options, grid, sets.canvas, time);
+    collected.layoutIssues.push(...geometryIssues);
+    issuesAtTime.push(...geometryIssues);
+  }
+  if (sets.motion.has(time)) {
+    collected.motionFrames.push(
+      await driver.collectMotionFrame(time, motion.selectors, motion.livenessScopes)
+    );
+  }
+  if (sets.contrast.has(time))
+    await collectContrastAt(driver, options, time, issuesAtTime, collected);
+  return collected;
+}
+async function collectGridSamples(driver, options, grid, motion, helpers) {
+  const geometryEnabled = grid.captionSamples.length > 0 || grid.frameSamples.length > 0;
+  const sets = {
+    layout: new Set(grid.layoutSamples),
+    motion: new Set(motion.times),
+    contrast: new Set(grid.contrastSamples),
+    canvas: geometryEnabled ? await driver.getCanvas() : null
+  };
+  const times = mergeSampleTimes(grid.layoutSamples, motion.times);
+  const pending = times.map((_, index) => index);
+  const perTime = [];
+  const work = async (worker, taken = []) => {
+    for (let index = pending.shift(); index !== void 0; index = pending.shift()) {
+      taken.push(index);
+      const time = times[index] ?? 0;
+      perTime[index] = await collectSampleAt(worker, options, grid, motion, sets, time);
     }
-    if (motionSet.has(time)) {
-      collected.motionFrames.push(
-        await driver.collectMotionFrame(time, motion.selectors, motion.livenessScopes)
-      );
+  };
+  const helpWith = async (helper) => {
+    const taken = [];
+    try {
+      await helper.initialize(options.contrast);
+      helper.markSamples?.("start");
+      await work(helper, taken);
+      helper.markSamples?.("end");
+    } catch {
+      helper.markSamples?.("drop");
+      for (const index of taken) delete perTime[index];
+      pending.push(...taken);
     }
-    if (contrastSet.has(time))
-      await collectContrastAt(driver, options, time, issuesAtTime, collected);
-  }
+  };
+  let firstPageDone = false;
+  const running = [];
+  void helpers.then((ready) => {
+    for (const helper of ready) if (!firstPageDone) running.push(helpWith(helper));
+  });
+  driver.markSamples?.("start");
+  await work(driver);
+  firstPageDone = true;
+  await Promise.all(running);
+  await work(driver);
+  driver.markSamples?.("end");
+  const collected = emptyGridSamples();
+  for (const samples of perTime) appendGridSamples(collected, samples);
   await collectMotionOverlapSamples(driver, grid, collected, options.range);
   return collected;
 }
@@ -731,6 +716,55 @@ function detectSweepStatic(duration, samples, motionIssues, hasNoTimelineDeclara
   if (allSame(signatures.map(seenPart))) return [sweepStaticIssue("audio")];
   return [];
 }
+async function framesMoved(driver, times) {
+  const [firstTime, ...rest] = times;
+  if (firstTime === void 0) return false;
+  const first = await frameAt(driver, firstTime);
+  for (const time of rest) {
+    if (!await driver.framesDiffer(first, await frameAt(driver, time))) continue;
+    return !await driver.framesDiffer(first, await frameAt(driver, firstTime));
+  }
+  return false;
+}
+async function frameAt(driver, time, scope) {
+  await driver.seek(time, true);
+  return driver.captureFrame(scope);
+}
+async function withFrameMotion(driver, frames, assertions) {
+  const marked = frames.map((frame) => ({ ...frame, liveness: { ...frame.liveness } }));
+  for (const assertion of assertions) {
+    if (assertion.kind !== "keepsMoving") continue;
+    const scope = assertion.withinSelector ?? "*";
+    if (frames.every((frame) => !frame.liveness[scope])) continue;
+    const maxStaticSec = assertion.maxStaticSec ?? DEFAULT_MAX_STATIC_SEC;
+    for (const span of frozenSpans(frames, scope, maxStaticSec)) {
+      const held = frames.find((frame) => frame.time === span.start)?.liveness[scope];
+      const inSpan = marked.filter(
+        (frame, index) => frame.time >= span.start && frame.time <= span.end && frames[index]?.liveness[scope] === held
+      );
+      await markFrameChanges(driver, inSpan, assertion.withinSelector, maxStaticSec / 2);
+    }
+  }
+  return marked;
+}
+async function markFrameChanges(driver, frames, within, captureEverySec) {
+  const scope = within ?? "*";
+  let reference;
+  let mark = 0;
+  let nextCapture = Number.NEGATIVE_INFINITY;
+  for (const frame of frames) {
+    if (frame.time >= nextCapture) {
+      nextCapture = frame.time + captureEverySec;
+      const capture = await frameAt(driver, frame.time, within);
+      if (reference === void 0) reference = capture;
+      else if (await driver.framesDiffer(reference, capture)) {
+        reference = capture;
+        mark++;
+      }
+    }
+    frame.liveness[scope] = `${frame.liveness[scope] ?? ""}|frame${mark}`;
+  }
+}
 function anAnimationIsStuck(samples) {
   const seenById = /* @__PURE__ */ new Map();
   for (const sample of samples) {
@@ -1097,7 +1131,7 @@ function detectOffPivotRotation(frames) {
 function annotationBoxesFrom(issues) {
   return issues.filter((issue) => issue.severity === "error" && issue.bbox.width > 0 && issue.bbox.height > 0).map((issue, index) => ({ label: `${index + 1} ${issue.code}`, bbox: issue.bbox }));
 }
-async function runAuditGrid(driver, options, motion) {
+async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([])) {
   await driver.initialize(options.contrast);
   const grid = await buildSampleGrid(driver, options);
   const plan = await planMotionSampling(
@@ -1106,24 +1140,32 @@ async function runAuditGrid(driver, options, motion) {
     grid.duration
   );
   const seekLoopStart = Date.now();
-  const collected = await collectGridSamples(driver, options, grid, plan);
+  const collected = await collectGridSamples(driver, options, grid, plan, helpers);
   const seekLoopMs = Date.now() - seekLoopStart;
   let motionIssues = plan.preflightIssues;
   if (motion.kind === "valid" && plan.assertions.length > 0 && collected.motionFrames.length > 0) {
-    const evaluated = evaluateMotion(
-      collected.motionFrames,
-      plan.assertions,
-      await driver.getCanvas()
-    );
+    const canvas = await driver.getCanvas();
+    let evaluated = evaluateMotion(collected.motionFrames, plan.assertions, canvas);
+    if (evaluated.some((issue) => issue.code === "motion_frozen")) {
+      const frames = await withFrameMotion(driver, collected.motionFrames, plan.assertions);
+      evaluated = evaluateMotion(frames, plan.assertions, canvas);
+    }
     motionIssues = [...motionIssues, ...await driver.anchorMotionIssues(evaluated)];
   }
   const userPicked = new Set(grid.userPickedSamples);
-  const sweepFindings = options.range ? [] : detectSweepStatic(
+  const sweepSamples = collected.layoutStateSignatures.filter(
+    (sample) => !userPicked.has(sample.time)
+  );
+  const sweepVerdict = options.range ? [] : detectSweepStatic(
     grid.duration,
-    collected.layoutStateSignatures.filter((sample) => !userPicked.has(sample.time)),
+    sweepSamples,
     motionIssues,
     await driver.hasNoTimelineDeclaration()
   );
+  const sweepFindings = sweepVerdict.length > 0 && await framesMoved(
+    driver,
+    sweepSamples.map((sample) => sample.time)
+  ) ? [] : sweepVerdict;
   const rotationFindings = detectRotationPivotDrift(
     collected.rotationSamples,
     await driver.getCanvas()
@@ -1620,13 +1662,21 @@ function resolveMotionSpec(projectDir) {
   };
 }
 async function runBrowserCheck(project, options, motion, deadline, prelaunched) {
-  const module = await import("./checkBrowser-VES2NF3K.js");
+  const module = await import("./checkBrowser-FNINXBMZ.js");
   return module.runBrowserCheck(project, options, motion, runAuditGrid, deadline, prelaunched);
 }
+var adoptedBrowser;
+async function prelaunchBrowserForNextCheck(project, options) {
+  adoptedBrowser = await prelaunchBrowser(project, options);
+  return adoptedBrowser;
+}
 async function prelaunchBrowser(project, options) {
+  const adopted = adoptedBrowser;
+  adoptedBrowser = void 0;
+  if (adopted) return adopted;
   const html = await readFile(project.indexPath, "utf8").catch(() => void 0);
   if (html === void 0) return void 0;
-  const { prelaunchCompositionBrowser } = await import("./captureCompositionFrame-QOF5BRF4.js");
+  const { prelaunchCompositionBrowser } = await import("./captureCompositionFrame-4236FVWJ.js");
   return prelaunchCompositionBrowser(html, options.browserGpuMode);
 }
 async function writeSnapshot(projectDir, index, time, pngBase64) {
@@ -1638,7 +1688,7 @@ async function writeSnapshot(projectDir, index, time, pngBase64) {
   return relative(projectDir, path);
 }
 async function captureFindingCrops(project, options, requests, deadline) {
-  const module = await import("./checkBrowser-VES2NF3K.js");
+  const module = await import("./checkBrowser-FNINXBMZ.js");
   return module.captureFindingCrops(project, options, requests, deadline);
 }
 var DEFAULT_DEPENDENCIES2 = {
@@ -1898,6 +1948,10 @@ function parseCheckOptions(args) {
     browserGpuMode: resolveLocalBrowserGpuMode(args["browser-gpu"])
   };
 }
+function prelaunchBrowserForCheck(rawArgs) {
+  const args = parseArgs(rawArgs, CHECK_COMMAND_ARGS);
+  return prelaunchBrowserForNextCheck(resolveProject(args.dir), parseCheckOptions(args));
+}
 function parseCheckRange(value) {
   if (value === void 0) return void 0;
   const parts = String(value).split(/[,:]/);
@@ -2171,11 +2225,13 @@ function printCounts(section2) {
   );
 }
 var check_default = createCheckCommand();
+
 export {
-  createCheckCommand,
-  check_default as default,
   examples,
+  createCheckCommand,
+  prelaunchBrowserForCheck,
   parseCheckRange,
   parseFrameCheck,
-  parseLayout
+  parseLayout,
+  check_default
 };

package/dist/{chunk-RXQHSGAQ.js → chunk-HR23IKLZ.js}

@@ -12,10 +12,10 @@ import {
 } from "./chunk-DCAI5DBR.js";
 import {
   createProjectConfig
-} from "./chunk-XH262OWN.js";
+} from "./chunk-PFYWVUHA.js";
 import {
   isHyperframesProject
-} from "./chunk-LBQFLUIY.js";
+} from "./chunk-J3QM7AHP.js";
 
 // src/utils/desktopApp.ts
 import { spawn, spawnSync } from "child_process";

package/dist/{chunk-KMAAOHLO.js → chunk-HRPWRZGF.js}

@@ -9,7 +9,7 @@ import {
   buildAuthHeaders,
   refreshTokens,
   resolveCredential
-} from "./chunk-NAMGMP3R.js";
+} from "./chunk-7KVVNF7B.js";
 
 // src/cloud/auth.ts
 async function resolveCloudAuthHeaders() {

package/dist/{chunk-UPFUC4DB.js → chunk-HTIUNMTP.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   CliUsageError
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";

package/dist/{chunk-V2UNZ7QP.js → chunk-ICJEAFPD.js}

@@ -8,29 +8,31 @@ import {
   resolveCompositionViewportFromHtml
 } from "./chunk-FH7WODJH.js";
 import {
-  gotoWhenSent,
   launchManagedBrowser,
   resolveManagedGpuMode,
   rethrowAfterBrowserCleanup
-} from "./chunk-IL3GTCQY.js";
+} from "./chunk-KN46TGHV.js";
+import {
+  gotoWhenSent
+} from "./chunk-MOEGCMKI.js";
 import {
   pageNavigationTimeoutMs,
   windowsChromeCrashRemediation
-} from "./chunk-XSRUVMXK.js";
+} from "./chunk-ES426XRJ.js";
 import {
   oneProcessOverPipe
-} from "./chunk-BRHI7EIA.js";
+} from "./chunk-DKPNNYBZ.js";
 import {
   resolveLocalBrowserGpuMode,
   resolveLocalWebGpu
-} from "./chunk-4OT3FWVV.js";
+} from "./chunk-UNNXFKVG.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
-} from "./chunk-YPBIAONI.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -135,15 +137,24 @@ async function waitForCompositionSettle(page, options) {
   }).catch(() => {
     console.warn(`   ${c.warn("\u26A0")} Shader transitions did not finish pre-rendering`);
   });
-  await waitForLateSubresources(page);
+  await waitForLateSubresources(page, options.lateSubresourceTimeoutMs ?? CAPTURE_SETTLE_MS);
+  const { resolveConfig, waitForImagesReady } = await import("./src-4UYM2K3S.js");
+  const imageTimeoutMs = resolveConfig().playerReadyTimeout;
+  await waitForImagesReady(
+    page,
+    imageTimeoutMs,
+    (sources) => console.warn(
+      `   ${c.warn("\u26A0")} Some images did not load within ${imageTimeoutMs}ms: ${sources}. They may show blank.`
+    )
+  );
   return runtimeReady;
 }
-async function waitForLateSubresources(page) {
+async function waitForLateSubresources(page, timeoutMs) {
   let cap;
-  const deadline = Date.now() + CAPTURE_SETTLE_MS;
+  const deadline = Date.now() + timeoutMs;
   const ready = (async () => {
     await page.waitForFunction(() => document.readyState === "complete", {
-      timeout: CAPTURE_SETTLE_MS
+      timeout: timeoutMs
     });
     await page.waitForNetworkIdle({
       idleTime: NETWORK_IDLE_MS,
@@ -159,7 +170,7 @@ async function waitForLateSubresources(page) {
     await Promise.race([
       ready,
       new Promise((resolveCap) => {
-        cap = setTimeout(resolveCap, CAPTURE_SETTLE_MS);
+        cap = setTimeout(resolveCap, timeoutMs);
       })
     ]);
   } catch {
@@ -176,7 +187,7 @@ async function installPageFunctionGuard(page) {
 async function openSettledCompositionPage(html, url, options) {
   const viewport = resolveCompositionViewportFromHtml(html);
   const requiresWebGpu = compositionRequiresWebGpu(html);
-  const answer = (await import("./staticProjectServer-GYPUQGI7.js")).inProcessAnswer(url);
+  const answer = (await import("./staticProjectServer-ERDTFP45.js")).inProcessAnswer(url);
   const noListen = answer !== void 0;
   let chromeBrowser;
   try {
@@ -200,10 +211,10 @@ async function openSettledCompositionPage(html, url, options) {
 }
 async function launchCompositionBrowser(html, noListen, options) {
   const viewport = resolveCompositionViewportFromHtml(html);
-  const { ensureBrowser, findSystemBrowser } = await import("./manager-V2QCCPOJ.js");
+  const { ensureBrowser, findSystemBrowser } = await import("./manager-UHWEKPXC.js");
   const browser = await ensureBrowser({ signal: options.signal });
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-RDSWHMJS.js");
+  const { buildChromeArgs } = await import("./src-4UYM2K3S.js");
   const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
   const requiresWebGpu = compositionRequiresWebGpu(html);
   let softwareWebGpu = false;

package/dist/{chunk-EOADENKV.js → chunk-IWTNTUPQ.js}

@@ -11,41 +11,43 @@ import {
 } from "./chunk-6JR2XUEE.js";
 import {
   readCompositionFps
-} from "./chunk-S3RYRF3W.js";
+} from "./chunk-PSKEKWVU.js";
 import {
   HF_AUDIO_GROUP_ATTR,
   extractAudioMetadata,
-  extractMediaMetadata,
-  resolveReferencedDuration,
-  resolveReferencedStart
-} from "./chunk-YPBIAONI.js";
+  extractMediaMetadata
+} from "./chunk-RGXVEYHI.js";
 import {
   byStart,
-  compositionOriginSeconds,
-  cutToHostSlots,
   fpsToNumber,
-  hostInPointSeconds,
-  parseFpsWithDefault,
-  resolveMediaStartSeconds
-} from "./chunk-LBQFLUIY.js";
+  parseFpsWithDefault
+} from "./chunk-J3QM7AHP.js";
 import {
   HF_AUDIO_AUTOMATION_ATTR,
   HF_AUDIO_FX_ATTR,
   parseAudioFxChain,
   parseAutomation,
   resolveAutomation
-} from "./chunk-BAZ5LCR3.js";
+} from "./chunk-R2SQBPMH.js";
 import {
   isSubCompositionHost,
   topLevelElements,
   trackKindOf
 } from "./chunk-YMS5FOMC.js";
+import {
+  resolveReferencedDuration,
+  resolveReferencedStart
+} from "./chunk-ADDHW2FS.js";
 import {
   resolveAuthoredAssetFile
 } from "./chunk-6BNTGNGD.js";
 import {
-  parseNumeric
-} from "./chunk-32GKETR7.js";
+  compositionOriginSeconds,
+  cutToHostSlots,
+  hostInPointSeconds,
+  parseNumeric,
+  resolveMediaStartSeconds
+} from "./chunk-MMQ52NIZ.js";
 import {
   readMediaOffsetSeconds,
   readPlaybackRate,