hyperframes 0.8.184 → 0.8.186

package/dist/{chunk-GDEV42FA.js → chunk-TH7J3JZ5.js}

@@ -11,13 +11,13 @@ import {
 } from "./chunk-57GN6KWT.js";
 import {
   captureArtifactRevision
-} from "./chunk-VDM3FEDP.js";
+} from "./chunk-DQZMJS2P.js";
 import {
   loadProducer
-} from "./chunk-BCHSTE7U.js";
+} from "./chunk-PEIV2SOG.js";
 import {
   trackLintRun
-} from "./chunk-Q33P4EAC.js";
+} from "./chunk-EZINX6HH.js";
 import {
   beginCheckSnapshots,
   checkSnapshotDirectory,
@@ -27,6 +27,7 @@ import {
 import {
   CONTENT_OVERLAP_HELD_ERROR_MS,
   DEFAULT_MAX_STATIC_SEC,
+  END_CARD_HOLD_SEC,
   assertionTargets,
   buildLayoutSampleTimes,
   buildTransitionSampleTimes,
@@ -45,27 +46,27 @@ import {
   mergeSampleTimes,
   parseAt,
   readMotionSpec
-} from "./chunk-QL2PNIXC.js";
+} from "./chunk-5ZMXGNGC.js";
 import {
   resolveProject
-} from "./chunk-LRGYPXHF.js";
+} from "./chunk-HZ7M2MZA.js";
 import {
   recordArtifacts
 } from "./chunk-U6RXZNZE.js";
 import {
   BrowserCleanupError,
   closeManagedBrowser
-} from "./chunk-KN46TGHV.js";
+} from "./chunk-UAJCTEK2.js";
 import {
   withRemainingBudget
 } from "./chunk-EHSBBBR2.js";
 import {
   resolveLocalBrowserGpuMode
-} from "./chunk-UNNXFKVG.js";
+} from "./chunk-RVZNSKRH.js";
 import {
   trackCheckReport,
   trackCommandFailure
-} from "./chunk-JIUTXKWA.js";
+} from "./chunk-77QM6YRQ.js";
 import {
   swallowedFlagUsageError
 } from "./chunk-HTIUNMTP.js";
@@ -85,17 +86,17 @@ import {
 import {
   extractMediaMetadata,
   findHdrAutoPromotion
-} from "./chunk-RGXVEYHI.js";
+} from "./chunk-7M7TMM4S.js";
 import {
   lintProject,
   shouldBlockRender
-} from "./chunk-ADDHW2FS.js";
+} from "./chunk-Q447CX26.js";
 import {
   resolveProjectRelativeSrc
 } from "./chunk-6BNTGNGD.js";
 import {
   withMeta
-} from "./chunk-ABZYYUUH.js";
+} from "./chunk-FRLTKTOR.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -109,10 +110,20 @@ import { join as join2, resolve } from "path";
 var CHECK_DEADLINE_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) {
+  constructor(sourceFile, phases = "") {
     super(
-      sourceFile === void 0 ? "Check did not finish within its deadline." : `${sourceFile}: its script did not finish within the check deadline.`
+      (sourceFile === void 0 ? "Check did not finish within its deadline" : `${sourceFile}: its script did not finish within the check deadline`) + (phases || ".")
     );
     this.sourceFile = sourceFile;
   }
@@ -129,16 +140,38 @@ var CheckDeadline = class {
   expiry;
   rejectExpiry;
   phase = "waiting";
+  work;
+  spent = /* @__PURE__ */ new Map();
   constructor() {
     this.expiry = new Promise((_, reject) => {
       this.rejectExpiry = reject;
     });
   }
+  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);
+  };
+  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 ` (${CHECK_DEADLINE_MS / 1e3} s from when 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");
     this.timer = setTimeout(() => {
-      this.expired = new CheckDeadlineError(this.scripts.at(-1));
+      this.expired = new CheckDeadlineError(this.scripts.at(-1), this.describe());
       this.rejectExpiry(this.expired);
       this.abort.abort(this.expired);
     }, CHECK_DEADLINE_MS);
@@ -201,9 +234,378 @@ 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-Q3N6QXMT.js");
+  const { bundleToSingleHtml } = await import("./compiler-2EKSMC3I.js");
   return bundleToSingleHtml(projectDir);
 }
 async function collectBundledRenderMedia(html) {
@@ -279,7 +681,7 @@ function parseColorRGBA(color) {
 // src/utils/checkPipeline.ts
 var MOTION_FPS = 20;
 var MOTION_MAX_SAMPLES = 300;
-var ZERO_BBOX = { x: 0, y: 0, width: 0, height: 0 };
+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 = {
@@ -518,7 +920,8 @@ function emptyGridSamples() {
     contrastMs: 0,
     layoutStateSignatures: [],
     rotationSamples: [],
-    indicatorFrames: []
+    indicatorFrames: [],
+    craftFrames: []
   };
 }
 function appendGridSamples(into, from) {
@@ -530,6 +933,7 @@ function appendGridSamples(into, from) {
   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();
@@ -561,7 +965,7 @@ async function collectSampleAt(driver, options, grid, motion, sets, time) {
     await collectContrastAt(driver, options, time, issuesAtTime, collected);
   return collected;
 }
-async function collectGridSamples(driver, options, grid, motion, helpers) {
+async function collectGridSamples(driver, options, grid, motion, helpers, enter) {
   const geometryEnabled = grid.captionSamples.length > 0 || grid.frameSamples.length > 0;
   const sets = {
     layout: new Set(grid.layoutSamples),
@@ -605,9 +1009,20 @@ async function collectGridSamples(driver, options, grid, motion, helpers) {
   driver.markSamples?.("end");
   const collected = emptyGridSamples();
   for (const samples of perTime) appendGridSamples(collected, samples);
-  await collectMotionOverlapSamples(driver, grid, collected, options.range);
+  enter("overlap");
+  await collectMotionOverlapSamples(
+    driver,
+    grid,
+    collected,
+    options.range,
+    craftEnabled(driver, options)
+  );
+  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);
@@ -683,9 +1098,16 @@ async function denseOverlapTimes(driver, grid, range) {
   const overlapTimes = buildOverlapSampleTimes(range ? range[1] - range[0] : grid.duration, edges);
   return range ? mergeSampleTimes(overlapTimes.map((time) => time + range[0])) : overlapTimes;
 }
-async function collectMotionOverlapSamples(driver, grid, collected, range) {
+async function collectMotionOverlapSamples(driver, grid, collected, range, craft) {
   const baseTimes = new Set(grid.layoutSamples);
   const shiftedTimes = await denseOverlapTimes(driver, grid, range);
+  if (craft) {
+    for (const time of buildCraftSampleTimes(grid.duration)) {
+      if (time >= grid.duration) continue;
+      await driver.seekGeometry(time);
+      collected.craftFrames.push(...await collectCraftFrame(driver, time));
+    }
+  }
   const probeHold = holdProber(driver, collected, range ? range[1] : grid.duration);
   const gridIssues = await driver.collectOverlapGrid(shiftedTimes.filter((t) => !baseTimes.has(t)));
   let sample = 0;
@@ -696,6 +1118,22 @@ async function collectMotionOverlapSamples(driver, grid, collected, range) {
     await probeHold(time, shiftedTimes[index + 1] ?? Number.POSITIVE_INFINITY, issues);
   }
 }
+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,
@@ -797,7 +1235,7 @@ function sweepStaticIssue(kind) {
     selector: "[data-composition-id]",
     dataAttributes: {},
     sourceFile: "index.html",
-    bbox: ZERO_BBOX,
+    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
@@ -1131,7 +1569,17 @@ function detectOffPivotRotation(frames) {
 function annotationBoxesFrom(issues) {
   return issues.filter((issue) => issue.severity === "error" && issue.bbox.width > 0 && issue.bbox.height > 0).map((issue, index) => ({ label: `${index + 1} ${issue.code}`, bbox: issue.bbox }));
 }
-async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([])) {
+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 = () => {
+}) {
+  enter("samples");
   await driver.initialize(options.contrast);
   const grid = await buildSampleGrid(driver, options);
   const plan = await planMotionSampling(
@@ -1140,28 +1588,24 @@ async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([
     grid.duration
   );
   const seekLoopStart = Date.now();
-  const collected = await collectGridSamples(driver, options, grid, plan, helpers);
+  const collected = await collectGridSamples(driver, options, grid, plan, helpers, enter);
   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);
+    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);
+      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,
-    await driver.hasNoTimelineDeclaration()
-  );
+  const sweepVerdict = options.range ? [] : detectSweepStatic(grid.duration, sweepSamples, motionIssues, noTimeline);
   const sweepFindings = sweepVerdict.length > 0 && await framesMoved(
     driver,
     sweepSamples.map((sample) => sample.time)
@@ -1172,6 +1616,20 @@ async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([
   );
   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");
@@ -1181,7 +1639,8 @@ async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([
       ...rotationFindings,
       ...offPivotFindings,
       ...motionIssues,
-      ...contrast.findings
+      ...contrast.findings,
+      ...craft.findings
     ];
     const matches = await driver.matchComponents(options.components, findings);
     findings.forEach((finding, i) => {
@@ -1206,6 +1665,7 @@ async function runAuditGrid(driver, options, motion, helpers = Promise.resolve([
     contrastFindings: contrast.findings,
     contrastChecked: collected.contrastEntries.length,
     contrastPassed: contrast.passed,
+    craft,
     screenshots: collected.screenshots,
     timings: { launchSettleMs: 0, seekLoopMs, contrastMs: collected.contrastMs },
     skipped: false
@@ -1332,6 +1792,7 @@ 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)
     );
@@ -1443,7 +1904,7 @@ function buildLintSection(result) {
       selector: finding.selector ?? (finding.elementId ? `#${finding.elementId}` : "[data-composition-id]"),
       dataAttributes: {},
       sourceFile: finding.file ?? file,
-      bbox: ZERO_BBOX,
+      bbox: ZERO_BBOX2,
       time: 0,
       fixHint: finding.fixHint
     }))
@@ -1458,10 +1919,12 @@ function buildReport(options, lint, browser, motion, extraMotionFindings, snapsh
   const runtime = section(browser.runtimeFindings);
   const motionSection = section(motionFindings);
   const contrastSection = section(browser.contrastFindings);
-  const warningCount = lint.warningCount + runtime.warningCount + layout.warningCount + motionSection.warningCount + contrastSection.warningCount;
-  const errorCount = lint.errorCount + runtime.errorCount + layout.errorCount + motionSection.errorCount + contrastSection.errorCount;
+  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 || warningCount === 0),
+    ok: errorCount === 0 && (!options.strict || strictWarningCount === 0),
     strict: options.strict,
     browserSkipped: browser.skipped,
     lint,
@@ -1480,6 +1943,12 @@ function buildReport(options, lint, browser, motion, extraMotionFindings, snapsh
       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,
@@ -1504,6 +1973,7 @@ function buildReport(options, lint, browser, motion, extraMotionFindings, snapsh
     motionWarnings: motionSection.warningCount,
     contrastErrors: contrastSection.errorCount,
     contrastWarnings: contrastSection.warningCount,
+    craftWarnings: craftSection.warningCount,
     launchSettleMs: browser.timings.launchSettleMs,
     seekLoopMs: browser.timings.seekLoopMs,
     contrastMs: browser.timings.contrastMs,
@@ -1525,11 +1995,11 @@ function filterComponentReport(report, options) {
       notes: [
         "Static lint and unscoped runtime failures remain project-wide.",
         ...options.range ? [
-          "Whole-timeline motion assertions and frozen-sweep detection are skipped for range checks."
+          "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]) {
+    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;
@@ -1612,6 +2082,7 @@ function emptyBrowserResult() {
     contrastFindings: [],
     contrastChecked: 0,
     contrastPassed: 0,
+    craft: disabledCraft(),
     screenshots: [],
     timings: { launchSettleMs: 0, seekLoopMs: 0, contrastMs: 0 },
     skipped: true
@@ -1633,7 +2104,7 @@ function findingAtRoot(code, severity, message, sourceFile) {
     selector: "[data-composition-id]",
     dataAttributes: {},
     sourceFile,
-    bbox: ZERO_BBOX,
+    bbox: ZERO_BBOX2,
     time: 0
   };
 }
@@ -1662,7 +2133,7 @@ function resolveMotionSpec(projectDir) {
   };
 }
 async function runBrowserCheck(project, options, motion, deadline, prelaunched) {
-  const module = await import("./checkBrowser-FNINXBMZ.js");
+  const module = await import("./checkBrowser-X7G6YNR7.js");
   return module.runBrowserCheck(project, options, motion, runAuditGrid, deadline, prelaunched);
 }
 var adoptedBrowser;
@@ -1676,7 +2147,7 @@ async function prelaunchBrowser(project, options) {
   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-4236FVWJ.js");
+  const { prelaunchCompositionBrowser } = await import("./captureCompositionFrame-5FVLAETA.js");
   return prelaunchCompositionBrowser(html, options.browserGpuMode);
 }
 async function writeSnapshot(projectDir, index, time, pngBase64) {
@@ -1688,7 +2159,7 @@ async function writeSnapshot(projectDir, index, time, pngBase64) {
   return relative(projectDir, path);
 }
 async function captureFindingCrops(project, options, requests, deadline) {
-  const module = await import("./checkBrowser-FNINXBMZ.js");
+  const module = await import("./checkBrowser-X7G6YNR7.js");
   return module.captureFindingCrops(project, options, requests, deadline);
 }
 var DEFAULT_DEPENDENCIES2 = {
@@ -2134,6 +2605,7 @@ function printHumanReport(report) {
   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");
@@ -2192,6 +2664,16 @@ function printContrastSection(report) {
   }
   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"));