@popcraft/kit 0.24.3 → 0.26.0

package/dist/chunks/chunk-DWAIR3ZY.js

@@ -1,503 +0,0 @@
-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-FRTK4Z5G.js";
-import {
-  SLIDE_TRANSITIONS
-} from "./chunk-GFVGMGY5.js";
-import {
-  documentFromTemplate
-} from "./chunk-2Y24BYTM.js";
-import {
-  evaluatePose
-} from "./chunk-TNFFT3O5.js";
-import {
-  cueLayers,
-  swapTimes
-} from "./chunk-IUUXJSAI.js";
-import {
-  U,
-  UNIT_STRIDE,
-  animatorFrames,
-  letterOpacities,
-  textPoseOf
-} from "./chunk-ITAEZYM3.js";
-import {
-  timelineDuration
-} from "./chunk-KJQMMKPO.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-PLZOQXMQ.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
-};