@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

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

@@ -0,0 +1,2820 @@
+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 {
+  pngDimensions,
+  reportArtifacts,
+  withProjectLock
+} from "./chunk-3LM6YPBR.js";
+import {
+  captureArtifactRevision
+} from "./chunk-UTEIUGAZ.js";
+import {
+  loadProducer
+} from "./chunk-PURHAXFL.js";
+import {
+  trackLintRun
+} from "./chunk-IVSUQR2B.js";
+import {
+  beginCheckSnapshots,
+  checkSnapshotDirectory,
+  finishCheckSnapshots,
+  preResolveHostileMediaProxies,
+  rectToBbox
+} from "./chunk-MLQP2QUF.js";
+import {
+  CONTENT_OVERLAP_HELD_ERROR_MS,
+  DEFAULT_MAX_STATIC_SEC,
+  END_CARD_HOLD_SEC,
+  assertionTargets,
+  buildLayoutSampleTimes,
+  buildTransitionSampleTimes,
+  collapseStaticLayoutIssues,
+  collectSamplingTargets,
+  dedupeLayoutIssues,
+  evaluateMotion,
+  findMotionSpec,
+  findingElementKey,
+  formatFindingTimes,
+  formatLayoutIssue,
+  frozenSpans,
+  groupSampledFindings,
+  limitLayoutIssues,
+  longestContiguousRunMs,
+  mergeSampleTimes,
+  parseAt,
+  readMotionSpec
+} from "./chunk-FUFP7A7S.js";
+import {
+  withMeta
+} from "./chunk-O4YRB27L.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import {
+  recordArtifacts
+} from "./chunk-YPRBGITP.js";
+import {
+  BrowserCleanupError,
+  closeManagedBrowser,
+  withRemainingBudget
+} from "./chunk-SZNTYTIV.js";
+import {
+  resolveLocalBrowserGpuMode
+} from "./chunk-WKBM7NDG.js";
+import {
+  trackCheckReport,
+  trackCommandFailure
+} from "./chunk-GNEFDLFB.js";
+import {
+  swallowedFlagUsageError
+} from "./chunk-U242RTCT.js";
+import {
+  defineCommand,
+  parseArgs
+} from "./chunk-S3S4TGEH.js";
+import {
+  getRunId
+} from "./chunk-54HJ63Q2.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import {
+  extractMediaMetadata,
+  findHdrAutoPromotion
+} from "./chunk-TIQB63MX.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import {
+  lintProject,
+  shouldBlockRender
+} from "./chunk-4P7NX5BM.js";
+import {
+  resolveProjectRelativeSrc
+} from "./chunk-6BNTGNGD.js";
+
+// src/commands/check.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve } from "path";
+
+// src/utils/checkDeadline.ts
+var CHECK_IDLE_MS = 12e4;
+var SCRIPT_START = "[hyperframes:script:start] ";
+var SCRIPT_FINISH = "[hyperframes:script:finish] ";
+var PHASE_LABELS = {
+  copies: "making video copies",
+  launch: "starting Chrome",
+  load: "loading the page",
+  settle: "waiting for the page to be ready",
+  samples: "checking samples",
+  overlap: "running the overlap pass",
+  crops: "capturing finding crops"
+};
+var BEFORE_DEADLINE = /* @__PURE__ */ new Set(["copies", "launch"]);
+var CheckDeadlineError = class extends Error {
+  constructor(sourceFile, phases = "") {
+    super(
+      (sourceFile === void 0 ? "Check did not finish within its deadline" : `${sourceFile}: its script did not finish within the check deadline`) + (phases || ".")
+    );
+    this.sourceFile = sourceFile;
+  }
+  sourceFile;
+};
+var CheckDeadline = class {
+  abort = new AbortController();
+  operations = /* @__PURE__ */ new Set();
+  signal = this.abort.signal;
+  browsers = /* @__PURE__ */ new Set();
+  scripts = [];
+  expired;
+  timer;
+  expiry;
+  rejectExpiry;
+  phase = "waiting";
+  work;
+  spent = /* @__PURE__ */ new Map();
+  partials = [];
+  constructor() {
+    this.expiry = new Promise((_, reject) => {
+      this.rejectExpiry = reject;
+    });
+  }
+  keepPartial = (read) => {
+    this.partials.push(read);
+  };
+  partialResult() {
+    return Object.assign({}, ...this.partials.map((read) => read()));
+  }
+  enter = (phase) => {
+    if (this.expired) return;
+    const now = Date.now();
+    if (this.work) this.spend(this.work.phase, now - this.work.since);
+    this.work = { phase, since: now };
+    this.spend(phase, 0);
+    this.rearm();
+  };
+  spend(phase, ms) {
+    this.spent.set(phase, (this.spent.get(phase) ?? 0) + ms);
+  }
+  describe() {
+    if (!this.work) return "";
+    const open = Date.now() - this.work.since;
+    const parts = [...this.spent].map(([phase, ms]) => {
+      const seconds2 = ((phase === this.work?.phase ? ms + open : ms) / 1e3).toFixed(1);
+      return `${PHASE_LABELS[phase]} ${seconds2}${BEFORE_DEADLINE.has(phase) ? " (before the deadline)" : ""}`;
+    });
+    return ` (no progress for ${CHECK_IDLE_MS / 1e3} s after Chrome was ready), while ${PHASE_LABELS[this.work.phase]}. Seconds per phase: ${parts.join(", ")}.`;
+  }
+  start = () => {
+    if (this.phase !== "waiting") return;
+    this.phase = "started";
+    this.enter("load");
+  };
+  rearm() {
+    if (this.phase !== "started" || this.expired) return;
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.expired = new CheckDeadlineError(this.scripts.at(-1), this.describe());
+      this.rejectExpiry(this.expired);
+      this.abort.abort(this.expired);
+    }, CHECK_IDLE_MS);
+  }
+  ownBrowser = (browser) => {
+    if (this.expired) throw this.expired;
+    if (this.phase === "closed") throw new Error("Check has already finished.");
+    this.browsers.add(browser);
+  };
+  async preparePage(page) {
+    page.on("console", (message) => {
+      const text = message.text();
+      if (text.startsWith(SCRIPT_START)) this.scripts.push(text.slice(SCRIPT_START.length));
+      if (text.startsWith(SCRIPT_FINISH)) {
+        const index = this.scripts.lastIndexOf(text.slice(SCRIPT_FINISH.length));
+        if (index !== -1) this.scripts.splice(index, 1);
+      }
+    });
+    await page.evaluateOnNewDocument(
+      (start, finish) => {
+        Reflect.set(window, "__hfScriptState", (phase, source) => {
+          console.debug((phase === "start" ? start : finish) + source);
+        });
+      },
+      SCRIPT_START,
+      SCRIPT_FINISH
+    );
+  }
+  run(operation) {
+    if (this.expired) return Promise.reject(this.expired);
+    const pending = operation();
+    this.operations.add(pending);
+    const settled = () => this.rearm();
+    pending.then(settled, settled);
+    return Promise.race([pending, this.expiry]);
+  }
+  async close() {
+    this.phase = "closed";
+    clearTimeout(this.timer);
+    const closes = await Promise.allSettled([...this.browsers].map(closeManagedBrowser));
+    const errors = closes.filter((entry) => entry.status === "rejected").map((entry) => entry.reason);
+    try {
+      const drained = await withRemainingBudget(
+        Promise.allSettled(this.operations),
+        1e3,
+        "draining check cleanup"
+      );
+      for (const entry of drained) {
+        if (entry.status === "rejected" && entry.reason instanceof BrowserCleanupError)
+          errors.push(entry.reason);
+      }
+    } catch (error) {
+      errors.push(error);
+    }
+    if (errors.length > 0)
+      throw new BrowserCleanupError(errors, errors.map(normalizeErrorMessage).join("; "));
+  }
+};
+
+// src/utils/checkPipeline.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, relative } from "path";
+
+// src/utils/craftAudit.ts
+var CRAFT_THRESHOLDS = {
+  readHeightAt1080: 30,
+  readOpacity: 0.5,
+  shortLineWords: 2,
+  shortLineFloorSec: 0.4,
+  holdBaseSec: 0.5,
+  holdPerWordSec: 0.3,
+  holdFloorFraction: 0.75,
+  finalLineFloorSec: 2,
+  deadStretchSec: 3,
+  endCardSec: END_CARD_HOLD_SEC,
+  typeFloorFraction: 0.026,
+  typeFloorHoldSec: 0.5,
+  silentFilmSec: 15,
+  /** One video frame: a line held exactly at its floor measures a hair under it. */
+  measureToleranceSec: 1 / 30,
+  /** Halvings of a grid step when re-measuring a line's edges (0.125 s → ~8 ms). */
+  refineSteps: 4,
+  maxRefinedLines: 24
+};
+var T = CRAFT_THRESHOLDS;
+var ZERO_BBOX = { x: 0, y: 0, width: 0, height: 0 };
+var WORD_RUNS = /[\p{L}\p{M}\p{N}%$]+/gu;
+var WORD_SEGMENTER = new Intl.Segmenter("ja", { granularity: "word" });
+function readingWords(text) {
+  const runs = text.toLowerCase().normalize("NFC").match(WORD_RUNS) ?? [];
+  return runs.reduce(
+    (count, run) => count + Math.max(1, [...WORD_SEGMENTER.segment(run)].filter((s) => s.isWordLike).length),
+    0
+  );
+}
+function lineTargetSec(words) {
+  return T.holdBaseSec + T.holdPerWordSec * words;
+}
+function lineFloorSec(words, finalLine) {
+  const floor = words <= T.shortLineWords ? T.shortLineFloorSec : T.holdFloorFraction * lineTargetSec(words);
+  return finalLine ? Math.max(floor, T.finalLineFloorSec) : floor;
+}
+async function auditCraft(input, probe) {
+  const frames = [...input.frames].sort((a, b) => a.time - b.time);
+  const step = sampleStep(frames);
+  const findings = [
+    ...detectFirstFrameEmpty(frames),
+    ...await detectLineUnread(frames, input.duration, input.canvas, probe),
+    ...input.stillnessJudgedElsewhere ? [] : detectDeadStretches(frames, input.duration),
+    ...detectTextBelowFloor(frames, input.duration, input.canvas),
+    ...detectFilmSilent(input.duration, input.soundSources)
+  ].sort((a, b) => a.time - b.time);
+  return { enabled: true, step, samples: frames.length, findings };
+}
+function sampleStep(frames) {
+  const gaps = frames.slice(1).map((frame, index) => frame.time - (frames[index]?.time ?? frame.time)).filter((gap) => gap > 0).sort((a, b) => a - b);
+  return gaps[Math.floor(gaps.length / 2)] ?? 0;
+}
+function seconds(value) {
+  return `${value.toFixed(2)} s`;
+}
+function filmFinding(code, time, message, extra = {}) {
+  return {
+    code,
+    severity: "warning",
+    message,
+    selector: "[data-composition-id]",
+    dataAttributes: {},
+    sourceFile: "index.html",
+    bbox: ZERO_BBOX,
+    time,
+    ...extra
+  };
+}
+function detectFirstFrameEmpty(frames) {
+  const first = frames[0];
+  if (!first || first.time > 1e-3 || first.painted) return [];
+  return [
+    filmFinding(
+      "first_frame_empty",
+      0,
+      "Frame 0 shows only the background, and the first frame is the thumbnail on social players: have the title or key image already on screen at 0 s instead of entering from nothing; see references/review.md."
+    )
+  ];
+}
+function detectFilmSilent(duration, soundSources) {
+  if (soundSources === null || soundSources > 0 || duration <= T.silentFilmSec) return [];
+  return [
+    filmFinding(
+      "film_silent",
+      0,
+      `This ${Math.round(duration)} s film has no sound source (no <audio>, no <video> with sound): add a music bed and sounds on the visible actions unless the person asked for silence; see references/sound.md.`
+    )
+  ];
+}
+function detectDeadStretches(frames, duration) {
+  const endCardStart = duration - T.endCardSec;
+  const findings = [];
+  let start = null;
+  let end = 0;
+  const flush = () => {
+    if (start !== null && end - start > T.deadStretchSec) findings.push(deadStretch(start, end));
+    start = null;
+  };
+  for (let index = 1; index < frames.length; index += 1) {
+    const before = frames[index - 1];
+    const after = frames[index];
+    if (!before || !after) continue;
+    const still = before.signature !== "" && before.signature === after.signature && !before.held && !after.held && before.time < endCardStart;
+    if (!still) {
+      flush();
+      continue;
+    }
+    start ??= before.time;
+    end = Math.min(after.time, endCardStart);
+  }
+  flush();
+  return findings;
+}
+function deadStretch(start, end) {
+  const length = end - start;
+  return filmFinding(
+    "dead_stretch",
+    start,
+    `Nothing on screen changes for ${seconds(length)} (${start.toFixed(2)}\u2013${end.toFixed(2)} s): start the next move within ${T.deadStretchSec} s, or put data-hold on the element whose stillness is deliberate; see references/motion.md.`,
+    { seconds: round(length), floorSeconds: T.deadStretchSec, until: round(end) }
+  );
+}
+function readableBlocks(frame, readHeight) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const part of frame.parts) {
+    if (part.captions || part.opacity < T.readOpacity) continue;
+    const rect = {
+      left: part.rect.left,
+      top: part.rect.top,
+      right: part.rect.left + part.rect.width,
+      bottom: part.rect.top + part.rect.height
+    };
+    const block = blocks.get(part.block);
+    if (!block) {
+      blocks.set(part.block, {
+        text: part.text,
+        rect,
+        selector: part.blockSelector,
+        sourceFile: part.sourceFile
+      });
+      continue;
+    }
+    block.text = `${block.text} ${part.text}`;
+    block.rect = {
+      left: Math.min(block.rect.left, rect.left),
+      top: Math.min(block.rect.top, rect.top),
+      right: Math.max(block.rect.right, rect.right),
+      bottom: Math.max(block.rect.bottom, rect.bottom)
+    };
+  }
+  for (const [key, block] of blocks) {
+    if (block.rect.bottom - block.rect.top < readHeight) blocks.delete(key);
+  }
+  return blocks;
+}
+function trackBlocks(frames, readHeight) {
+  const tracks = /* @__PURE__ */ new Map();
+  frames.forEach((frame, index) => {
+    for (const [key, block] of readableBlocks(frame, readHeight)) {
+      const track = tracks.get(key) ?? {
+        key,
+        selector: block.selector,
+        sourceFile: block.sourceFile,
+        seen: /* @__PURE__ */ new Map()
+      };
+      track.seen.set(index, { text: block.text, rect: block.rect });
+      tracks.set(key, track);
+    }
+  });
+  return [...tracks.values()];
+}
+function indexRuns(indices) {
+  const sorted = [...indices].sort((a, b) => a - b);
+  const runs = [];
+  for (const index of sorted) {
+    const last = runs[runs.length - 1];
+    if (last && index === last[1] + 1) last[1] = index;
+    else runs.push([index, index]);
+  }
+  return runs;
+}
+function windowSeconds(window2) {
+  return (window2.endIn + window2.endOut) / 2 - (window2.startOut + window2.startIn) / 2;
+}
+function runWindow(frames, [first, last], duration) {
+  const timeAt = (index) => frames[Math.min(Math.max(index, 0), frames.length - 1)]?.time ?? 0;
+  const reachesEnd = last === frames.length - 1;
+  return {
+    startOut: timeAt(first - 1),
+    startIn: timeAt(first),
+    endIn: reachesEnd ? duration : timeAt(last),
+    endOut: reachesEnd ? duration : timeAt(last + 1)
+  };
+}
+function lineCandidates(frames, duration, canvas) {
+  const readHeight = T.readHeightAt1080 * (Math.min(canvas.width, canvas.height) / 1080);
+  const tracks = trackBlocks(frames, readHeight);
+  const lastEnd = (track) => Math.max(...track.seen.keys());
+  const latest = Math.max(-1, ...tracks.map(lastEnd));
+  const candidates = [];
+  for (const track of tracks) {
+    const runs = indexRuns([...track.seen.keys()]);
+    const finalLine = lastEnd(track) === latest;
+    const windows = runs.map((run2) => runWindow(frames, run2, duration));
+    const chosen = finalLine ? windows.length - 1 : windows.reduce((best, window3, index) => {
+      const bestWindow = windows[best];
+      return bestWindow && windowSeconds(window3) > windowSeconds(bestWindow) ? index : best;
+    }, 0);
+    const window2 = windows[chosen];
+    const run = runs[chosen];
+    if (!window2 || !run) continue;
+    const texts = [...track.seen.values()].map((seen) => seen.text);
+    const text = texts.reduce(
+      (longest, next) => readingWords(next) > readingWords(longest) ? next : longest
+    );
+    const words = readingWords(text);
+    if (words === 0) continue;
+    const floor = lineFloorSec(words, finalLine);
+    if (window2.endIn - window2.startIn >= floor) continue;
+    candidates.push({ track, words, text, finalLine, floor, window: window2, firstIndex: run[0] });
+  }
+  return candidates;
+}
+async function refineWindow(candidate, probe, canvas) {
+  const readHeight = T.readHeightAt1080 * (Math.min(canvas.width, canvas.height) / 1080);
+  const visibleAt = async (time) => readableBlocks(await probe(time), readHeight).has(candidate.track.key);
+  const window2 = { ...candidate.window };
+  for (let step = 0; step < T.refineSteps; step += 1) {
+    if (window2.startIn > window2.startOut) {
+      const mid = (window2.startOut + window2.startIn) / 2;
+      if (await visibleAt(mid)) window2.startIn = mid;
+      else window2.startOut = mid;
+    }
+    if (window2.endOut > window2.endIn) {
+      const mid = (window2.endIn + window2.endOut) / 2;
+      if (await visibleAt(mid)) window2.endIn = mid;
+      else window2.endOut = mid;
+    }
+  }
+  return window2;
+}
+async function detectLineUnread(frames, duration, canvas, probe) {
+  const findings = [];
+  const candidates = lineCandidates(frames, duration, canvas);
+  for (const [index, candidate] of candidates.entries()) {
+    const window2 = probe && index < T.maxRefinedLines ? await refineWindow(candidate, probe, canvas) : candidate.window;
+    const held = windowSeconds(window2);
+    if (held >= candidate.floor - T.measureToleranceSec) continue;
+    const error = Math.max(window2.startIn - window2.startOut, window2.endOut - window2.endIn) / 2;
+    findings.push(lineUnreadFinding(candidate, window2, held, error));
+  }
+  return findings;
+}
+function lineUnreadFinding(candidate, window2, held, error) {
+  const { track, words, text, finalLine, floor } = candidate;
+  const quoted = quote(text, 60);
+  const wordLabel = `${words} word${words === 1 ? "" : "s"}`;
+  const measured = `${seconds(held)} (\xB1${Math.max(0.01, error).toFixed(2)} s)`;
+  const target = lineTargetSec(words);
+  const message = finalLine ? `The film's last line ${quoted} (${wordLabel}) is on screen ${measured}, under the ${seconds(floor)} a closing line needs: hold it about 0.5 s + 0.3 s a word and at least 2 s before the film ends; see references/motion.md.` : `${quoted} (${wordLabel}) is on screen ${measured}, under its ${seconds(floor)} floor: hold it about 0.5 s + 0.3 s a word (${seconds(target)} here) before it leaves or changes; see references/motion.md.`;
+  const firstSeen = track.seen.get(candidate.firstIndex);
+  const rect = firstSeen?.rect;
+  return {
+    code: "line_unread",
+    severity: "warning",
+    message,
+    text,
+    selector: track.selector,
+    dataAttributes: {},
+    sourceFile: track.sourceFile,
+    bbox: rect ? { x: rect.left, y: rect.top, width: rect.right - rect.left, height: rect.bottom - rect.top } : ZERO_BBOX,
+    time: round(window2.startIn),
+    words,
+    seconds: round(held),
+    floorSeconds: round(floor)
+  };
+}
+function typeFloorPx(canvas) {
+  return Math.round(T.typeFloorFraction * Math.min(canvas.width, canvas.height));
+}
+function detectTextBelowFloor(frames, duration, canvas) {
+  const floorPx = typeFloorPx(canvas);
+  const step = sampleStep(frames);
+  const sightings = /* @__PURE__ */ new Map();
+  frames.forEach((frame, index) => {
+    for (const part of frame.parts) {
+      if (part.captions || part.opacity < T.readOpacity) continue;
+      if (part.fontPx >= floorPx - 0.5 || readingWords(part.text) === 0) continue;
+      const seen = sightings.get(part.key) ?? /* @__PURE__ */ new Map();
+      seen.set(index, part);
+      sightings.set(part.key, seen);
+    }
+  });
+  const small = [];
+  for (const seen of sightings.values()) {
+    const [first, last] = longestRun(indexRuns([...seen.keys()]));
+    const start = frames[first]?.time ?? 0;
+    const end = last === frames.length - 1 ? duration : (frames[last]?.time ?? start) + step;
+    if (end - start < T.typeFloorHoldSec) continue;
+    const parts = [...seen.values()];
+    const part = parts[0];
+    if (!part) continue;
+    small.push({
+      selector: part.selector,
+      sourceFile: part.sourceFile,
+      text: part.text,
+      fontPx: Math.min(...parts.map((entry) => entry.fontPx)),
+      seconds: end - start,
+      time: start,
+      bbox: {
+        x: part.rect.left,
+        y: part.rect.top,
+        width: part.rect.width,
+        height: part.rect.height
+      }
+    });
+  }
+  const shortSide = Math.min(canvas.width, canvas.height);
+  return groupBySourceFile(small).map((group) => smallTextFinding(group, floorPx, shortSide));
+}
+function longestRun(runs) {
+  return runs.reduce((best, run) => run[1] - run[0] > best[1] - best[0] ? run : best, [0, -1]);
+}
+function groupBySourceFile(small) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of small)
+    groups.set(entry.sourceFile, [...groups.get(entry.sourceFile) ?? [], entry]);
+  return [...groups.values()].map(
+    (group) => group.sort((a, b) => a.fontPx - b.fontPx || a.time - b.time)
+  );
+}
+function quote(text, max) {
+  return `"${text.length > max ? `${text.slice(0, max - 3)}...` : text}"`;
+}
+function smallTextFinding(group, floorPx, shortSide) {
+  const [smallest] = group;
+  if (!smallest) throw new Error("text_below_floor group is empty");
+  const subject = group.length === 1 ? `${quote(smallest.text, 48)} renders at ${Math.round(smallest.fontPx)} px for ${seconds(smallest.seconds)}` : `${group.length} text elements stay under it for 0.5 s or more, the smallest ${quote(smallest.text, 40)} at ${Math.round(smallest.fontPx)} px`;
+  const byTime = [...group].sort((a, b) => a.time - b.time);
+  return {
+    code: "text_below_floor",
+    severity: "warning",
+    message: `Type floor is ${floorPx} px (2.6% of the ${shortSide} px short side, what a phone can read) and ${subject}: set reading text to at least ${floorPx} px, or put data-layout-ignore on text that is texture rather than reading; see references/look.md.`,
+    text: smallest.text,
+    selector: smallest.selector,
+    dataAttributes: {},
+    sourceFile: smallest.sourceFile,
+    bbox: smallest.bbox,
+    time: round(smallest.time),
+    times: byTime.map((entry) => round(entry.time)),
+    fontPx: round(smallest.fontPx),
+    floorPx,
+    seconds: round(smallest.seconds),
+    elements: group.map((entry) => ({
+      selector: entry.selector,
+      text: entry.text,
+      fontPx: round(entry.fontPx),
+      time: round(entry.time),
+      seconds: round(entry.seconds)
+    }))
+  };
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+
+// src/utils/hdrPromotion.ts
+async function bundleProjectHtml(projectDir) {
+  const { bundleToSingleHtml } = await import("./compiler-TM3W6GYF.js");
+  return bundleToSingleHtml(projectDir);
+}
+async function collectBundledRenderMedia(html) {
+  const producer = await loadProducer();
+  if (!producer.collectRenderMedia) throw new Error("Render media collector unavailable");
+  return producer.collectRenderMedia(html);
+}
+var DEFAULT_DEPENDENCIES = {
+  bundleHtml: bundleProjectHtml,
+  collectMedia: collectBundledRenderMedia
+};
+async function inspectHdrAutoPromotion(project, extractMetadata = extractMediaMetadata, dependencies = DEFAULT_DEPENDENCIES) {
+  const assets = [];
+  const media = await dependencies.collectMedia(await dependencies.bundleHtml(project.dir));
+  for (const { src } of [...media.videos, ...media.images]) {
+    const path = /^https?:\/\//i.test(src) ? src : resolveProjectRelativeSrc(src, project.dir, project.dir);
+    try {
+      assets.push({
+        asset: src,
+        colorSpace: (await extractMetadata(path)).colorSpace
+      });
+    } catch {
+      continue;
+    }
+  }
+  return findHdrAutoPromotion(assets);
+}
+
+// src/commands/contrast-bg.ts
+function relativeLuminance(color) {
+  const channel = (value) => {
+    const srgb = value / 255;
+    return srgb <= 0.03928 ? srgb / 12.92 : ((srgb + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * channel(color[0]) + 0.7152 * channel(color[1]) + 0.0722 * channel(color[2]);
+}
+function contrastRatio(first, second) {
+  const firstLuminance = relativeLuminance(first);
+  const secondLuminance = relativeLuminance(second);
+  const lighter = Math.max(firstLuminance, secondLuminance);
+  const darker = Math.min(firstLuminance, secondLuminance);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function requiredContrastRatio(large) {
+  return large ? 3 : 4.5;
+}
+function suggestCompliantForegroundColor(foreground, background, requiredRatio) {
+  if (contrastRatio(foreground, background) >= requiredRatio) return [...foreground];
+  const black = [0, 0, 0];
+  const white = [255, 255, 255];
+  const target = contrastRatio(white, background) >= contrastRatio(black, background) ? white : black;
+  for (let step = 1; step <= 255; step += 1) {
+    const amount = step / 255;
+    const candidate = [
+      Math.round(foreground[0] + (target[0] - foreground[0]) * amount),
+      Math.round(foreground[1] + (target[1] - foreground[1]) * amount),
+      Math.round(foreground[2] + (target[2] - foreground[2]) * amount)
+    ];
+    if (contrastRatio(candidate, background) >= requiredRatio) return candidate;
+  }
+  return [...target];
+}
+function parseColorRGBA(color) {
+  const body = /rgba?\(([^)]+)\)/.exec(color ?? "")?.[1];
+  if (body == null) return null;
+  const p = body.split(",").map((s) => parseFloat(s.trim()));
+  if (p.length < 3 || p.some((n) => Number.isNaN(n))) return null;
+  const [r, g, b, a] = p;
+  if (r == null || g == null || b == null) return null;
+  return [r, g, b, a ?? 1];
+}
+
+// src/utils/checkPipeline.ts
+var MOTION_FPS = 20;
+var MOTION_MAX_SAMPLES = 300;
+var ZERO_BBOX2 = { x: 0, y: 0, width: 0, height: 0 };
+var FRAME_BREACH_FLOOR_PX = 120;
+var FRAME_BREACH_FLOOR_FRACTION = 0.06;
+var DEFAULT_CHECK_OPTIONS = {
+  samples: 9,
+  atTransitions: false,
+  maxIssues: 80,
+  collapseStatic: true,
+  tolerance: 2,
+  timeout: 3e3,
+  contrast: true,
+  strict: false,
+  snapshots: false,
+  browserGpuMode: "auto"
+};
+function selectContrastTimes(grid) {
+  if (grid.length <= 5) return [...grid];
+  return Array.from({ length: 5 }, (_, index) => {
+    const selected = Math.floor(index * (grid.length - 1) / 4);
+    return grid[selected] ?? grid[0] ?? 0;
+  });
+}
+function buildMotionSampleTimes(duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return [];
+  const count = Math.min(MOTION_MAX_SAMPLES, Math.max(2, Math.ceil(duration * MOTION_FPS) + 1));
+  const step = duration / (count - 1);
+  return Array.from({ length: count }, (_, index) => Math.round(index * step * 1e3) / 1e3);
+}
+function gateSampleTimes(duration, seeks, fallback) {
+  if (!Number.isFinite(duration) || duration <= 0) return [];
+  const fractions = seeks && seeks.length > 0 ? seeks : [fallback];
+  return mergeSampleTimes(fractions.map((fraction) => fraction * duration));
+}
+function validateSampleRange([start, end], duration) {
+  if (!Number.isFinite(start + end) || start < 0 || end <= start || end > duration)
+    throw new Error(`Check range must lie within the composition duration (${duration} seconds)`);
+}
+function gateSamplesInRange(flag, samples, inRange, range) {
+  if (!range) return samples;
+  const selected = samples.filter(inRange);
+  if (samples.length > 0 && selected.length === 0) {
+    throw new Error(`No ${flag} seek samples lie within --range`);
+  }
+  return selected;
+}
+function layoutSamplesInRange(options, duration) {
+  if (!options.range)
+    return {
+      inRange: (_t) => true,
+      baseSamples: buildLayoutSampleTimes({ duration, samples: options.samples, at: options.at })
+    };
+  validateSampleRange(options.range, duration);
+  const [start, end] = options.range;
+  const inRange = (t) => t >= start && t <= end;
+  const selected = (options.at ?? []).filter(inRange);
+  if (options.at?.length && !selected.length) throw new Error("No --at samples lie within --range");
+  const baseSamples = buildLayoutSampleTimes({
+    duration: end - start,
+    samples: options.samples,
+    at: selected.map((t) => t - start)
+  }).map((t) => t + start);
+  return { inRange, baseSamples };
+}
+async function buildSampleGrid(driver, options) {
+  const duration = await driver.getDuration();
+  const { inRange, baseSamples } = layoutSamplesInRange(options, duration);
+  const transitions = options.atTransitions ? buildTransitionSampleTimes({
+    duration,
+    boundaries: (await driver.getTransitionBoundaries()).filter(inRange),
+    cap: options.maxTransitionSamples
+  }) : { times: [], dropped: 0 };
+  const captionSamples = gateSamplesInRange(
+    "--caption-zone",
+    options.captionZone ? gateSampleTimes(duration, options.captionZone.seek, 1) : [],
+    inRange,
+    options.range
+  );
+  const frameSamples = gateSamplesInRange(
+    "--frame-check",
+    options.frameCheck ? gateSampleTimes(duration, options.frameCheck.seek, 0.5) : [],
+    inRange,
+    options.range
+  );
+  transitions.times = transitions.times.filter(inRange);
+  const auditSamples = mergeSampleTimes(baseSamples, transitions.times).filter(inRange);
+  const layoutSamples = mergeSampleTimes(auditSamples, captionSamples, frameSamples).filter(
+    inRange
+  );
+  if (layoutSamples.length === 0) {
+    throw new Error("Could not determine composition duration \u2014 no layout samples run");
+  }
+  return {
+    duration,
+    layoutSamples,
+    userPickedSamples: options.at?.length ? baseSamples : [],
+    captionSamples,
+    frameSamples,
+    transitionSamples: transitions.times,
+    transitionSamplesDropped: transitions.dropped,
+    contrastSamples: options.contrast ? selectContrastTimes(auditSamples) : []
+  };
+}
+async function planMotionSampling(driver, motion, duration) {
+  if (motion.kind !== "valid") {
+    return { times: [], selectors: [], livenessScopes: [], preflightIssues: [], assertions: [] };
+  }
+  const preflightIssues = await driver.findAmbiguousSelectors(
+    collectSamplingTargets(motion.spec.assertions).selectors
+  );
+  const ambiguous = new Set(preflightIssues.map((issue) => issue.selector));
+  const assertions = motion.spec.assertions.filter(
+    (assertion) => !assertionTargets(assertion).selectors.some((selector) => ambiguous.has(selector))
+  );
+  noteSkippedAssertions(preflightIssues, motion.spec.assertions);
+  const targets = collectSamplingTargets(assertions);
+  const times = assertions.length > 0 ? buildMotionSampleTimes(motion.spec.duration ?? duration) : [];
+  return { times, ...targets, preflightIssues, assertions };
+}
+function noteSkippedAssertions(issues, assertions) {
+  for (const issue of issues) {
+    const skipped = assertions.filter(
+      (assertion) => assertionTargets(assertion).selectors.includes(issue.selector)
+    ).length;
+    if (skipped > 0) issue.message += ` ${skipped} assertion(s) naming it were not evaluated.`;
+  }
+}
+function geometryRequest(time, grid, options) {
+  const text = grid.captionSamples.includes(time);
+  const media = grid.frameSamples.includes(time);
+  if (!text && !media) return null;
+  const configuredTolerance = options.frameCheck?.tol;
+  const tolerance = typeof configuredTolerance === "number" ? configuredTolerance : 2;
+  return { text, media, tolerance };
+}
+function candidateIsSized(candidate, canvas) {
+  if (candidate.elementRect.width < 4 || candidate.elementRect.height < 4) return false;
+  return !(candidate.elementRect.width >= 0.95 * canvas.width && candidate.elementRect.height >= 0.95 * canvas.height);
+}
+function geometryIssueAnchor(candidate, time) {
+  return {
+    selector: candidate.selector,
+    dataAttributes: candidate.dataAttributes,
+    sourceFile: candidate.sourceFile,
+    bbox: candidate.bbox,
+    time,
+    rect: candidate.rect
+  };
+}
+function captionBoxOverlapsZone(box, zone, canvas) {
+  const zx0 = zone.x0 * canvas.width;
+  const zy0 = zone.y0 * canvas.height;
+  const zx1 = zone.x1 * canvas.width;
+  const zy1 = zone.y1 * canvas.height;
+  const bx1 = box.left + box.width;
+  const by1 = box.top + box.height;
+  const overlaps = box.left < zx1 && bx1 > zx0 && box.top < zy1 && by1 > zy0;
+  return { overlaps, cy: box.top + box.height / 2 };
+}
+function captionFinding(candidate, options, canvas, time) {
+  const zone = options.captionZone;
+  if (!zone || candidate.kind !== "text" || !candidateIsSized(candidate, canvas)) return null;
+  if ("data-layout-allow-caption-zone" in candidate.dataAttributes) return null;
+  const { overlaps, cy } = captionBoxOverlapsZone(candidate.elementRect, zone, canvas);
+  if (!overlaps) return null;
+  const text = candidate.text.slice(0, 48);
+  const pctFromBottom = Math.round((canvas.height - cy) / canvas.height * 100);
+  return {
+    ...geometryIssueAnchor(candidate, time),
+    code: "caption_zone_collision",
+    severity: zone.severity === "error" ? "error" : "warning",
+    text,
+    message: `<${candidate.tag}> "${text}" overlaps the reserved caption band (~${pctFromBottom}% up from the bottom).`,
+    fixHint: "Keep main content outside the configured caption band, or mark intentional lower-third copy with data-layout-allow-caption-zone."
+  };
+}
+function maxOverflow(candidate) {
+  if (!candidate.overflow) return 0;
+  return Math.max(
+    candidate.overflow.left ?? 0,
+    candidate.overflow.top ?? 0,
+    candidate.overflow.right ?? 0,
+    candidate.overflow.bottom ?? 0
+  );
+}
+function overflowMessage(candidate) {
+  const overflow = candidate.overflow ?? {};
+  const edges = [];
+  if (overflow.left) edges.push(`${overflow.left}px past the left`);
+  if (overflow.top) edges.push(`${overflow.top}px past the top`);
+  if (overflow.right) edges.push(`${overflow.right}px past the right`);
+  if (overflow.bottom) edges.push(`${overflow.bottom}px past the bottom`);
+  return `<${candidate.tag}> "${candidate.text.slice(0, 48)}" spills outside the frame (${edges.join(", ")}).`;
+}
+function frameFinding(candidate, options, canvas, time) {
+  if (!options.frameCheck || candidate.kind !== "media" || !candidateIsSized(candidate, canvas)) {
+    return null;
+  }
+  const floor = Math.max(
+    FRAME_BREACH_FLOOR_PX,
+    FRAME_BREACH_FLOOR_FRACTION * Math.min(canvas.width, canvas.height)
+  );
+  if (maxOverflow(candidate) < floor) return null;
+  const text = candidate.text.slice(0, 48);
+  return {
+    ...geometryIssueAnchor(candidate, time),
+    code: "frame_out_of_frame",
+    severity: options.frameCheck.severity === "error" ? "error" : "warning",
+    text,
+    overflow: candidate.overflow,
+    message: overflowMessage(candidate),
+    fixHint: "Keep media within the composition frame's safe area."
+  };
+}
+async function collectGeometryAt(driver, options, grid, canvas, time) {
+  const request = geometryRequest(time, grid, options);
+  if (!request) return [];
+  const candidates = await driver.collectGeometryCandidates(time, request);
+  const issues = [];
+  for (const candidate of candidates) {
+    if (request.text) {
+      const finding = captionFinding(candidate, options, canvas, time);
+      if (finding) issues.push(finding);
+    }
+    if (request.media) {
+      const finding = frameFinding(candidate, options, canvas, time);
+      if (finding) issues.push(finding);
+    }
+  }
+  return issues;
+}
+function emptyGridSamples() {
+  return {
+    layoutIssues: [],
+    motionFrames: [],
+    contrastEntries: [],
+    screenshots: [],
+    contrastMs: 0,
+    layoutStateSignatures: [],
+    rotationSamples: [],
+    indicatorFrames: [],
+    craftFrames: []
+  };
+}
+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);
+  into.craftFrames.push(...from.craftFrames);
+}
+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, enter, report, keep) {
+  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 = [];
+  keep(() => {
+    const so = emptyGridSamples();
+    for (const samples of perTime) if (samples) appendGridSamples(so, samples);
+    const contrast = buildContrastResults(so.contrastEntries);
+    return {
+      layoutIssues: so.layoutIssues,
+      contrastFindings: contrast.findings,
+      contrastChecked: so.contrastEntries.length,
+      contrastPassed: contrast.passed
+    };
+  });
+  let finished = 0;
+  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);
+      enter("samples");
+      report("samples", ++finished, times.length);
+    }
+  };
+  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);
+    }
+  };
+  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);
+  enter("overlap");
+  await collectMotionOverlapSamples(
+    driver,
+    grid,
+    collected,
+    options.range,
+    craftEnabled(driver, options),
+    () => enter("overlap"),
+    report
+  );
+  enter("samples");
+  return collected;
+}
+function craftEnabled(driver, options) {
+  return !options.range && typeof driver.collectCraftFrame === "function";
+}
+async function collectContrastAt(driver, options, time, issuesAtTime, collected) {
+  const contrastStart = Date.now();
+  const capture = options.snapshots ? await driver.collectContrast(time, annotationBoxesFrom(issuesAtTime)) : await driver.collectContrast(time);
+  collected.contrastMs += Date.now() - contrastStart;
+  collected.contrastEntries.push(...capture.entries);
+  if (capture.pngBase64) collected.screenshots.push({ time, pngBase64: capture.pngBase64 });
+}
+var OVERLAP_SAMPLE_FPS = 8;
+var OVERLAP_MAX_SAMPLES = 240;
+var OVERLAP_HOLD_PROBES = 60;
+var OVERLAP_BATCH = 8;
+function evenlyPicked(times, count) {
+  if (times.length <= count) return times;
+  const last = Math.max(1, count - 1);
+  return Array.from(
+    { length: count },
+    (_, i) => times[Math.floor(i * (times.length - 1) / last)] ?? 0
+  );
+}
+function uniformTimes(duration, fill) {
+  const step = duration / Math.max(1, fill - 1);
+  return Array.from({ length: fill }, (_, i) => i * step);
+}
+function buildOverlapSampleTimes(duration, clipEdges) {
+  if (!Number.isFinite(duration) || duration <= 0) return [];
+  const count = Math.min(
+    OVERLAP_MAX_SAMPLES - OVERLAP_HOLD_PROBES,
+    Math.max(2, Math.ceil(duration * OVERLAP_SAMPLE_FPS) + 1)
+  );
+  const cuts = [];
+  for (const time of mergeSampleTimes(
+    [0, duration],
+    clipEdges.filter((t) => t > 0 && t < duration)
+  ))
+    if (time - (cuts.at(-1) ?? -Infinity) >= CONTENT_OVERLAP_HELD_ERROR_MS / 1e3) cuts.push(time);
+  const uncovered = (fill2) => {
+    const step = duration / Math.max(1, fill2 - 1);
+    return cuts.slice(1).flatMap((end, i) => {
+      const start = cuts[i] ?? 0;
+      return Math.floor(start / step) === Math.floor(end / step) ? [(start + end) / 2] : [];
+    });
+  };
+  let fill = count - Math.floor(count / 2);
+  let windows = uncovered(fill);
+  if (windows.length < count - fill) {
+    fill = count - windows.length;
+    windows = uncovered(fill);
+  }
+  const picked = evenlyPicked(windows, count - fill);
+  return mergeSampleTimes(
+    [...picked, ...uniformTimes(duration, fill)].map((t) => Math.round(t * 1e3) / 1e3)
+  );
+}
+function holdProber(driver, collected, end) {
+  const holdS = CONTENT_OVERLAP_HELD_ERROR_MS / 1e3;
+  const held = /* @__PURE__ */ new Set();
+  const keyOf = (issue) => `${issue.code} ${issue.selector}`;
+  let probes = 0;
+  return async (time, next, issues) => {
+    const unproven = new Set(issues.map(keyOf).filter((key) => !held.has(key)));
+    const probe = Math.round((time + holdS) * 1e3) / 1e3;
+    const sparse = next - time > 2 * holdS && probe <= end;
+    if (!unproven.size || !sparse || probes >= OVERLAP_HOLD_PROBES) return;
+    probes += 1;
+    await driver.seekGeometry(probe);
+    const later = await driver.collectOverlap(probe);
+    collected.layoutIssues.push(...later);
+    for (const key of later.map(keyOf)) if (unproven.has(key)) held.add(key);
+  };
+}
+async function denseOverlapTimes(driver, grid, range) {
+  const offset = range?.[0] ?? 0;
+  const edges = (await driver.getClipEdges()).map((time) => time - offset);
+  const overlapTimes = buildOverlapSampleTimes(range ? range[1] - range[0] : grid.duration, edges);
+  return range ? mergeSampleTimes(overlapTimes.map((time) => time + range[0])) : overlapTimes;
+}
+async function collectOverlapGridInBatches(driver, times, progress, report) {
+  const issues = [];
+  const batches = Math.ceil(times.length / OVERLAP_BATCH);
+  for (let from = 0; from < times.length; from += OVERLAP_BATCH) {
+    issues.push(...await driver.collectOverlapGrid(times.slice(from, from + OVERLAP_BATCH)));
+    progress();
+    report("overlap", from / OVERLAP_BATCH + 1, batches);
+  }
+  return issues;
+}
+async function collectMotionOverlapSamples(driver, grid, collected, range, craft, progress, report) {
+  const baseTimes = new Set(grid.layoutSamples);
+  const shiftedTimes = await denseOverlapTimes(driver, grid, range);
+  if (craft) {
+    const craftTimes = buildCraftSampleTimes(grid.duration).filter((time) => time < grid.duration);
+    for (const [index, time] of craftTimes.entries()) {
+      await driver.seekGeometry(time);
+      collected.craftFrames.push(...await collectCraftFrame(driver, time));
+      progress();
+      report("craft", index + 1, craftTimes.length);
+    }
+  }
+  const probeHold = holdProber(driver, collected, range ? range[1] : grid.duration);
+  const gridTimes = shiftedTimes.filter((t) => !baseTimes.has(t));
+  const gridIssues = await collectOverlapGridInBatches(driver, gridTimes, progress, report);
+  let sample = 0;
+  for (const [index, time] of shiftedTimes.entries()) {
+    if (baseTimes.has(time)) continue;
+    const issues = gridIssues[sample++] ?? [];
+    collected.layoutIssues.push(...issues);
+    await probeHold(time, shiftedTimes[index + 1] ?? Number.POSITIVE_INFINITY, issues);
+    progress();
+  }
+}
+var CRAFT_SAMPLE_FPS = 8;
+var CRAFT_MAX_SAMPLES = 600;
+function buildCraftSampleTimes(duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return [];
+  const count = Math.min(
+    CRAFT_MAX_SAMPLES,
+    Math.max(2, Math.ceil(duration * CRAFT_SAMPLE_FPS) + 1)
+  );
+  const step = duration / (count - 1);
+  return mergeSampleTimes(
+    Array.from({ length: count }, (_, index) => Math.round(index * step * 1e3) / 1e3)
+  );
+}
+async function collectCraftFrame(driver, time) {
+  return driver.collectCraftFrame ? [await driver.collectCraftFrame(time)] : [];
+}
+var SWEEP_STATIC_MIN_DURATION_SEC = 3;
+var ZERO_LAYOUT_RECT = {
+  left: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  width: 0,
+  height: 0
+};
+function detectSweepStatic(duration, samples, motionIssues, hasNoTimelineDeclaration) {
+  if (hasNoTimelineDeclaration) return [];
+  if (duration < SWEEP_STATIC_MIN_DURATION_SEC) return [];
+  if (samples.length < 2) return [];
+  if (motionIssues.some((issue) => issue.code === "motion_frozen")) return [];
+  const signatures = samples.map((sample) => sample.signature);
+  if (allSame(signatures))
+    return [sweepStaticIssue(anAnimationIsStuck(samples) ? "error" : "still")];
+  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) {
+    for (const clock of new Map(sample.clock.map((clock2) => [clock2.id, clock2])).values()) {
+      seenById.set(clock.id, [...seenById.get(clock.id) ?? [], clock]);
+    }
+  }
+  return [...seenById.values()].some(
+    (seen) => seen.length > 1 && allSame(seen.map((clock) => clock.time)) && seen.every((clock) => !clock.done)
+  );
+}
+var AUDIO_TIME_SEPARATOR = "";
+function seenPart(signature) {
+  return signature.split(AUDIO_TIME_SEPARATOR)[0] ?? signature;
+}
+function allSame(values) {
+  return values.every((value) => value === values[0]);
+}
+var STILL_FIX_HINT = "If the composition is meant to be still, add `data-no-timeline` to the element with `data-composition-id`. Otherwise confirm it seeks a paused GSAP/CSS timeline under `data-*` timing attributes rather than only autoplaying.";
+var SWEEP_STATIC_MESSAGES = {
+  error: "Timeline did not advance under seek; every green verdict on this run is unreliable.",
+  still: "Nothing on screen moved under seek.",
+  audio: "Only the audio advanced under seek; nothing on screen moved."
+};
+function sweepStaticIssue(kind) {
+  return {
+    code: "sweep_static",
+    severity: kind === "error" ? "error" : "warning",
+    time: 0,
+    selector: "[data-composition-id]",
+    dataAttributes: {},
+    sourceFile: "index.html",
+    bbox: ZERO_BBOX2,
+    rect: ZERO_LAYOUT_RECT,
+    message: SWEEP_STATIC_MESSAGES[kind],
+    fixHint: kind === "error" ? "An animation on the page never moved under seek. Build it on the paused GSAP timeline registered in `window.__timelines[compositionId]`, or as a CSS animation, so the seek drives it." : STILL_FIX_HINT
+  };
+}
+var ROTATION_MIN_SAMPLES = 3;
+var ROTATION_MIN_ANGLE_SPREAD_DEG = 20;
+var ROTATION_MAX_SIZE_RATIO = 1.6;
+var ROTATION_RIGID_AABB_RATIO = 1.15;
+var ROTATION_RIGID_ESTIMATE_MIN_DET = 0.15;
+var ROTATION_MIN_MEDIAN_AREA_PX = 2500;
+var ROTATION_DRIFT_SIZE_FRACTION = 0.1;
+var ROTATION_DRIFT_VIEWPORT_FRACTION = 0.02;
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  const upper = sorted[mid] ?? 0;
+  return sorted.length % 2 === 0 ? ((sorted[mid - 1] ?? 0) + upper) / 2 : upper;
+}
+function maxAngleSpread(angles) {
+  let max = 0;
+  for (let i = 0; i < angles.length; i++) {
+    const a = angles[i];
+    if (a === void 0) continue;
+    for (let j = i + 1; j < angles.length; j++) {
+      const b = angles[j];
+      if (b === void 0) continue;
+      const raw = Math.abs(a - b) % 360;
+      max = Math.max(max, Math.min(raw, 360 - raw));
+    }
+  }
+  return max;
+}
+function maxCenterDrift(samples) {
+  let max = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const first = samples[i];
+    if (!first) continue;
+    for (let j = i + 1; j < samples.length; j++) {
+      const second = samples[j];
+      if (!second) continue;
+      max = Math.max(max, Math.hypot(first.cx - second.cx, first.cy - second.cy));
+    }
+  }
+  return max;
+}
+function rotationDriftFinding(samples, drift) {
+  const last = samples[samples.length - 1];
+  if (!last) return null;
+  const rect = {
+    left: last.cx - last.w / 2,
+    top: last.cy - last.h / 2,
+    right: last.cx + last.w / 2,
+    bottom: last.cy + last.h / 2,
+    width: last.w,
+    height: last.h
+  };
+  return {
+    code: "rotation_pivot_drift",
+    // EF promotes this to error separately; keep it a warning here.
+    severity: "warning",
+    time: last.time,
+    selector: last.selector,
+    dataAttributes: {},
+    sourceFile: "index.html",
+    bbox: rectToBbox(rect),
+    rect,
+    message: `Rotating element's bounding-box center drifts ${Math.round(drift)}px across rotation \u2014 it is not spinning about its own center (check transformOrigin/svgOrigin).`,
+    fixHint: "The bounding-box center should stay fixed while the element spins; check its transformOrigin/svgOrigin so rotation pivots about the element's own center rather than a point in a coordinate space it was resized out of."
+  };
+}
+function groupBy(items, keyOf) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = byKey.get(keyOf(item));
+    if (group) group.push(item);
+    else byKey.set(keyOf(item), [item]);
+  }
+  return byKey;
+}
+function groupBySelector(samples) {
+  return groupBy(samples, (sample) => sample.selector);
+}
+function hasEnoughRotationSamples(group) {
+  return group.length >= ROTATION_MIN_SAMPLES;
+}
+function isActuallySpinning(group) {
+  return maxAngleSpread(group.map((s) => s.angle)) > ROTATION_MIN_ANGLE_SPREAD_DEG;
+}
+function aabbForRotatedRect(elemW, elemH, angleDeg) {
+  const rad = angleDeg * Math.PI / 180;
+  const cosAbs = Math.abs(Math.cos(rad));
+  const sinAbs = Math.abs(Math.sin(rad));
+  return { w: elemW * cosAbs + elemH * sinAbs, h: elemW * sinAbs + elemH * cosAbs };
+}
+function unrotatedSizeFromSample(sample) {
+  const rad = sample.angle * Math.PI / 180;
+  const cosAbs = Math.abs(Math.cos(rad));
+  const sinAbs = Math.abs(Math.sin(rad));
+  const det = cosAbs * cosAbs - sinAbs * sinAbs;
+  if (Math.abs(det) < ROTATION_RIGID_ESTIMATE_MIN_DET) return null;
+  const elemW = (cosAbs * sample.w - sinAbs * sample.h) / det;
+  const elemH = (cosAbs * sample.h - sinAbs * sample.w) / det;
+  if (!(elemW > 0) || !(elemH > 0)) return null;
+  return { w: elemW, h: elemH };
+}
+function aabbMatchesSample(expected, sample) {
+  if (expected.w <= 0 || expected.h <= 0 || sample.w <= 0 || sample.h <= 0) return false;
+  return Math.max(expected.w, sample.w) / Math.min(expected.w, sample.w) <= ROTATION_RIGID_AABB_RATIO && Math.max(expected.h, sample.h) / Math.min(expected.h, sample.h) <= ROTATION_RIGID_AABB_RATIO;
+}
+function isSingularRotationAngle(angleDeg) {
+  const rad = angleDeg * Math.PI / 180;
+  const cosAbs = Math.abs(Math.cos(rad));
+  const sinAbs = Math.abs(Math.sin(rad));
+  return Math.abs(cosAbs * cosAbs - sinAbs * sinAbs) < ROTATION_RIGID_ESTIMATE_MIN_DET;
+}
+function isNearSquareAabb(sample) {
+  if (sample.w <= 0 || sample.h <= 0) return false;
+  return Math.max(sample.w, sample.h) / Math.min(sample.w, sample.h) <= ROTATION_RIGID_AABB_RATIO;
+}
+function fitsSingularPhaseRigidProjection(group) {
+  if (group.length === 0 || !group.every((s) => isSingularRotationAngle(s.angle))) return false;
+  if (!group.every(isNearSquareAabb)) return false;
+  const ref = group[0];
+  if (!ref) return false;
+  return group.every((sample) => aabbMatchesSample({ w: ref.w, h: ref.h }, sample));
+}
+function fitsOneRigidRectangle(group) {
+  for (const ref of group) {
+    const size = unrotatedSizeFromSample(ref);
+    if (!size) continue;
+    if (group.every(
+      (sample) => aabbMatchesSample(aabbForRotatedRect(size.w, size.h, sample.angle), sample)
+    )) {
+      return true;
+    }
+  }
+  return fitsSingularPhaseRigidProjection(group);
+}
+function isRotationSizeStable(group) {
+  if (group.some((s) => s.w <= 0 || s.h <= 0)) return false;
+  const longSides = group.map((s) => Math.max(s.w, s.h));
+  const minLong = Math.min(...longSides);
+  if (minLong <= 0) return false;
+  if (Math.max(...longSides) / minLong > ROTATION_MAX_SIZE_RATIO) return false;
+  return fitsOneRigidRectangle(group);
+}
+function isSizableRotation(group) {
+  return median(group.map((s) => s.w * s.h)) >= ROTATION_MIN_MEDIAN_AREA_PX;
+}
+function isRotationDriftCandidate(group) {
+  return hasEnoughRotationSamples(group) && isActuallySpinning(group) && isRotationSizeStable(group) && isSizableRotation(group);
+}
+function detectRotationPivotDrift(samples, canvas) {
+  const findings = [];
+  const viewportFloor = ROTATION_DRIFT_VIEWPORT_FRACTION * Math.min(canvas.width, canvas.height);
+  for (const group of groupBySelector(samples).values()) {
+    if (!isRotationDriftCandidate(group)) continue;
+    const medianSize = median(group.map((s) => Math.max(s.w, s.h)));
+    const threshold = Math.max(ROTATION_DRIFT_SIZE_FRACTION * medianSize, viewportFloor);
+    const drift = maxCenterDrift(group);
+    if (drift <= threshold) continue;
+    const finding = rotationDriftFinding(group, drift);
+    if (finding) findings.push(finding);
+  }
+  return findings;
+}
+var INDICATOR_MIN_SAMPLES = 5;
+var INDICATOR_MIN_ANGLE_SPREAD_DEG = 20;
+var INDICATOR_MIN_HUB_CIRCLES = 2;
+var INDICATOR_MAX_FIT_RESIDUAL_FRACTION = 0.05;
+var INDICATOR_MAX_RIGID_LEN_VARIATION = 0.15;
+var INDICATOR_DRIFT_LENGTH_FRACTION = 0.35;
+function fitCircle(points) {
+  const count = points.length;
+  if (count < 3) return null;
+  const meanX = points.reduce((sum, p) => sum + p.x, 0) / count;
+  const meanY = points.reduce((sum, p) => sum + p.y, 0) / count;
+  let suu = 0;
+  let svv = 0;
+  let suv = 0;
+  let suuu = 0;
+  let svvv = 0;
+  let suvv = 0;
+  let svuu = 0;
+  for (const point of points) {
+    const u = point.x - meanX;
+    const v = point.y - meanY;
+    suu += u * u;
+    svv += v * v;
+    suv += u * v;
+    suuu += u * u * u;
+    svvv += v * v * v;
+    suvv += u * v * v;
+    svuu += v * u * u;
+  }
+  const determinant = suu * svv - suv * suv;
+  if (Math.abs(determinant) < 1e-6) return null;
+  const rhsU = (suuu + suvv) / 2;
+  const rhsV = (svvv + svuu) / 2;
+  const uc = (rhsU * svv - rhsV * suv) / determinant;
+  const vc = (rhsV * suu - rhsU * suv) / determinant;
+  const cx = uc + meanX;
+  const cy = vc + meanY;
+  const radius = Math.sqrt(uc * uc + vc * vc + (suu + svv) / count);
+  let squaredError = 0;
+  for (const point of points) {
+    const delta = Math.hypot(point.x - cx, point.y - cy) - radius;
+    squaredError += delta * delta;
+  }
+  return { cx, cy, radius, residual: Math.sqrt(squaredError / count) };
+}
+var INDICATOR_MIN_HUB_PRESENCE_FRACTION = 0.6;
+function resolveHub(group) {
+  const present = group.filter(
+    (s) => s.hx !== null && s.hy !== null && s.hubCount >= INDICATOR_MIN_HUB_CIRCLES
+  );
+  if (present.length < INDICATOR_MIN_HUB_PRESENCE_FRACTION * group.length) return null;
+  const hx = median(present.map((s) => s.hx));
+  const hy = median(present.map((s) => s.hy));
+  return { hx, hy };
+}
+function isRigidBody(group) {
+  const lengths = group.map((s) => s.len).filter((len) => len > 0);
+  if (lengths.length < group.length) return false;
+  const mid = median(lengths);
+  if (mid <= 0) return false;
+  const spread = Math.max(...lengths) - Math.min(...lengths);
+  return spread <= INDICATOR_MAX_RIGID_LEN_VARIATION * mid;
+}
+function recoverPivot(group) {
+  if (group.length < INDICATOR_MIN_SAMPLES) return null;
+  const endpointA = group.map((s) => ({ x: s.ax, y: s.ay }));
+  const endpointB = group.map((s) => ({ x: s.bx, y: s.by }));
+  const fits = [fitCircle(endpointA), fitCircle(endpointB)].filter(
+    (fit) => fit !== null
+  );
+  if (fits.length === 0) return null;
+  const best = fits.reduce((widest, fit) => fit.radius > widest.radius ? fit : widest);
+  if (best.radius <= 0) return null;
+  if (best.residual > INDICATOR_MAX_FIT_RESIDUAL_FRACTION * best.radius) return null;
+  return best;
+}
+function offPivotRotationFinding(group, drift) {
+  const last = group[group.length - 1];
+  if (!last) return null;
+  const rect = {
+    left: Math.min(last.ax, last.bx) - 4,
+    top: Math.min(last.ay, last.by) - 4,
+    right: Math.max(last.ax, last.bx) + 4,
+    bottom: Math.max(last.ay, last.by) + 4,
+    width: Math.abs(last.bx - last.ax) + 8,
+    height: Math.abs(last.by - last.ay) + 8
+  };
+  return {
+    code: "off_pivot_rotation",
+    severity: "warning",
+    time: last.time,
+    selector: last.selector,
+    dataAttributes: {},
+    sourceFile: "index.html",
+    bbox: rectToBbox(rect),
+    rect,
+    message: `Gauge/dial pointer rotates about a point ${Math.round(drift)}px from the dial hub \u2014 its center-of-rotation is off the hub, so it points wrong or overshoots the track (check the rotating group's pivot: translate to the hub before rotate, or set svgOrigin/transform-origin to the hub).`,
+    fixHint: "The pointer's center-of-rotation must coincide with the dial hub. Rotate the group about the hub (e.g. transform-origin/svgOrigin set to the hub center, or translate the group so its rotation pivot lands on the hub) rather than about the element's own bbox center."
+  };
+}
+function countAngularBodies(angles) {
+  const clusters = [];
+  for (const angle of angles) {
+    if (!clusters.some((rep) => Math.min(Math.abs(angle - rep), 360 - Math.abs(angle - rep)) <= 25)) {
+      clusters.push(angle);
+    }
+  }
+  return clusters.length;
+}
+function angleAboutHub(group, hub) {
+  const midX = median(group.map((s) => (s.ax + s.bx) / 2));
+  const midY = median(group.map((s) => (s.ay + s.by) / 2));
+  return Math.atan2(midY - hub.hy, midX - hub.hx) * 180 / Math.PI;
+}
+function buildIndicatorCandidate(group) {
+  if (group.length < INDICATOR_MIN_SAMPLES) return null;
+  if (maxAngleSpread(group.map((s) => s.angle)) <= INDICATOR_MIN_ANGLE_SPREAD_DEG) return null;
+  const hub = resolveHub(group);
+  if (!hub) return null;
+  if (!isRigidBody(group)) return null;
+  const pivot = recoverPivot(group);
+  if (!pivot) return null;
+  const drift = Math.hypot(pivot.cx - hub.hx, pivot.cy - hub.hy);
+  const length = median(group.map((s) => s.len));
+  const eligible = drift > INDICATOR_DRIFT_LENGTH_FRACTION * length;
+  return {
+    // Scoped-known blind spot: hubs bucketed by rounded screen coords, so two
+    // separate dials whose screen hubs land in the same 5px bucket merge into
+    // one multi-body group (rare — distinct dials stacked at ~identical screen
+    // position). Key by owning <svg> identity if that pattern shows up.
+    hubKey: `${Math.round(hub.hx / 5)}:${Math.round(hub.hy / 5)}`,
+    angleAboutHub: angleAboutHub(group, hub),
+    drift,
+    length,
+    finding: eligible ? offPivotRotationFinding(group, drift) : null
+  };
+}
+function selectHubFindings(candidates) {
+  const byHub = groupBy(candidates, (candidate) => candidate.hubKey);
+  const findings = [];
+  for (const group of byHub.values()) {
+    const eligible = group.filter((c2) => c2.finding !== null);
+    if (countAngularBodies(eligible.map((c2) => c2.angleAboutHub)) >= 2) continue;
+    const best = group.filter((c2) => c2.finding !== null).reduce(
+      (max, c2) => !max || c2.length > max.length ? c2 : max,
+      null
+    );
+    if (best?.finding) findings.push(best.finding);
+  }
+  return findings;
+}
+function detectOffPivotRotation(frames) {
+  const timed = frames.flatMap(
+    (frame) => frame.samples.map((sample) => ({ ...sample, time: frame.time }))
+  );
+  const candidates = [];
+  for (const group of groupBySelector(timed).values()) {
+    const candidate = buildIndicatorCandidate(group);
+    if (candidate) candidates.push(candidate);
+  }
+  return selectHubFindings(candidates);
+}
+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 }));
+}
+function wholeCompositionKeepsMoving(assertions) {
+  return assertions.some(
+    (assertion) => assertion.kind === "keepsMoving" && assertion.withinSelector === void 0
+  );
+}
+function disabledCraft() {
+  return { enabled: false, step: 0, samples: 0, findings: [] };
+}
+async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([]), enter = () => {
+}, report = () => {
+}, keep = () => {
+}) {
+  enter("samples");
+  await driver.initialize(options.contrast);
+  const grid = await buildSampleGrid(driver, options);
+  const plan = await planMotionSampling(
+    driver,
+    options.range ? { kind: "none" } : motion,
+    grid.duration
+  );
+  const seekLoopStart = Date.now();
+  const collected = await collectGridSamples(
+    driver,
+    options,
+    grid,
+    plan,
+    helpers,
+    enter,
+    report,
+    keep
+  );
+  const seekLoopMs = Date.now() - seekLoopStart;
+  let motionIssues = plan.preflightIssues;
+  if (motion.kind === "valid" && plan.assertions.length > 0 && collected.motionFrames.length > 0) {
+    const canvas = await driver.getCanvas();
+    let evaluated = evaluateMotion(collected.motionFrames, plan.assertions, canvas, grid.duration);
+    if (evaluated.some((issue) => issue.code === "motion_frozen")) {
+      const frames = await withFrameMotion(driver, collected.motionFrames, plan.assertions);
+      evaluated = evaluateMotion(frames, plan.assertions, canvas, grid.duration);
+    }
+    motionIssues = [...motionIssues, ...await driver.anchorMotionIssues(evaluated)];
+  }
+  const userPicked = new Set(grid.userPickedSamples);
+  const noTimeline = await driver.hasNoTimelineDeclaration();
+  const sweepSamples = collected.layoutStateSignatures.filter(
+    (sample) => !userPicked.has(sample.time)
+  );
+  const sweepVerdict = options.range ? [] : detectSweepStatic(grid.duration, sweepSamples, motionIssues, noTimeline);
+  const sweepFindings = sweepVerdict.length > 0 && await framesMoved(
+    driver,
+    sweepSamples.map((sample) => sample.time)
+  ) ? [] : sweepVerdict;
+  const rotationFindings = detectRotationPivotDrift(
+    collected.rotationSamples,
+    await driver.getCanvas()
+  );
+  const offPivotFindings = detectOffPivotRotation(collected.indicatorFrames);
+  const contrast = buildContrastResults(collected.contrastEntries);
+  const craft = craftEnabled(driver, options) ? await auditCraft(
+    {
+      frames: collected.craftFrames,
+      duration: grid.duration,
+      canvas: await driver.getCanvas(),
+      soundSources: driver.collectCraftFilm ? (await driver.collectCraftFilm()).soundSources : null,
+      stillnessJudgedElsewhere: noTimeline || sweepFindings.length > 0 || wholeCompositionKeepsMoving(plan.assertions)
+    },
+    async (time) => {
+      await driver.seekGeometry(time);
+      if (!driver.collectCraftFrame) throw new Error("craft sampling unavailable");
+      return driver.collectCraftFrame(time);
+    }
+  ) : disabledCraft();
+  if (options.components?.length) {
+    if (!driver.matchComponents)
+      throw new Error("Component filtering unavailable in this check driver");
+    const findings = [
+      ...collected.layoutIssues,
+      ...sweepFindings,
+      ...rotationFindings,
+      ...offPivotFindings,
+      ...motionIssues,
+      ...contrast.findings,
+      ...craft.findings
+    ];
+    const matches = await driver.matchComponents(options.components, findings);
+    findings.forEach((finding, i) => {
+      finding.componentMatch = matches[i];
+    });
+  }
+  return {
+    duration: grid.duration,
+    layoutSamples: grid.layoutSamples,
+    transitionSamples: grid.transitionSamples,
+    transitionSamplesDropped: grid.transitionSamplesDropped,
+    runtimeFindings: [],
+    layoutIssues: [
+      ...collected.layoutIssues,
+      ...sweepFindings,
+      ...rotationFindings,
+      ...offPivotFindings
+    ],
+    motionIssues,
+    motionSampleCount: collected.motionFrames.length,
+    contrastSamples: grid.contrastSamples,
+    contrastFindings: contrast.findings,
+    contrastChecked: collected.contrastEntries.length,
+    contrastPassed: contrast.passed,
+    craft,
+    screenshots: collected.screenshots,
+    timings: { launchSettleMs: 0, seekLoopMs, contrastMs: collected.contrastMs },
+    skipped: false
+  };
+}
+async function runCheckPipeline(project, options, dependencies = DEFAULT_DEPENDENCIES2) {
+  beginCheckSnapshots(project.dir);
+  const prelaunched = dependencies.prelaunchBrowser?.(project, options).catch(() => void 0);
+  try {
+    let lintResult;
+    const lintStartedAt = Date.now();
+    try {
+      lintResult = await dependencies.lintProject(project.dir);
+    } catch (error) {
+      return failureReport(options, runtimeFailure(error, "check_lint_failure"));
+    }
+    trackLintRun(project.dir, lintResult, {
+      command: "check",
+      durationMs: Date.now() - lintStartedAt,
+      ...getRunId() !== void 0 ? { runId: getRunId() } : {}
+    });
+    const lint = buildLintSection(lintResult);
+    let hdrPromotion = null;
+    let hdrInspection = "available";
+    try {
+      hdrPromotion = await (dependencies.inspectHdrAutoPromotion ?? inspectHdrAutoPromotion)(
+        project
+      );
+    } catch {
+      hdrInspection = "unavailable";
+    }
+    if (shouldBlockRender(true, false, lintResult.totalErrors, lintResult.totalWarnings)) {
+      return buildReport(
+        options,
+        lint,
+        emptyBrowserResult(),
+        { kind: "none" },
+        [],
+        [],
+        hdrPromotion,
+        hdrInspection
+      );
+    }
+    const motion = dependencies.resolveMotionSpec(project.dir);
+    const specFindings = motion.kind === "invalid" ? [
+      findingAtRoot(
+        "motion_spec_invalid",
+        "error",
+        motion.message,
+        relative(project.dir, motion.path) || "index.motion.json"
+      )
+    ] : [];
+    const deadline = new CheckDeadline();
+    let outcome;
+    try {
+      let browser;
+      try {
+        const browserAhead = await prelaunched;
+        browser = await deadline.run(
+          () => dependencies.runBrowserCheck(project, options, motion, deadline, browserAhead)
+        );
+      } catch (error) {
+        const found = deadline.partialResult();
+        browser = { ...emptyBrowserResult(), ...found, skipped: Object.keys(found).length === 0 };
+        browser.runtimeFindings = [...browser.runtimeFindings, runtimeFailure(error)];
+      }
+      const snapshotFiles = options.snapshots ? await writeContrastSnapshots(dependencies, project.dir, browser) : [];
+      const report = buildReport(
+        options,
+        lint,
+        browser,
+        motion,
+        specFindings,
+        snapshotFiles,
+        hdrPromotion,
+        hdrInspection
+      );
+      outcome = {
+        kind: "report",
+        report: options.snapshots ? await withFindingCrops(dependencies, project, options, report, deadline) : report
+      };
+    } catch (error) {
+      outcome = { kind: "failed", error };
+    }
+    try {
+      await deadline.close();
+    } catch (error) {
+      if (outcome.kind === "failed") {
+        throw new BrowserCleanupError(
+          [outcome.error, error],
+          `${normalizeErrorMessage(outcome.error)}; ${normalizeErrorMessage(error)}`
+        );
+      }
+      const report = outcome.report;
+      return {
+        ...report,
+        ok: false,
+        runtime: section([
+          ...report.runtime.findings,
+          runtimeFailure(error, "check_cleanup_failure")
+        ])
+      };
+    }
+    if (outcome.kind === "failed") throw outcome.error;
+    return outcome.report;
+  } finally {
+    await (await prelaunched)?.discard();
+    await finishCheckSnapshots(project.dir).catch(() => void 0);
+  }
+}
+async function writeContrastSnapshots(dependencies, projectDir, browser) {
+  const files = [];
+  for (let index = 0; index < browser.screenshots.length; index += 1) {
+    const shot = browser.screenshots[index];
+    if (!shot) continue;
+    try {
+      files.push(await dependencies.writeSnapshot(projectDir, index, shot.time, shot.pngBase64));
+    } catch (error) {
+      browser.runtimeFindings.push(runtimeFailure(error, "snapshot_write_failed"));
+    }
+  }
+  return files;
+}
+async function withFindingCrops(dependencies, project, options, report, deadline) {
+  const cropRequests = selectFindingCropRequests(report);
+  if (cropRequests.length === 0) return report;
+  try {
+    deadline.enter("crops");
+    const findingFiles = await deadline.run(
+      () => dependencies.captureFindingCrops(project, options, cropRequests, deadline)
+    );
+    return { ...report, snapshots: { ...report.snapshots, findingFiles } };
+  } catch (error) {
+    if (error instanceof CheckDeadlineError) {
+      const finding = runtimeFailure(error);
+      return { ...report, ok: false, runtime: section([...report.runtime.findings, finding]) };
+    }
+    console.error("   finding crops skipped: " + normalizeErrorMessage(error));
+    trackCommandFailure("check-finding-crops", error);
+    return report;
+  }
+}
+var MAX_FINDING_CROPS = 12;
+function selectFindingCropRequests(report) {
+  const candidates = [
+    ...report.layout.findings,
+    ...report.motion.findings,
+    ...report.contrast.findings,
+    ...report.runtime.findings
+  ];
+  const requests = [];
+  for (const finding of candidates) {
+    if (requests.length >= MAX_FINDING_CROPS) break;
+    if (finding.severity !== "error" || !hasRealBbox(finding.bbox)) continue;
+    requests.push({
+      filename: findingCropFilename(requests.length, finding.code),
+      time: finding.time,
+      bbox: finding.bbox
+    });
+  }
+  return requests;
+}
+function hasRealBbox(bbox) {
+  return bbox.width > 0 && bbox.height > 0;
+}
+function findingCropFilename(index, code) {
+  const safeCode = code.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `finding-${String(index).padStart(2, "0")}-${safeCode}.png`;
+}
+function checkExitCode(report) {
+  return report.ok ? 0 : 1;
+}
+function contrastFailureHeld(entries) {
+  const sampledTimes = new Set(entries.map((entry) => entry.time)).size;
+  const failureSamples = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.wcagAA) continue;
+    const key = findingElementKey(entry);
+    const times = failureSamples.get(key) ?? /* @__PURE__ */ new Set();
+    times.add(entry.time);
+    failureSamples.set(key, times);
+  }
+  return (entry) => sampledTimes < 2 || (failureSamples.get(findingElementKey(entry))?.size ?? 0) >= 2;
+}
+function buildContrastResults(entries) {
+  const findings = [];
+  let passed = 0;
+  const isHeld = contrastFailureHeld(entries);
+  for (const entry of entries) {
+    if (entry.wcagAA) {
+      passed += 1;
+      continue;
+    }
+    const held = isHeld(entry);
+    const requiredRatio = requiredContrastRatio(entry.large);
+    findings.push({
+      code: "contrast_aa_failure",
+      severity: held ? "error" : "warning",
+      message: `Contrast is ${entry.ratio}:1; WCAG AA requires ${requiredRatio}:1.`,
+      text: entry.text,
+      fg: entry.fg,
+      bg: entry.bg,
+      ratio: entry.ratio,
+      requiredRatio,
+      suggestedColor: suggestedColor(entry.fg, entry.bg, requiredRatio),
+      large: entry.large,
+      selector: entry.selector,
+      dataAttributes: entry.dataAttributes,
+      sourceFile: entry.sourceFile,
+      bbox: entry.bbox,
+      time: entry.time
+    });
+  }
+  return {
+    findings: groupSampledFindings(
+      findings,
+      (next, current) => current.ratio / current.requiredRatio - next.ratio / next.requiredRatio
+    ),
+    passed
+  };
+}
+function suggestedColor(fg, bg, requiredRatio) {
+  const foreground = parseColorRGBA(fg);
+  const background = parseColorRGBA(bg);
+  if (!foreground || !background) return fg;
+  const fgRgb = [foreground[0], foreground[1], foreground[2]];
+  const bgRgb = [background[0], background[1], background[2]];
+  const suggested = suggestCompliantForegroundColor(fgRgb, bgRgb, requiredRatio);
+  return `rgb(${suggested[0]},${suggested[1]},${suggested[2]})`;
+}
+function buildLintSection(result) {
+  const findings = result.results.flatMap(
+    ({ file, result: fileResult }) => fileResult.findings.map((finding) => ({
+      code: finding.code,
+      severity: finding.severity,
+      message: finding.message,
+      selector: finding.selector ?? (finding.elementId ? `#${finding.elementId}` : "[data-composition-id]"),
+      dataAttributes: {},
+      sourceFile: finding.file ?? file,
+      bbox: ZERO_BBOX2,
+      time: 0,
+      fixHint: finding.fixHint
+    }))
+  );
+  return { ...section(findings), filesScanned: result.results.length };
+}
+function buildReport(options, lint, browser, motion, extraMotionFindings, snapshotFiles, hdrPromotion = null, hdrInspection = "available") {
+  const shaping = options.components?.length ? { ...options, maxIssues: Number.MAX_SAFE_INTEGER } : options;
+  const layout = shapeLayoutSection(browser.layoutIssues, browser, shaping);
+  const shapedMotion = shapeLayoutFindings(browser.motionIssues, shaping);
+  const motionFindings = [...shapedMotion.findings, ...extraMotionFindings];
+  const runtime = section(browser.runtimeFindings);
+  const motionSection = section(motionFindings);
+  const contrastSection = section(browser.contrastFindings);
+  const craftSection = section(browser.craft.findings);
+  const warningCount = lint.warningCount + runtime.warningCount + layout.warningCount + motionSection.warningCount + contrastSection.warningCount + craftSection.warningCount;
+  const errorCount = lint.errorCount + runtime.errorCount + layout.errorCount + motionSection.errorCount + contrastSection.errorCount + craftSection.errorCount;
+  const strictWarningCount = warningCount - craftSection.warningCount;
+  const report = {
+    ok: errorCount === 0 && (!options.strict || strictWarningCount === 0),
+    strict: options.strict,
+    browserSkipped: browser.skipped,
+    lint,
+    runtime,
+    layout,
+    motion: {
+      ...motionSection,
+      enabled: motion.kind !== "none" && !options.range,
+      specPath: motion.kind === "none" ? void 0 : motion.path,
+      samples: browser.motionSampleCount
+    },
+    contrast: {
+      ...contrastSection,
+      enabled: options.contrast,
+      samples: browser.contrastSamples,
+      checked: browser.contrastChecked,
+      passed: browser.contrastPassed
+    },
+    craft: {
+      ...craftSection,
+      enabled: browser.craft.enabled,
+      step: browser.craft.step,
+      samples: browser.craft.samples
+    },
+    hdr: { autoPromotion: hdrPromotion, inspection: hdrInspection },
+    snapshots: {
+      enabled: options.snapshots,
+      files: snapshotFiles,
+      times: options.snapshots ? browser.screenshots.map((shot) => shot.time) : [],
+      findingFiles: []
+    }
+  };
+  trackCheckReport({
+    contrastGate: options.contrast,
+    motionGate: motion.kind !== "none" && !options.range,
+    captionZoneGate: options.captionZone !== void 0,
+    frameCheckGate: options.frameCheck !== void 0,
+    snapshotsGate: options.snapshots,
+    lintErrors: lint.errorCount,
+    lintWarnings: lint.warningCount,
+    runtimeErrors: runtime.errorCount,
+    runtimeWarnings: runtime.warningCount,
+    layoutErrors: layout.errorCount,
+    layoutWarnings: layout.warningCount,
+    motionErrors: motionSection.errorCount,
+    motionWarnings: motionSection.warningCount,
+    contrastErrors: contrastSection.errorCount,
+    contrastWarnings: contrastSection.warningCount,
+    craftWarnings: craftSection.warningCount,
+    launchSettleMs: browser.timings.launchSettleMs,
+    seekLoopMs: browser.timings.seekLoopMs,
+    contrastMs: browser.timings.contrastMs,
+    gridPoints: browser.layoutSamples.length,
+    contrastPoints: browser.contrastChecked,
+    ok: report.ok,
+    exitCode: checkExitCode(report),
+    runId: getRunId()
+  });
+  return filterComponentReport(report, options);
+}
+function filterComponentReport(report, options) {
+  if (!options.range && !options.components?.length) return report;
+  {
+    report.scope = {
+      range: options.range,
+      components: options.components,
+      hiddenFindings: 0,
+      notes: [
+        "Static lint and unscoped runtime failures remain project-wide.",
+        ...options.range ? [
+          "Whole-timeline motion assertions, frozen-sweep detection and craft warnings are skipped for range checks."
+        ] : []
+      ]
+    };
+    for (const group of [report.layout, report.motion, report.contrast, report.craft]) {
+      const before = group.findings.length;
+      group.findings = group.findings.filter((f) => f.componentMatch !== false);
+      report.scope.hiddenFindings += before - group.findings.length;
+      if (group !== report.contrast && group.findings.length > options.maxIssues) {
+        group.findings = group.findings.slice(0, options.maxIssues);
+        report.scope.notes.push(
+          "Selected findings exceed --max-issues; increase it to see the remainder."
+        );
+        if (group === report.layout) report.layout.truncated = true;
+      }
+    }
+  }
+  return report;
+}
+function shapeLayoutSection(issues, browser, options) {
+  const shaped = shapeLayoutFindings(issues, options, browser.layoutSamples.length);
+  return {
+    ...section(shaped.findings),
+    duration: browser.duration,
+    samples: browser.layoutSamples,
+    transitionSamples: browser.transitionSamples,
+    transitionSamplesDropped: browser.transitionSamplesDropped,
+    tolerance: options.tolerance,
+    totalIssueCount: shaped.totalIssueCount,
+    truncated: shaped.truncated
+  };
+}
+function shapeLayoutFindings(issues, options, totalSampleCount) {
+  const deduped = dedupeLayoutIssues(issues);
+  const all = options.collapseStatic ? collapseStaticLayoutIssues(deduped, totalSampleCount) : deduped;
+  const anchored = all.map(ensureAnchoredLayoutIssue);
+  let grouped = anchored;
+  if (options.collapseStatic) {
+    grouped = groupSampledFindings(anchored).map((finding) => ({
+      ...finding,
+      firstSeen: finding.times[0] ?? finding.time,
+      lastSeen: finding.times.at(-1) ?? finding.time,
+      occurrences: finding.times.length,
+      heldMs: longestContiguousRunMs(finding.times)
+    }));
+  }
+  const limited = limitLayoutIssues(grouped, options.maxIssues);
+  return {
+    findings: limited.issues.map(ensureAnchoredLayoutIssue),
+    totalIssueCount: limited.totalIssueCount,
+    truncated: limited.truncated
+  };
+}
+function ensureAnchoredLayoutIssue(issue) {
+  const sourceFile = Reflect.get(issue, "sourceFile");
+  const dataAttributes = Reflect.get(issue, "dataAttributes");
+  const bbox = Reflect.get(issue, "bbox");
+  if (typeof sourceFile === "string" && isStringRecord(dataAttributes) && isBbox(bbox)) {
+    return { ...issue, sourceFile, dataAttributes, bbox };
+  }
+  return {
+    ...issue,
+    sourceFile: "index.html",
+    dataAttributes: {},
+    bbox: rectToBbox(issue.rect)
+  };
+}
+function section(findings) {
+  const errorCount = findings.filter((finding) => finding.severity === "error").length;
+  const warningCount = findings.filter((finding) => finding.severity === "warning").length;
+  const infoCount = findings.filter((finding) => finding.severity === "info").length;
+  return { ok: errorCount === 0, errorCount, warningCount, infoCount, findings };
+}
+function emptyBrowserResult() {
+  return {
+    duration: 0,
+    layoutSamples: [],
+    transitionSamples: [],
+    transitionSamplesDropped: 0,
+    runtimeFindings: [],
+    layoutIssues: [],
+    motionIssues: [],
+    motionSampleCount: 0,
+    contrastSamples: [],
+    contrastFindings: [],
+    contrastChecked: 0,
+    contrastPassed: 0,
+    craft: disabledCraft(),
+    screenshots: [],
+    timings: { launchSettleMs: 0, seekLoopMs: 0, contrastMs: 0 },
+    skipped: true
+  };
+}
+function runtimeFailure(error, code = "check_runtime_failure") {
+  return findingAtRoot(
+    code,
+    "error",
+    normalizeErrorMessage(error),
+    error instanceof CheckDeadlineError ? error.sourceFile ?? "index.html" : "index.html"
+  );
+}
+function findingAtRoot(code, severity, message, sourceFile) {
+  return {
+    code,
+    severity,
+    message,
+    selector: "[data-composition-id]",
+    dataAttributes: {},
+    sourceFile,
+    bbox: ZERO_BBOX2,
+    time: 0
+  };
+}
+function failureReport(options, finding) {
+  const lint = { ...section([]), filesScanned: 0 };
+  const browser = emptyBrowserResult();
+  browser.runtimeFindings.push(finding);
+  return buildReport(options, lint, browser, { kind: "none" }, [], []);
+}
+function isBbox(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return ["x", "y", "width", "height"].every((key) => typeof Reflect.get(value, key) === "number");
+}
+function isStringRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return Object.keys(value).every((key) => typeof Reflect.get(value, key) === "string");
+}
+function resolveMotionSpec(projectDir) {
+  const path = findMotionSpec(projectDir);
+  if (!path) return { kind: "none" };
+  const result = readMotionSpec(path);
+  return result.ok ? { kind: "valid", path, spec: result.spec } : {
+    kind: "invalid",
+    path,
+    message: `Invalid motion spec ${path}: ${result.errors.join("; ")}`
+  };
+}
+async function runBrowserCheck(project, options, motion, deadline, prelaunched) {
+  const module = await import("./checkBrowser-LZ66CMJG.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-4DA6SEH2.js");
+  return prelaunchCompositionBrowser(html, options.browserGpuMode);
+}
+async function writeSnapshot(projectDir, index, time, pngBase64) {
+  const snapshotDir = checkSnapshotDirectory(projectDir);
+  mkdirSync(snapshotDir, { recursive: true });
+  const filename = `frame-${String(index).padStart(2, "0")}-at-${time.toFixed(1)}s.png`;
+  const path = join(snapshotDir, filename);
+  writeFileSync(path, Buffer.from(pngBase64, "base64"));
+  return relative(projectDir, path);
+}
+async function captureFindingCrops(project, options, requests, deadline) {
+  const module = await import("./checkBrowser-LZ66CMJG.js");
+  return module.captureFindingCrops(project, options, requests, deadline);
+}
+var DEFAULT_DEPENDENCIES2 = {
+  lintProject,
+  resolveMotionSpec,
+  runBrowserCheck,
+  prelaunchBrowser,
+  writeSnapshot,
+  captureFindingCrops,
+  inspectHdrAutoPromotion
+};
+
+// src/commands/check.ts
+var examples = [
+  ["Run the full verification gate", "framey check"],
+  ["Output one agent-readable envelope", "framey check --json"],
+  ["Persist the five audited contrast frames", "framey check --snapshots"],
+  ["Also fail on warnings", "framey check --strict"],
+  ["Make only the browser-playable video copies, then exit", "framey check --prepare-media"]
+];
+var DEFAULT_COMMAND_DEPENDENCIES = {
+  resolveProject,
+  async runPipeline(project, options) {
+    const capturing = captureArtifactRevision(project.dir).catch(warnNotRecorded);
+    const report = await runCheckPipeline(project, options);
+    const images = (files) => files.map((file) => resolve(project.dir, file));
+    reportArtifacts("check", "frame", images(report.snapshots.files));
+    reportArtifacts("check", "finding", images(report.snapshots.findingFiles));
+    const capture = await capturing;
+    if (!capture) return report;
+    try {
+      return { ...report, saved: await saveCheckReport(project, options, report, capture) };
+    } catch (error) {
+      warnNotRecorded(error);
+      return report;
+    }
+  },
+  async prepareMedia(project, options) {
+    const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-ALYBQEQT.js");
+    const html = await bundleWithLocalizedFonts(project.dir);
+    return (await preResolveHostileMediaProxies(project.dir, html, options.autoProxy)).files;
+  },
+  withMeta
+};
+function warnNotRecorded(error) {
+  console.warn(`${c.warn("\u26A0")}  Check report was not recorded: ${normalizeErrorMessage(error)}`);
+  return void 0;
+}
+async function saveCheckReport(project, options, report, capture) {
+  const id = randomUUID();
+  const directory = join2(project.dir, ".hyperframes", "artifacts", "checks");
+  mkdirSync2(directory, { recursive: true });
+  const path = join2(directory, `${id}.json`);
+  writeFileSync2(path, JSON.stringify(report, null, 2) + "\n", { flag: "wx" });
+  const reportScope = "scope" in report && typeof report.scope === "object" && report.scope !== null ? report.scope : void 0;
+  const artifacts = [
+    {
+      kind: "check",
+      id,
+      scope: reportScope ? "scoped" : "project",
+      report: resolve(path),
+      metadata: {
+        ok: report.ok,
+        browserSkipped: report.browserSkipped,
+        scope: reportScope,
+        options
+      }
+    }
+  ];
+  for (const [index, image] of report.snapshots.files.entries()) {
+    artifacts.push({
+      kind: "snapshot",
+      id: `${id}-${index}`,
+      scope: "full",
+      image: resolve(project.dir, image),
+      time: report.snapshots.times[index],
+      metadata: {
+        checkId: id,
+        ...pngDimensions(resolve(project.dir, image))
+      }
+    });
+  }
+  const crops = selectFindingCropRequests(report);
+  for (const [index, image] of report.snapshots.findingFiles.entries()) {
+    const crop = crops.find((request) => image.endsWith(request.filename));
+    artifacts.push({
+      kind: "snapshot",
+      id: `${id}-crop-${index}`,
+      scope: "finding",
+      image: resolve(project.dir, image),
+      time: crop?.time,
+      metadata: {
+        checkId: id,
+        finding: crop,
+        ...pngDimensions(resolve(project.dir, image))
+      }
+    });
+  }
+  const [saved] = await recordArtifacts(project.dir, capture, artifacts);
+  if (!saved) throw new Error("no history record was written");
+  reportArtifacts("check", "check-report", [resolve(path)]);
+  return {
+    id: saved.id,
+    revision: saved.revision,
+    report: saved.report,
+    attribution: saved.attribution
+  };
+}
+var CHECK_COMMAND_ARGS = {
+  dir: { type: "positional", description: "Project directory", required: false },
+  json: { type: "boolean", description: "Output agent-readable JSON", default: false },
+  samples: {
+    type: "string",
+    description: "Number of midpoint samples across the duration (default: 9)",
+    default: "9"
+  },
+  range: {
+    type: "string",
+    description: "Runtime sample interval in global seconds: start,end. Static lint remains project-wide."
+  },
+  components: {
+    type: "string",
+    description: "CSS selector list: filter findings involving these components or descendants; preserve full-check status."
+  },
+  at: {
+    type: "string",
+    description: "Comma-separated timestamps in seconds (e.g., --at 1.5,4,7.25)"
+  },
+  "at-transitions": {
+    type: "boolean",
+    description: "Also sample at every tween start/end boundary (plus segment midpoints) to catch transient overlaps at transition seams",
+    default: false
+  },
+  "max-transition-samples": {
+    type: "string",
+    description: "Optional cap on transition-derived samples; when it truncates, the omitted count is reported (default: unlimited)"
+  },
+  "max-issues": {
+    type: "string",
+    description: "Maximum issues to print or return after static collapse (default: 80)",
+    default: "80"
+  },
+  "collapse-static": {
+    type: "boolean",
+    description: "Collapse repeated static issues across samples (default: true)",
+    default: true
+  },
+  tolerance: {
+    type: "string",
+    description: "Allowed pixel overflow before reporting an issue (default: 2)",
+    default: "2"
+  },
+  timeout: {
+    type: "string",
+    description: "Initial render-ready timeout in ms; also sets the navigation minimum (10s floor, default: 3000)",
+    default: "3000"
+  },
+  contrast: {
+    type: "boolean",
+    description: "Run the WCAG AA contrast pass (enabled by default)",
+    default: true
+  },
+  strict: {
+    type: "boolean",
+    description: "Exit non-zero on warnings too",
+    default: false
+  },
+  "prepare-media": {
+    type: "boolean",
+    description: "Only make the browser-playable copies of videos Chrome cannot decode, then exit (no browser, no report). Stopped copies resume on the next run",
+    default: false
+  },
+  proxy: {
+    type: "boolean",
+    description: "Auto-transcode browser-hostile video codecs (default: hyperframes.json media.autoProxy, which defaults on)",
+    default: void 0
+  },
+  "browser-gpu": {
+    type: "boolean",
+    description: "Use hardware browser GPU capture; pass --no-browser-gpu for deterministic SwiftShader (default: auto-detect, PRODUCER_BROWSER_GPU_MODE overrides)",
+    default: void 0
+  },
+  snapshots: {
+    type: "boolean",
+    description: "Save contrast-pass PNGs under .hyperframes/artifacts/snapshots/",
+    default: false
+  },
+  "caption-zone": {
+    type: "string",
+    description: 'Caption band "x0=0;y0=.82;x1=1;y1=1[;severity=warning|error][;seek=.5,1]" (fractions 0-1; defaults: warning, seek=1)'
+  },
+  "frame-check": {
+    type: "string",
+    description: 'Bare --frame-check uses defaults (tol=2px, severity=warning, seek=.5; breach floor=max(120px, 6% of shorter canvas edge)); or pass "severity=error;seek=.25,.75;tol=4" to tune'
+  },
+  layout: {
+    type: "string",
+    description: 'Layout knobs: "proseCoverageFloor=0.05" (0\u20131; default 0.15).'
+  }
+};
+function createCheckCommand(dependencies = DEFAULT_COMMAND_DEPENDENCIES) {
+  return defineCommand({
+    meta: {
+      name: "check",
+      description: "Run lint, runtime, layout, motion, and WCAG contrast verification in one browser session"
+    },
+    args: CHECK_COMMAND_ARGS,
+    async run({ rawArgs }) {
+      const args = parseArgs(rawArgs, CHECK_COMMAND_ARGS);
+      const asJson = args.json === true;
+      try {
+        const project = dependencies.resolveProject(args.dir);
+        const options = parseCheckOptions(args);
+        if (!asJson) {
+          console.log(`${c.accent("\u25C6")}  Checking ${c.accent(project.name)}`);
+        }
+        if (args["prepare-media"] === true) {
+          await runPrepareMedia(dependencies, project, options, asJson);
+          return;
+        }
+        const report = await withProjectLock(
+          project.dir,
+          "check",
+          () => dependencies.runPipeline(project, options)
+        );
+        if (asJson) {
+          console.log(JSON.stringify(dependencies.withMeta(report), null, 2));
+        } else {
+          printHumanReport(report);
+          if (report.saved) {
+            console.log(`Report: ${report.saved.report}`);
+            console.log(
+              `Revision: ${report.saved.revision ?? "none"} (${report.saved.attribution})`
+            );
+          }
+        }
+        setCommandExitCode(checkExitCode(report));
+      } catch (error) {
+        const message = normalizeErrorMessage(error);
+        if (asJson) {
+          console.log(
+            JSON.stringify(dependencies.withMeta({ ok: false, error: message }), null, 2)
+          );
+        } else {
+          console.error(`${c.error("\u2717")} Check failed: ${message}`);
+        }
+        setCommandExitCode(1);
+      }
+    }
+  });
+}
+async function runPrepareMedia(dependencies, project, options, asJson) {
+  const files = await withProjectLock(
+    project.dir,
+    "check",
+    () => dependencies.prepareMedia(project, options)
+  );
+  const failed = files.filter((file) => file.state === "failed");
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        dependencies.withMeta({
+          ok: failed.length === 0,
+          prepared: files,
+          total: files.length,
+          ready: files.length - failed.length,
+          failed: failed.length
+        }),
+        null,
+        2
+      )
+    );
+  } else {
+    const mark = failed.length === 0 ? c.success("\u2713") : c.error("\u2717");
+    console.log(
+      `${mark}  Browser-playable copies: ${files.length - failed.length}/${files.length} ready`
+    );
+    for (const file of failed) console.log(`   ${file.file}: ${file.reason}`);
+  }
+  setCommandExitCode(failed.length === 0 ? 0 : 1);
+}
+function parseCheckOptions(args) {
+  const maxTransitionSamples = positiveInteger(args["max-transition-samples"], 0);
+  return {
+    samples: positiveInteger(args.samples, DEFAULT_CHECK_OPTIONS.samples),
+    range: parseCheckRange(args.range),
+    components: typeof args.components === "string" ? [args.components] : void 0,
+    at: parseAt(args.at),
+    atTransitions: args["at-transitions"] === true,
+    maxTransitionSamples: maxTransitionSamples > 0 ? maxTransitionSamples : void 0,
+    maxIssues: positiveInteger(args["max-issues"], DEFAULT_CHECK_OPTIONS.maxIssues),
+    collapseStatic: args["collapse-static"] !== false,
+    tolerance: nonNegativeNumber(args.tolerance, DEFAULT_CHECK_OPTIONS.tolerance),
+    timeout: Math.max(500, positiveInteger(args.timeout, DEFAULT_CHECK_OPTIONS.timeout)),
+    contrast: args.contrast !== false,
+    strict: args.strict === true,
+    snapshots: args.snapshots === true,
+    captionZone: parseCaptionZone(args["caption-zone"]),
+    frameCheck: parseFrameCheck(args["frame-check"]),
+    layout: parseLayout(args.layout),
+    autoProxy: args.proxy,
+    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(/[,:]/);
+  const start = Number(parts[0]), end = Number(parts[1]);
+  if (parts.length !== 2 || parts.some((p) => !p.trim()) || !Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end <= start)
+    throw new Error("Invalid --range: use non-negative start,end with end > start");
+  return [start, end];
+}
+var CAPTION_ZONE_FIELDS = /* @__PURE__ */ new Set(["x0", "y0", "x1", "y1", "severity", "seek"]);
+var FRAME_CHECK_FIELDS = /* @__PURE__ */ new Set(["severity", "seek", "tol"]);
+var LAYOUT_FIELDS = /* @__PURE__ */ new Set(["proseCoverageFloor"]);
+function parseFrameCheck(value) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true || value === "") return {};
+  if (typeof value !== "string") throw frameCheckError();
+  if (value.startsWith("-")) throw swallowedFlagUsageError("frame-check", value);
+  const fields = parseFrameCheckFields(value);
+  const severity = captionSeverity(fields.get("severity"), frameCheckError);
+  const seek = captionSeeks(fields.get("seek"), frameCheckError);
+  const tol = parseFrameCheckTolerance(fields.get("tol"));
+  return {
+    ...severity ? { severity } : {},
+    ...seek ? { seek } : {},
+    ...tol !== void 0 ? { tol } : {}
+  };
+}
+function parseFrameCheckFields(value) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const part of value.split(";")) {
+    const { key, entry } = parseCaptionField(part, frameCheckError);
+    if (!FRAME_CHECK_FIELDS.has(key) || fields.has(key)) throw frameCheckError();
+    fields.set(key, entry);
+  }
+  return fields;
+}
+function parseFrameCheckTolerance(raw) {
+  if (raw === void 0) return void 0;
+  const tol = parseNumberStrict(raw);
+  if (tol === null || tol < 0) throw frameCheckError();
+  return tol;
+}
+function frameCheckError() {
+  return new Error(
+    'Invalid --frame-check: use bare --frame-check or "severity=warning|error;seek=.25,.75;tol=4" (all fields optional)'
+  );
+}
+function parseLayout(value) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true || value === "") throw layoutError();
+  if (typeof value !== "string") throw layoutError();
+  const fields = parseLayoutFields(value);
+  const proseCoverageFloor = parseProseCoverageFloor(fields.get("proseCoverageFloor"));
+  if (proseCoverageFloor === void 0) throw layoutError();
+  return { proseCoverageFloor };
+}
+function parseLayoutFields(value) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const part of value.split(";")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) throw layoutError();
+    const key = trimmed.slice(0, separator).trim();
+    const entry = trimmed.slice(separator + 1).trim();
+    if (!LAYOUT_FIELDS.has(key) || fields.has(key)) throw layoutError();
+    fields.set(key, entry);
+  }
+  return fields;
+}
+function parseProseCoverageFloor(raw) {
+  if (raw === void 0) return void 0;
+  const floor = parseNumberStrict(raw);
+  if (floor === null || floor < 0 || floor > 1) throw layoutError();
+  return floor;
+}
+function layoutError() {
+  return new Error(
+    'Invalid --layout: use "proseCoverageFloor=0.05" with a fraction from 0 to 1 (inclusive)'
+  );
+}
+function parseNumberStrict(raw) {
+  if (raw === "") return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+function parseCaptionZone(value) {
+  if (value === void 0 || value === null) return void 0;
+  const fields = parseCaptionFields(captionZoneString(value));
+  const { x0, y0, x1, y1 } = parseCaptionBounds(fields);
+  const severity = captionSeverity(fields.get("severity"));
+  const seek = captionSeeks(fields.get("seek"));
+  return {
+    x0,
+    y0,
+    x1,
+    y1,
+    ...severity ? { severity } : {},
+    ...seek ? { seek } : {}
+  };
+}
+function captionZoneString(value) {
+  if (typeof value !== "string" || value.trim() === "") throw captionZoneError();
+  return value;
+}
+function parseCaptionFields(value) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const part of value.split(";")) {
+    const { key, entry } = parseCaptionField(part);
+    if (!CAPTION_ZONE_FIELDS.has(key) || fields.has(key)) throw captionZoneError();
+    fields.set(key, entry);
+  }
+  return fields;
+}
+function parseCaptionField(part, errorFactory = captionZoneError) {
+  const separator = part.indexOf("=");
+  if (separator <= 0) throw errorFactory();
+  return {
+    key: part.slice(0, separator).trim(),
+    entry: part.slice(separator + 1).trim()
+  };
+}
+function parseCaptionBounds(fields) {
+  const x0 = requiredCaptionFraction(fields, "x0");
+  const y0 = requiredCaptionFraction(fields, "y0");
+  const x1 = requiredCaptionFraction(fields, "x1");
+  const y1 = requiredCaptionFraction(fields, "y1");
+  if (x0 > x1 || y0 > y1) throw captionZoneError();
+  return { x0, y0, x1, y1 };
+}
+function requiredCaptionFraction(fields, key) {
+  const value = captionFraction(fields.get(key));
+  if (value === null) throw captionZoneError();
+  return value;
+}
+function captionFraction(value) {
+  if (value === void 0 || value === "") return null;
+  const parsed = parseNumberStrict(value);
+  return parsed !== null && parsed >= 0 && parsed <= 1 ? parsed : null;
+}
+function captionSeverity(value, errorFactory = captionZoneError) {
+  if (value === void 0) return void 0;
+  if (value === "error" || value === "warning") return value;
+  throw errorFactory();
+}
+function captionSeeks(value, errorFactory = captionZoneError) {
+  if (value === void 0) return void 0;
+  if (value === "") return [];
+  const values = value.split(",").map(captionFraction);
+  if (values.some((entry) => entry === null)) throw errorFactory();
+  return values.flatMap((entry) => entry === null ? [] : entry);
+}
+function captionZoneError() {
+  return new Error(
+    'Invalid --caption-zone; use "x0=0;y0=.82;x1=1;y1=1[;severity=warning|error][;seek=.5,1]" with fractions from 0 to 1.'
+  );
+}
+function positiveInteger(value, fallback) {
+  const parsed = parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function nonNegativeNumber(value, fallback) {
+  const parsed = parseFloat(String(value ?? ""));
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function printHumanReport(report) {
+  if (report.scope) {
+    console.log(
+      `Scope: ${report.scope.range ? report.scope.range.join("\u2013") + "s" : "full timeline"}; ${report.scope.hiddenFindings} findings hidden by component filter. Counts/status include hidden findings.`
+    );
+    for (const note of report.scope.notes) console.log(note);
+  }
+  printSection("Lint", report.lint);
+  if (report.browserSkipped) {
+    console.log();
+    console.log(
+      `  ${c.warn("\u26A0")} Browser session never ran \u2014 layout, motion, and contrast below are empty placeholders, not a clean pass.`
+    );
+  }
+  printSection("Runtime", report.runtime);
+  printLayoutSection("Layout", report.layout);
+  printSection("Motion", report.motion);
+  printContrastSection(report);
+  printCraftSection(report);
+  printSnapshotSection(report);
+  console.log();
+  const label = report.ok ? c.success("Check passed") : c.error("Check failed");
+  console.log(`${report.ok ? c.success("\u25C7") : c.error("\u25C7")}  ${label}`);
+}
+function isEmptySection(section2) {
+  return section2.findings.length === 0 && section2.errorCount + section2.warningCount + section2.infoCount === 0;
+}
+function printSection(title, section2) {
+  console.log();
+  console.log(c.bold(title));
+  if (isEmptySection(section2)) {
+    console.log(`  ${c.success("\u25C7")} 0 errors, 0 warnings`);
+    return;
+  }
+  for (const finding of section2.findings) printFinding(finding);
+  printCounts(section2);
+}
+function printLayoutSection(title, section2) {
+  console.log();
+  console.log(c.bold(title));
+  if (isEmptySection(section2)) {
+    console.log(`  ${c.success("\u25C7")} 0 issues across ${section2.samples.length} sample(s)`);
+  } else {
+    for (const finding of section2.findings) {
+      const formatted = formatLayoutIssue(finding).replace(/\n/g, "\n    ");
+      console.log(`  ${findingIcon(finding)} ${formatted}`);
+    }
+    printCounts(section2);
+  }
+  if (section2.transitionSamplesDropped > 0) {
+    console.log(
+      `  ${c.warn("\u26A0")} ${section2.transitionSamplesDropped} transition sample(s) omitted`
+    );
+  }
+}
+function printContrastSection(report) {
+  const section2 = report.contrast;
+  console.log();
+  console.log(c.bold("Contrast"));
+  if (!section2.enabled) {
+    console.log(`  ${c.dim("\u25C7")} skipped`);
+    return;
+  }
+  if (isEmptySection(section2)) {
+    console.log(
+      `  ${c.success("\u25C7")} ${section2.passed}/${section2.checked} text checks pass WCAG AA`
+    );
+    return;
+  }
+  for (const finding of section2.findings) {
+    console.log(
+      `  ${c.error("\u2717")} ${finding.selector} ${finding.ratio}:1 (need ${finding.requiredRatio}:1, ${formatFindingTimes(finding)})`
+    );
+    console.log(`    ${c.dim(`Try ${finding.suggestedColor}; source ${finding.sourceFile}`)}`);
+  }
+  printCounts(section2);
+}
+function printCraftSection(report) {
+  const section2 = report.craft;
+  if (!section2.enabled) {
+    console.log();
+    console.log(c.bold("Craft"));
+    console.log(`  ${c.dim("\u25C7")} skipped`);
+    return;
+  }
+  printSection("Craft", section2);
+}
+function printSnapshotSection(report) {
+  console.log();
+  console.log(c.bold("Snapshots"));
+  if (!report.snapshots.enabled) {
+    console.log(`  ${c.dim("\u25C7")} disabled`);
+  } else {
+    console.log(`  ${c.success("\u25C7")} ${report.snapshots.files.length} PNG(s) saved`);
+    for (const file of report.snapshots.files) console.log(`    ${c.dim(file)}`);
+    if (report.snapshots.findingFiles.length > 0) {
+      console.log(
+        `  ${c.success("\u25C7")} ${report.snapshots.findingFiles.length} finding crop(s) saved`
+      );
+      for (const file of report.snapshots.findingFiles) console.log(`    ${c.dim(file)}`);
+    }
+  }
+}
+function printFinding(finding) {
+  const where = `${finding.sourceFile} ${finding.selector} ${formatFindingTimes(finding)}`;
+  console.log(`  ${findingIcon(finding)} ${finding.code}: ${finding.message}`);
+  console.log(`    ${c.dim(where)}`);
+  if (finding.fixHint) console.log(`    ${c.dim(`Fix: ${finding.fixHint}`)}`);
+}
+function findingIcon(finding) {
+  if (finding.severity === "error") return c.error("\u2717");
+  if (finding.severity === "warning") return c.warn("\u26A0");
+  return c.dim("\u2139");
+}
+function printCounts(section2) {
+  console.log(
+    `  ${c.dim(`${section2.errorCount} error(s), ${section2.warningCount} warning(s), ${section2.infoCount} info(s)`)}`
+  );
+}
+var check_default = createCheckCommand();
+
+export {
+  examples,
+  createCheckCommand,
+  prelaunchBrowserForCheck,
+  parseCheckRange,
+  parseFrameCheck,
+  parseLayout,
+  check_default
+};