@popcraft/kit 0.26.0 → 0.26.1

package/dist/chunks/chunk-D2GOQC3Y.js

@@ -0,0 +1,503 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  pauseTimes,
+  presentSteps,
+  presentStretches
+} from "./chunk-BW436IBB.js";
+import {
+  SLIDE_TRANSITIONS
+} from "./chunk-66JE536K.js";
+import {
+  documentFromTemplate
+} from "./chunk-TP2KNL6S.js";
+import {
+  evaluatePose
+} from "./chunk-OO67GSCX.js";
+import {
+  cueLayers,
+  swapTimes
+} from "./chunk-SOHOKD4X.js";
+import {
+  U,
+  UNIT_STRIDE,
+  animatorFrames,
+  letterOpacities,
+  textPoseOf
+} from "./chunk-HRDPBECW.js";
+import {
+  timelineDuration
+} from "./chunk-2WU6JQAQ.js";
+import {
+  clipEnd,
+  compositionDuration
+} from "./chunk-XV5ONKNC.js";
+import {
+  ZOOM_IN_SCALE,
+  ZOOM_OUT_SCALE,
+  coverRadius,
+  flatTransitionType,
+  transitionCenter,
+  whipSmear
+} from "./chunk-Q5FICCEE.js";
+import {
+  init_print_pages,
+  listPrintPages
+} from "./chunk-PEAXERBE.js";
+import {
+  formatCounter,
+  init_text_units,
+  textUnits
+} from "./chunk-MFNTHBR5.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-6VMOKHMF.js";
+
+// templates/src/motion-qa.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_print_pages();
+init_text_units();
+var CLOSE = /* @__PURE__ */ Symbol("closeTo");
+var isClose = (x) => !!x && typeof x === "object" && CLOSE in x;
+function same(a, b) {
+  if (isClose(b)) return typeof a === "number" && Math.abs(a - b.value) < 10 ** -b.digits / 2;
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b || Array.isArray(a) !== Array.isArray(b)) return false;
+  const ka = Object.keys(a).filter((k) => a[k] !== void 0), kb = Object.keys(b).filter((k) => b[k] !== void 0);
+  return ka.length === kb.length && kb.every((k) => same(a[k], b[k]));
+}
+var shown2 = (x) => JSON.stringify(x, (_k, v) => isClose(v) ? `\u2248${v.value}` : v);
+var recording = null;
+var fail = (message) => {
+  if (!recording) throw new Error(message);
+  recording.push({ check: "motion", message });
+};
+var expect = Object.assign((actual) => ({
+  toEqual: (want) => {
+    if (!same(actual, want)) fail(`${shown2(actual)}, should be ${shown2(want)}`);
+  },
+  toBe: (want) => {
+    if (!Object.is(actual, want)) fail(`${shown2(actual)}, should be ${shown2(want)}`);
+  },
+  toBeGreaterThanOrEqual: (n) => {
+    if (!(actual >= n)) fail(`${shown2(actual)}, should be at least ${n}`);
+  },
+  toBeLessThanOrEqual: (n) => {
+    if (!(actual <= n)) fail(`${shown2(actual)}, should be at most ${n}`);
+  }
+}), { closeTo: (value, digits = 2) => ({ [CLOSE]: true, value, digits }) });
+var CURVES = {
+  linear: (k) => k,
+  "cubic-out": (k) => 1 - (1 - k) ** 3,
+  "cubic-in": (k) => k ** 3,
+  "cubic-in-out": (k) => k < 0.5 ? 4 * k ** 3 : 1 - (-2 * k + 2) ** 3 / 2,
+  "quart-out": (k) => 1 - (1 - k) ** 4,
+  "expo-out": (k) => k === 1 ? 1 : 1 - 2 ** (-10 * k),
+  "expo-in": (k) => k === 0 ? 0 : 2 ** (10 * k - 10),
+  "expo-in-out": (k) => k === 0 ? 0 : k === 1 ? 1 : k < 0.5 ? 2 ** (20 * k - 10) / 2 : (2 - 2 ** (-20 * k + 10)) / 2,
+  "sine-in-out": (k) => -(Math.cos(Math.PI * k) - 1) / 2,
+  "back-out": (k, c) => 1 + (c + 1) * (k - 1) ** 3 + c * (k - 1) ** 2,
+  "back-in": (k, c) => (c + 1) * k ** 3 - c * k ** 2
+};
+var curve = (i) => {
+  if (i.kind === "linear") return (k) => k;
+  if (i.kind === "hold") return (k) => k < 1 ? 0 : 1;
+  if (i.kind !== "ease" || !CURVES[i.name]) throw new Error(`no formula here for ${JSON.stringify(i)}: add it`);
+  const f = CURVES[i.name], c = i.param ?? 1.70158;
+  return (k) => f(k, c);
+};
+var named = (name, param) => ({ kind: "ease", name, ...param !== void 0 ? { param } : {} });
+var opacity = (n) => n.opacity ?? 1;
+var tx = (n) => n.translateX ?? 0;
+var ty = (n) => n.translateY ?? 0;
+var sx = (n) => n.scaleX ?? 1;
+var blur = (n) => n.effects?.find((e) => e.type === "LAYER_BLUR")?.radius ?? 0;
+var width = (n) => n.width;
+var rotation = (n) => n.rotation ?? 0;
+var WIPE_MIN = 0.01;
+var text = (unit, dir, stagger) => ({ duration: dir === "in" ? 600 : 450, ease: named(dir === "in" ? "expo-out" : "expo-in"), kind: dir === "in" ? "text-in" : "text-out", probe: () => opacity, amount: stagger, unit });
+var SPECS = {
+  "fade-in": { duration: 400, ease: named("cubic-out"), kind: "in", probe: () => opacity },
+  "rise-in": { duration: 600, ease: named("expo-out"), kind: "in", probe: () => ty },
+  "drop-in": { duration: 600, ease: named("expo-out"), kind: "in", probe: () => ty },
+  "pop-in": { duration: 500, ease: named("back-out", 1.7), kind: "in", probe: () => sx },
+  "scale-in": { duration: 600, ease: named("expo-out"), kind: "in", probe: () => sx },
+  "slide-in": { duration: 600, ease: named("expo-out"), kind: "in", probe: (c) => c.params?.direction === "up" || c.params?.direction === "down" ? ty : tx },
+  "blur-in": { duration: 600, ease: named("cubic-out"), kind: "in", probe: () => blur },
+  "wipe-in": { duration: 600, ease: named("expo-out"), kind: "in", probe: () => width, wipe: true },
+  "fade-out": { duration: 400, ease: named("cubic-in"), kind: "out", probe: () => opacity },
+  "rise-out": { duration: 500, ease: named("expo-in"), kind: "out", probe: () => ty },
+  "drop-out": { duration: 500, ease: named("expo-in"), kind: "out", probe: () => ty },
+  "pop-out": { duration: 400, ease: named("back-in", 1.7), kind: "out", probe: () => sx },
+  "slide-out": { duration: 500, ease: named("expo-in"), kind: "out", probe: (c) => c.params?.direction === "up" || c.params?.direction === "down" ? ty : tx },
+  "blur-out": { duration: 500, ease: named("cubic-in"), kind: "out", probe: () => blur },
+  "wipe-out": { duration: 500, ease: named("expo-in"), kind: "out", probe: () => width, wipe: true },
+  shake: { duration: 600, ease: named("sine-in-out"), kind: "rest", probe: () => tx },
+  wobble: { duration: 800, ease: named("sine-in-out"), kind: "rest", probe: () => rotation },
+  // Bounce: a hop up by its distance at 30 % of its length, landing back at rest.
+  bounce: { duration: 900, ease: named("cubic-out"), kind: "rest", probe: () => ty },
+  pulse: { duration: 800, ease: named("sine-in-out"), kind: "pulse", probe: () => sx, amount: 0.08 },
+  "push-in": { duration: 3e3, ease: named("cubic-in-out"), kind: "grow", probe: () => sx, amount: 0.15 },
+  drift: { duration: 4e3, ease: named("sine-in-out"), kind: "grow", probe: () => sx, amount: 0.03 },
+  "pull-out": { duration: 3e3, ease: named("cubic-in-out"), kind: "shrink", probe: () => sx, amount: 0.15 },
+  flash: { duration: 800, ease: named("sine-in-out"), kind: "rest", probe: () => opacity },
+  // Camera shake: a seeded jitter on the offset (and the turn), dying away to rest.
+  "camera-shake": { duration: 500, ease: named("sine-in-out"), kind: "rest", probe: () => tx },
+  // An impact frame: full on for a few held frames from the hit, off, on again, and back to rest (a flash layer rests hidden).
+  "impact-frame": { duration: 160, ease: { kind: "hold" }, kind: "impact", probe: () => opacity },
+  // Text: every unit faded (and moved) while its animator's amount is 1; unit k runs `stagger` ms after unit k − 1.
+  "letters-in": text("letter", "in", 35),
+  "words-in": text("word", "in", 90),
+  "lines-in": text("line", "in", 160),
+  "letters-out": text("letter", "out", 35),
+  "words-out": text("word", "out", 90),
+  "lines-out": text("line", "out", 160),
+  // Typewriter: the range's start sweeps 0 → 1 over the letters, and every letter it has passed is typed.
+  typewriter: { duration: 1500, ease: { kind: "linear" }, kind: "type", probe: () => opacity, unit: "letter" }
+};
+var FADES = /* @__PURE__ */ new Set(["fade-in", "rise-in", "drop-in", "pop-in", "scale-in", "slide-in", "blur-in", "fade-out", "rise-out", "drop-out", "pop-out", "slide-out", "blur-out"]);
+var isIn = (preset) => ["in", "text-in", "type"].includes(SPECS[preset].kind);
+function sizes(src, t) {
+  const motion = src.motion;
+  return t.payload.variants.map((v) => {
+    const doc = documentFromTemplate(t, t.meta.name, v.sizeId);
+    const at = (frameId, ms) => evaluatePose(doc.nodes, { kind: "frame", frameId }, ms).nodes;
+    const sheets = doc.nodes[doc.pages[0]].childIds.map((id) => doc.nodes[id]).filter((f) => f.type === "FRAME");
+    const sequences = "scenes" in motion ? [motion.scenes, ...motion.more ?? []].filter((seq) => sheets.some((f) => f.name === seq[0].sheet)) : [];
+    const playedIn = (seq) => seq.map((sc) => {
+      const frame = sheets.find((p) => p.name === sc.sheet);
+      if (!frame) throw new Error(`${src.id} ${v.sizeId}: no scene "${sc.sheet}"`);
+      return { frame, cues: sc.cues, counts: sc.counts ?? [], swaps: [] };
+    });
+    const played = "scenes" in motion ? sequences.flatMap(playedIn) : "slides" in motion ? motion.slides.map((sc) => {
+      const frame = listPrintPages(doc, doc.pages[0]).find((p) => p.name === sc.slide);
+      if (!frame) throw new Error(`${src.id} ${v.sizeId}: no slide "${sc.slide}"`);
+      return { frame, cues: sc.cues, counts: [], swaps: [] };
+    }) : doc.nodes[doc.pages[0]].childIds.map((id) => doc.nodes[id]).filter((f) => f.type === "FRAME" && f.timeline).map((frame) => ({ frame, cues: motion.cues, counts: motion.counts ?? [], swaps: motion.swaps ?? [] }));
+    const components = "slides" in motion || "scenes" in motion ? [] : (motion.components ?? []).map((cc) => {
+      const [set, state] = cc.component.split("/");
+      const all = Object.values(doc.nodes);
+      const comp = state ? all.find((n) => n.type === "COMPONENT" && n.name.endsWith(`=${state}`) && doc.nodes[n.parentId ?? ""]?.name === set) : all.find((n) => n.type === "COMPONENT" && n.name === set);
+      if (!comp) throw new Error(`${src.id} ${v.sizeId}: no component "${cc.component}"`);
+      return { frame: comp, cues: cc.cues, counts: [], swaps: [] };
+    });
+    return { sizeId: v.sizeId, doc, played, components, at, sequences: sequences.map((seq) => ({ seq, played: playedIn(seq) })) };
+  });
+}
+function starts(doc, frameId, cue) {
+  const ids = cueLayers(doc, frameId, cue);
+  const n = ids.length;
+  return ids.map((id, i) => {
+    const centre = Math.abs(i - (n - 1) / 2) - (n % 2 ? 0 : 0.5);
+    const place = !cue.stagger ? 0 : cue.stagger.order === "reverse" ? n - 1 - i : cue.stagger.order === "center" ? centre : i;
+    if (cue.stagger?.order && !["index", "selection", "reverse", "center"].includes(cue.stagger.order)) throw new Error(`stagger order ${JSON.stringify(cue.stagger.order)}: add it here`);
+    return { id, t: cue.at + (cue.params?.delay ?? 0) + place * (cue.stagger?.delay ?? 0) };
+  });
+}
+function shown(doc, chars) {
+  return chars.replace(/\{\{\s*brand\.([A-Za-z0-9_-]+)\s*\}\}/g, (m, name) => {
+    const v = Object.values(doc.variables ?? {}).find((x) => x.name === `brand/${name}` && x.type === "STRING");
+    return v ? String(Object.values(v.valuesByMode)[0]) : m;
+  });
+}
+function unitPoses(doc, n, animatorId, field = "weight") {
+  const posed = n;
+  const info = textPoseOf(posed);
+  if (!info) throw new Error(`${n.name}: not posed as a text with animators`);
+  const chars = shown(doc, posed.characters);
+  const i = posed.textAnimators.findIndex((a) => a.id === animatorId);
+  if (i < 0) throw new Error(`${n.name}: no animator ${animatorId}`);
+  const f = animatorFrames({ ...posed, characters: chars }, info, (unit) => textUnits(chars, unit))[i];
+  return Array.from({ length: f.units.count }, (_, u) => f.poses[u * UNIT_STRIDE + U[field]]);
+}
+var unitOpacity = (doc, n) => letterOpacities(n, shown(doc, n.characters));
+function checkCues(sizeId, doc, frame, cues, at) {
+  expect({ size: sizeId, sheet: frame.name, fps: frame.timeline?.fps }).toEqual({ size: sizeId, sheet: frame.name, fps: 30 });
+  const pose = (ms) => at(frame.id, ms);
+  for (const cue of cues) {
+    const spec = SPECS[cue.preset];
+    if (!spec) throw new Error(`${cue.preset}: describe it in SPECS`);
+    const d = cue.params?.duration ?? spec.duration;
+    const e = curve(cue.params?.ease ?? spec.ease);
+    const probe = spec.probe(cue);
+    for (const { id, t } of starts(doc, frame.id, cue)) {
+      const label = { size: sizeId, sheet: frame.name, layer: doc.nodes[id].name, preset: cue.preset, at: t };
+      if (spec.kind === "text-in" || spec.kind === "text-out") {
+        const s = cue.params?.amount ?? spec.amount;
+        const w = (ms) => unitPoses(doc, pose(ms)[id], cue.preset);
+        const n = w(t).length;
+        const hidden = spec.kind === "text-in" ? 1 : 0, shownW = 1 - hidden;
+        expect({ ...label, units: n > 1 }).toEqual({ ...label, units: true });
+        expect({ ...label, start: w(t) }).toEqual({ ...label, start: new Array(n).fill(hidden) });
+        const mid = w(t + d / 2);
+        const share = spec.kind === "text-in" ? 1 - e(0.5) : e(0.5);
+        expect({ ...label, first: mid[0] }).toEqual({ ...label, first: expect.closeTo(share, 5) });
+        if (n > 1 && (n - 1) * s > d / 2) expect({ ...label, last: mid[n - 1] }).toEqual({ ...label, last: hidden });
+        expect({ ...label, firstLands: w(t + d)[0] }).toEqual({ ...label, firstLands: shownW });
+        expect({ ...label, allLand: w(t + (n - 1) * s + d) }).toEqual({ ...label, allLand: new Array(n).fill(shownW) });
+        if (spec.kind === "text-in") {
+          const o = unitPoses(doc, pose(t)[id], cue.preset, "opacity");
+          expect({ ...label, opacityAtStart: o }).toEqual({ ...label, opacityAtStart: new Array(n).fill(0) });
+        }
+        continue;
+      }
+      if (spec.kind === "type") {
+        const w = (ms) => unitPoses(doc, pose(ms)[id], "typewriter");
+        const n = w(t).length;
+        expect({ ...label, start: w(t) }).toEqual({ ...label, start: new Array(n).fill(1) });
+        expect({ ...label, end: w(t + d) }).toEqual({ ...label, end: new Array(n).fill(0) });
+        const mid = w(t + d / 2);
+        const typed = mid.filter((v) => v === 0).length;
+        expect({ ...label, prefix: mid.slice(0, typed).every((v) => v === 0) && mid.slice(typed).every((v) => v === 1), typed: Math.abs(typed - n / 2) <= 1 }).toEqual({ ...label, prefix: true, typed: true });
+        continue;
+      }
+      if (spec.wipe) {
+        const host = doc.nodes[id];
+        const group = doc.nodes[host.parentId ?? ""];
+        const maskId = [...host.childIds, ...group?.childIds ?? []].find((c) => doc.nodes[c]?.name === "Wipe mask" && doc.nodes[c].isMask);
+        expect({ ...label, mask: !!maskId }).toEqual({ ...label, mask: true });
+        const dir = cue.params?.direction ?? "right";
+        const size = (n) => dir === "up" || dir === "down" ? n.height : n.width;
+        const full = size(doc.nodes[maskId]), closed = WIPE_MIN;
+        const [from, to] = spec.kind === "in" ? [closed, full] : [full, closed];
+        const m = (ms) => size(pose(ms)[maskId]);
+        expect({ ...label, from: m(t), to: m(t + d), share: (m(t + d / 2) - from) / (to - from) }).toEqual({ ...label, from: expect.closeTo(from, 4), to: expect.closeTo(to, 4), share: expect.closeTo(e(0.5), 5) });
+        continue;
+      }
+      const rest = probe(doc.nodes[id]);
+      const v0 = probe(pose(t)[id]), v1 = probe(pose(t + d)[id]), vm = probe(pose(t + d / 2)[id]);
+      if (spec.kind === "in") expect({ ...label, lands: v1 }).toEqual({ ...label, lands: expect.closeTo(rest, 6) });
+      if (spec.kind === "out") expect({ ...label, leavesFrom: v0 }).toEqual({ ...label, leavesFrom: expect.closeTo(rest, 6) });
+      if (spec.kind === "in" || spec.kind === "out" || spec.kind === "grow") {
+        if (Math.abs(v1 - v0) > 1e-6) expect({ ...label, share: (vm - v0) / (v1 - v0) }).toEqual({ ...label, share: expect.closeTo(e(0.5), 5) });
+      }
+      if (FADES.has(cue.preset)) {
+        const o0 = opacity(pose(t)[id]), o1 = opacity(pose(t + d)[id]);
+        expect({ ...label, opacity: spec.kind === "in" ? o0 : o1 }).toEqual({ ...label, opacity: 0 });
+      }
+      if (spec.kind === "pulse") {
+        const amount = cue.params?.amount ?? spec.amount;
+        expect({ ...label, swell: probe(pose(t + d / 4)[id]), after: v1 }).toEqual({ ...label, swell: expect.closeTo(rest * (1 + amount), 6), after: expect.closeTo(rest, 6) });
+      }
+      if (spec.kind === "rest" || spec.kind === "impact") expect({ ...label, from: v0, to: v1 }).toEqual({ ...label, from: expect.closeTo(rest, 6), to: expect.closeTo(rest, 6) });
+      if (cue.preset === "bounce") expect({ ...label, top: probe(pose(t + d * 0.3)[id]) }).toEqual({ ...label, top: expect.closeTo(rest - Number(cue.params?.distance ?? 40), 6) });
+      if (spec.kind === "rest" && cue.preset === "camera-shake") {
+        const dist = cue.params?.distance ?? 24;
+        const path = [0.1, 0.25, 0.4, 0.6].map((f) => probe(pose(t + d * f)[id]) - rest);
+        expect({ ...label, moves: path.some((v) => Math.abs(v) > 0.05 * dist), bounded: path.every((v) => Math.abs(v) <= dist + 1e-6) }).toEqual({ ...label, moves: true, bounded: true });
+      }
+      if (spec.kind === "impact") {
+        const at2 = (f) => probe(pose(t + f)[id]);
+        expect({ ...label, frames: [at2(2), at2(Math.round(0.45 * d) + 1), at2(Math.round(0.65 * d) + 1)] }).toEqual({ ...label, frames: [1, 0, 1] });
+      }
+      if (spec.kind === "shrink") {
+        const amount = cue.params?.amount ?? spec.amount;
+        expect({ ...label, from: v0, to: v1 }).toEqual({ ...label, from: expect.closeTo(rest * (1 + amount), 6), to: expect.closeTo(rest, 6) });
+        if (Math.abs(v1 - v0) > 1e-6) expect({ ...label, share: (vm - v0) / (v1 - v0) }).toEqual({ ...label, share: expect.closeTo(e(0.5), 5) });
+      }
+      if (spec.kind === "grow") {
+        const amount = cue.params?.amount ?? spec.amount;
+        expect({ ...label, from: v0, to: v1 }).toEqual({ ...label, from: expect.closeTo(rest, 6), to: expect.closeTo(rest * (1 + amount), 6) });
+      }
+    }
+  }
+}
+function expectedCount(c, ms) {
+  const { from, to } = c.counter;
+  const k = Math.min(1, Math.max(0, (ms - c.at) / c.duration));
+  if (c.tick) {
+    const steps = Math.round(c.duration / c.tick);
+    const i = Math.min(steps, Math.max(0, Math.floor((ms - c.at) / c.tick + 1e-9)));
+    return formatCounter(c.counter, from + (to - from) * i / steps);
+  }
+  return formatCounter(c.counter, from + (to - from) * curve(c.ease ?? named("cubic-out"))(k));
+}
+var countTimes = (c) => c.tick ? Array.from({ length: Math.round(c.duration / c.tick) + 1 }, (_, i) => c.at + i * c.tick + (i < Math.round(c.duration / c.tick) ? c.tick / 2 : 0)) : [c.at, c.at + c.duration / 2, c.at + c.duration];
+function checkCounts(sizeId, doc, frame, counts, at) {
+  for (const c of counts) {
+    const [id] = cueLayers(doc, frame.id, { layer: c.layer, preset: "fade-in", at: c.at });
+    const label = { size: sizeId, sheet: frame.name, layer: c.layer };
+    expect({ ...label, rest: doc.nodes[id].characters }).toEqual({ ...label, rest: formatCounter(c.counter, c.counter.value ?? c.counter.to) });
+    for (const ms of countTimes(c)) expect({ ...label, ms, reads: at(frame.id, ms)[id].characters }).toEqual({ ...label, ms, reads: expectedCount(c, ms) });
+  }
+}
+function checkSwaps(sizeId, doc, frame, swaps, at) {
+  for (const sw of swaps) {
+    const [id] = cueLayers(doc, frame.id, { layer: sw.layer, preset: "fade-in", at: sw.at });
+    const label = { size: sizeId, sheet: frame.name, layer: sw.layer };
+    expect({ ...label, rest: doc.nodes[id].characters }).toEqual({ ...label, rest: sw.words[0] });
+    const read = (ms) => {
+      const n = at(frame.id, ms)[id];
+      return { chars: n.characters, w: unitPoses(doc, n, "swap") };
+    };
+    for (const w of swapTimes(sw)) {
+      const n = read(w.enters).w.length;
+      const tag = { ...label, word: w.word };
+      expect({ ...tag, entering: read(w.enters) }).toEqual({ ...tag, entering: { chars: w.word, w: new Array(n).fill(1) } });
+      expect({ ...tag, first: read(w.enters + sw.in / 2).w[0] }).toEqual({ ...tag, first: expect.closeTo(1 - curve(named("expo-out"))(0.5), 5) });
+      expect({ ...tag, landed: read(w.landed) }).toEqual({ ...tag, landed: { chars: w.word, w: new Array(n).fill(0) } });
+      expect({ ...tag, leaving: read(w.leaves + sw.out / 2).w[0] }).toEqual({ ...tag, leaving: expect.closeTo(curve(named("expo-in"))(0.5), 5) });
+      expect({ ...tag, gone: read(w.gone).w.every((v) => v === 1) }).toEqual({ ...tag, gone: true });
+    }
+  }
+}
+function compositionRoots(doc, comp, ms) {
+  const p = evaluatePose(doc.nodes, { kind: "composition", compositionId: comp.id }, ms, { compositions: doc.compositions });
+  return { pose: p, roots: p.roots.map((r) => ({ id: r.rootId, opacity: r.opacity, scale: r.matrix[0], dx: r.matrix[4], dy: r.matrix[5], r: r.clip?.r, ...r.smear ? { smear: r.smear.radius } : {} })) };
+}
+function checkComposition(sizeId, doc, scenes, played) {
+  const frames = played.map((p) => p.frame);
+  const comp = Object.values(doc.compositions ?? {}).find((c) => c.clips[0]?.frameId === frames[0].id);
+  expect({ size: sizeId, composition: !!comp }).toEqual({ size: sizeId, composition: true });
+  if (!comp) return;
+  const label = { size: sizeId, composition: comp.name };
+  expect({ ...label, fps: comp.fps, stage: [comp.width, comp.height] }).toEqual({ ...label, fps: 30, stage: [frames[0].width, frames[0].height] });
+  expect({ ...label, clips: comp.clips.map((c) => [doc.nodes[c.frameId]?.name, c.in, c.out, c.transitionIn?.type ?? "CUT"]) }).toEqual({ ...label, clips: scenes.map((s, i) => [s.sheet, 0, timelineDuration(doc.nodes, frames[i].id), i === 0 ? "CUT" : s.transition?.type ?? "CUT"]) });
+  let t = 0;
+  comp.clips.forEach((c, i) => {
+    if (i) t += comp.clips[i - 1].out - comp.clips[i - 1].in - (c.transitionIn?.duration ?? 0);
+    expect({ ...label, clip: i, start: c.start }).toEqual({ ...label, clip: i, start: t });
+  });
+  expect({ ...label, duration: compositionDuration(comp) }).toEqual({ ...label, duration: clipEnd(comp.clips[comp.clips.length - 1]) });
+  const { pose: first } = compositionRoots(doc, comp, 0);
+  const stage = first.stage.rect;
+  const shift = (i) => ({ dx: stage.x + stage.width / 2 - (frames[i].x + frames[i].width / 2), dy: stage.y + stage.height / 2 - (frames[i].y + frames[i].height / 2) });
+  comp.clips.forEach((c, i) => {
+    const tr = c.transitionIn;
+    const lands = c.start + (tr?.duration ?? 0);
+    expect({ ...label, scene: frames[i].name, at: lands, roots: compositionRoots(doc, comp, lands).roots }).toEqual({ ...label, scene: frames[i].name, at: lands, roots: [{ id: frames[i].id, opacity: 1, scale: 1, ...shift(i), r: void 0 }] });
+    for (const count of played[i].counts) {
+      const [id] = cueLayers(doc, frames[i].id, { layer: count.layer, preset: "fade-in", at: count.at });
+      for (const ms of [lands, clipEnd(c) - 1]) {
+        const local = ms - c.start + c.in;
+        expect({ ...label, scene: frames[i].name, counter: count.layer, at: ms, reads: compositionRoots(doc, comp, ms).pose.nodes[id].characters }).toEqual({ ...label, scene: frames[i].name, counter: count.layer, at: ms, reads: expectedCount(count, local) });
+      }
+    }
+    if (!tr || i === 0) return;
+    const p = curve(tr.interp)(0.5);
+    const { roots } = compositionRoots(doc, comp, c.start + tr.duration / 2);
+    const a = frames[i - 1], b = frames[i];
+    const byId = (id) => roots.find((r) => r.id === id);
+    const tag = { ...label, into: b.name, type: tr.type };
+    const cen = transitionCenter(stage, tr.params);
+    const R = coverRadius(stage, cen);
+    const W = stage.width, H = stage.height;
+    const want = {
+      DISSOLVE: { a: { opacity: 1 - p }, b: { opacity: p } },
+      CIRCLE_WIPE: { a: { r: void 0 }, b: { r: R * p } },
+      IRIS: { a: { r: R * (1 - p) }, b: { r: void 0 } },
+      ZOOM_THROUGH: { a: { scale: 1 + (ZOOM_OUT_SCALE - 1) * p, opacity: 1 - p }, b: { scale: ZOOM_IN_SCALE + (1 - ZOOM_IN_SCALE) * p, opacity: p } },
+      SLIDE_FROM_LEFT: { a: { dx: shift(i - 1).dx }, b: { dx: shift(i).dx - W * (1 - p) } },
+      SLIDE_FROM_RIGHT: { a: { dx: shift(i - 1).dx }, b: { dx: shift(i).dx + W * (1 - p) } },
+      SLIDE_FROM_TOP: { a: { dy: shift(i - 1).dy }, b: { dy: shift(i).dy - H * (1 - p) } },
+      SLIDE_FROM_BOTTOM: { a: { dy: shift(i - 1).dy }, b: { dy: shift(i).dy + H * (1 - p) } },
+      PUSH_FROM_LEFT: { a: { dx: shift(i - 1).dx + W * p }, b: { dx: shift(i).dx - W * (1 - p) } },
+      PUSH_FROM_RIGHT: { a: { dx: shift(i - 1).dx - W * p }, b: { dx: shift(i).dx + W * (1 - p) } },
+      PUSH_FROM_TOP: { a: { dy: shift(i - 1).dy + H * p }, b: { dy: shift(i).dy - H * (1 - p) } },
+      PUSH_FROM_BOTTOM: { a: { dy: shift(i - 1).dy - H * p }, b: { dy: shift(i).dy + H * (1 - p) } },
+      // A whip pan travels as a push does, both scenes streaked by a motion blur longest at the pan's middle.
+      WHIP_LEFT: { a: { dx: shift(i - 1).dx + W * p, smear: whipSmear(p, W) }, b: { dx: shift(i).dx - W * (1 - p), smear: whipSmear(p, W) } },
+      WHIP_RIGHT: { a: { dx: shift(i - 1).dx - W * p, smear: whipSmear(p, W) }, b: { dx: shift(i).dx + W * (1 - p), smear: whipSmear(p, W) } }
+    };
+    const w = want[tr.type] ?? want[flatTransitionType(tr.type)];
+    if (!w) throw new Error(`${tr.type}: describe it here`);
+    for (const [side, frame] of [["a", a], ["b", b]]) {
+      const got = byId(frame.id);
+      const exp = w[side];
+      for (const [k, v] of Object.entries(exp)) {
+        const g = got?.[k];
+        if (v === void 0) expect({ ...tag, side, [k]: g }).toEqual({ ...tag, side, [k]: void 0 });
+        else expect({ ...tag, side, [k]: g }).toEqual({ ...tag, side, [k]: expect.closeTo(v, 5) });
+      }
+    }
+  });
+}
+function motionCueIssues(src, t) {
+  if (!src.motion) return [];
+  const motion = src.motion;
+  const issues = [];
+  recording = issues;
+  try {
+    for (const { sizeId, doc, played, components, at, sequences } of sizes(src, t)) {
+      for (const { frame, cues, counts, swaps } of played) {
+        checkCues(sizeId, doc, frame, cues, at);
+        checkCounts(sizeId, doc, frame, counts, at);
+        checkSwaps(sizeId, doc, frame, swaps, at);
+      }
+      for (const { frame, cues } of components) checkCues(sizeId, doc, frame, cues, at);
+      if ("scenes" in motion) {
+        expect({ size: sizeId, sequences: sequences.length > 0 }).toEqual({ size: sizeId, sequences: true });
+        for (const { seq, played: p } of sequences) checkComposition(sizeId, doc, seq, p);
+      }
+      if ("slides" in motion) checkBuilds(doc, played, at);
+      if ("loop" in motion && motion.loop) checkLoop(doc, played[0], at);
+    }
+    expect(t.meta.fps).toBe(30);
+    if ("slides" in motion) expect(t.meta.durationMs).toBeGreaterThanOrEqual(1e3 * motion.slides.length);
+    else {
+      const short = t.meta.formats?.some((f) => f === "logo-sting" || f === "title-card");
+      const lottie = t.meta.tags.includes("lottie");
+      const film = t.meta.tags.includes("slideshow");
+      expect(t.meta.durationMs).toBeGreaterThanOrEqual(lottie ? 1e3 : short ? 3e3 : 4e3);
+      expect(t.meta.durationMs).toBeLessThanOrEqual(lottie ? 6e3 : film ? 9e4 : "scenes" in motion ? 4e4 : 2e4);
+      if (film) expect(t.meta.durationMs).toBeGreaterThanOrEqual(3e4);
+    }
+  } catch (e) {
+    issues.push({ check: "motion", message: e.message });
+  } finally {
+    recording = null;
+  }
+  return issues;
+}
+function checkBuilds(doc, played, at) {
+  const known = new Set(SLIDE_TRANSITIONS.map((o) => o.value));
+  for (const { frame, cues } of played) {
+    const clicks = [...new Set(cues.filter((c) => c.onClick).map((c) => c.at))].sort((a, b) => a - b);
+    expect({ slide: frame.name, pauses: pauseTimes(doc.nodes, frame.id) }).toEqual({ slide: frame.name, pauses: clicks });
+    expect({ slide: frame.name, clicks: presentSteps(doc.nodes, frame.id), stretches: presentStretches(doc.nodes, frame.id).length }).toEqual({ slide: frame.name, clicks: clicks.length, stretches: clicks.length + 1 });
+    for (const c of cues.filter((x) => x.onClick && SPECS[x.preset].kind === "in")) {
+      const posed = at(frame.id, c.at);
+      for (const id of cueLayers(doc, frame.id, c)) expect({ slide: frame.name, layer: doc.nodes[id].name, waiting: opacity(posed[id]) }).toEqual({ slide: frame.name, layer: doc.nodes[id].name, waiting: 0 });
+    }
+    const master = frame.print?.masterId ? doc.nodes[frame.print.masterId] : void 0;
+    if (frame.print?.masterId) expect({ slide: frame.name, master: master && [master.width, master.height] }).toEqual({ slide: frame.name, master: [frame.width, frame.height] });
+    const tr = frame.print?.transition;
+    expect({ slide: frame.name, transition: !!tr && tr.type !== "INSTANT" && known.has(tr.type) && tr.duration > 0 }).toEqual({ slide: frame.name, transition: true });
+  }
+}
+function checkLoop(doc, { frame, cues }, at) {
+  const end = timelineDuration(doc.nodes, frame.id);
+  const shownAt = (ms) => {
+    const posed = at(frame.id, ms);
+    const alpha = (id) => {
+      const n = posed[id];
+      return n.id === frame.id ? 1 : (n.opacity ?? 1) * (n.parentId ? alpha(n.parentId) : 1);
+    };
+    const out = [];
+    const open = (id) => alpha(id) > 0.01 && posed[id].visible !== false && posed[id].width >= 1 && posed[id].height >= 1 && (posed[id].type !== "TEXT" || unitOpacity(doc, posed[id]).some((o) => o > 0.01));
+    const walk = (id, masked = false) => {
+      let hidden = masked;
+      for (const c of posed[id].childIds) {
+        if (posed[c].isMask) {
+          if (!open(c)) hidden = true;
+          continue;
+        }
+        if (!hidden && open(c)) out.push(posed[c].name);
+        walk(c, hidden);
+      }
+    };
+    walk(frame.id);
+    return out;
+  };
+  expect(shownAt(end)).toEqual(shownAt(0));
+  const cued = new Set(cues.filter((c) => isIn(c.preset)).flatMap((c) => cueLayers(doc, frame.id, c).map((id) => doc.nodes[id].name)));
+  for (const name of cued) expect({ layer: name, shownAtEnd: shownAt(end).includes(name) }).toEqual({ layer: name, shownAtEnd: false });
+}
+
+export {
+  motionCueIssues
+};