@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-MLQP2QUF.js

@@ -0,0 +1,1809 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+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 {
+  ambiguousIssue,
+  loadBrowserScript
+} from "./chunk-FUFP7A7S.js";
+import {
+  auditClipDurations,
+  shouldIgnoreHttpError,
+  shouldIgnoreRequestFailure
+} from "./chunk-WN4XZC5F.js";
+import {
+  serveStaticProjectHtml
+} from "./chunk-C5BO7PMT.js";
+import {
+  FfmpegUnavailableError,
+  STUDIO_PREVIEW_CAPTURE_MODE,
+  STUDIO_PREVIEW_MARK_META,
+  decideMediaProxyEligibility,
+  getProxyCachePath,
+  proxyVariantFor,
+  resolveProxies,
+  scanProjectMediaCodecMap
+} from "./chunk-THJALHFJ.js";
+import {
+  artifactDirectory,
+  finishSnapshotRun
+} from "./chunk-YPRBGITP.js";
+import {
+  AUDIT_SEEK_OPTIONS,
+  BrowserCleanupError,
+  DEFAULT_ZOOM_PADDING_PX,
+  DEFAULT_ZOOM_SCALE,
+  DENSE_GEOMETRY_SEEK_OPTIONS,
+  SCREENSHOT_SEEK_OPTIONS,
+  captureRegionCrop,
+  closeManagedBrowser,
+  openSettledCompositionPage,
+  padCropRegion,
+  resolveCliChromeGpuMode,
+  seekCompositionTimeline,
+  seekInPage,
+  waitForPreferredSeekTarget
+} from "./chunk-SZNTYTIV.js";
+import {
+  findStageProxyBox
+} from "./chunk-LEKZNRKI.js";
+import {
+  resolveAutoProxy
+} from "./chunk-4BNN5FGX.js";
+import {
+  injectTagsAtHeadStart
+} from "./chunk-UJZREAV6.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+
+// src/utils/checkProgress.ts
+function logCheckProgress(stage, done, total) {
+  console.error(`[hyperframes] check: ${stage} ${done}/${total}`);
+}
+
+// src/utils/checkMotionBlur.ts
+var OFF_HINTS = {
+  "accelerated-canvas": "html-in-canvas captures WebGL/WebGPU frozen, in sub-compositions too: render that effect separately or flatten it out of the page, or drop data-motion-blur on this composition",
+  "backface-visibility": "backface-visibility: hidden inside a 3D transform is drawn mirrored; avoid the 3D flip or drop motion blur",
+  "iframe-in-root": "move the <iframe>, <object>, <embed> or custom element out of the composition root (each is re-initialised when blur wraps the root), or drop motion blur",
+  "root-transform": "animate a child element instead of the composition root, or drop motion blur",
+  "root-opacity": "animate a child element instead of the composition root, or drop motion blur",
+  "root-blend-mode": "set mix-blend-mode on a child element instead of the composition root, or drop motion blur",
+  "nested-capture-canvas": "remove the inner <canvas layoutsubtree> / content=drawable, or drop motion blur"
+};
+var CHOSEN = /* @__PURE__ */ new Set(["translation-only", "tier-attribute"]);
+var GENERIC_OFF_HINT = "remove what the reason names, or drop data-motion-blur";
+var ASKED = 'data-motion-blur="on" is set but';
+function motionBlurDrafts(probe) {
+  if (!probe) return [];
+  if (probe.reasonCode === "unsupported-browser") {
+    return [
+      {
+        code: "motion_blur_unverified",
+        severity: "info",
+        message: `${ASKED} the check browser cannot run capture blur, so it was drawn with the filter fallback`,
+        fixHint: "the check browser has no html-in-canvas (drawElementImage); render once to see how capture blur looks",
+        time: 0
+      }
+    ];
+  }
+  if (probe.state === "off") {
+    return [
+      {
+        code: "motion_blur_off",
+        severity: "warning",
+        message: `${ASKED} blur is off: ${probe.reason ?? "unknown reason"}`,
+        fixHint: OFF_HINTS[probe.reasonCode ?? ""] ?? GENERIC_OFF_HINT,
+        time: 0
+      }
+    ];
+  }
+  if (probe.tier === "filter" && probe.movers > 0 && !CHOSEN.has(probe.reasonCode ?? "")) {
+    return [
+      {
+        code: "motion_blur_filter_fallback",
+        severity: "info",
+        message: `data-motion-blur="on" is drawn by the filter fallback: ${probe.reason ?? "capture blur cannot run here"}`,
+        fixHint: `the fallback smears movement but only softens zoom and rotation; ${OFF_HINTS[probe.reasonCode ?? ""] ?? GENERIC_OFF_HINT}`,
+        time: 0
+      }
+    ];
+  }
+  if (probe.movers === 0) {
+    return [
+      {
+        code: "motion_blur_no_movers",
+        severity: "info",
+        message: `${ASKED} nothing in the composition moves fast enough to blur, so it has no effect`,
+        fixHint: `animate an element's transform or position by 2+ px per frame; if the motion is set from a timeline callback (onUpdate, render(t)), add data-motion-blur-events="on"; otherwise drop data-motion-blur`,
+        time: 0
+      }
+    ];
+  }
+  return [];
+}
+function readMotionBlurProbe() {
+  const api = Reflect.get(window, "__hfMotionBlur");
+  if (typeof api !== "object" || api === null) return null;
+  const probe = Reflect.get(api, "probe");
+  if (typeof probe !== "function") return null;
+  const report = Reflect.apply(probe, api, []);
+  if (typeof report !== "object" || report === null) return null;
+  const reason = Reflect.get(report, "reason");
+  const code = Reflect.get(report, "reasonCode");
+  const movers = Reflect.get(report, "movers");
+  const tier = Reflect.get(report, "tier");
+  const suspend = Reflect.get(api, "suspend");
+  if (typeof suspend === "function") Reflect.apply(suspend, api, []);
+  return {
+    state: Reflect.get(report, "state") === "off" ? "off" : "on",
+    tier: tier === "capture" || tier === "filter" ? tier : null,
+    reason: typeof reason === "string" ? reason : null,
+    reasonCode: typeof code === "string" ? code : null,
+    movers: typeof movers === "number" ? movers : 0
+  };
+}
+async function collectMotionBlurDrafts(page) {
+  const probe = await page.evaluate(readMotionBlurProbe).catch(() => null);
+  return motionBlurDrafts(probe);
+}
+function dropMotionBlurConsoleEcho(drafts, found) {
+  if (found.length === 0) return drafts;
+  return drafts.filter(
+    (d) => !(d.code === "console_warning" && d.message.startsWith("[motion-blur] off:"))
+  );
+}
+
+// src/utils/checkSnapshotDirectory.ts
+import { resolve } from "path";
+var runDirectories = /* @__PURE__ */ new Map();
+var activeChecks = /* @__PURE__ */ new Map();
+function beginCheckSnapshots(projectDir) {
+  const project = resolve(projectDir);
+  activeChecks.set(project, (activeChecks.get(project) ?? 0) + 1);
+}
+function checkSnapshotDirectory(projectDir) {
+  const project = resolve(projectDir);
+  let directory = runDirectories.get(project);
+  if (!directory) {
+    directory = artifactDirectory(project, "snapshots");
+    runDirectories.set(project, directory);
+  }
+  return directory;
+}
+async function finishCheckSnapshots(projectDir) {
+  const project = resolve(projectDir);
+  const remaining = Math.max(0, (activeChecks.get(project) ?? 1) - 1);
+  if (remaining > 0) {
+    activeChecks.set(project, remaining);
+    return;
+  }
+  activeChecks.delete(project);
+  const path = runDirectories.get(project);
+  if (!path) return;
+  runDirectories.delete(project);
+  await finishSnapshotRun(project, path);
+}
+
+// src/utils/checkBrowser.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import os from "os";
+import { join, resolve as resolve2 } from "path";
+
+// src/utils/gsapTweenTails.ts
+var TWEEN_TAIL_WINDOW = 0.25;
+function findTweenTails(records) {
+  return records.flatMap(
+    (earlier) => records.flatMap((later) => {
+      const tail = tailBetween(earlier, later);
+      return tail ? [tail] : [];
+    })
+  );
+}
+function tailBetween(earlier, later) {
+  if (later.target !== earlier.target || later.timeline !== earlier.timeline) return null;
+  const overlaps = earlier.start < later.start && later.start < earlier.end;
+  const tail = earlier.end - later.end;
+  if (!overlaps || tail <= 0 || tail > TWEEN_TAIL_WINDOW) return null;
+  const properties = earlier.properties.filter((name) => later.properties.includes(name));
+  if (properties.length === 0) return null;
+  return {
+    timeline: earlier.timeline,
+    label: earlier.label,
+    properties,
+    earlier: { start: earlier.start, end: earlier.end },
+    later: { start: later.start, end: later.end }
+  };
+}
+function tweenTailMessage(tail) {
+  const props = tail.properties.join(", ");
+  const seconds = (value) => `${value.toFixed(3)} s`;
+  return `In timeline "${tail.timeline}", a tween on ${props} of ${tail.label} ends at ${seconds(tail.earlier.end)}, ${(tail.earlier.end - tail.later.end).toFixed(3)} s after a later tween on ${props} ends at ${seconds(tail.later.end)}. For that tail the earlier tween takes ${props} back and leaves its own end value on screen, so the later tween's end never shows. End the earlier tween by ${seconds(tail.later.start)}, or add overwrite: "auto" to the later tween.`;
+}
+function collectTweenRecords() {
+  const NOT_PROPERTIES = /* @__PURE__ */ new Set([
+    "duration",
+    "force3D",
+    "autoRound",
+    "delay",
+    "ease",
+    "repeat",
+    "repeatDelay",
+    "repeatRefresh",
+    "yoyo",
+    "yoyoEase",
+    "stagger",
+    "overwrite",
+    "immediateRender",
+    "lazy",
+    "paused",
+    "reversed",
+    "runBackwards",
+    "startAt",
+    "keyframes",
+    "inherit",
+    "data",
+    "id",
+    "callbackScope",
+    "onStart",
+    "onStartParams",
+    "onUpdate",
+    "onUpdateParams",
+    "onComplete",
+    "onCompleteParams",
+    "onRepeat",
+    "onRepeatParams",
+    "onReverseComplete",
+    "onReverseCompleteParams",
+    "parent",
+    "onInterrupt",
+    "autoRevert",
+    "smoothChildTiming"
+  ]);
+  const registered = window.__timelines ?? {};
+  const names = /* @__PURE__ */ new Map();
+  for (const [name, timeline] of Object.entries(registered)) {
+    if (typeof timeline?.getChildren === "function") names.set(timeline, name);
+  }
+  const ids = /* @__PURE__ */ new Map();
+  function nestedInAnother(timeline) {
+    for (let parent = timeline.parent; parent; parent = parent.parent) {
+      if (names.has(parent)) return true;
+    }
+    return false;
+  }
+  function plainProperties(tween) {
+    const vars = tween.vars ?? {};
+    const plain = !vars.repeat && !vars.yoyo && !vars.keyframes && !vars.overwrite;
+    return plain ? Object.keys(vars).filter((key) => !NOT_PROPERTIES.has(key)) : [];
+  }
+  function labelOf(target) {
+    if (!(target instanceof Element)) return "an object";
+    if (target.id) return `#${target.id}`;
+    return [target.tagName.toLowerCase(), ...target.classList].join(".");
+  }
+  function recordsOf(timeline, name) {
+    const origin = timeline.globalTime(0);
+    return (timeline.getChildren?.(true, true, false) ?? []).flatMap((tween) => {
+      const duration = tween.totalDuration();
+      const properties = plainProperties(tween);
+      if (!(duration > 0) || properties.length === 0) return [];
+      const start = tween.globalTime(0) - origin;
+      const end = tween.globalTime(duration) - origin;
+      return tween.targets().map((target) => {
+        if (!ids.has(target)) ids.set(target, ids.size);
+        const id = ids.get(target) ?? -1;
+        return { timeline: name, target: id, label: labelOf(target), properties, start, end };
+      });
+    });
+  }
+  return [...names].flatMap(
+    ([timeline, name]) => nestedInAnother(timeline) ? [] : recordsOf(timeline, name)
+  );
+}
+
+// src/utils/checkTypes.ts
+function rectToBbox(rect) {
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+
+// src/utils/checkBrowser.ts
+async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride) {
+  const none = { findings: [], failedPaths: /* @__PURE__ */ new Set(), files: [] };
+  if (!resolveAutoProxy(projectDir, autoProxyOverride)) return none;
+  let codecMap;
+  try {
+    codecMap = await scanProjectMediaCodecMap(projectDir, [{ html }]);
+  } catch (err) {
+    console.error(
+      `[hyperframes] media proxy pre-resolve: scan failed (${normalizeErrorMessage(err)})`
+    );
+    return none;
+  }
+  const hostileEntries = Object.entries(codecMap).filter(
+    ([, facts]) => decideMediaProxyEligibility(facts).eligible
+  );
+  if (hostileEntries.length === 0) return none;
+  const startedAt = Date.now();
+  const stageBox = findStageProxyBox(html);
+  const sources = hostileEntries.map(([pathname, facts]) => {
+    const file = pathname.replace(/^\/+/, "");
+    return {
+      pathname,
+      file,
+      sourcePath: resolve2(projectDir, file),
+      variant: proxyVariantFor(facts),
+      box: stageBox
+    };
+  });
+  const total = hostileEntries.length;
+  const cached = sources.map((source) => proxyCached(projectDir, source));
+  const toMake = cached.filter((isCached) => !isCached).length;
+  if (toMake > 0) {
+    console.error(
+      `[hyperframes] Making browser-playable copies of ${toMake} video${toMake === 1 ? "" : "s"} Chrome cannot decode. Only the first check of these files waits for this; later checks reuse the copies.`
+    );
+  }
+  let settled = 0;
+  const results = await resolveProxies(projectDir, sources, () => {
+    settled += 1;
+    if (toMake > 0) console.error(`[hyperframes] browser-playable copies: ${settled}/${total}`);
+  });
+  const failures = sources.flatMap((source, index) => {
+    const result = results[index];
+    return result.status === "rejected" ? [{ ...source, reason: result.reason }] : [];
+  });
+  console.error(
+    `[hyperframes] media proxy pre-resolve: ${total - failures.length}/${total} ready, ${failures.length} failed (${Date.now() - startedAt}ms)`
+  );
+  const unusableFfmpeg = failures.filter(({ reason }) => reason instanceof FfmpegUnavailableError);
+  const findings = failures.filter(({ reason }) => !(reason instanceof FfmpegUnavailableError)).map(
+    ({ file, reason }) => proxyFailedDraft(
+      `Could not make a browser-playable copy of ${file}: ${normalizeErrorMessage(reason)}. A default render decodes the original with ffmpeg and does not need it, but publish stops on it (unless run with --no-proxy) and a browser that cannot decode the original will not play it in preview.`
+    )
+  );
+  if (unusableFfmpeg[0]) {
+    findings.unshift(
+      proxyFailedDraft(
+        `Could not make browser-playable copies of ${unusableFfmpeg.map(({ file }) => file).join(", ")}: ${normalizeErrorMessage(unusableFfmpeg[0].reason)}. Publish stops on them (unless run with --no-proxy) and a browser that cannot decode them will not play them in preview.`
+      )
+    );
+  }
+  const files = sources.map(({ file }, index) => {
+    const result = results[index];
+    if (result.status === "rejected") {
+      return { file, state: "failed", reason: normalizeErrorMessage(result.reason) };
+    }
+    return { file, state: cached[index] ? "cached" : "ready" };
+  });
+  return { findings, failedPaths: new Set(failures.map(({ pathname }) => pathname)), files };
+}
+function proxyCached(projectDir, source) {
+  try {
+    return existsSync(getProxyCachePath(projectDir, source.sourcePath, source.variant, source.box));
+  } catch {
+    return false;
+  }
+}
+function proxyFailedDraft(message) {
+  return { code: "media_proxy_failed", severity: "warning", message, time: 0 };
+}
+async function loadCheckHtml(dir) {
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-ALYBQEQT.js");
+  return injectTagsAtHeadStart(
+    await bundleWithLocalizedFonts(dir),
+    `<meta name="${STUDIO_PREVIEW_MARK_META}" content="${STUDIO_PREVIEW_CAPTURE_MODE}">`
+  );
+}
+async function runBrowserCheck(project, options, motion, runGrid, deadline, prelaunched) {
+  const html = await loadCheckHtml(project.dir);
+  deadline?.enter("copies");
+  const { findings: drafts, failedPaths } = await preResolveHostileMediaProxies(
+    project.dir,
+    html,
+    options.autoProxy
+  );
+  deadline?.enter("launch");
+  const server = await serveStaticProjectHtml(
+    project.dir,
+    html,
+    "Failed to bind check server",
+    [],
+    options.autoProxy
+  );
+  const clock = createRuntimeClock();
+  let failure = { kind: "none" };
+  let chromeBrowser;
+  const helperSession = samplingBrowserCount(options) > 1 ? startHelperSession(html, server.url, options, deadline) : void 0;
+  const helperOpen = helperSession?.opened;
+  const helpers = helperOpen?.then(
+    (helper) => [helper.driver],
+    () => []
+  );
+  try {
+    const launchSettleStart = Date.now();
+    const session = await openSettledCompositionPage(html, server.url, {
+      navigationTimeoutMs: options.timeout,
+      renderReadyTimeoutMs: options.timeout,
+      renderReadyWarningSuffix: "checking the current page state",
+      prelaunched,
+      browserGpuMode: options.browserGpuMode ?? resolveCliChromeGpuMode(),
+      signal: deadline?.signal,
+      onBrowser: deadline?.ownBrowser,
+      onBrowserReady: deadline?.start,
+      beforeNavigate: async (page2) => {
+        wireRuntimeListeners(page2, drafts, clock);
+        await deadline?.preparePage(page2);
+      },
+      onLoaded: () => deadline?.enter("settle")
+    });
+    chromeBrowser = session.browser;
+    const page = session.page;
+    await waitForPreferredSeekTarget(page);
+    const rootAnchor = await resolveRootAnchor(page);
+    deadline?.keepPartial(() => ({
+      runtimeFindings: dropFailedProxyEchoes(
+        keepBrokenImageAborts(drafts, /* @__PURE__ */ new Set()),
+        failedPaths
+      ).map((draft) => runtimeFinding(draft, rootAnchor))
+    }));
+    const launchSettleMs = Date.now() - launchSettleStart;
+    const { analyzeClipMediaFit } = await import("./src-Z5PGEMXB.js");
+    for (const entry of await auditClipDurations(page, analyzeClipMediaFit, options.timeout)) {
+      drafts.push({ code: "clip_media_fit", severity: entry.level, message: entry.text, time: 0 });
+    }
+    for (const tail of findTweenTails(await page.evaluate(collectTweenRecords) ?? [])) {
+      const message = tweenTailMessage(tail);
+      drafts.push({ code: "gsap_tween_tail", severity: "warning", message, time: tail.later.end });
+    }
+    const blur = await collectMotionBlurDrafts(page);
+    drafts.push(...blur);
+    const sampleLog = sampleWindow(drafts);
+    const driver = createPageDriver(page, clock, sampleLog);
+    const result = await runGrid(
+      driver,
+      options,
+      motion,
+      helpers,
+      deadline?.enter,
+      logCheckProgress,
+      deadline?.keepPartial
+    );
+    helperSession?.stop();
+    const helper = await helperOpen?.catch(() => void 0);
+    const merged = helper ? mergeHelperDrafts(sampleLog, helper.sampleLog) : drafts;
+    const broken = await abortedImagesStillBroken(page, merged);
+    return {
+      ...result,
+      timings: { ...result.timings, launchSettleMs },
+      runtimeFindings: dropFailedProxyEchoes(
+        dropMotionBlurConsoleEcho(keepBrokenImageAborts(merged, broken), blur),
+        failedPaths
+      ).map((draft) => runtimeFinding(draft, rootAnchor))
+    };
+  } catch (error) {
+    failure = { kind: "failed", error };
+    throw error;
+  } finally {
+    helperSession?.stop();
+    await helperOpen?.catch(() => void 0);
+    await closeCheckResources([chromeBrowser, helperSession?.browser()], server, failure);
+  }
+}
+function createRuntimeClock() {
+  let stamp = { time: 0 };
+  return {
+    now: () => stamp,
+    at: (time) => {
+      stamp = { time };
+    },
+    during: (range) => {
+      stamp = { time: range[0], timeRange: range };
+    }
+  };
+}
+var SAMPLING_BROWSER_BYTES = 250 * 1024 * 1024;
+function samplingBrowserCount(options, cores = os.availableParallelism(), free = Math.min(os.freemem(), process.availableMemory())) {
+  if (options.at?.length === 1) return 1;
+  return Math.max(1, Math.min(2, cores - 1, Math.floor(free / SAMPLING_BROWSER_BYTES)));
+}
+function sampleWindow(drafts) {
+  return { drafts, start: Number.POSITIVE_INFINITY, end: Number.POSITIVE_INFINITY };
+}
+function startHelperSession(html, url, options, deadline) {
+  const abort = new AbortController();
+  let browser;
+  const opened = openHelperSession(html, url, options, deadline, {
+    signal: deadline ? AbortSignal.any([deadline.signal, abort.signal]) : abort.signal,
+    onBrowser: (launched) => {
+      browser = launched;
+      deadline?.ownBrowser(launched);
+    }
+  });
+  return {
+    opened,
+    browser: () => browser,
+    stop: () => {
+      abort.abort();
+      if (browser) void closeManagedBrowser(browser).catch(() => void 0);
+    }
+  };
+}
+async function openHelperSession(html, url, options, deadline, owner) {
+  const sampleLog = sampleWindow([]);
+  const clock = createRuntimeClock();
+  const session = await openSettledCompositionPage(html, url, {
+    navigationTimeoutMs: options.timeout,
+    renderReadyTimeoutMs: options.timeout,
+    renderReadyWarningSuffix: "checking the current page state",
+    browserGpuMode: options.browserGpuMode ?? resolveCliChromeGpuMode(),
+    signal: owner.signal,
+    onBrowser: owner.onBrowser,
+    beforeNavigate: async (page) => {
+      wireRuntimeListeners(page, sampleLog.drafts, clock);
+      await deadline?.preparePage(page);
+    }
+  });
+  await waitForPreferredSeekTarget(session.page);
+  return {
+    driver: createPageDriver(session.page, clock, sampleLog),
+    sampleLog
+  };
+}
+var draftKey = (draft) => `${draft.code} ${draft.time} ${draft.message}`;
+function mergeHelperDrafts(primary, helper) {
+  const window2 = ({ drafts, start: start2, end }) => drafts.slice(Math.min(start2, drafts.length), Math.min(end, drafts.length));
+  const own = window2(primary);
+  const seen = new Set(own.map(draftKey));
+  const extra = window2(helper).filter((draft) => !seen.has(draftKey(draft)));
+  const start = Math.min(primary.start, primary.drafts.length);
+  return [
+    ...primary.drafts.slice(0, start),
+    ...[...own, ...extra].sort((a, b) => a.time - b.time),
+    ...primary.drafts.slice(start + own.length)
+  ];
+}
+async function captureFindingCrops(project, options, requests, deadline) {
+  if (requests.length === 0) return [];
+  const html = await loadCheckHtml(project.dir);
+  const server = await serveStaticProjectHtml(
+    project.dir,
+    html,
+    "Failed to bind check server",
+    [],
+    options.autoProxy
+  );
+  let chromeBrowser;
+  const written = [];
+  let failure = { kind: "none" };
+  try {
+    const session = await openSettledCompositionPage(html, server.url, {
+      navigationTimeoutMs: options.timeout,
+      renderReadyTimeoutMs: options.timeout,
+      renderReadyWarningSuffix: "capturing finding crops",
+      signal: deadline?.signal,
+      onBrowser: deadline?.ownBrowser,
+      onBrowserReady: deadline?.start,
+      beforeNavigate: (page2) => deadline?.preparePage(page2),
+      browserGpuMode: options.browserGpuMode ?? resolveCliChromeGpuMode()
+    });
+    chromeBrowser = session.browser;
+    const page = session.page;
+    await waitForPreferredSeekTarget(page);
+    const snapshotDir = checkSnapshotDirectory(project.dir);
+    mkdirSync(snapshotDir, { recursive: true });
+    for (const request of requests) {
+      await seekCompositionTimeline(page, request.time, SCREENSHOT_SEEK_OPTIONS);
+      const canvas = await page.evaluate(() => ({
+        width: window.innerWidth,
+        height: window.innerHeight
+      }));
+      const region = padCropRegion(request.bbox, canvas, DEFAULT_ZOOM_PADDING_PX);
+      const buffer = await captureRegionCrop(page, region, DEFAULT_ZOOM_SCALE);
+      writeFileSync(join(snapshotDir, request.filename), buffer);
+      written.push(join(snapshotDir, request.filename));
+    }
+    return written;
+  } catch (error) {
+    failure = { kind: "failed", error };
+    throw error;
+  } finally {
+    await closeCheckResources([chromeBrowser], server, failure);
+  }
+}
+async function closeCheckResources(browsers, server, failure) {
+  const cleanup = await Promise.allSettled([
+    ...browsers.map((browser) => browser ? closeManagedBrowser(browser) : Promise.resolve()),
+    server.close()
+  ]);
+  const errors = cleanup.filter((entry) => entry.status === "rejected").map((entry) => entry.reason);
+  if (errors.length === 0) return;
+  if (failure.kind === "failed") errors.unshift(failure.error);
+  throw new BrowserCleanupError(errors, errors.map(normalizeErrorMessage).join("; "));
+}
+var MEDIA_PROXY_MARKER_PREFIX = "[hyperframes] runtime_media_proxy_";
+var MEDIA_PROXY_UNAVAILABLE_MARKER = "[hyperframes] runtime_media_proxy_unavailable";
+var WEB_AUDIO_BYPASS_MARKER = "[hyperframes] runtime_web_audio_bypass";
+var WEBGPU_RUNTIME_FAILURE = /\b(?:GPUValidationError|GPUOutOfMemoryError|GPUInternalError)\b|WebGPU uncaptured error|(?:destroyed\b.*\b(?:GPU )?(?:resource|buffer|texture)\b.*\bsubmit)|(?:(?:GPU )?(?:resource|buffer|texture)\b.*\bdestroyed\b.*\bsubmit)/i;
+function isWebGpuRuntimeFailure(text) {
+  return WEBGPU_RUNTIME_FAILURE.test(text);
+}
+function pushRuntimeDraft(drafts, draft) {
+  if (draft.code !== "webgpu_runtime_error") {
+    drafts.push(draft);
+    return;
+  }
+  const duplicate = drafts.find(
+    (entry) => entry.code === draft.code && entry.message === draft.message && entry.url === draft.url && entry.line === draft.line
+  );
+  if (duplicate) {
+    duplicate.count = (duplicate.count ?? 1) + 1;
+    return;
+  }
+  drafts.push({ ...draft, count: 1 });
+}
+function runtimeInfoFindingCode(text) {
+  if (text.startsWith(WEB_AUDIO_BYPASS_MARKER)) return "web_audio_bypass";
+  if (!text.startsWith(MEDIA_PROXY_MARKER_PREFIX)) return null;
+  return text.includes(MEDIA_PROXY_UNAVAILABLE_MARKER) ? "media_proxy_unavailable" : "media_proxy_fallback";
+}
+function wireRuntimeListeners(page, drafts, clock) {
+  followSampleTimeMarkers(page, clock.at);
+  page.on("console", (message) => {
+    const type = message.type();
+    const text = message.text();
+    if (type === "error" && !text.startsWith("Failed to load resource")) {
+      const location = message.location();
+      pushRuntimeDraft(drafts, {
+        code: "console_error",
+        severity: "error",
+        message: text,
+        ...clock.now(),
+        url: location.url,
+        line: location.lineNumber
+      });
+    } else if (type === "warn") {
+      const location = message.location();
+      const webGpuFailure = isWebGpuRuntimeFailure(text);
+      pushRuntimeDraft(drafts, {
+        code: webGpuFailure ? "webgpu_runtime_error" : "console_warning",
+        severity: webGpuFailure ? "error" : "warning",
+        message: text,
+        ...clock.now(),
+        url: location.url,
+        line: location.lineNumber
+      });
+    } else if (type === "info") {
+      const code = runtimeInfoFindingCode(text);
+      if (!code) return;
+      const location = message.location();
+      pushRuntimeDraft(drafts, {
+        code,
+        severity: "info",
+        message: text,
+        ...clock.now(),
+        url: location.url,
+        line: location.lineNumber
+      });
+    }
+  });
+  page.on("pageerror", (error) => {
+    const message = normalizeErrorMessage(error);
+    if (message.includes("Unexpected token '<'") || message.includes("Unexpected token '&lt;'")) {
+      return;
+    }
+    pushRuntimeDraft(drafts, {
+      code: "page_error",
+      severity: "error",
+      message,
+      ...clock.now()
+    });
+  });
+  wireNetworkListeners(page, drafts, clock);
+}
+function keepBrokenImageAborts(drafts, broken) {
+  return drafts.filter((draft) => !draft.abortedImage || broken.has(draft.url ?? ""));
+}
+function dropFailedProxyEchoes(drafts, failedPaths) {
+  if (failedPaths.size === 0) return drafts;
+  return drafts.filter((draft) => !failedPaths.has(proxyEchoPath(draft) ?? ""));
+}
+function proxyEchoPath(draft) {
+  if (draft.code === "http_error" || draft.code === "request_failed") {
+    const url = parseUrl(draft.url);
+    return url?.searchParams.has("hf-proxy") ? decodedPath(url) : void 0;
+  }
+  if (draft.code === "media_proxy_fallback" || draft.code === "media_proxy_unavailable") {
+    return decodedPath(parseUrl(/"([^"]+)"/.exec(draft.message)?.[1]));
+  }
+  return void 0;
+}
+function parseUrl(target) {
+  if (!target) return void 0;
+  try {
+    return new URL(target, "http://check.invalid/");
+  } catch {
+    return void 0;
+  }
+}
+function decodedPath(url) {
+  if (!url) return void 0;
+  try {
+    return decodeURIComponent(url.pathname);
+  } catch {
+    return void 0;
+  }
+}
+var IMAGE_DECODE_CAP_MS = 5e3;
+async function abortedImagesStillBroken(page, drafts) {
+  const urls = drafts.filter((draft) => draft.abortedImage).map((draft) => draft.url ?? "");
+  if (urls.length === 0) return /* @__PURE__ */ new Set();
+  const broken = await page.evaluate(
+    async (candidates, capMs) => {
+      const fails = (img) => new Promise((resolve3) => {
+        const cap = setTimeout(() => resolve3(false), capMs);
+        img.decode().then(
+          () => resolve3(false),
+          () => resolve3(true)
+        ).finally(() => clearTimeout(cap));
+      });
+      const stillBroken = await Promise.all(
+        candidates.map(async (url) => {
+          const shown = Array.from(document.querySelectorAll("img")).filter(
+            (img) => img.currentSrc === url || img.src === url
+          );
+          return (await Promise.all(shown.map(fails))).some(Boolean);
+        })
+      );
+      return candidates.filter((_, i) => stillBroken[i]);
+    },
+    urls,
+    IMAGE_DECODE_CAP_MS
+  );
+  return new Set(broken);
+}
+function wireNetworkListeners(page, drafts, clock) {
+  page.on("requestfailed", (request) => {
+    const url = request.url();
+    if (url.includes("favicon") || url.startsWith("data:")) return;
+    const failure = request.failure()?.errorText;
+    if (shouldIgnoreRequestFailure(url, failure, request.resourceType())) return;
+    drafts.push({
+      code: "request_failed",
+      severity: "error",
+      message: `Failed to load ${urlPath(url)}: ${failure ?? "net::ERR_FAILED"}`,
+      ...clock.now(),
+      url,
+      abortedImage: failure === "net::ERR_ABORTED" && request.resourceType() === "image"
+    });
+  });
+  page.on("response", (response) => {
+    if (response.status() < 400) return;
+    const url = response.url();
+    if (url.includes("favicon")) return;
+    if (shouldIgnoreHttpError(url, response.status())) return;
+    drafts.push({
+      code: "http_error",
+      severity: "error",
+      message: `${response.status()} loading ${urlPath(url)}`,
+      ...clock.now(),
+      url
+    });
+  });
+}
+function failWhenPageDies(page, driver) {
+  const dead = new Promise((_, reject) => {
+    page.on(
+      "error",
+      (error) => reject(new Error(`The page crashed: ${normalizeErrorMessage(error)}`))
+    );
+    page.on("close", () => reject(new Error("The page closed before the check finished")));
+  });
+  dead.catch(() => void 0);
+  return Object.fromEntries(
+    Object.entries(driver).map(([name, member]) => [
+      name,
+      typeof member === "function" ? (...args) => {
+        const result = Reflect.apply(member, driver, args);
+        return result instanceof Promise ? Promise.race([result, dead]) : result;
+      } : member
+    ])
+  );
+}
+function createPageDriver(page, clock = createRuntimeClock(), sampleLog) {
+  return failWhenPageDies(page, {
+    initialize: (contrast) => injectAuditScripts(page, contrast),
+    markSamples: (phase) => {
+      if (!sampleLog) return;
+      if (phase === "drop") sampleLog.start = sampleLog.end = Number.POSITIVE_INFINITY;
+      else sampleLog[phase] = sampleLog.drafts.length;
+    },
+    matchComponents: (components, findings) => page.evaluate(matchComponentFindings, { components, findings }),
+    getDuration: () => getCompositionDuration(page),
+    hasNoTimelineDeclaration: () => hasNoTimelineDeclaration(page),
+    getTransitionBoundaries: () => collectTweenBoundaries(page),
+    getClipEdges: () => collectClipEdges(page),
+    getCanvas: () => page.evaluate(() => ({ width: window.innerWidth, height: window.innerHeight })),
+    findAmbiguousSelectors: (selectors) => findAmbiguousSelectors(page, selectors),
+    seek: async (time, screenshotFollows) => {
+      clock.at(time);
+      await seekCompositionTimeline(
+        page,
+        time,
+        screenshotFollows ? SCREENSHOT_SEEK_OPTIONS : AUDIT_SEEK_OPTIONS
+      );
+    },
+    seekGeometry: async (time) => {
+      clock.at(time);
+      await seekCompositionTimeline(page, time, DENSE_GEOMETRY_SEEK_OPTIONS);
+    },
+    collectLayout: (time, tolerance, layout) => collectLayout(page, time, tolerance, layout),
+    collectOverlap: (time) => collectOverlap(page, time),
+    collectOverlapGrid: async (times) => {
+      const issues = await collectOverlapGrid(page, times);
+      if (times.length > 0) clock.during([times[0] ?? 0, times.at(-1) ?? 0]);
+      return issues;
+    },
+    collectLayoutGeometry: () => collectLayoutGeometry(page),
+    captureFrame: (scope) => captureFrame(page, scope),
+    framesDiffer: (first, second) => page.evaluate(
+      (a, b) => Reflect.apply(Reflect.get(window, "__hyperframesFramesDiffer"), window, [a, b]),
+      first,
+      second
+    ).then((differ) => differ === true),
+    collectSeekClock: () => collectSeekClock(page),
+    collectRotationSample: (time) => collectRotationSample(page, time),
+    collectOffPivotRotationSample: (time) => collectOffPivotRotationSample(page, time),
+    collectGeometryCandidates: (time, request) => collectGeometryCandidates(page, time, request),
+    collectMotionFrame: (time, selectors, scopes) => collectMotionFrame(page, time, selectors, scopes),
+    anchorMotionIssues: (issues) => anchorLayoutIssues(page, issues),
+    collectContrast: (time, annotations) => collectContrast(page, time, annotations),
+    collectCraftFrame: (time) => collectCraftFrame(page, time),
+    collectCraftFilm: () => collectCraftFilm(page)
+  });
+}
+async function collectCraftFrame(page, time) {
+  const raw = await page.evaluate(() => {
+    const sample = Reflect.get(window, "__hyperframesCraftSample");
+    return typeof sample === "function" ? Reflect.apply(sample, window, []) : null;
+  });
+  const record = isRecord(raw) ? raw : {};
+  const parts = Reflect.get(record, "parts");
+  return {
+    time,
+    parts: Array.isArray(parts) ? parts.flatMap(parseCraftTextPart) : [],
+    held: booleanValue(record, "held") ?? false,
+    painted: booleanValue(record, "painted") ?? true,
+    signature: stringValue(record, "signature") ?? ""
+  };
+}
+async function collectCraftFilm(page) {
+  const raw = await page.evaluate(() => {
+    const film = Reflect.get(window, "__hyperframesCraftFilm");
+    return typeof film === "function" ? Reflect.apply(film, window, []) : null;
+  });
+  return { soundSources: (isRecord(raw) ? numberValue(raw, "soundSources") : null) ?? 0 };
+}
+var CRAFT_PART_NUMBERS = ["key", "block", "opacity", "fontPx"];
+var CRAFT_PART_STRINGS = ["selector", "blockSelector", "sourceFile", "text"];
+var CRAFT_RECT_NUMBERS = ["left", "top", "width", "height"];
+function parseCraftTextPart(value) {
+  if (!isRecord(value)) return [];
+  const nums = requiredNumbers(value, CRAFT_PART_NUMBERS);
+  const strings = requiredStrings(value, CRAFT_PART_STRINGS);
+  const rect = recordField(value, "rect");
+  const box = rect ? requiredNumbers(rect, CRAFT_RECT_NUMBERS) : null;
+  const captions = booleanValue(value, "captions");
+  return nums && strings && box && captions !== null ? [{ ...nums, ...strings, rect: box, captions }] : [];
+}
+function requiredStrings(value, keys) {
+  const out = {};
+  for (const key of keys) {
+    const entry = stringValue(value, key);
+    if (entry === null) return null;
+    out[key] = entry;
+  }
+  return out;
+}
+async function hasNoTimelineDeclaration(page) {
+  return page.evaluate(
+    () => document.querySelector("[data-composition-id]")?.hasAttribute("data-no-timeline") ?? false
+  );
+}
+async function injectAuditScripts(page, contrast) {
+  await page.addScriptTag({ content: loadBrowserScript("motion-signature.browser.js") });
+  await page.addScriptTag({ content: loadBrowserScript("layout-audit.browser.js") });
+  await page.addScriptTag({ content: loadBrowserScript("motion-sample.browser.js") });
+  if (contrast) {
+    await page.addScriptTag({ content: loadBrowserScript("contrast-audit.browser.js") });
+  }
+}
+async function getCompositionDuration(page) {
+  return page.evaluate(() => {
+    const value = (target, key) => typeof target === "object" && target !== null ? Reflect.get(target, key) : void 0;
+    const positive = (candidate) => typeof candidate === "number" && candidate > 0 ? candidate : null;
+    const callDuration = (target) => {
+      const duration = value(target, "duration");
+      if (typeof duration === "function") {
+        const result = Reflect.apply(duration, target, []);
+        return positive(result);
+      }
+      return positive(duration);
+    };
+    const hfDuration = positive(value(Reflect.get(window, "__hf"), "duration"));
+    if (hfDuration) return hfDuration;
+    const playerDuration = callDuration(Reflect.get(window, "__player"));
+    if (playerDuration) return playerDuration;
+    const root = document.querySelector("[data-composition-id][data-duration]");
+    const authored = root ? parseFloat(root.getAttribute("data-duration") ?? "0") : 0;
+    if (authored > 0) return authored;
+    const timelines = Reflect.get(window, "__timelines");
+    if (typeof timelines !== "object" || timelines === null) return 0;
+    for (const key of Object.keys(timelines)) {
+      const duration = callDuration(Reflect.get(timelines, key));
+      if (duration) return duration;
+    }
+    return 0;
+  });
+}
+async function collectClipEdges(page) {
+  return page.evaluate(() => {
+    const manifest = Reflect.get(window, "__clipManifest");
+    return (manifest?.clips ?? []).filter((clip) => clip.kind !== "audio").flatMap((clip) => [clip.start, clip.start + clip.duration]);
+  });
+}
+async function collectTweenBoundaries(page) {
+  return page.evaluate(() => {
+    const property = (target, key) => typeof target === "object" && target !== null || typeof target === "function" ? Reflect.get(target, key) : void 0;
+    const numberCall = (target, key, fallback) => {
+      const method = property(target, key);
+      if (typeof method !== "function") return fallback;
+      const result = Reflect.apply(method, target, []);
+      return typeof result === "number" ? result : fallback;
+    };
+    const rootTime = (root, animation, local) => {
+      let time = local;
+      let node = animation;
+      while (node && node !== root) {
+        time = numberCall(node, "startTime", 0) + time / (numberCall(node, "timeScale", 1) || 1);
+        node = property(node, "parent");
+      }
+      return time;
+    };
+    const timelines = Reflect.get(window, "__timelines");
+    if (typeof timelines !== "object" || timelines === null) return [];
+    const boundaries = [];
+    for (const key of Object.keys(timelines)) {
+      const timeline = Reflect.get(timelines, key);
+      const getChildren = property(timeline, "getChildren");
+      if (typeof getChildren !== "function") continue;
+      try {
+        const children = Reflect.apply(getChildren, timeline, [true, true, false]);
+        if (!Array.isArray(children)) continue;
+        for (const child of children) {
+          const duration = numberCall(child, "duration", Number.NaN);
+          if (!Number.isFinite(duration)) continue;
+          boundaries.push(rootTime(timeline, child, 0), rootTime(timeline, child, duration));
+        }
+      } catch {
+        continue;
+      }
+    }
+    return boundaries.filter(Number.isFinite);
+  });
+}
+async function collectLayout(page, time, tolerance, layout) {
+  const raw = await page.evaluate(
+    (options) => {
+      const audit = Reflect.get(window, "__hyperframesLayoutAudit");
+      if (typeof audit !== "function") return [];
+      const result = Reflect.apply(audit, window, [options]);
+      return Array.isArray(result) ? result : [];
+    },
+    {
+      time,
+      tolerance,
+      ...typeof layout?.proseCoverageFloor === "number" ? { proseCoverageFloor: layout.proseCoverageFloor } : {}
+    }
+  );
+  return anchorLayoutIssues(page, raw.flatMap(parseLayoutIssue));
+}
+async function collectOverlap(page, time) {
+  const raw = await page.evaluate(
+    (options) => {
+      const audit = Reflect.get(window, "__hyperframesOverlapAudit");
+      if (typeof audit !== "function") return [];
+      const result = Reflect.apply(audit, window, [options]);
+      return Array.isArray(result) ? result : [];
+    },
+    { time }
+  );
+  return anchorLayoutIssues(page, raw.flatMap(parseLayoutIssue));
+}
+var SAMPLE_TIME_MARKER = "__hfCheckSample ";
+function followSampleTimeMarkers(page, setTime) {
+  page.on("console", (message) => {
+    const text = message.text();
+    if (message.type() === "debug" && text.startsWith(SAMPLE_TIME_MARKER)) {
+      setTime(Number(text.slice(SAMPLE_TIME_MARKER.length)));
+    }
+  });
+}
+async function overlapGridInPage(grid, seek, anchors) {
+  const audit = Reflect.get(window, "__hyperframesOverlapAudit");
+  const waitForCompletion = Reflect.get(window, "__hfWaitForSeekCompletion");
+  const samples = [];
+  for (const time of grid.times) {
+    console.debug(`${grid.marker}${time}`);
+    seek(time, grid.fallback, false, grid.skipDraws);
+    if (typeof waitForCompletion === "function") {
+      await Reflect.apply(waitForCompletion, window, [{ videoFrames: grid.videoFrames }]);
+    }
+    const result = typeof audit === "function" ? Reflect.apply(audit, window, [{ time }]) : [];
+    const raw = Array.isArray(result) ? result : [];
+    const zero = { x: 0, y: 0, width: 0, height: 0 };
+    const requests = raw.map((issue) => ({
+      selector: String(Reflect.get(Object(issue), "selector")),
+      time,
+      bbox: zero
+    }));
+    samples.push({ raw, anchors: anchors(requests) });
+  }
+  return samples;
+}
+async function collectOverlapGrid(page, times) {
+  if (times.length === 0) return [];
+  const grid = {
+    times,
+    marker: SAMPLE_TIME_MARKER,
+    fallback: DENSE_GEOMETRY_SEEK_OPTIONS.fallbackToBridgeAndTimelines,
+    skipDraws: DENSE_GEOMETRY_SEEK_OPTIONS.skipWebglDraws,
+    videoFrames: DENSE_GEOMETRY_SEEK_OPTIONS.waitForVideoFrames
+  };
+  const samples = await page.evaluate(
+    `(${overlapGridInPage})(${JSON.stringify(grid)}, ${seekInPage}, ${anchorsInPage})`
+  );
+  return samples.map(
+    ({ raw, anchors }) => raw.flatMap(
+      (value, index) => parseLayoutIssue(value).map((issue) => ({
+        ...issue,
+        ...anchors[index] ?? fallbackAnchor(void 0),
+        bbox: rectToBbox(issue.rect),
+        time: issue.time
+      }))
+    )
+  );
+}
+async function captureFrame(page, scope) {
+  if (!scope) return page.screenshot({ encoding: "base64", type: "png" });
+  try {
+    const box = await page.evaluate(isolateScopePaint, scope);
+    if (!box || box.width < 1 || box.height < 1) return "";
+    return await page.screenshot({
+      encoding: "base64",
+      type: "png",
+      clip: box,
+      omitBackground: true
+    });
+  } finally {
+    await page.evaluate(restoreScopePaint);
+  }
+}
+function isolateScopePaint(scope) {
+  let target = null;
+  try {
+    target = document.querySelector(scope);
+  } catch {
+    return null;
+  }
+  if (!target) return null;
+  const visibility = getComputedStyle(target).visibility;
+  target.setAttribute("data-hf-capture-scope", "");
+  const style = document.createElement("style");
+  style.id = "__hf_capture_scope_style";
+  style.textContent = `:not([data-hf-capture-scope], [data-hf-capture-scope] *) { visibility: hidden !important; }
+    :root:not([data-hf-capture-scope]), body:not([data-hf-capture-scope]) { background: none !important; }
+    [data-hf-capture-scope] { visibility: ${visibility} !important; }`;
+  document.head.append(style);
+  const rect = target.getBoundingClientRect();
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+function restoreScopePaint() {
+  document.getElementById("__hf_capture_scope_style")?.remove();
+  document.querySelector("[data-hf-capture-scope]")?.removeAttribute("data-hf-capture-scope");
+}
+async function collectLayoutGeometry(page) {
+  return page.evaluate(() => {
+    const geometry = Reflect.get(window, "__hyperframesLayoutGeometry");
+    if (typeof geometry !== "function") return "";
+    const result = Reflect.apply(geometry, window, []);
+    return typeof result === "string" ? result : "";
+  });
+}
+async function collectSeekClock(page) {
+  return page.evaluate(() => {
+    const callOrUndefined = (target, key, args = []) => {
+      try {
+        return Reflect.apply(Reflect.get(Object(target), key), target, args);
+      } catch {
+        return void 0;
+      }
+    };
+    const known = Reflect.get(
+      window,
+      "__hfSeekClocks"
+    ) ?? {
+      ids: /* @__PURE__ */ new WeakMap(),
+      next: 0
+    };
+    Reflect.set(window, "__hfSeekClocks", known);
+    const idOf = (target) => {
+      if (!known.ids.has(target)) known.ids.set(target, ++known.next);
+      return known.ids.get(target) ?? 0;
+    };
+    const clocks = [];
+    const timelines = Reflect.get(window, "__timelines");
+    const registered = typeof timelines === "object" && timelines ? Object.values(timelines) : [];
+    const gsapRoot = Reflect.get(Reflect.get(window, "gsap") ?? {}, "globalTimeline");
+    const children = callOrUndefined(gsapRoot, "getChildren", [false, true, true]);
+    for (const timeline of [...registered, ...Array.isArray(children) ? children : []]) {
+      const total = Number(
+        callOrUndefined(timeline, "totalDuration") ?? callOrUndefined(timeline, "duration")
+      );
+      if (typeof timeline !== "object" || !timeline || !(total > 0)) continue;
+      const time = callOrUndefined(timeline, "totalTime") ?? callOrUndefined(timeline, "time");
+      if (typeof time !== "number" || !Number.isFinite(time)) continue;
+      const progress = Number(callOrUndefined(timeline, "totalProgress") ?? time / total);
+      const done = callOrUndefined(timeline, "reversed") === true ? progress <= 0 : progress >= 1;
+      clocks.push({ id: idOf(timeline), time, done });
+    }
+    for (const animation of document.getAnimations?.() ?? []) {
+      if (typeof animation.currentTime !== "number") continue;
+      const time = animation.currentTime;
+      const end = Number(animation.effect?.getComputedTiming().endTime ?? Number.POSITIVE_INFINITY);
+      const atEnd = animation.playbackRate < 0 ? time <= 0 : time >= end;
+      clocks.push({ id: idOf(animation), time, done: animation.playState === "finished" || atEnd });
+    }
+    return clocks;
+  });
+}
+async function evaluateSampler(page, globalName) {
+  return page.evaluate((name) => {
+    const sample = Reflect.get(window, name);
+    if (typeof sample !== "function") return [];
+    const result = Reflect.apply(sample, window, []);
+    return Array.isArray(result) ? result : [];
+  }, globalName);
+}
+async function collectRotationSample(page, time) {
+  const raw = await evaluateSampler(page, "__hyperframesRotationSample");
+  return raw.flatMap((value) => parseRotationSample(value, time));
+}
+function parseRotationSample(value, time) {
+  if (!isRecord(value)) return [];
+  const selector = stringValue(value, "selector");
+  const cx = numberValue(value, "cx");
+  const cy = numberValue(value, "cy");
+  const w = numberValue(value, "w");
+  const h = numberValue(value, "h");
+  const angle = numberValue(value, "angle");
+  if (!selector || cx === null || cy === null || w === null || h === null || angle === null) {
+    return [];
+  }
+  return [{ time, selector, cx, cy, w, h, angle }];
+}
+async function collectOffPivotRotationSample(page, time) {
+  const raw = await evaluateSampler(page, "__hyperframesOffPivotRotationSample");
+  return { time, samples: raw.flatMap(parseOffPivotRotationSample) };
+}
+function requiredNumbers(value, keys) {
+  const out = {};
+  for (const key of keys) {
+    const num = numberValue(value, key);
+    if (num === null) return null;
+    out[key] = num;
+  }
+  return out;
+}
+var OFF_PIVOT_REQUIRED_NUMBERS = ["ax", "ay", "bx", "by", "len", "angle", "hubCount"];
+function parseOffPivotRotationSample(value) {
+  if (!isRecord(value)) return [];
+  const selector = stringValue(value, "selector");
+  const nums = requiredNumbers(value, OFF_PIVOT_REQUIRED_NUMBERS);
+  if (!selector || !nums) return [];
+  return [
+    {
+      selector,
+      ax: nums.ax,
+      ay: nums.ay,
+      bx: nums.bx,
+      by: nums.by,
+      len: nums.len,
+      angle: nums.angle,
+      hx: numberValue(value, "hx"),
+      hy: numberValue(value, "hy"),
+      hr: numberValue(value, "hr"),
+      hubCount: nums.hubCount
+    }
+  ];
+}
+async function collectGeometryCandidates(page, time, request) {
+  try {
+    const raw = await page.evaluate((options) => {
+      const collect = Reflect.get(window, "__hyperframesGeometryCandidates");
+      if (typeof collect !== "function") return [];
+      const result = Reflect.apply(collect, window, [options]);
+      return Array.isArray(result) ? result : [];
+    }, request);
+    return raw.flatMap((value) => parseGeometryCandidate(value, time));
+  } catch {
+    return [];
+  }
+}
+async function findAmbiguousSelectors(page, selectors) {
+  const ambiguous = await page.evaluate(
+    (values) => values.filter((selector) => {
+      try {
+        return document.querySelectorAll(selector).length > 1;
+      } catch {
+        return false;
+      }
+    }),
+    selectors
+  );
+  return anchorLayoutIssues(page, ambiguous.map(ambiguousIssue));
+}
+async function collectMotionFrame(page, time, selectors, livenessScopes) {
+  const raw = await page.evaluate(
+    (options) => {
+      const sample = Reflect.get(window, "__hyperframesMotionSample");
+      if (typeof sample !== "function") return null;
+      return Reflect.apply(sample, window, [options]);
+    },
+    { selectors, livenessScopes }
+  );
+  return parseMotionFrame(raw, time, selectors, livenessScopes);
+}
+async function anchorLayoutIssues(page, issues) {
+  const requests = issues.map((issue) => ({
+    selector: issue.selector,
+    time: issue.time,
+    bbox: rectToBbox(issue.rect)
+  }));
+  const anchors = await resolveAnchors(page, requests);
+  return issues.map((issue, index) => ({
+    ...issue,
+    ...anchors[index] ?? fallbackAnchor(requests[index])
+  }));
+}
+async function resolveAnchors(page, requests) {
+  if (requests.length === 0) return [];
+  return page.evaluate(anchorsInPage, requests);
+}
+function anchorsInPage(values) {
+  const root = document.querySelector("[data-composition-id]");
+  return values.map((request) => {
+    let element = null;
+    try {
+      element = document.querySelector(request.selector);
+    } catch {
+      element = null;
+    }
+    element ??= root;
+    const dataAttributes = {};
+    for (const attribute of Array.from(element?.attributes ?? [])) {
+      if (attribute.name.startsWith("data-")) dataAttributes[attribute.name] = attribute.value;
+    }
+    const source = element?.closest("[data-composition-file]")?.getAttribute("data-composition-file");
+    return {
+      selector: element ? request.selector : "[data-composition-id]",
+      dataAttributes,
+      sourceFile: source || "index.html",
+      bbox: request.bbox,
+      time: request.time
+    };
+  });
+}
+async function resolveRootAnchor(page) {
+  const selector = await page.evaluate(
+    (explicit) => document.querySelector(explicit) ? explicit : "[data-composition-id]",
+    '[data-composition-id][data-root="true"]'
+  );
+  const anchors = await resolveAnchors(page, [
+    { selector, time: 0, bbox: await compositionBbox(page, selector) }
+  ]);
+  return anchors[0] ?? fallbackAnchor(void 0);
+}
+async function compositionBbox(page, selector) {
+  return page.evaluate((root) => {
+    const rect = document.querySelector(root)?.getBoundingClientRect();
+    return rect ? { x: rect.x, y: rect.y, width: rect.width, height: rect.height } : { x: 0, y: 0, width: 0, height: 0 };
+  }, selector);
+}
+async function collectContrast(page, time, snapshotAnnotations) {
+  let prepared = [];
+  try {
+    prepared = parsePreparedContrast(await prepareContrast(page, time));
+    if (prepared.length === 0 && !snapshotAnnotations) return { entries: [] };
+    const { shot, region } = await measurementShot(page, prepared);
+    const raw = await finishContrast(
+      page,
+      shot,
+      time,
+      prepared.map((entry) => entry.raw),
+      region
+    );
+    const finished = raw.flatMap(parseFinishedContrast);
+    const entries = joinContrastEntries(finished, prepared);
+    if (!snapshotAnnotations) return { entries };
+    const overviewShot = await page.screenshot({ encoding: "base64", type: "png" });
+    if (typeof overviewShot !== "string") throw new Error("Overview screenshot was not base64");
+    const annotations = [
+      ...snapshotAnnotations,
+      ...contrastFailureAnnotations(entries, snapshotAnnotations.length)
+    ];
+    const pngBase64 = await captureOverviewShot(page, annotations, overviewShot);
+    return { entries, pngBase64 };
+  } finally {
+    await page.evaluate(() => {
+      const restore = Reflect.get(window, "__contrastAuditRestoreIfPending");
+      if (typeof restore === "function") Reflect.apply(restore, window, []);
+    }).catch(() => void 0);
+  }
+}
+async function measurementShot(page, prepared) {
+  const frame = plainFrame(page.viewport());
+  const sampled = prepared.filter((entry) => !entry.knownBackdrop);
+  if (frame && sampled.length === 0) {
+    const clip = { x: 0, y: 0, ...frame };
+    return { shot: null, region: { clip, frameWidth: frame.width, frameHeight: frame.height } };
+  }
+  const region = textRegion(sampled, frame);
+  const shot = await page.screenshot({
+    encoding: "base64",
+    type: "png",
+    omitBackground: true,
+    ...region ? { clip: region.clip, captureBeyondViewport: false } : {}
+  });
+  if (typeof shot !== "string") throw new Error("Contrast screenshot was not base64");
+  return { shot, region };
+}
+function contrastFailureAnnotations(entries, labelOffset) {
+  return entries.filter((entry) => !entry.wcagAA).map((entry, index) => ({
+    label: `${labelOffset + index + 1} contrast_aa_failure`,
+    bbox: entry.bbox
+  }));
+}
+var ANNOTATION_OVERLAY_ID = "__hyperframesCheckAnnotations";
+async function captureOverviewShot(page, annotations, fallbackScreenshot) {
+  if (annotations.length === 0) return fallbackScreenshot;
+  await injectAnnotationOverlay(page, annotations);
+  try {
+    const shot = await page.screenshot({ encoding: "base64", type: "png" });
+    return typeof shot === "string" ? shot : fallbackScreenshot;
+  } finally {
+    await removeAnnotationOverlay(page);
+  }
+}
+async function injectAnnotationOverlay(page, boxes) {
+  await page.evaluate(
+    (items, overlayId) => {
+      const root = document.createElement("div");
+      root.id = overlayId;
+      root.style.cssText = "position:fixed;inset:0;z-index:2147483647;pointer-events:none;";
+      for (const item of items) {
+        const box = document.createElement("div");
+        box.style.cssText = `position:fixed;left:${item.bbox.x}px;top:${item.bbox.y}px;width:${item.bbox.width}px;height:${item.bbox.height}px;border:2px solid #ff2d55;box-sizing:border-box;`;
+        const label = document.createElement("div");
+        label.textContent = item.label;
+        label.style.cssText = "position:absolute;top:-18px;left:0;background:#ff2d55;color:#fff;font:11px/16px monospace;padding:0 4px;white-space:nowrap;";
+        box.appendChild(label);
+        root.appendChild(box);
+      }
+      document.body.appendChild(root);
+    },
+    boxes,
+    ANNOTATION_OVERLAY_ID
+  );
+}
+async function removeAnnotationOverlay(page) {
+  await page.evaluate((overlayId) => {
+    document.getElementById(overlayId)?.remove();
+  }, ANNOTATION_OVERLAY_ID);
+}
+async function prepareContrast(page, time) {
+  return page.evaluate((sampleTime) => {
+    const prepare = Reflect.get(window, "__contrastAuditPrepare");
+    const candidates = typeof prepare === "function" ? Reflect.apply(prepare, window, []) : [];
+    if (!Array.isArray(candidates)) return [];
+    const restores = Reflect.get(window, "__contrastAuditRestores");
+    const restoreList = Array.isArray(restores) ? restores : [];
+    const escape = (value) => typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(value) : value.replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+    const selectorFor = (element, fallback) => {
+      if (!element) return fallback;
+      if (element.id) return `#${escape(element.id)}`;
+      const parts = [];
+      for (let current = element; current && current !== document.body; current = current.parentElement) {
+        const tag = current.tagName.toLowerCase();
+        const siblings = current.parentElement ? Array.from(current.parentElement.children).filter(
+          (item) => item.tagName === current?.tagName
+        ) : [];
+        parts.push(
+          siblings.length > 1 ? `${tag}:nth-of-type(${siblings.indexOf(current) + 1})` : tag
+        );
+      }
+      return parts.reverse().join(" > ") || fallback;
+    };
+    return candidates.map((candidate, index) => {
+      const restore = restoreList[index];
+      const candidateObject = typeof candidate === "object" && candidate !== null ? candidate : {};
+      const elementValue = typeof restore === "object" && restore !== null ? Reflect.get(restore, "el") : null;
+      const element = elementValue instanceof Element ? elementValue : null;
+      const fallback = Reflect.get(candidateObject, "selector");
+      const selector = selectorFor(
+        element,
+        typeof fallback === "string" ? fallback : "[data-composition-id]"
+      );
+      const dataAttributes = {};
+      for (const attribute of Array.from(element?.attributes ?? [])) {
+        if (attribute.name.startsWith("data-")) dataAttributes[attribute.name] = attribute.value;
+      }
+      const source = element?.closest("[data-composition-file]")?.getAttribute("data-composition-file");
+      return {
+        candidate: { ...candidateObject, selector },
+        anchor: {
+          selector,
+          dataAttributes,
+          sourceFile: source || "index.html",
+          bbox: Reflect.get(candidateObject, "bbox"),
+          time: sampleTime
+        }
+      };
+    });
+  }, time);
+}
+function plainFrame(viewport) {
+  if (!viewport || (viewport.deviceScaleFactor ?? 1) !== 1) return void 0;
+  return { width: viewport.width, height: viewport.height };
+}
+function textRegion(prepared, viewport) {
+  if (!viewport || prepared.length === 0) return void 0;
+  const boxes = prepared.map((entry) => entry.candidate.bbox);
+  const x = Math.max(0, Math.floor(Math.min(...boxes.map((box) => box.x))));
+  const y = Math.max(0, Math.floor(Math.min(...boxes.map((box) => box.y))));
+  const right = Math.min(viewport.width, Math.ceil(Math.max(...boxes.map((b) => b.x + b.width))));
+  const bottom = Math.min(
+    viewport.height,
+    Math.ceil(Math.max(...boxes.map((b) => b.y + b.height)))
+  );
+  if (right <= x || bottom <= y) return void 0;
+  const clip = { x, y, width: right - x, height: bottom - y };
+  return { clip, frameWidth: viewport.width, frameHeight: viewport.height };
+}
+async function finishContrast(page, screenshot, time, candidates, region) {
+  return page.evaluate(
+    async (payload) => {
+      const finish = Reflect.get(window, "__contrastAuditFinish");
+      if (typeof finish !== "function") return [];
+      const result = await Reflect.apply(finish, window, [
+        payload.screenshot,
+        payload.time,
+        payload.candidates,
+        payload.region
+      ]);
+      return Array.isArray(result) ? result : [];
+    },
+    { screenshot, time, candidates, region: region ?? null }
+  );
+}
+function parsePreparedContrast(raw) {
+  return raw.flatMap((value) => {
+    if (!isRecord(value)) return [];
+    const raw2 = Reflect.get(value, "candidate");
+    const candidate = parseContrastCandidate(raw2);
+    const anchor = parseAnchor(Reflect.get(value, "anchor"));
+    return candidate && anchor ? [{ raw: raw2, candidate, anchor, knownBackdrop: knownBackdrop(raw2) }] : [];
+  });
+}
+function knownBackdrop(raw) {
+  if (!isRecord(raw)) return false;
+  const own = Reflect.get(raw, "ownBg");
+  const solid = Reflect.get(raw, "solidBg");
+  return Array.isArray(solid) || Array.isArray(own) && own.length >= 4 && own[3] >= 0.99;
+}
+function parseContrastCandidate(value) {
+  if (!isRecord(value)) return null;
+  const selector = stringValue(value, "selector");
+  const text = stringValue(value, "text");
+  const fg = rgbaValue(Reflect.get(value, "fg"));
+  const large = booleanValue(value, "large");
+  const bbox = parseBbox(Reflect.get(value, "bbox"));
+  return selector && text !== null && fg && large !== null && bbox ? { selector, text, fg, large, bbox } : null;
+}
+function parseFinishedContrast(value) {
+  if (!isRecord(value)) return [];
+  const selector = stringValue(value, "selector");
+  const text = stringValue(value, "text");
+  const ratio = numberValue(value, "ratio");
+  const wcagAA = booleanValue(value, "wcagAA");
+  const large = booleanValue(value, "large");
+  const fg = stringValue(value, "fg");
+  const bg = stringValue(value, "bg");
+  return selector && text !== null && ratio !== null && wcagAA !== null && large !== null && fg && bg ? [{ selector, text, ratio, wcagAA, large, fg, bg }] : [];
+}
+function joinContrastEntries(finished, prepared) {
+  const remaining = [...prepared];
+  return finished.flatMap((entry) => {
+    const index = remaining.findIndex(
+      (candidate) => candidate.candidate.selector === entry.selector && candidate.candidate.text === entry.text
+    );
+    const match = index >= 0 ? remaining.splice(index, 1)[0] : void 0;
+    return match ? [{ ...entry, ...match.anchor }] : [];
+  });
+}
+function parseLayoutIssue(value) {
+  if (!isRecord(value)) return [];
+  const code = layoutCodeValue(Reflect.get(value, "code"));
+  const severity = severityValue(Reflect.get(value, "severity"));
+  const time = numberValue(value, "time");
+  const selector = stringValue(value, "selector");
+  const message = stringValue(value, "message");
+  const rect = parseRect(Reflect.get(value, "rect"));
+  if (!code || !severity || time === null || !selector || !message || !rect) return [];
+  const issue = { code, severity, time, selector, message, rect };
+  assignOptionalLayoutFields(issue, value);
+  return [issue];
+}
+function parseGeometryCandidate(value, time) {
+  if (!isRecord(value)) return [];
+  const rect = parseRect(Reflect.get(value, "rect"));
+  const elementRect = parseRect(Reflect.get(value, "elementRect"));
+  if (!rect || !elementRect) return [];
+  const identity = parseGeometryIdentity(value);
+  if (!identity) return [];
+  const anchor = parseGeometryAnchor(value, rect, time);
+  if (!anchor) return [];
+  const candidate = { ...identity, ...anchor, rect, elementRect };
+  const overflow = parseOverflow(Reflect.get(value, "overflow"));
+  if (overflow) candidate.overflow = overflow;
+  return [candidate];
+}
+function parseGeometryIdentity(value) {
+  const kindValue = Reflect.get(value, "kind");
+  const kind = kindValue === "text" || kindValue === "media" ? kindValue : null;
+  if (!kind) return null;
+  const tag = stringValue(value, "tag");
+  if (!tag) return null;
+  const text = stringValue(value, "text");
+  return text === null ? null : { kind, tag, text };
+}
+function parseGeometryAnchor(value, rect, time) {
+  const selector = stringValue(value, "selector");
+  if (!selector) return null;
+  const sourceFile = stringValue(value, "sourceFile");
+  if (!sourceFile) return null;
+  const dataAttributes = stringRecord(Reflect.get(value, "dataAttributes"));
+  return dataAttributes ? {
+    selector,
+    sourceFile,
+    dataAttributes,
+    bbox: rectToBbox(rect),
+    time
+  } : null;
+}
+function assignOptionalLayoutFields(issue, value) {
+  assignOptionalString(issue, value, "containerSelector");
+  assignOptionalString(issue, value, "text");
+  assignOptionalString(issue, value, "fixHint");
+  const containerRect = parseRect(Reflect.get(value, "containerRect"));
+  if (containerRect) issue.containerRect = containerRect;
+  const overflow = parseOverflow(Reflect.get(value, "overflow"));
+  if (overflow) issue.overflow = overflow;
+  const coveredFraction = numberValue(value, "coveredFraction");
+  if (coveredFraction !== null) issue.coveredFraction = coveredFraction;
+}
+function recordField(value, key) {
+  if (!isRecord(value)) return null;
+  const field = Reflect.get(value, key);
+  return isRecord(field) ? field : null;
+}
+function parseMotionFrame(value, time, selectors, scopes) {
+  const rawData = recordField(value, "data");
+  const rawLiveness = recordField(value, "liveness");
+  const data = {};
+  for (const selector of selectors) {
+    data[selector] = rawData ? parseFrameSample(Reflect.get(rawData, selector)) : null;
+  }
+  const liveness = {};
+  for (const scope of scopes) {
+    const signature = rawLiveness ? Reflect.get(rawLiveness, scope) : "";
+    liveness[scope] = typeof signature === "string" ? signature : "";
+  }
+  return { time, data, liveness };
+}
+function parseFrameSample(value) {
+  if (!isRecord(value)) return null;
+  const rect = parseRect(Reflect.get(value, "rect"));
+  const opacity = numberValue(value, "opacity");
+  const visible = booleanValue(value, "visible");
+  return rect && opacity !== null && visible !== null ? { rect, opacity, visible } : null;
+}
+function parseAnchor(value) {
+  if (!isRecord(value)) return null;
+  const selector = stringValue(value, "selector");
+  const sourceFile = stringValue(value, "sourceFile");
+  const time = numberValue(value, "time");
+  const bbox = parseBbox(Reflect.get(value, "bbox"));
+  const dataAttributes = stringRecord(Reflect.get(value, "dataAttributes"));
+  return selector && sourceFile && time !== null && bbox && dataAttributes ? { selector, sourceFile, time, bbox, dataAttributes } : null;
+}
+function runtimeFinding(draft, root) {
+  return {
+    code: draft.code,
+    severity: draft.severity,
+    message: (draft.count ?? 1) > 1 ? `${draft.message} (repeated ${draft.count} times)` : draft.message,
+    selector: root.selector,
+    dataAttributes: root.dataAttributes,
+    sourceFile: root.sourceFile,
+    bbox: root.bbox,
+    time: draft.time,
+    ...draft.timeRange ? { timeRange: draft.timeRange } : {},
+    url: draft.url,
+    line: draft.line,
+    ...draft.fixHint ? { fixHint: draft.fixHint } : {}
+  };
+}
+function fallbackAnchor(request) {
+  return {
+    selector: request?.selector ?? "[data-composition-id]",
+    dataAttributes: {},
+    sourceFile: "index.html",
+    bbox: request?.bbox ?? { x: 0, y: 0, width: 0, height: 0 },
+    time: request?.time ?? 0
+  };
+}
+function parseBbox(value) {
+  if (!isRecord(value)) return null;
+  const x = numberValue(value, "x");
+  const y = numberValue(value, "y");
+  const width = numberValue(value, "width") ?? numberValue(value, "w");
+  const height = numberValue(value, "height") ?? numberValue(value, "h");
+  return x !== null && y !== null && width !== null && height !== null ? { x, y, width, height } : null;
+}
+function parseRect(value) {
+  if (!isRecord(value)) return null;
+  const left = numberValue(value, "left");
+  const top = numberValue(value, "top");
+  const right = numberValue(value, "right");
+  const bottom = numberValue(value, "bottom");
+  const width = numberValue(value, "width");
+  const height = numberValue(value, "height");
+  return left !== null && top !== null && right !== null && bottom !== null && width !== null && height !== null ? { left, top, right, bottom, width, height } : null;
+}
+function parseOverflow(value) {
+  if (!isRecord(value)) return null;
+  const overflow = {};
+  for (const side of ["left", "right", "top", "bottom"]) {
+    const amount = numberValue(value, side);
+    if (amount !== null) overflow[side] = amount;
+  }
+  return Object.keys(overflow).length > 0 ? overflow : null;
+}
+var LAYOUT_ISSUE_CODES = [
+  "text_box_overflow",
+  "clipped_text",
+  "canvas_overflow",
+  "container_overflow",
+  "content_overlap",
+  "visibility_escapes_segment",
+  "text_occluded",
+  "video_alpha_unread",
+  "text_not_painted",
+  "caption_zone_collision",
+  "frame_out_of_frame",
+  "escaped_container",
+  "panel_out_of_canvas",
+  "canvas_content_at_edge",
+  "connector_detached",
+  "connector_orphan",
+  "rotation_pivot_drift",
+  "off_pivot_rotation",
+  "motion_appears_late",
+  "motion_out_of_order",
+  "motion_off_frame",
+  "motion_frozen",
+  "motion_selector_missing",
+  "motion_selector_ambiguous"
+];
+function layoutCodeValue(value) {
+  return LAYOUT_ISSUE_CODES.find((code) => code === value) ?? null;
+}
+function severityValue(value) {
+  return value === "error" || value === "warning" || value === "info" ? value : null;
+}
+function rgbaValue(value) {
+  if (!Array.isArray(value) || value.length < 4) return null;
+  const [red, green, blue, alpha] = value;
+  return [red, green, blue, alpha].every((channel) => typeof channel === "number") ? [red, green, blue, alpha] : null;
+}
+function stringRecord(value) {
+  if (!isRecord(value)) return null;
+  const record = {};
+  for (const key of Object.keys(value)) {
+    const entry = Reflect.get(value, key);
+    if (typeof entry !== "string") return null;
+    record[key] = entry;
+  }
+  return record;
+}
+function assignOptionalString(issue, source, key) {
+  const value = stringValue(source, key);
+  if (value !== null) issue[key] = value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value, key) {
+  const entry = Reflect.get(value, key);
+  return typeof entry === "string" ? entry : null;
+}
+function numberValue(value, key) {
+  const entry = Reflect.get(value, key);
+  return typeof entry === "number" && Number.isFinite(entry) ? entry : null;
+}
+function booleanValue(value, key) {
+  const entry = Reflect.get(value, key);
+  return typeof entry === "boolean" ? entry : null;
+}
+function urlPath(url) {
+  try {
+    return decodeURIComponent(new URL(url).pathname).replace(/^\//, "");
+  } catch {
+    return url;
+  }
+}
+function matchComponentFindings({
+  components,
+  findings
+}) {
+  const roots = components.flatMap((selector) => {
+    const matches = [...document.querySelectorAll(selector)];
+    if (!matches.length) throw new Error(`Component selector matched nothing: ${selector}`);
+    return matches;
+  });
+  function matchesSelector(selector) {
+    try {
+      const elements = [...document.querySelectorAll(selector)];
+      if (!elements.length) return null;
+      return elements.some((el) => roots.some((root) => root.contains(el)));
+    } catch {
+      return null;
+    }
+  }
+  return findings.map((finding) => {
+    if (!finding.selector || finding.selector === "[data-composition-id]") return true;
+    const container = Reflect.get(finding, "containerSelector");
+    return matchesSelector(finding.selector) !== false || typeof container === "string" && matchesSelector(container) !== false;
+  });
+}
+
+export {
+  beginCheckSnapshots,
+  checkSnapshotDirectory,
+  finishCheckSnapshots,
+  rectToBbox,
+  preResolveHostileMediaProxies,
+  runBrowserCheck,
+  samplingBrowserCount,
+  mergeHelperDrafts,
+  captureFindingCrops,
+  keepBrokenImageAborts,
+  dropFailedProxyEchoes,
+  createPageDriver,
+  collectSeekClock,
+  captureOverviewShot,
+  matchComponentFindings
+};