@popcraft/kit 0.29.0 → 0.30.0

package/dist/chunks/chunk-74UIMI6P.js

@@ -0,0 +1,930 @@
+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 {
+  animate,
+  ease,
+  shiftPositionKeys
+} from "./chunk-YYQUCS6P.js";
+import {
+  UNIT_DEFAULTS,
+  animatorPath,
+  isTextNode,
+  withAnimator
+} from "./chunk-QZWEMMEL.js";
+import {
+  frameMotionEnd,
+  frameTimeline
+} from "./chunk-XDMQ6YHY.js";
+import {
+  addMarker,
+  updateMarker
+} from "./chunk-6YRHCDDT.js";
+import {
+  hostFrameOf
+} from "./chunk-PXXO7PQR.js";
+import {
+  asPath,
+  init_properties,
+  readPath
+} from "./chunk-4VICNBUI.js";
+import {
+  init_time,
+  staggerRanks,
+  timeShift
+} from "./chunk-RW67KLLE.js";
+import {
+  init_scene3d,
+  is3DContext
+} from "./chunk-NMFXCSU4.js";
+import {
+  init_transform3d,
+  zoomPx
+} from "./chunk-CK43FENV.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.js";
+
+// lib/motion/presets.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_properties();
+init_time();
+init_scene3d();
+init_transform3d();
+var PRESET_IDS = [
+  "fade-in",
+  "rise-in",
+  "drop-in",
+  "pop-in",
+  "scale-in",
+  "slide-in",
+  "wipe-in",
+  "blur-in",
+  "fade-out",
+  "rise-out",
+  "drop-out",
+  "pop-out",
+  "scale-out",
+  "slide-out",
+  "wipe-out",
+  "blur-out",
+  "pulse",
+  "shake",
+  "bounce",
+  "wobble",
+  "flash",
+  "impact-frame",
+  "push-in",
+  "pull-out",
+  "dolly",
+  "drift",
+  "zoom-through",
+  "truck",
+  "crane",
+  "pan",
+  "orbit",
+  "camera-shake",
+  "whip-pan",
+  "typewriter",
+  "letters-in",
+  "words-in",
+  "lines-in",
+  "letters-out",
+  "words-out",
+  "lines-out"
+];
+var num = (n, path, fallback) => {
+  const v = readPath(n, asPath(path));
+  return typeof v === "number" ? v : fallback;
+};
+var restOpacity = (n) => num(n, "opacity", 1);
+var overshoots = (i) => i.kind === "spring" || i.kind === "ease" && /^(back|elastic)-/.test(i.name);
+var fadeCurve = (i, dir) => overshoots(i) ? ease.named("cubic", dir) : i;
+var span = (path, a, b, p, curve = p.ease) => ({ path, keys: [{ t: 0, v: a, ease: curve }, { t: p.duration, v: b }] });
+var enter = (n, path, from, p, curve) => span(path, from, num(n, path, 0), p, curve);
+var leave = (n, path, to, p, curve) => span(path, num(n, path, 0), to, p, curve);
+var fadeIn = (n, p) => span("opacity", 0, restOpacity(n), p, fadeCurve(p.ease, "out"));
+var fadeOut = (n, p) => span("opacity", restOpacity(n), 0, p, fadeCurve(p.ease, "in"));
+var along = (dir, d) => dir === "left" ? { path: "translateX", by: -d } : dir === "right" ? { path: "translateX", by: d } : dir === "up" ? { path: "translateY", by: -d } : { path: "translateY", by: d };
+var scaleSpan = (n, a, b, p, curve) => {
+  const sx = num(n, "scaleX", 1), sy = num(n, "scaleY", 1);
+  return [span("scaleX", sx * a, sx * b, p, curve), span("scaleY", sy * a, sy * b, p, curve)];
+};
+var wave = (n, path, points, p, curve, rest = num(n, path, 0)) => ({ path, keys: points.map(([f, dv], i) => ({ t: f * p.duration, v: rest + dv, ...i < points.length - 1 ? { ease: curve } : {} })) });
+var BLUR_ID = "motion-blur";
+function withBlur(n) {
+  const effects = n.effects ?? [];
+  if (effects.some((e) => e.type === "LAYER_BLUR" && e.id)) return n;
+  return { ...n, effects: [...effects, { type: "LAYER_BLUR", radius: 0, visible: true, id: BLUR_ID }] };
+}
+function blurPath(n) {
+  const e = (n.effects ?? []).find((x) => x.type === "LAYER_BLUR" && x.id);
+  return `effects[@${e.id}].radius`;
+}
+var SMEAR_ID = "motion-smear";
+function withSmear(n, angle) {
+  const effects = n.effects ?? [];
+  const at = effects.findIndex((e) => e.type === "MOTION_BLUR" && e.id);
+  if (at >= 0) return { ...n, effects: effects.map((e, i) => i === at ? { ...e, angle } : e) };
+  return { ...n, effects: [...effects, { type: "MOTION_BLUR", radius: 0, angle, visible: true, id: SMEAR_ID }] };
+}
+function smearPath(n) {
+  const e = (n.effects ?? []).find((x) => x.type === "MOTION_BLUR" && x.id);
+  return `effects[@${e.id}].radius`;
+}
+var SHAKE_STEPS = 12;
+var SHAKE = (() => {
+  let seed = 23118;
+  const rnd = () => {
+    seed = Math.imul(seed, 1103515245) + 12345 >>> 0;
+    return seed / 2 ** 32 * 2 - 1;
+  };
+  const out = [[0, 0, 0, 0]];
+  for (let i = 1; i < SHAKE_STEPS; i++) {
+    const k = 1 - i / SHAKE_STEPS;
+    const sx = i % 2 ? 1 : -1;
+    out.push([i / SHAKE_STEPS, sx * k * (0.55 + 0.45 * Math.abs(rnd())), k * rnd(), k * rnd()]);
+  }
+  out.push([1, 0, 0, 0]);
+  return out;
+})();
+var clips = (n) => "clipsContent" in n || n.type === "FRAME";
+var clipping = (n) => !clips(n) || n.clipsContent ? n : { ...n, clipsContent: true };
+var WIPE_MIN = 0.01;
+function wipe(n, p, open) {
+  const w = num(n, "width", 0), tx = num(n, "translateX", 0);
+  const [a, b] = open ? [WIPE_MIN, w] : [w, WIPE_MIN];
+  const out = [span("width", a, b, p)];
+  if (p.direction === "left") out.push(open ? span("translateX", tx + w - WIPE_MIN, tx, p) : span("translateX", tx, tx + w - WIPE_MIN, p));
+  return out;
+}
+function maskWipe(m, p, open) {
+  const horizontal = p.direction === "left" || p.direction === "right";
+  const size = horizontal ? "width" : "height", shift = horizontal ? "translateX" : "translateY";
+  const full = num(m, size, 0), t0 = num(m, shift, 0);
+  const [a, b] = open ? [WIPE_MIN, full] : [full, WIPE_MIN];
+  const out = [span(size, a, b, p)];
+  if (p.direction === "left" || p.direction === "up") out.push(open ? span(shift, t0 + full - WIPE_MIN, t0, p) : span(shift, t0, t0 + full - WIPE_MIN, p));
+  return out;
+}
+var wipeGroupId = (layerId) => `${layerId}-wipe`;
+var wipeMaskId = (layerId) => `${layerId}-wipe-mask`;
+function ensureWipeMask(nodes, id, hostFrameId) {
+  const n = nodes[id];
+  const maskId = wipeMaskId(id);
+  if (nodes[maskId]) return { nodes, maskId };
+  const mask = (parentId, w, h) => ({
+    id: maskId,
+    type: "RECTANGLE",
+    name: "Wipe mask",
+    x: 0,
+    y: 0,
+    width: w,
+    height: h,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId,
+    childIds: [],
+    isMask: true,
+    maskType: "ALPHA",
+    fills: [{ type: "SOLID", color: { r: 1, g: 1, b: 1, a: 1 }, opacity: 1, visible: true }],
+    strokes: [],
+    cornerRadius: 0,
+    blendMode: "NORMAL",
+    layoutPositioning: "ABSOLUTE"
+  });
+  if (id === hostFrameId) {
+    return { nodes: { ...nodes, [maskId]: mask(id, n.width, n.height), [id]: { ...n, childIds: [maskId, ...n.childIds] } }, maskId };
+  }
+  const parent = n.parentId ? nodes[n.parentId] : void 0;
+  if (!parent) return { nodes, maskId };
+  const gid = wipeGroupId(id);
+  const group = {
+    id: gid,
+    type: "GROUP",
+    name: `${n.name || "Layer"} wipe`,
+    x: n.x,
+    y: n.y,
+    width: n.width,
+    height: n.height,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: parent.id,
+    childIds: [maskId, id],
+    blendMode: "NORMAL",
+    isMaskGroup: true,
+    ...n.layoutPositioning ? { layoutPositioning: n.layoutPositioning } : {}
+  };
+  const moved = { ...n, parentId: gid, x: 0, y: 0, motion: shiftPositionKeys(n.motion, -n.x, -n.y) };
+  if (!moved.motion) delete moved.motion;
+  return {
+    nodes: {
+      ...nodes,
+      [gid]: group,
+      [maskId]: mask(gid, n.width, n.height),
+      [id]: moved,
+      [parent.id]: { ...parent, childIds: parent.childIds.map((c) => c === id ? gid : c) }
+    },
+    maskId
+  };
+}
+var any = () => true;
+var CONTAINERS = /* @__PURE__ */ new Set(["FRAME", "GROUP", "COMPONENT", "INSTANCE", "SECTION"]);
+var isContainer = (n) => CONTAINERS.has(n.type) && n.childIds.length > 0;
+var autoRise = (n) => Math.max(24, Math.min(n.width, n.height) * 0.5);
+var CAM = "scene3d.camera.";
+var zoomOf = (n) => zoomPx(num(n, `${CAM}focalLength`, 50), n.width);
+var camTravel = (n, axis, by, p) => {
+  const r = num(n, CAM + axis, 0);
+  return span(CAM + axis, r, r + by, p);
+};
+var camArrive = (n, axis, by, p) => {
+  const r = num(n, CAM + axis, 0);
+  return span(CAM + axis, r + by, r, p);
+};
+var dollyAxis = (dir, d) => dir === "left" ? { axis: "x", by: -d } : dir === "right" ? { axis: "x", by: d } : dir === "up" ? { axis: "z", by: -d } : { axis: "z", by: d };
+function crane(n, p) {
+  const dy = p.direction === "down" ? p.distance : -p.distance;
+  const tilt = Math.atan2(-dy, zoomOf(n)) * 180 / Math.PI;
+  const r = num(n, `${CAM}rotateX`, 0);
+  return [camTravel(n, "y", dy, p), span(`${CAM}rotateX`, r, r + tilt, p)];
+}
+var cameraOrGroup = (n) => is3DContext(n) || isContainer(n);
+var isPlainText = (n) => isTextNode(n) && !n.threadPrevId;
+var TEXT_NEEDS = "a text layer";
+var unitRise = (n, unit) => Math.round((n.fontSize || 16) * UNIT_DEFAULTS[unit].rise);
+var cascade = (id, unit, sign) => (n, p) => isTextNode(n) ? withAnimator(n, { id, unit, range: { start: 0, end: 1, offset: 0 }, amount: 0, order: "forward", stagger: p.amount, props: { opacity: 0, translateY: sign * p.distance } }) : n;
+var cascadeKeys = (id, dir) => (_n, p) => [span(animatorPath(id, "amount"), dir === "in" ? 1 : 0, dir === "in" ? 0 : 1, p)];
+var cascadeAmount = (unit) => ({ label: "Stagger", default: UNIT_DEFAULTS[unit].stagger, min: 0, max: 2e3, step: 5, unit: "ms" });
+function textCascade(unit, dir) {
+  const id = `${unit}s-${dir}`;
+  const name = { letter: "Letters", word: "Words", line: "Lines" }[unit];
+  return {
+    id,
+    category: "text",
+    label: `${name} ${dir}`,
+    duration: dir === "in" ? 600 : 450,
+    description: dir === "in" ? `Each ${unit} rises into place and fades in, one after another` : `Each ${unit} rises away and fades, one after another`,
+    ease: dir === "in" ? ease.out("expo") : ease.named("expo", "in"),
+    distance: "auto",
+    autoDistance: (n) => unitRise(n, unit),
+    amount: cascadeAmount(unit),
+    appliesTo: isPlainText,
+    needs: TEXT_NEEDS,
+    prepare: cascade(id, unit, dir === "in" ? 1 : -1),
+    tracks: cascadeKeys(id, dir)
+  };
+}
+var slideDistance = (n, dir) => dir === "left" || dir === "right" ? n.width : n.height;
+var LIBRARY = [
+  // Entrances: they end at rest.
+  {
+    id: "fade-in",
+    category: "entrance",
+    label: "Fade in",
+    description: "Opacity from 0",
+    duration: 400,
+    ease: ease.out("cubic"),
+    appliesTo: any,
+    tracks: (n, p) => [span("opacity", 0, restOpacity(n), p)]
+  },
+  {
+    id: "rise-in",
+    category: "entrance",
+    label: "Rise",
+    description: "Moves up into place and fades in",
+    duration: 600,
+    ease: ease.out("expo"),
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => [fadeIn(n, p), enter(n, "translateY", num(n, "translateY", 0) + p.distance, p)]
+  },
+  {
+    id: "drop-in",
+    category: "entrance",
+    label: "Drop",
+    description: "Moves down into place and fades in",
+    duration: 600,
+    ease: ease.out("expo"),
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => [fadeIn(n, p), enter(n, "translateY", num(n, "translateY", 0) - p.distance, p)]
+  },
+  {
+    id: "pop-in",
+    category: "entrance",
+    label: "Pop",
+    description: "Grows from smaller with an overshoot",
+    duration: 500,
+    ease: ease.back(1.7),
+    amount: { label: "From scale", default: 0.6, min: 0, max: 1, step: 0.05 },
+    appliesTo: any,
+    tracks: (n, p) => [fadeIn(n, p), ...scaleSpan(n, p.amount, 1, p)]
+  },
+  {
+    id: "scale-in",
+    category: "entrance",
+    label: "Scale in",
+    description: "Grows from nothing about its anchor",
+    duration: 600,
+    ease: ease.out("expo"),
+    amount: { label: "From scale", default: 0, min: 0, max: 1, step: 0.05 },
+    appliesTo: any,
+    tracks: (n, p) => [fadeIn(n, p), ...scaleSpan(n, p.amount, 1, p)]
+  },
+  {
+    id: "slide-in",
+    category: "entrance",
+    label: "Slide in",
+    description: "Slides in from a side by its own size",
+    duration: 600,
+    ease: ease.out("expo"),
+    direction: "left",
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => {
+      const a = along(p.direction, p.distance);
+      return [fadeIn(n, p), enter(n, a.path, num(n, a.path, 0) + a.by, p)];
+    }
+  },
+  {
+    id: "wipe-in",
+    category: "entrance",
+    label: "Wipe",
+    description: "Revealed across by an opening mask",
+    duration: 600,
+    ease: ease.out("expo"),
+    direction: "right",
+    appliesTo: any,
+    prepare: clipping,
+    tracks: (n, p) => wipe(n, p, true),
+    mask: (m, p) => maskWipe(m, p, true)
+  },
+  {
+    id: "blur-in",
+    category: "entrance",
+    label: "Blur in",
+    description: "Comes into focus as it fades in",
+    duration: 600,
+    ease: ease.out("cubic"),
+    amount: { label: "Blur", default: 24, min: 0, max: 200, step: 1, unit: "px" },
+    appliesTo: any,
+    prepare: withBlur,
+    tracks: (n, p) => [fadeIn(n, p), span(blurPath(n), p.amount, 0, p)]
+  },
+  // Exits: they start at rest and end hidden (and stay so).
+  {
+    id: "fade-out",
+    category: "exit",
+    label: "Fade out",
+    description: "Opacity to 0",
+    duration: 400,
+    ease: ease.named("cubic", "in"),
+    appliesTo: any,
+    tracks: (n, p) => [span("opacity", restOpacity(n), 0, p)]
+  },
+  {
+    id: "rise-out",
+    category: "exit",
+    label: "Rise out",
+    description: "Moves up and fades away",
+    duration: 500,
+    ease: ease.named("expo", "in"),
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => [fadeOut(n, p), leave(n, "translateY", num(n, "translateY", 0) - p.distance, p)]
+  },
+  {
+    id: "drop-out",
+    category: "exit",
+    label: "Drop out",
+    description: "Moves down and fades away",
+    duration: 500,
+    ease: ease.named("expo", "in"),
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => [fadeOut(n, p), leave(n, "translateY", num(n, "translateY", 0) + p.distance, p)]
+  },
+  {
+    id: "pop-out",
+    category: "exit",
+    label: "Pop out",
+    description: "Winds up and shrinks away",
+    duration: 400,
+    ease: ease.back(1.7, "in"),
+    amount: { label: "To scale", default: 0.6, min: 0, max: 1, step: 0.05 },
+    appliesTo: any,
+    tracks: (n, p) => [fadeOut(n, p), ...scaleSpan(n, 1, p.amount, p)]
+  },
+  {
+    id: "scale-out",
+    category: "exit",
+    label: "Scale out",
+    description: "Shrinks to nothing about its anchor",
+    duration: 500,
+    ease: ease.named("expo", "in"),
+    amount: { label: "To scale", default: 0, min: 0, max: 1, step: 0.05 },
+    appliesTo: any,
+    tracks: (n, p) => [fadeOut(n, p), ...scaleSpan(n, 1, p.amount, p)]
+  },
+  {
+    id: "slide-out",
+    category: "exit",
+    label: "Slide out",
+    description: "Slides off toward a side by its own size",
+    duration: 500,
+    ease: ease.named("expo", "in"),
+    direction: "right",
+    distance: "auto",
+    appliesTo: any,
+    tracks: (n, p) => {
+      const a = along(p.direction, p.distance);
+      return [fadeOut(n, p), leave(n, a.path, num(n, a.path, 0) + a.by, p)];
+    }
+  },
+  {
+    id: "wipe-out",
+    category: "exit",
+    label: "Wipe out",
+    description: "Hidden across by a closing mask",
+    duration: 500,
+    ease: ease.named("expo", "in"),
+    direction: "right",
+    appliesTo: any,
+    prepare: clipping,
+    tracks: (n, p) => wipe(n, p, false),
+    mask: (m, p) => maskWipe(m, p, false)
+  },
+  {
+    id: "blur-out",
+    category: "exit",
+    label: "Blur out",
+    description: "Goes out of focus as it fades",
+    duration: 500,
+    ease: ease.named("cubic", "in"),
+    amount: { label: "Blur", default: 24, min: 0, max: 200, step: 1, unit: "px" },
+    appliesTo: any,
+    prepare: withBlur,
+    tracks: (n, p) => [fadeOut(n, p), span(blurPath(n), 0, p.amount, p)]
+  },
+  // Emphasis: from rest, back to rest.
+  {
+    id: "pulse",
+    category: "emphasis",
+    label: "Pulse",
+    description: "Swells and settles, twice",
+    duration: 800,
+    ease: ease.inOut("sine"),
+    amount: { label: "Swell", default: 0.08, min: 0, max: 1, step: 0.01 },
+    appliesTo: any,
+    tracks: (n, p) => ["scaleX", "scaleY"].map((path) => {
+      const r = num(n, path, 1);
+      return wave(n, path, [[0, 0], [0.25, r * p.amount], [0.5, 0], [0.75, r * p.amount], [1, 0]], p, p.ease);
+    })
+  },
+  {
+    id: "shake",
+    category: "emphasis",
+    label: "Shake",
+    description: "Side to side, dying away",
+    duration: 600,
+    ease: ease.inOut("sine"),
+    distance: 12,
+    appliesTo: any,
+    tracks: (n, p) => [wave(n, "translateX", [[0, 0], ...[1, 2, 3, 4, 5, 6, 7].map((i) => [i / 8, (i % 2 ? 1 : -1) * p.distance * (1 - i / 8)]), [1, 0]], p, p.ease)]
+  },
+  {
+    id: "bounce",
+    category: "emphasis",
+    label: "Bounce",
+    description: "Hops up and bounces back down",
+    duration: 900,
+    ease: ease.out("bounce"),
+    distance: 40,
+    appliesTo: any,
+    tracks: (n, p) => {
+      const r = num(n, "translateY", 0);
+      return [{ path: "translateY", keys: [{ t: 0, v: r, ease: ease.out("cubic") }, { t: 0.3 * p.duration, v: r - p.distance, ease: p.ease }, { t: p.duration, v: r }] }];
+    }
+  },
+  {
+    id: "wobble",
+    category: "emphasis",
+    label: "Wobble",
+    description: "Rocks about its anchor, dying away",
+    duration: 800,
+    ease: ease.inOut("sine"),
+    amount: { label: "Angle", default: 10, min: 0, max: 90, step: 1, unit: "\xB0" },
+    appliesTo: any,
+    tracks: (n, p) => [wave(n, "rotation", [[0, 0], ...[1, 2, 3, 4, 5].map((i) => [i / 6, (i % 2 ? 1 : -1) * p.amount * (1 - i / 6)]), [1, 0]], p, p.ease)]
+  },
+  {
+    id: "flash",
+    category: "emphasis",
+    label: "Flash",
+    description: "Blinks off and on, twice",
+    duration: 800,
+    ease: ease.inOut("sine"),
+    appliesTo: any,
+    tracks: (n, p) => {
+      const r = restOpacity(n);
+      return [wave(n, "opacity", [[0, 0], [0.25, -r], [0.5, 0], [0.75, -r], [1, 0]], p, p.ease, r)];
+    }
+  },
+  {
+    id: "impact-frame",
+    category: "emphasis",
+    label: "Impact frame",
+    description: "Held full on for a few frames at the hit, blinks off, on, and back to rest: a flash or inverted frame (rest it hidden)",
+    duration: 160,
+    ease: ease.hold,
+    appliesTo: any,
+    // Absolute: a flash is all or nothing. A flash layer rests hidden (opacity 0), so it is out of the way until the hit.
+    tracks: (n, p) => {
+      const r = restOpacity(n);
+      return [{ path: "opacity", keys: [{ t: 0, v: r, ease: ease.hold }, { t: 1, v: 1, ease: ease.hold }, { t: Math.round(0.45 * p.duration), v: 0, ease: ease.hold }, { t: Math.round(0.65 * p.duration), v: 1, ease: ease.hold }, { t: p.duration, v: r }] }];
+    }
+  },
+  // Camera: on a 3D context, moves its camera; on a group or frame, moves the group, carrying everything in it.
+  {
+    id: "push-in",
+    category: "camera",
+    label: "Push in",
+    description: "A slow move in: toward the scene in 3D, or the group grows about its anchor",
+    duration: 3e3,
+    ease: ease.inOut("cubic"),
+    amount: { label: "Zoom", default: 0.15, min: 0, max: 4, step: 0.01 },
+    appliesTo: cameraOrGroup,
+    needs: "a group or frame with layers in it, or a 3D scene",
+    tracks: (n, p) => is3DContext(n) ? [camTravel(n, "z", -zoomOf(n) * Math.min(0.95, p.amount), p)] : scaleSpan(n, 1, 1 + p.amount, p)
+  },
+  {
+    id: "pull-out",
+    category: "camera",
+    label: "Pull out",
+    description: "Starts close and eases back to the full view",
+    duration: 3e3,
+    ease: ease.inOut("cubic"),
+    amount: { label: "Zoom", default: 0.15, min: 0, max: 4, step: 0.01 },
+    appliesTo: cameraOrGroup,
+    needs: "a group or frame with layers in it, or a 3D scene",
+    tracks: (n, p) => is3DContext(n) ? [camArrive(n, "z", -zoomOf(n) * Math.min(0.95, p.amount), p)] : scaleSpan(n, 1 + p.amount, 1, p)
+  },
+  {
+    id: "dolly",
+    category: "camera",
+    label: "Dolly",
+    description: "Travels along a track: sideways, or in (up) and out (down) in 3D",
+    duration: 3e3,
+    ease: ease.inOut("expo"),
+    direction: "left",
+    distance: 160,
+    appliesTo: cameraOrGroup,
+    needs: "a group or frame with layers in it, or a 3D scene",
+    tracks: (n, p) => {
+      if (is3DContext(n)) {
+        const a2 = dollyAxis(p.direction, p.distance);
+        return [camTravel(n, a2.axis, a2.by, p)];
+      }
+      const a = along(p.direction, p.distance);
+      const r = num(n, a.path, 0);
+      return [span(a.path, r, r + a.by, p)];
+    }
+  },
+  {
+    id: "drift",
+    category: "camera",
+    label: "Drift",
+    description: "A slow float with a slight push",
+    duration: 4e3,
+    ease: ease.inOut("sine"),
+    direction: "right",
+    distance: 24,
+    amount: { label: "Zoom", default: 0.03, min: 0, max: 1, step: 0.01 },
+    appliesTo: isContainer,
+    needs: "a group or frame with layers in it",
+    tracks: (n, p) => {
+      const a = along(p.direction, p.distance);
+      const r = num(n, a.path, 0);
+      return [span(a.path, r, r + a.by, p), ...scaleSpan(n, 1, 1 + p.amount, p)];
+    }
+  },
+  {
+    id: "zoom-through",
+    category: "camera",
+    label: "Zoom through",
+    description: "Rushes toward the view and fades: a cut to the next scene",
+    duration: 800,
+    ease: ease.named("expo", "in"),
+    amount: { label: "Zoom", default: 2, min: 0, max: 20, step: 0.1 },
+    appliesTo: isContainer,
+    needs: "a group or frame with layers in it",
+    tracks: (n, p) => {
+      const r = restOpacity(n);
+      return [...scaleSpan(n, 1, 1 + p.amount, p), { path: "opacity", keys: [{ t: 0, v: r, ease: ease.hold }, { t: 0.6 * p.duration, v: r, ease: ease.named("cubic", "in") }, { t: p.duration, v: 0 }] }];
+    }
+  },
+  {
+    id: "truck",
+    category: "camera",
+    label: "Truck",
+    description: "The camera slides sideways past the scene",
+    duration: 3e3,
+    ease: ease.inOut("cubic"),
+    direction: "right",
+    distance: 240,
+    appliesTo: is3DContext,
+    needs: "a 3D scene (turn a group or frame 3D first)",
+    tracks: (n, p) => [camTravel(n, "x", p.direction === "left" ? -p.distance : p.distance, p)]
+  },
+  {
+    id: "crane",
+    category: "camera",
+    label: "Crane",
+    description: "The camera rises (or sinks), tilting to keep the scene in view",
+    duration: 3e3,
+    ease: ease.inOut("cubic"),
+    direction: "up",
+    distance: 240,
+    appliesTo: is3DContext,
+    needs: "a 3D scene (turn a group or frame 3D first)",
+    tracks: crane
+  },
+  {
+    id: "pan",
+    category: "camera",
+    label: "Pan",
+    description: "The camera turns in place to look across the scene",
+    duration: 3e3,
+    ease: ease.inOut("sine"),
+    direction: "right",
+    amount: { label: "Angle", default: 12, min: 0, max: 90, step: 1, unit: "\xB0" },
+    appliesTo: is3DContext,
+    needs: "a 3D scene (turn a group or frame 3D first)",
+    tracks: (n, p) => {
+      const r = num(n, `${CAM}rotateY`, 0);
+      return [span(`${CAM}rotateY`, r, r + (p.direction === "left" ? p.amount : -p.amount), p)];
+    }
+  },
+  {
+    id: "orbit",
+    category: "camera",
+    label: "Orbit",
+    description: "The camera circles the point of interest",
+    duration: 4e3,
+    ease: ease.inOut("cubic"),
+    direction: "right",
+    amount: { label: "Angle", default: 30, min: 0, max: 360, step: 1, unit: "\xB0" },
+    appliesTo: is3DContext,
+    needs: "a 3D scene (turn a group or frame 3D first)",
+    tracks: (n, p) => {
+      const r = num(n, `${CAM}orbit`, 0);
+      return [span(`${CAM}orbit`, r, r + (p.direction === "left" ? -p.amount : p.amount), p)];
+    }
+  },
+  {
+    id: "camera-shake",
+    category: "camera",
+    label: "Camera shake",
+    description: "A jolt that jitters and dies away: an impact, an explosion, a landing",
+    duration: 500,
+    ease: ease.inOut("sine"),
+    distance: 24,
+    amount: { label: "Turn", default: 1.5, min: 0, max: 20, step: 0.1, unit: "\xB0" },
+    appliesTo: isContainer,
+    needs: "a group or frame with layers in it",
+    tracks: (n, p) => [
+      wave(n, "translateX", SHAKE.map(([f, x]) => [f, x * p.distance]), p, p.ease),
+      wave(n, "translateY", SHAKE.map(([f, , y]) => [f, y * p.distance * 0.7]), p, p.ease),
+      wave(n, "rotation", SHAKE.map(([f, , , r]) => [f, r * p.amount]), p, p.ease)
+    ]
+  },
+  {
+    id: "whip-pan",
+    category: "camera",
+    label: "Whip pan",
+    description: "Swings fast along a direction, streaked with motion blur at its quickest",
+    duration: 360,
+    ease: ease.inOut("expo"),
+    direction: "left",
+    distance: "auto",
+    autoDistance: (n) => n.width,
+    amount: { label: "Streak", default: 120, min: 0, max: 1e3, step: 1, unit: "px" },
+    appliesTo: isContainer,
+    needs: "a group or frame with layers in it",
+    prepare: (n, p) => withSmear(n, p.direction === "up" || p.direction === "down" ? 90 : 0),
+    tracks: (n, p) => {
+      const a = along(p.direction, -p.distance);
+      const r = num(n, a.path, 0);
+      const blur = smearPath(n), b0 = num(n, blur, 0);
+      return [span(a.path, r, r + a.by, p), { path: blur, keys: [{ t: 0, v: b0, ease: ease.inOut("sine") }, { t: p.duration / 2, v: b0 + p.amount, ease: ease.inOut("sine") }, { t: p.duration, v: b0 }] }];
+    }
+  },
+  // Text: per letter, word or line (lib/motion/text-animators.ts).
+  {
+    id: "typewriter",
+    category: "text",
+    label: "Typewriter",
+    description: "Types the text out letter by letter",
+    duration: 1500,
+    ease: ease.linear,
+    appliesTo: isPlainText,
+    needs: TEXT_NEEDS,
+    // Every letter hidden while the range covers it; the range's start sweeps across, and each letter it passes is typed.
+    prepare: (n) => isTextNode(n) ? withAnimator(n, { id: "typewriter", unit: "letter", range: { start: 1, end: 1, offset: 0 }, order: "forward", props: { opacity: 0 }, ease: ease.hold }) : n,
+    tracks: (_n, p) => [{ path: animatorPath("typewriter", "range.start"), keys: [{ t: 0, v: 0, ease: p.ease }, { t: p.duration, v: 1 }] }]
+  },
+  textCascade("letter", "in"),
+  textCascade("word", "in"),
+  textCascade("line", "in"),
+  textCascade("letter", "out"),
+  textCascade("word", "out"),
+  textCascade("line", "out")
+];
+var BY_ID = new Map(LIBRARY.map((p) => [p.id, p]));
+if (BY_ID.size !== PRESET_IDS.length || PRESET_IDS.some((id) => !BY_ID.has(id))) throw new Error("motion presets: the id list and the library disagree");
+var MOTION_PRESETS = LIBRARY;
+var PRESET_CATEGORIES = [
+  { id: "entrance", label: "Entrance" },
+  { id: "exit", label: "Exit" },
+  { id: "emphasis", label: "Emphasis" },
+  { id: "camera", label: "Camera" },
+  { id: "text", label: "Text" }
+];
+var presetById = (id) => BY_ID.get(id);
+var isPresetId = (id) => BY_ID.has(id);
+function resolvePresetParams(preset, node, params = {}) {
+  const direction = params.direction ?? preset.direction ?? "left";
+  const distance = params.distance ?? (preset.distance === "auto" ? preset.autoDistance ? preset.autoDistance(node) : preset.id === "slide-in" || preset.id === "slide-out" ? slideDistance(node, direction) : autoRise(node) : preset.distance ?? 0);
+  return {
+    duration: Math.max(1, Math.round(params.duration ?? preset.duration)),
+    ease: params.ease ?? preset.ease,
+    distance,
+    direction,
+    amount: params.amount ?? preset.amount?.default ?? 0
+  };
+}
+function presetTracks(preset, node, params = {}) {
+  const p = resolvePresetParams(preset, node, params);
+  return preset.tracks(preset.prepare ? preset.prepare(node, p) : node, p);
+}
+function applyPreset(node, presetId, params = {}, at = 0) {
+  const preset = BY_ID.get(presetId);
+  if (!preset) throw new Error(`applyPreset: no preset "${presetId}"`);
+  const p = resolvePresetParams(preset, node, params);
+  let n = preset.prepare ? preset.prepare(node, p) : node;
+  const start = Math.max(0, at + (params.delay ?? 0));
+  for (const tr of preset.tracks(n, p)) n = animate(n, tr.path, tr.keys.map((k) => ({ ...k, t: start + k.t })));
+  return n;
+}
+function treeOrder(nodes, ids) {
+  const pathOf = (id) => {
+    const out = [];
+    for (let n = nodes[id]; n?.parentId; n = nodes[n.parentId]) {
+      const parent = nodes[n.parentId];
+      if (!parent) break;
+      out.unshift(parent.childIds.indexOf(n.id));
+    }
+    return out;
+  };
+  const paths = new Map(ids.map((id) => [id, pathOf(id)]));
+  return [...ids].sort((a, b) => {
+    const pa = paths.get(a), pb = paths.get(b);
+    for (let i = 0; i < Math.min(pa.length, pb.length); i++) if (pa[i] !== pb[i]) return pa[i] - pb[i];
+    return pa.length - pb.length;
+  });
+}
+function staggerPlaces(nodes, ids, order = "index", seed = 0) {
+  return order === "selection" ? staggerRanks(ids, "index") : staggerRanks(treeOrder(nodes, ids), order, seed);
+}
+function applyPresetToDocument(doc, ids, presetId, opts = {}) {
+  const preset = BY_ID.get(presetId);
+  if (!preset) throw new Error(`applyPresetToDocument: no preset "${presetId}"`);
+  let nodes = doc.nodes;
+  const skipped = [];
+  const hosts = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const n = nodes[id];
+    const host = n ? hostFrameOf(nodes, id) : null;
+    if (!n || !host) {
+      skipped.push({ id, reason: "not inside a frame" });
+      continue;
+    }
+    if (!preset.appliesTo(n)) {
+      skipped.push({ id, reason: `${preset.label} needs ${preset.needs ?? "another kind of layer"}` });
+      continue;
+    }
+    hosts.set(id, host);
+  }
+  const targets = [...hosts.keys()];
+  const frames = [...new Set(hosts.values())];
+  const startOf = new Map(frames.map((f) => [f, opts.at ?? (opts.onClick ? frameMotionEnd(nodes, f) : 0)]));
+  const liveParent = opts.stagger && !preset.mask ? liveStaggerParent(nodes, targets) : null;
+  const places = opts.stagger && !liveParent ? staggerPlaces(nodes, targets, opts.stagger.order, opts.stagger.seed) : null;
+  let out = { ...nodes };
+  if (liveParent && opts.stagger) {
+    const { delay, order = "index", seed } = opts.stagger;
+    const parent = out[liveParent];
+    out[liveParent] = { ...parent, motion: { tracks: {}, ...parent.motion, stagger: { delay, order: order === "selection" ? { ids: [...targets] } : order, ...order === "random" && seed !== void 0 ? { seed } : {} } } };
+  }
+  for (const id of targets) {
+    const frameId = hosts.get(id);
+    const frameAt = startOf.get(frameId) + (places ? (places.get(id) ?? 0) * opts.stagger.delay : 0);
+    if (preset.mask) {
+      const wrapped = ensureWipeMask(out, id, frameId);
+      out = { ...wrapped.nodes };
+      const m = out[wrapped.maskId];
+      if (!m) {
+        skipped.push({ id, reason: `${preset.label} needs a layer inside a frame` });
+        continue;
+      }
+      const p = resolvePresetParams(preset, m, opts);
+      const start = Math.max(0, frameAt - timeShift(out, m.id, frameId) + (opts.delay ?? 0));
+      let keyed = m;
+      for (const tr of preset.mask(m, p, preset.category === "entrance")) keyed = animate(keyed, tr.path, tr.keys.map((k) => ({ ...k, t: start + k.t })));
+      out[m.id] = keyed;
+      continue;
+    }
+    const local = frameAt - (id === frameId ? 0 : timeShift(nodes, id, frameId));
+    out[id] = applyPreset(nodes[id], presetId, opts, local);
+  }
+  nodes = out;
+  const timelines = {};
+  for (const frameId of frames) {
+    const end = frameMotionEnd(nodes, frameId);
+    const stored = nodes[frameId].timeline;
+    let tl = stored;
+    if (opts.onClick) {
+      const added = addMarker(frameTimeline(nodes, frameId), startOf.get(frameId));
+      tl = updateMarker(added.timeline, added.id, { kind: "pause" });
+    }
+    tl = lengthenedTo(tl, end);
+    if (tl !== stored) timelines[frameId] = { ...nodes[frameId], timeline: tl };
+  }
+  if (Object.keys(timelines).length) nodes = { ...nodes, ...timelines };
+  return { document: { ...doc, nodes }, ids: targets, frameIds: frames, skipped };
+}
+function liveStaggerParent(nodes, ids) {
+  if (ids.length < 2) return null;
+  const parentId = nodes[ids[0]]?.parentId;
+  const parent = parentId ? nodes[parentId] : void 0;
+  if (!parent || parent.type === "PAGE" || parent.motion?.stagger) return null;
+  const set = new Set(ids);
+  if (set.size !== parent.childIds.length || !parent.childIds.every((c) => set.has(c))) return null;
+  const still = (id) => {
+    const n = nodes[id];
+    if (!n) return true;
+    const m = n.motion;
+    if (m && (Object.keys(m.tracks).length || m.timeOffset || m.span || m.stagger)) return false;
+    return (n.childIds ?? []).every(still);
+  };
+  return ids.every(still) ? parent.id : null;
+}
+var lengthenedTo = (tl, end) => tl && tl.duration < end ? { ...tl, duration: Math.ceil(end) } : tl;
+function staggerDocument(doc, ids, opts) {
+  const present = ids.filter((id) => doc.nodes[id]);
+  if (!present.length) return doc;
+  const places = staggerPlaces(doc.nodes, present, opts.order, opts.seed);
+  const nodes = { ...doc.nodes };
+  for (const id of present) {
+    const n = nodes[id];
+    const offset = Math.round((opts.start ?? 0) + (places.get(id) ?? 0) * opts.delay);
+    const { timeOffset: _was, ...rest } = n.motion ?? { tracks: {} };
+    void _was;
+    const motion = offset ? { ...rest, timeOffset: offset } : rest;
+    const empty = !Object.keys(motion.tracks).length && motion.timeOffset === void 0 && !motion.span && !motion.stagger;
+    if (empty) {
+      const { motion: _m, ...bare } = n;
+      void _m;
+      nodes[id] = bare;
+    } else nodes[id] = { ...n, motion };
+  }
+  return { ...doc, nodes };
+}
+
+export {
+  PRESET_IDS,
+  wipeGroupId,
+  wipeMaskId,
+  ensureWipeMask,
+  MOTION_PRESETS,
+  PRESET_CATEGORIES,
+  presetById,
+  isPresetId,
+  resolvePresetParams,
+  presetTracks,
+  applyPreset,
+  treeOrder,
+  staggerPlaces,
+  applyPresetToDocument,
+  liveStaggerParent,
+  lengthenedTo,
+  staggerDocument
+};