kasaframe 0.0.0-stage → 0.1.3

package/packages/check/src/rules/camera.ts

@@ -0,0 +1,217 @@
+import type { Box, Finding, FrameText, MotionEvent, SafeArea } from "../types.ts";
+import type { SceneSpan } from "./layout.ts";
+
+// 화면 전체를 이유 없이 흔들면(사인 드리프트·박마다 자세·늘 다가가는 카메라) 주인공이 기울고 가장자리로 밀린다.
+// 픽셀만 봐서는 「화면 안 움직임」과 「카메라가 움직여 생긴 변화」가 안 갈린다 — 그래서 페이지에서 카메라 층의 transform 을 직접 잰다.
+
+export interface CamLayer {
+  key: string;
+  scene: string | null;
+  sel: string;
+  a: number;
+  b: number;
+  e: number;
+  f: number;
+  flat: boolean;
+}
+
+export interface CamSample {
+  t: number;
+  layers: CamLayer[];
+  heroes: { scene: string | null; sel: string; box: Box }[];
+}
+
+const r1 = (x: number) => Math.round(x * 10) / 10;
+
+function sceneOf(t: number, scenes: SceneSpan[]): string | undefined {
+  let hit: string | undefined;
+  for (const s of scenes) if (s.from <= t + 1e-3) hit = s.id;
+  return hit;
+}
+
+export interface WanderOptions {
+  fps: number;
+  // 이음매처럼 화면 전체가 움직이는 게 일인 장면
+  skipScenes?: string[];
+  // 이보다 짧게 이어진 이동은 등장 움직임으로 본다
+  minRunSec?: number;
+  // 장면 안에서 이유 없이 움직인 시간을 다 합쳐 이만큼 넘으면 경고
+  warnSec?: number;
+}
+
+// 이웃 표본 사이에 카메라 층이 움직였는데 그 시각에 카메라 이벤트(__kf.events 의 camera·shake)가 없으면 「이유 없는 이동」이다
+export function cameraWander(samples: CamSample[], events: MotionEvent[], o: WanderOptions): Finding[] {
+  const minRun = o.minRunSec ?? 0.3;
+  const warnSec = o.warnSec ?? 0.8;
+  const skip = new Set(o.skipScenes ?? []);
+  const reasons = events.filter((e) => e.kind === "camera" || e.kind === "shake");
+  const pad = 1.5 / o.fps;
+  const excused = (scene: string | null, a: number, b: number) => reasons.some((e) => (!e.scene || !scene || e.scene === scene) && e.t >= a - pad && e.t <= b + pad);
+
+  const tracks = new Map<string, { t: number; l: CamLayer }[]>();
+  for (const s of samples) for (const l of s.layers) (tracks.get(l.key) ?? tracks.set(l.key, []).get(l.key)!).push({ t: s.t, l });
+  const step = samples.length > 1 ? Math.min(...samples.slice(1).map((s, i) => s.t - samples[i].t).filter((d) => d > 0)) : 1 / 30;
+
+  interface Acc {
+    runs: { from: number; to: number }[];
+    shift: number;
+    rot: number;
+    sel: Set<string>;
+    tilt: boolean;
+  }
+  const byScene = new Map<string, Acc>();
+  for (const track of tracks.values()) {
+    track.sort((x, y) => x.t - y.t);
+    let run: { from: number; to: number } | null = null;
+    const scene = track[0].l.scene ?? "";
+    if (skip.has(scene)) continue;
+    const acc = byScene.get(scene) ?? { runs: [], shift: 0, rot: 0, sel: new Set<string>(), tilt: false };
+    const close = () => {
+      if (run && run.to - run.from >= minRun - 1e-6) acc.runs.push(run);
+      run = null;
+    };
+    for (let i = 1; i < track.length; i++) {
+      const p = track[i - 1];
+      const q = track[i];
+      if (q.t - p.t > step * 2.5) {
+        close();
+        continue;
+      }
+      const sp = Math.hypot(p.l.a, p.l.b);
+      const sq = Math.hypot(q.l.a, q.l.b);
+      const rp = (Math.atan2(p.l.b, p.l.a) * 180) / Math.PI;
+      const rq = (Math.atan2(q.l.b, q.l.a) * 180) / Math.PI;
+      const moved = Math.abs(q.l.e - p.l.e) > 0.5 || Math.abs(q.l.f - p.l.f) > 0.5 || Math.abs(sq - sp) / (sp || 1) > 0.001 || Math.abs(rq - rp) > 0.02 || p.l.flat !== q.l.flat;
+      if (!moved || excused(q.l.scene, p.t, q.t)) {
+        close();
+        continue;
+      }
+      if (run) run.to = q.t;
+      else run = { from: p.t, to: q.t };
+      acc.shift = Math.max(acc.shift, Math.hypot(q.l.e - track[0].l.e, q.l.f - track[0].l.f));
+      acc.rot = Math.max(acc.rot, Math.abs(rq));
+      acc.tilt ||= !q.l.flat;
+      acc.sel.add(q.l.sel);
+    }
+    close();
+    byScene.set(scene, acc);
+  }
+
+  const out: Finding[] = [];
+  for (const [scene, acc] of byScene) {
+    const total = acc.runs.reduce((a, r) => a + (r.to - r.from), 0);
+    if (total < warnSec - 1e-6) continue;
+    const longest = Math.max(...acc.runs.map((r) => r.to - r.from));
+    const turn = acc.rot > 0.05 || acc.tilt ? ` · 기울기 ${acc.tilt ? "원근(3D)" : `${r1(acc.rot)}°`}` : "";
+    out.push({
+      rule: "camera.wander",
+      severity: "warn",
+      from: Math.min(...acc.runs.map((r) => r.from)),
+      to: Math.max(...acc.runs.map((r) => r.to)),
+      message: `장면 ${scene || "?"} 의 카메라 층이 이유 없이 ${total.toFixed(1)}초 움직인다(가장 길게 ${longest.toFixed(1)}초, 최대 ${Math.round(acc.shift)}px${turn}) — 카메라는 가만히 두고, 드러냄·비교·따라가기·충격 때만 stage.camera(pushIn·pullOut·follow·impact)로. 쉬지 않는 몫은 화면 안 움직임에`,
+      detail: { scene, seconds: r1(total), longest: r1(longest), maxShiftPx: Math.round(acc.shift), maxRotateDeg: r1(acc.rot), tilt3d: acc.tilt, layers: [...acc.sel].slice(0, 3), runs: acc.runs.slice(0, 8).map((r) => [r1(r.from), r1(r.to)]) },
+    });
+  }
+  return out.sort((a, b) => a.from - b.from);
+}
+
+export interface EdgeOptions {
+  width: number;
+  height: number;
+  fps: number;
+  safe?: SafeArea;
+  // 안전 영역 가장자리에서 이 몫 안쪽 띠
+  band?: number;
+  minSec?: number;
+  skipScenes?: string[];
+  // 장면이 주인공을 짚지 않았을 때 「가장 큰 글」로 칠 최소 글자 크기(1080 기준 px)
+  heroPx?: number;
+}
+
+// 주인공 상자가 안전 영역 가장자리 4% 띠 안으로 들어가거나 넘어간 채 0.5초 넘게 — 카메라가 밀었거나 처음부터 구석에 놓였다.
+// 장면이 짚은 주인공(data-kf-hero)은 늘 본다. 짚지 않아 「가장 큰 글」로 어림할 때는 그 장면 카메라 층이 처음 자리(배율 1·이동 0)를
+// 벗어난 프레임만 센다 — HUD 구석 숫자·지면 밖으로 넘치는 큰 글처럼 일부러 가장자리에 둔 판을 카메라 탓으로 잡지 않게
+export function heroEdge(samples: CamSample[], texts: FrameText[], scenes: SceneSpan[], o: EdgeOptions): Finding[] {
+  const sa = o.safe ?? { top: 0, bottom: 0, left: 0, right: 0 };
+  const band = o.band ?? 0.04;
+  const minSec = o.minSec ?? 0.5;
+  const sw = o.width - sa.left - sa.right;
+  const sh = o.height - sa.top - sa.bottom;
+  const inner = { x0: sa.left + sw * band, y0: sa.top + sh * band, x1: o.width - sa.right - sw * band, y1: o.height - sa.bottom - sh * band };
+  const heroPx = (o.heroPx ?? 72) * (Math.min(o.width, o.height) / 1080);
+  const skip = new Set(o.skipScenes ?? []);
+
+  // 프레임마다 주인공 상자 — 짚은 것이 있으면 그것, 없으면 가장 큰 글(자막 판은 빼고)
+  const marked = new Map<number, { sel: string; box: Box }[]>();
+  for (const s of samples) if (s.heroes.length) marked.set(Math.round(s.t * o.fps), s.heroes);
+  const away = (l: CamLayer) => Math.abs(Math.hypot(l.a, l.b) - 1) > 0.002 || Math.abs(l.b) > 0.0005 || Math.abs(l.e) > 1 || Math.abs(l.f) > 1 || !l.flat;
+  const moved = samples.map((s) => ({ t: s.t, scenes: new Set(s.layers.filter(away).map((l) => l.scene ?? "")) }));
+  let mi = 0;
+  const camAway = (t: number, scene: string) => {
+    while (mi + 1 < moved.length && Math.abs(moved[mi + 1].t - t) <= Math.abs(moved[mi].t - t)) mi++;
+    const m = moved[mi];
+    return !!m && Math.abs(m.t - t) <= 2.5 / o.fps && m.scenes.has(scene);
+  };
+  const frames: { t: number; what: string; box: Box }[] = [];
+  const seen = new Set<number>();
+  for (const f of texts) {
+    const k = Math.round(f.t * o.fps);
+    seen.add(k);
+    const hs = marked.get(k);
+    if (hs) {
+      for (const h of hs) frames.push({ t: f.t, what: h.sel, box: h.box });
+      continue;
+    }
+    let best: FrameText["hits"][number] | undefined;
+    for (const h of f.hits) {
+      if (!h.box || h.via === "caption" || h.alpha < 0.6 || h.sizePx < heroPx || !/[\p{L}\p{N}]/u.test(h.text)) continue;
+      if (!best || h.sizePx > best.sizePx) best = h;
+    }
+    if (best?.box && camAway(f.t, sceneOf(f.t, scenes) ?? "")) frames.push({ t: f.t, what: `「${best.text.slice(0, 24)}」`, box: best.box });
+  }
+  for (const [k, hs] of marked) if (!seen.has(k)) for (const h of hs) frames.push({ t: k / o.fps, what: h.sel, box: h.box });
+  frames.sort((a, b) => a.t - b.t);
+
+  const sides = (b: Box) => [b.x0 < inner.x0 && "왼쪽", b.x1 > inner.x1 && "오른쪽", b.y0 < inner.y0 && "위", b.y1 > inner.y1 && "아래"].filter(Boolean) as string[];
+  const byScene = new Map<string, { runs: { from: number; to: number }[]; what: Set<string>; side: Set<string>; worst: number }>();
+  let run: { from: number; to: number; scene: string } | null = null;
+  const close = () => {
+    if (run && run.to - run.from >= minSec - 1e-6) byScene.get(run.scene)!.runs.push({ from: run.from, to: run.to });
+    run = null;
+  };
+  const at = new Map<number, typeof frames>();
+  for (const f of frames) (at.get(f.t) ?? at.set(f.t, []).get(f.t)!).push(f);
+  for (const [t, fs] of [...at].sort((a, b) => a[0] - b[0])) {
+    const scene = sceneOf(t, scenes) ?? "";
+    const hit = skip.has(scene) ? [] : fs.map((f) => ({ f, s: sides(f.box) })).filter((x) => x.s.length);
+    if (!hit.length) {
+      close();
+      continue;
+    }
+    const acc = byScene.get(scene) ?? byScene.set(scene, { runs: [], what: new Set(), side: new Set(), worst: 0 }).get(scene)!;
+    for (const { f, s } of hit) {
+      acc.what.add(f.what);
+      s.forEach((x) => acc.side.add(x));
+      acc.worst = Math.max(acc.worst, inner.x0 - f.box.x0, f.box.x1 - inner.x1, inner.y0 - f.box.y0, f.box.y1 - inner.y1);
+    }
+    if (run && (run.scene !== scene || t - run.to > 2.5 / o.fps)) close();
+    if (run) run.to = t;
+    else run = { from: t, to: t, scene };
+  }
+  close();
+
+  const out: Finding[] = [];
+  for (const [scene, acc] of byScene) {
+    if (!acc.runs.length) continue;
+    const total = acc.runs.reduce((a, r) => a + (r.to - r.from), 0);
+    out.push({
+      rule: "layout.edge",
+      severity: "warn",
+      from: acc.runs[0].from,
+      to: acc.runs[acc.runs.length - 1].to,
+      message: `장면 ${scene || "?"} 의 주인공 ${[...acc.what].slice(0, 2).join(" · ")} 이 안전 영역 ${[...acc.side].join("·")} 가장자리 ${Math.round(band * 100)}% 띠에 ${total.toFixed(1)}초 붙어 있다(가장 깊이 ${Math.round(acc.worst)}px) — 주인공은 안전 영역 가운데에. 카메라가 밀었으면 그 이동을 걷는다`,
+      detail: { scene, seconds: r1(total), sides: [...acc.side], worstPx: Math.round(acc.worst), heroes: [...acc.what].slice(0, 3), runs: acc.runs.slice(0, 8).map((r) => [r1(r.from), r1(r.to)]) },
+    });
+  }
+  return out.sort((a, b) => a.from - b.from);
+}

package/packages/check/src/rules/captions.ts

@@ -0,0 +1,49 @@
+import type { Box, Finding, FrameText } from "../types.ts";
+import { runs } from "./runs.ts";
+import { assembleLines, roundBox } from "./text.ts";
+
+// 화면 자막 판(엔진이 장면 위에 얹은 data-kf-captions)이 장면 글을 덮는 곳. 엔진이 장면을 자막 띠 위로 올리지만,
+// 장면이 일부러 띠 자리까지 내려오게 짰거나(안전 영역 밖 배치) 띠보다 큰 움직임이면 여전히 겹친다
+export function captionOverlap(frames: FrameText[], o: { fps: number; minSec?: number }): Finding[] {
+  const minSec = o.minSec ?? 0.3;
+  const seen = new Map<string, { times: number[]; box: Box; caption: string }>();
+  for (const f of frames) {
+    const lines = assembleLines(f.hits).filter((l) => l.box && l.alpha > 0.3);
+    const caps = lines.filter((l) => l.hits[0]?.via === "caption");
+    if (!caps.length) continue;
+    // 글 상자에 판의 안쪽 여백(글자 크기의 절반·⅓)을 더하면 판 자리다
+    const size = Math.max(...caps.map((l) => l.sizePx));
+    const plate: Box = {
+      x0: Math.min(...caps.map((l) => l.box!.x0)) - size * 0.5,
+      y0: Math.min(...caps.map((l) => l.box!.y0)) - size * 0.3,
+      x1: Math.max(...caps.map((l) => l.box!.x1)) + size * 0.5,
+      y1: Math.max(...caps.map((l) => l.box!.y1)) + size * 0.3,
+    };
+    const caption = caps.map((l) => l.text).join(" ");
+    for (const l of lines) {
+      if (l.hits[0]?.via === "caption" || !/[\p{L}\p{N}]/u.test(l.text)) continue;
+      const b = l.box!;
+      const w = Math.min(b.x1, plate.x1) - Math.max(b.x0, plate.x0);
+      const h = Math.min(b.y1, plate.y1) - Math.max(b.y0, plate.y0);
+      if (w <= 2 || h <= 2) continue;
+      let s = seen.get(l.text);
+      if (!s) seen.set(l.text, (s = { times: [], box: b, caption }));
+      s.times.push(f.t);
+    }
+  }
+  const out: Finding[] = [];
+  for (const [text, s] of seen) {
+    for (const r of runs(s.times, 1.5 / o.fps)) {
+      if (r.to - r.from + 1 / o.fps < minSec) continue;
+      out.push({
+        rule: "caption.overlap",
+        severity: "warn",
+        from: r.from,
+        to: r.to + 1 / o.fps,
+        message: `자막 판이 장면 글 "${text.slice(0, 40)}" 을 덮는다 — 그 글을 안전 영역(ctx.safe) 안 위쪽으로 옮긴다. 자막 띠 자리(안전 영역 아래쪽)는 비워 둔다`,
+        detail: { text: text.slice(0, 120), box: roundBox(s.box), caption: s.caption.slice(0, 120) },
+      });
+    }
+  }
+  return out;
+}

package/packages/check/src/rules/flash.ts

@@ -0,0 +1,235 @@
+import { FLASH_GRID, type Thumb } from "../image.ts";
+import type { Finding } from "../types.ts";
+
+// 빛에 민감한 사람을 위한 섬광 안전(ITU-R BT.1702·WCAG 2.3.1 취지). 박마다 번쩍이는 드롭·컷 연출이 흔해 기계로 센다.
+// 섬광 1회 = 화면 25% 넘는 영역의 평균 상대휘도가 10%p 넘게 올랐다가(또는 내렸다가) 되돌아오는 한 쌍(어두운 쪽이 0.8 아래일 때).
+
+export interface FlashOptions {
+  // 아무 1초 창에 이보다 많으면 오류(style.json motion.maxFlashPerSec, 기본 3)
+  maxPerSec?: number;
+  // 장면 경계·드롭처럼 일부러 끊는 시각 — 컷 휘도 차 판정에 쓴다
+  cuts?: number[];
+}
+
+const G = FLASH_GRID;
+const AREA = 0.25;
+const SWING = 0.1;
+
+// 감마 밝기(0..255) → 상대휘도 근사(0..1). 썸네일은 회색조라 채널별 선형화 대신 밝기 하나로 어림한다
+const lin = new Float32Array(256).map((_, v) => {
+  const c = v / 255;
+  return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+});
+
+function tiles(t: Thumb): Float32Array {
+  const w = 160;
+  const h = Math.round(t.luma.length / w);
+  const sum = new Float32Array(G * G);
+  const cnt = new Float32Array(G * G);
+  for (let y = 0; y < h; y++) {
+    const r = Math.min(G - 1, Math.floor((y * G) / h));
+    for (let x = 0; x < w; x++) {
+      const k = r * G + Math.min(G - 1, Math.floor((x * G) / w));
+      sum[k] += lin[t.luma[y * w + x]];
+      cnt[k]++;
+    }
+  }
+  for (let k = 0; k < sum.length; k++) sum[k] /= cnt[k] || 1;
+  return sum;
+}
+
+interface Turn {
+  t: number;
+  sign: 1 | -1;
+}
+
+// 칸 하나의 시계열에서 오르내림 — 지난 꺾임 뒤의 가장 낮은(높은) 값에서 swing 넘게 반대로 가면 한 번 꺾인 것
+function turns(series: number[], times: number[], swing: number, dark: (lo: number) => boolean): Turn[] {
+  const out: Turn[] = [];
+  let lo = series[0];
+  let hi = series[0];
+  let state = 0;
+  for (let i = 1; i < series.length; i++) {
+    const v = series[i];
+    if (state !== 1 && v - lo >= swing && dark(lo)) {
+      out.push({ t: times[i], sign: 1 });
+      state = 1;
+      hi = v;
+      continue;
+    }
+    if (state !== -1 && hi - v >= swing && dark(v)) {
+      out.push({ t: times[i], sign: -1 });
+      state = -1;
+      lo = v;
+      continue;
+    }
+    if (state >= 0) hi = Math.max(hi, v);
+    if (state <= 0) lo = Math.min(lo, v);
+  }
+  return out;
+}
+
+// 칸마다 꺾인 시각을 모아, 같은 쪽으로 동시에(이웃 두 표본 안) 꺾인 칸이 화면 25% 를 넘으면 화면 전체가 한 번 꺾인 것
+function frameTurns(perTile: Turn[][], step: number): Turn[] {
+  const all = perTile.flatMap((ts, k) => ts.map((x) => ({ ...x, k }))).sort((a, b) => a.t - b.t);
+  const out: Turn[] = [];
+  const need = Math.ceil(AREA * G * G);
+  for (let i = 0; i < all.length; i++) {
+    const a = all[i];
+    if (out.length && out[out.length - 1].sign === a.sign && a.t - out[out.length - 1].t <= step * 2.5) continue;
+    const tiles = new Set<number>();
+    for (let j = i; j < all.length && all[j].t - a.t <= step * 2.5; j++) if (all[j].sign === a.sign) tiles.add(all[j].k);
+    if (tiles.size >= need) out.push({ t: a.t, sign: a.sign });
+  }
+  return out;
+}
+
+// 반대로 꺾인 이웃 둘 = 섬광 1회 — 아무 1초 창 안의 꺾임 n 번이면 섬광 ⌊n/2⌋ 번. max 를 넘는 구간을 묶어 돌려준다
+function overLimit(ts: Turn[], max: number): { from: number; to: number; count: number }[] {
+  const out: { from: number; to: number; count: number }[] = [];
+  for (let i = 0; i < ts.length; i++) {
+    let j = i;
+    while (j + 1 < ts.length && ts[j + 1].t - ts[i].t < 1) j++;
+    const count = Math.floor((j - i + 1) / 2);
+    if (count <= max) continue;
+    const last = out[out.length - 1];
+    if (last && ts[i].t <= last.to) {
+      last.to = Math.max(last.to, ts[j].t);
+      last.count = Math.max(last.count, count);
+    } else out.push({ from: ts[i].t, to: ts[j].t, count });
+  }
+  return out;
+}
+
+export function flashes(thumbs: Thumb[], o: FlashOptions = {}): Finding[] {
+  if (thumbs.length < 3) return [];
+  const max = o.maxPerSec ?? 3;
+  const step = thumbs[1].t - thumbs[0].t;
+  const times = thumbs.map((t) => t.t);
+  const lum = thumbs.map(tiles);
+  const out: Finding[] = [];
+  const r2 = (x: number) => Math.round(x * 100) / 100;
+
+  // 1) 휘도 섬광 — 어두운 쪽이 0.8 아래인 오르내림만
+  const lt = Array.from({ length: G * G }, (_, k) =>
+    turns(
+      lum.map((l) => l[k]),
+      times,
+      SWING,
+      (lo) => lo < 0.8,
+    ),
+  );
+  for (const r of overLimit(frameTurns(lt, step), max)) {
+    out.push({
+      rule: "frame.flash",
+      severity: "error",
+      from: r.from,
+      to: r.to,
+      message: `화면 25% 넘는 영역이 1초에 ${r.count}번 번쩍인다 — ${max}번까지(빛에 민감한 사람이 발작할 수 있다). 박마다 섬광이면 두 박·한 마디에 한 번으로, 섬광은 2마디 안에서 끝낸다`,
+      detail: { flashesPerSec: r.count, max },
+    });
+  }
+
+  // 2) 채도 높은 빨강 깜빡임 — 화면 25% 넘게 빨강이 켜졌다 꺼지기를 1초에 두 번 넘게
+  if (thumbs.every((t) => t.red)) {
+    const rt = Array.from({ length: G * G }, (_, k) =>
+      turns(
+        thumbs.map((t) => t.red![k]),
+        times,
+        0.5,
+        () => true,
+      ),
+    );
+    for (const r of overLimit(frameTurns(rt, step), 1)) {
+      out.push({
+        rule: "frame.flash-red",
+        severity: "error",
+        from: r.from,
+        to: r.to,
+        message: `채도 높은 빨강이 화면 25% 넘게 1초에 ${r.count}번 깜빡인다 — 빨강 전체 깜빡임은 쓰지 않는다. 빨강은 화면 10% 아래 작은 요소로`,
+        detail: { flashesPerSec: r.count },
+      });
+    }
+  }
+
+  // 3) 빠른 줄무늬·나선 — 센 가장자리가 빽빽하고 대비가 큰 칸이 다음 표본에서 크게 바뀐다. 화면 25% 넘게 0.3초 넘으면 경고
+  const hot = thumbs.map((t, i) => (i ? stripeShare(thumbs[i - 1], t) : 0));
+  let start = -1;
+  for (let i = 0; i <= hot.length; i++) {
+    const on = i < hot.length && hot[i] > AREA;
+    if (on && start < 0) start = i;
+    if (!on && start >= 0) {
+      const from = times[start];
+      const to = times[i - 1];
+      if (to - from >= 0.3 - 1e-6) {
+        out.push({
+          rule: "frame.flash-pattern",
+          severity: "warn",
+          from,
+          to,
+          message: `대비 큰 줄무늬·나선이 빠르게 움직이며 화면 ${Math.round(Math.max(...hot.slice(start, i)) * 100)}% 를 덮는다(${(to - from).toFixed(1)}초) — 25% 아래로 줄이거나 느리게`,
+          detail: { seconds: r2(to - from) },
+        });
+      }
+      start = -1;
+    }
+  }
+
+  // 4) 컷 휘도 차 — 이어지는 컷 앞뒤 화면 평균 상대휘도가 50%p 넘게 뛰면 경고(어둠 ↔ 흰 화면을 박마다 오가는 컷)
+  const mean = lum.map((l) => l.reduce((a, b) => a + b, 0) / l.length);
+  const near = (t: number) => times.findIndex((x) => x >= t - 1e-3);
+  const seen = new Set<number>();
+  for (const c of o.cuts ?? []) {
+    const i = near(c);
+    if (i <= 0 || i >= thumbs.length || seen.has(i)) continue;
+    seen.add(i);
+    const jump = Math.abs(mean[i] - mean[i - 1]);
+    if (jump <= 0.5) continue;
+    out.push({
+      rule: "frame.flash-cut",
+      severity: "warn",
+      from: times[i],
+      to: times[i],
+      message: `${times[i].toFixed(2)}초 컷 앞뒤 화면 밝기(상대휘도)가 ${Math.round(jump * 100)}%p 뛴다 — 50% 아래로(어둠과 흰 화면을 이어 붙이지 않는다)`,
+      detail: { jump: r2(jump), before: r2(mean[i - 1]), after: r2(mean[i]) },
+    });
+  }
+  return out;
+}
+
+// 칸마다: 센 가장자리 몫 ≥ 0.3 이고 밝기 표준편차 ≥ 50(대비 큰 줄무늬) 이면서 앞 표본과 평균 절대차 ≥ 25(빠르게 움직임) — 그런 칸의 화면 몫
+function stripeShare(a: Thumb, b: Thumb): number {
+  const w = 160;
+  const h = Math.round(b.luma.length / w);
+  if (a.luma.length !== b.luma.length) return 0;
+  let n = 0;
+  for (let ty = 0; ty < G; ty++) {
+    for (let tx = 0; tx < G; tx++) {
+      const y0 = Math.floor((ty * h) / G);
+      const y1 = Math.floor(((ty + 1) * h) / G);
+      const x0 = Math.floor((tx * w) / G);
+      const x1 = Math.floor(((tx + 1) * w) / G);
+      let edges = 0;
+      let px = 0;
+      let s = 0;
+      let s2 = 0;
+      let d = 0;
+      for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+          const i = y * w + x;
+          const v = b.luma[i];
+          px++;
+          s += v;
+          s2 += v * v;
+          d += Math.abs(v - a.luma[i]);
+          if (x + 1 < x1 && y + 1 < y1 && Math.abs(v - b.luma[i + 1]) + Math.abs(v - b.luma[i + w]) > 48) edges++;
+        }
+      }
+      if (!px) continue;
+      const m = s / px;
+      const std = Math.sqrt(Math.max(0, s2 / px - m * m));
+      if (edges / px >= 0.3 && std >= 50 && d / px >= 25) n++;
+    }
+  }
+  return n / (G * G);
+}

package/packages/check/src/rules/frames.ts

@@ -0,0 +1,136 @@
+import { meanAbsDiff, type Thumb } from "../image.ts";
+import type { Finding } from "../types.ts";
+
+export interface FreezeOptions {
+  // 160×90 회색조 평균 절대차(0..255). 커서 깜빡임 한 번이면 넘는 정도.
+  threshold?: number;
+  // 틀·style.json 의 motion.maxFreezeSec(틀이 이긴다) — 고정 관찰 화면(설명·뮤비)은 틀에서 늘려 허용한다. 없으면 0.1초
+  errorSec?: number;
+  warnSec?: number;
+}
+
+// 바뀐 면적(픽셀 몫) — 「거의 멈춤」을 숫자로 말해 준다.
+function changedArea(a: Uint8Array, b: Uint8Array): number {
+  let n = 0;
+  for (let i = 0; i < a.length; i++) if (Math.abs(a[i] - b[i]) > 8) n++;
+  return n / a.length;
+}
+
+export function diffs(thumbs: Thumb[]): number[] {
+  const out = [0];
+  for (let i = 1; i < thumbs.length; i++) out.push(meanAbsDiff(thumbs[i - 1].luma, thumbs[i].luma));
+  return out;
+}
+
+// 이웃 프레임끼리 비교하면 60fps 의 느린 움직임이 멈춤으로 보인다. 멈춤이 시작된 프레임(닻)과 비교해
+// 닻에서 얼마나 멀어졌는지로 잰다 — 10fps 로 찍든 60fps 로 읽든 같은 답이 나온다.
+// 공통 규칙: 단 0.1초도 쉬지 않는다 — 끝 카드·큰 숫자·로고도 예외 없이 0.1초(60fps 6프레임) 넘게 멈추면 오류
+export const MAX_FREEZE_SEC = 0.1;
+
+export function freezes(thumbs: Thumb[], o: FreezeOptions = {}): Finding[] {
+  const thr = o.threshold ?? 0.35;
+  const errorSec = o.errorSec ?? MAX_FREEZE_SEC;
+  const warnSec = Math.min(o.warnSec ?? errorSec, errorSec);
+  const out: Finding[] = [];
+  let a = 0;
+  while (a < thumbs.length - 1) {
+    let j = a + 1;
+    while (j < thumbs.length && meanAbsDiff(thumbs[a].luma, thumbs[j].luma) < thr) j++;
+    const end = j - 1;
+    const len = thumbs[end].t - thumbs[a].t;
+    // 「이보다 오래」 멈출 때만 — 딱 경계 길이는 재는 간격 안의 오차다.
+    if (len > warnSec + 1e-6) {
+      const severity = len > errorSec + 1e-6 ? "error" : "warn";
+      const area = changedArea(thumbs[a].luma, thumbs[end].luma);
+      out.push({
+        rule: "frame.freeze",
+        severity,
+        from: thumbs[a].t,
+        to: thumbs[end].t,
+        message: `화면이 ${len.toFixed(2)}초 ${area > 0 ? `거의 멈췄다(바뀐 면적 ${(area * 100).toFixed(1)}%)` : "멈췄다"}${severity === "warn" ? ` — 경고 기준 ${warnSec}초 넘음` : ` — 기준 ${errorSec}초(틀·style.json maxFreezeSec)`} — 그 사이에 눈에 띄는 움직임 하나를 둔다`,
+        detail: { seconds: Math.round(len * 100) / 100, changedArea: Math.round(area * 10000) / 10000 },
+      });
+    }
+    a = Math.max(end, a + 1);
+  }
+  return out;
+}
+
+// 한 색으로 칠해진 화면. 드롭 섬광처럼 한두 프레임은 일부러 그럴 수 있어 길이로 거른다.
+export function blanks(thumbs: Thumb[], duration: number, o: { std?: number; minSec?: number } = {}): Finding[] {
+  const stdMax = o.std ?? 2.5;
+  const minSec = o.minSec ?? 0.5;
+  const out: Finding[] = [];
+  let start = -1;
+  const step = thumbs.length > 1 ? thumbs[1].t - thumbs[0].t : 0;
+  const close = (end: number) => {
+    if (start < 0) return;
+    const from = thumbs[start].t;
+    const to = thumbs[end].t + step;
+    const len = to - from;
+    const edge = from <= 0.001 || to >= duration - step - 0.001;
+    if (len >= minSec) {
+      const severity = edge && len <= 1.0 ? "warn" : "error";
+      const mean = thumbs[start].mean;
+      out.push({
+        rule: "frame.blank",
+        severity,
+        from,
+        to,
+        message: `${len.toFixed(2)}초 동안 화면이 한 색(밝기 ${Math.round(mean)})뿐이다${edge ? " — 시작·끝이면 짧게 줄인다" : " — 장면이 비었거나 그리기가 실패했다"}`,
+        detail: { seconds: Math.round(len * 100) / 100, mean: Math.round(mean) },
+      });
+    }
+    start = -1;
+  };
+  for (let i = 0; i < thumbs.length; i++) {
+    if (thumbs[i].std < stdMax) {
+      if (start < 0) start = i;
+    } else close(i - 1);
+  }
+  close(thumbs.length - 1);
+  return out;
+}
+
+// 이웃 프레임 차가 갑자기 튀는 곳 = 컷. 앞뒤 평소 움직임보다 훨씬 커야 한다.
+export function cuts(thumbs: Thumb[], o: { min?: number; ratio?: number } = {}): number[] {
+  const min = o.min ?? 22;
+  const ratio = o.ratio ?? 4;
+  const d = diffs(thumbs);
+  const out: number[] = [];
+  for (let i = 1; i < d.length; i++) {
+    const around = [d[i - 2], d[i - 1], d[i + 1], d[i + 2]].filter((x) => x !== undefined) as number[];
+    const base = around.length ? around.sort((a, b) => a - b)[around.length >> 1] : 0;
+    if (d[i] >= min && d[i] >= ratio * (base + 0.5)) out.push(thumbs[i].t);
+  }
+  return out;
+}
+
+// 한 프레임 튐 — 앞뒤 프레임끼리는 비슷한데 가운데 한 프레임만 둘 다와 크게 다르면 깜빡임·한 프레임 오류다.
+// 일부러 하는 컷·섬광은 장면 경계·드롭 시각 근처면 뺀다
+export function spikes(thumbs: Thumb[], o: { exclude?: number[]; ratio?: number; floor?: number } = {}): Finding[] {
+  const ratio = o.ratio ?? 3;
+  const floor = o.floor ?? 2.5;
+  const step = thumbs.length > 1 ? thumbs[1].t - thumbs[0].t : 0;
+  const near = (t: number) => (o.exclude ?? []).some((x) => Math.abs(x - t) <= step * 1.5 + 1e-3);
+  const out: Finding[] = [];
+  for (let i = 1; i < thumbs.length - 1; i++) {
+    const a = thumbs[i - 1].luma;
+    const b = thumbs[i].luma;
+    const c = thumbs[i + 1].luma;
+    const jump = Math.min(meanAbsDiff(a, b), meanAbsDiff(b, c));
+    if (jump < floor) continue;
+    const around = meanAbsDiff(a, c);
+    if (jump <= ratio * Math.max(around, 0.5)) continue;
+    if (near(thumbs[i].t)) continue;
+    out.push({
+      rule: "frame.spike",
+      severity: "warn",
+      from: thumbs[i].t,
+      to: thumbs[i].t + step,
+      message: `${thumbs[i].t.toFixed(2)}초 한 프레임만 앞뒤와 크게 다르다(앞뒤 차 ${jump.toFixed(1)} · 건너 차 ${around.toFixed(1)}) — 깜빡임이거나 한 프레임 오류. 일부러 한 섬광이면 드롭·장면 경계에 붙인다`,
+      detail: { jump: Math.round(jump * 100) / 100, around: Math.round(around * 100) / 100 },
+    });
+  }
+  return out;
+}