@idle-screens/schema 3.14.0 → 3.15.0

package/dist/index.js

@@ -96,6 +96,8 @@ var LIMITS = {
   // ms — a `clock`ed layer breathes in unison, so 1 Hz not 2
   minClockRate: 0.1,
   maxClockRate: 4,
+  maxWobble: 0.25,
+  // min(w,h) units — drift `bob` / rise `sway` above this warn `motion-amplitude` (× referenceViewport in px specs)
   defaultListGap: 0.06,
   // viewport units between list/table cells (40 px in px specs)
   defaultListGapPx: 40,
@@ -103,6 +105,17 @@ var LIMITS = {
   maxPolygonSides: 12,
   maxShapePoints: 24,
   // polygon.points / stroke.points
+  maxTextNumberDecimals: 6,
+  maxTextAffix: 64,
+  // characters of a counter's prefix / suffix
+  maxRevealRise: 1,
+  // em
+  maxRockAmp: 45,
+  // degrees either side of rest — a swing, not a spin
+  minRockPeriod: 1e3,
+  // ms — a calm swing; at most once a second
+  maxLifeStagger: 6e4,
+  // ms between successive entities' entrances
   minEaseTau: 100,
   // ms
   maxEaseTau: 12e4
@@ -368,7 +381,7 @@ function lerpPathD(a, b, k) {
 }
 function textStringsOf(sprite) {
   if (sprite.kind === "text") return sprite.strings;
-  if (sprite.kind === "textBlock") return [sprite.text];
+  if (sprite.kind === "textBlock") return [sprite.number ? `${sprite.number.prefix ?? ""}\0${sprite.number.suffix ?? ""}` : sprite.text];
   return null;
 }
 function textStringsDiffer(a, b, i) {
@@ -462,6 +475,28 @@ function easeSmooth(k) {
   const c = Math.max(0, Math.min(1, k));
   return c * c * (3 - 2 * c);
 }
+var SPRING_OMEGA = 8;
+var SPRING_END = 1 - (1 + SPRING_OMEGA) * Math.exp(-SPRING_OMEGA);
+function easeGlide(ease2, k) {
+  const c = Math.max(0, Math.min(1, k));
+  switch (ease2) {
+    case "step":
+      return c >= 1 ? 1 : 0;
+    case "linear":
+      return c;
+    case "in":
+      return c * c * c;
+    case "out": {
+      const u = 1 - c;
+      return 1 - u * u * u;
+    }
+    case "spring":
+      return c >= 1 ? 1 : (1 - (1 + SPRING_OMEGA * c) * Math.exp(-SPRING_OMEGA * c)) / SPRING_END;
+    default:
+      return c * c * (3 - 2 * c);
+  }
+}
+var STEER_EASES = /* @__PURE__ */ new Set(["in", "out", "spring"]);
 function structuralSignature(spec) {
   return JSON.stringify([
     spec.units,
@@ -497,7 +532,9 @@ function structuralSignature(spec) {
         l.sprite.kind === "emoji" ? [l.sprite.glyphs.length, l.sprite.cycle?.period] : l.sprite.kind === "text" ? [l.sprite.strings.length, l.sprite.cycle?.period] : l.sprite.kind === "textBlock" ? l.sprite.anchor ? [l.sprite.fontSize, l.sprite.anchor] : [l.sprite.fontSize] : void 0,
         // Static rotation is baked into entities (a range draws a seeded
         // angle). Appended only when set — same rule as `anchor` above.
-        ...l.rotate !== void 0 ? [l.rotate] : []
+        ...l.rotate !== void 0 ? [l.rotate] : [],
+        // `rock` is baked per entity like `pulse` (and draws a seeded phase).
+        ...l.rock !== void 0 ? [{ rock: l.rock }] : []
       ];
     })
   ]);
@@ -613,6 +650,7 @@ function sequenceSwapCompatible(prev, next) {
 function transitionKey(tr) {
   if (!tr || tr.type === "cut") return "cut";
   if (tr.type === "morph") return `morph:${tr.dur}:${tr.text ?? "step"}`;
+  if (tr.type === "wipe") return `wipe:${tr.dur}:${JSON.stringify([tr.shape ?? "circle", tr.origin ?? null, tr.angle ?? 0, tr.feather ?? 0.08])}`;
   return `fade:${tr.dur}`;
 }
 
@@ -649,10 +687,7 @@ function timelineLocalTime(tl, t) {
   return t;
 }
 function ease(k, x) {
-  const c = x <= 0 ? 0 : x >= 1 ? 1 : x;
-  if (k.ease === "step") return c >= 1 ? 1 : 0;
-  if (k.ease === "linear") return c;
-  return easeSmooth(c);
+  return easeGlide(k.ease, x);
 }
 function evalTrack(keys, start, tt, leaf) {
   let from = start;
@@ -801,7 +836,10 @@ function strokeSamples(s, halfSize, n) {
   if (m < 2) return pts;
   const smooth = s.curve !== "linear" && m >= 3;
   const segs = m - 1;
-  n = n ?? Math.max(STROKE_SAMPLES, segs * 6 + 1);
+  if (n === void 0) {
+    n = Math.max(STROKE_SAMPLES, segs * 6 + 1);
+    if (!smooth) n = Math.ceil((n - 1) / segs) * segs + 1;
+  }
   const at = (k) => pts[Math.max(0, Math.min(m - 1, k))];
   const out = [];
   for (let i = 0; i < n; i++) {
@@ -820,6 +858,22 @@ function strokeSamples(s, halfSize, n) {
   }
   return out;
 }
+function strokeDrawnSamples(s, halfSize) {
+  const pts = strokeSamples(s, halfSize);
+  const span = drawSpan(s.draw);
+  return span ? trimPolyline(pts, span[0], span[1]) : pts;
+}
+function strokeDrawnAt(s, halfSize, drawn) {
+  if (!s.draw) return void 0;
+  const total = pathLength(strokeSamples(s, halfSize));
+  if (!(total > 0)) return void 0;
+  const a = drawSpan(s.draw)?.[0] ?? 0;
+  let run = 0;
+  return drawn.map((p, i) => {
+    if (i > 0) run += Math.hypot(p.x - drawn[i - 1].x, p.y - drawn[i - 1].y);
+    return a + run / total;
+  });
+}
 function pathLength(pts) {
   let l = 0;
   for (let i = 1; i < pts.length; i++) {
@@ -829,6 +883,83 @@ function pathLength(pts) {
   }
   return l;
 }
+function drawSpan(d) {
+  if (!d) return null;
+  const a = Math.max(0, Math.min(1, d.start ?? 0));
+  const b = Math.max(0, Math.min(1, d.end ?? 1));
+  return a <= 0 && b >= 1 ? null : [a, b];
+}
+function trimPolyline(pts, a, b) {
+  if (pts.length < 2 || b <= a) return [];
+  const total = pathLength(pts);
+  if (!(total > 0)) return [];
+  const from = a * total;
+  const to = b * total;
+  const out = [];
+  let run = 0;
+  for (let i = 1; i < pts.length; i++) {
+    const p = pts[i - 1];
+    const q = pts[i];
+    const seg = Math.hypot(q.x - p.x, q.y - p.y);
+    const s0 = run;
+    const s1 = run + seg;
+    run = s1;
+    if (s1 < from || seg <= 0) continue;
+    if (s0 > to) break;
+    const at = (s) => {
+      const k = Math.max(0, Math.min(1, (s - s0) / seg));
+      return { x: p.x + (q.x - p.x) * k, y: p.y + (q.y - p.y) * k };
+    };
+    if (out.length === 0) out.push(s0 >= from ? { x: p.x, y: p.y } : at(from));
+    out.push(s1 <= to ? { x: q.x, y: q.y } : at(to));
+    if (s1 >= to) break;
+  }
+  return out.length >= 2 ? out : [];
+}
+function trimLines(lines, a, b) {
+  const key = `${a}|${b}`;
+  let byLines = trimCache.get(lines);
+  const hit = byLines?.get(key);
+  if (hit) return hit;
+  const lens = lines.map((l) => {
+    const pts = l.points.map(([x, y]) => ({ x, y }));
+    if (l.closed && pts.length > 1) pts.push(pts[0]);
+    return pathLength(pts);
+  });
+  const total = lens.reduce((m, v) => m + v, 0);
+  const out = [];
+  if (total > 0 && b > a) {
+    const from = a * total;
+    const to = b * total;
+    let run = 0;
+    lines.forEach((l, i) => {
+      const len = lens[i];
+      const s0 = run;
+      run += len;
+      if (len <= 0 || run < from || s0 > to) return;
+      if (s0 >= from && run <= to) {
+        out.push(l);
+        return;
+      }
+      const pts = l.points.map(([x, y]) => ({ x, y }));
+      if (l.closed && pts.length > 1) pts.push(pts[0]);
+      const cut = trimPolyline(pts, (Math.max(from, s0) - s0) / len, (Math.min(to, run) - s0) / len);
+      if (cut.length >= 2) out.push({ points: cut.map((q) => [q.x, q.y]), closed: false });
+    });
+  }
+  if (!byLines) {
+    byLines = /* @__PURE__ */ new Map();
+    trimCache.set(lines, byLines);
+  }
+  if (byLines.size > 64) byLines.clear();
+  byLines.set(key, out);
+  return out;
+}
+var trimCache = /* @__PURE__ */ new WeakMap();
+function strokeLines(part) {
+  const span = drawSpan(part.stroke?.draw);
+  return span ? trimLines(part.flat.lines, span[0], span[1]) : part.flat.lines;
+}
 function strokeTaper(u) {
   return Math.max(0.15, Math.sin(Math.PI * Math.max(0, Math.min(1, u))));
 }
@@ -873,10 +1004,10 @@ function ribbonSides(pts, half) {
   }
   return { left, right };
 }
-function strokeOutline(pts, lw, taper = true) {
+function strokeOutline(pts, lw, taper = true, at) {
   const n = pts.length;
   if (n < 2) return [];
-  const half = (i) => Math.max(0.5, taper ? lw * strokeTaper(i / (n - 1)) : lw) / 2;
+  const half = (i) => Math.max(0.5, taper ? lw * strokeTaper(at?.[i] ?? i / (n - 1)) : lw) / 2;
   const dir = (a, b) => {
     const dx = b.x - a.x;
     const dy = b.y - a.y;
@@ -968,7 +1099,7 @@ function partInkArea(part, sx, sy, r) {
   const fill = part.fill ? polygonArea(part.flat.points.map(([x, y]) => ({ x: x * sx, y: y * sy }))) * part.opacity : 0;
   let stroke = 0;
   if (part.stroke && part.stroke.width > 0) {
-    for (const l of part.flat.lines) {
+    for (const l of strokeLines(part)) {
       const pts = l.points.map(([x, y]) => ({ x: x * sx, y: y * sy }));
       if (l.closed && pts.length > 1) pts.push(pts[0]);
       stroke += pathLength(pts) * part.stroke.width * r;
@@ -1295,10 +1426,33 @@ function inside(pt, r) {
   }
   return c;
 }
+var ON_EDGE = 2 * PATH_TOLERANCE;
+function onEdge(pt, r) {
+  for (let k = 0, j = r.length - 1; k < r.length; j = k++) {
+    const a = r[j], b = r[k];
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    const len2 = dx * dx + dy * dy;
+    const t = len2 > 0 ? Math.max(0, Math.min(1, ((pt[0] - a[0]) * dx + (pt[1] - a[1]) * dy) / len2)) : 0;
+    const ex = a[0] + dx * t - pt[0], ey = a[1] + dy * t - pt[1];
+    if (ex * ex + ey * ey <= ON_EDGE * ON_EDGE) return true;
+  }
+  return false;
+}
 function containsRing(r, rb, sub, sb) {
-  if (sb.x0 < rb.x0 || sb.x1 > rb.x1 || sb.y0 < rb.y0 || sb.y1 > rb.y1) return false;
-  for (const p of sub) if (!inside(p, r)) return false;
-  return true;
+  if (sb.x0 < rb.x0 - ON_EDGE || sb.x1 > rb.x1 + ON_EDGE || sb.y0 < rb.y0 - ON_EDGE || sb.y1 > rb.y1 + ON_EDGE) return false;
+  let strictly = false;
+  for (const p of sub) {
+    if (inside(p, r)) strictly = true;
+    else if (!onEdge(p, r)) return false;
+  }
+  if (strictly) return true;
+  let cx = 0, cy = 0;
+  for (const p of sub) {
+    cx += p[0];
+    cy += p[1];
+  }
+  const c = [cx / sub.length, cy / sub.length];
+  return !onEdge(c, r) && inside(c, r);
 }
 function boxOf(r) {
   const b = { x0: Infinity, x1: -Infinity, y0: Infinity, y1: -Infinity };
@@ -1447,6 +1601,7 @@ var KNOWN_LAYER = /* @__PURE__ */ new Set([
   "emit",
   "clock",
   "rotate",
+  "rock",
   "opacity",
   "transform",
   "group"
@@ -1457,6 +1612,7 @@ var GROUP_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
 var KNOWN_POSITION = /* @__PURE__ */ new Set(["x", "y", "dx", "dy"]);
 var KNOWN_TIMELINE = /* @__PURE__ */ new Set(["loop", "duration", "keys"]);
 var KNOWN_TIMELINE_KEY = /* @__PURE__ */ new Set(["t", "path", "value", "ease", "dur"]);
+var GLIDE_EASES = /* @__PURE__ */ new Set(["step", "linear", "smooth", "in", "out", "spring"]);
 var KNOWN_CIRCLE = /* @__PURE__ */ new Set(["kind", "radius", "color", "soft", "colors", "colorWeights"]);
 var KNOWN_RING = /* @__PURE__ */ new Set(["kind", "radius", "color", "width", "colors", "colorWeights"]);
 var KNOWN_STREAK = /* @__PURE__ */ new Set(["kind", "length", "color", "width", "colors", "colorWeights"]);
@@ -1464,28 +1620,89 @@ var KNOWN_RECT = /* @__PURE__ */ new Set(["kind", "width", "aspect", "color", "f
 var KNOWN_BAR = /* @__PURE__ */ new Set(["kind", "values", "length", "thickness", "color", "max", "direction", "colors", "colorWeights"]);
 var KNOWN_PATH_PART = /* @__PURE__ */ new Set(["path", "color", "fillRule", "fill", "gradient", "stroke", "opacity"]);
 var KNOWN_POLYGON = /* @__PURE__ */ new Set(["kind", "radius", "color", "sides", "points", "path", "fillRule", "fill", "gradient", "stroke", "parts", "span", "origin", "soft", "colors", "colorWeights"]);
-var KNOWN_STROKE = /* @__PURE__ */ new Set(["kind", "length", "points", "color", "width", "curve", "taper", "orient", "colors", "colorWeights"]);
+var KNOWN_STROKE = /* @__PURE__ */ new Set(["kind", "length", "points", "color", "width", "curve", "taper", "orient", "draw", "colors", "colorWeights"]);
 var KNOWN_EMOJI = /* @__PURE__ */ new Set(["kind", "glyphs", "cycle"]);
 var KNOWN_TEXT = /* @__PURE__ */ new Set(["kind", "strings", "color", "font", "align", "baseline", "maxWidth", "cycle", "role"]);
-var KNOWN_TEXT_BLOCK = /* @__PURE__ */ new Set(["kind", "text", "maxWidth", "fontSize", "lineHeight", "align", "color", "reveal", "anchor", "font", "opacity", "role"]);
+var KNOWN_TEXT_BLOCK = /* @__PURE__ */ new Set(["kind", "text", "maxWidth", "fontSize", "lineHeight", "align", "color", "reveal", "anchor", "font", "opacity", "role", "number"]);
+var KNOWN_TEXT_NUMBER = /* @__PURE__ */ new Set(["value", "decimals", "prefix", "suffix", "grouping"]);
 var TEXT_ROLES = /* @__PURE__ */ new Set(["read", "atmosphere"]);
 var TEXT_BLOCK_ANCHORS = /* @__PURE__ */ new Set(["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"]);
 var FONT_SIZE_RE = /\d(?:px|pt|pc|em|rem|ex|ch|vw|vh|vmin|vmax|%)/i;
-var KNOWN_REVEAL = /* @__PURE__ */ new Set(["progress", "mode", "speed", "caret", "fade"]);
+var KNOWN_REVEAL = /* @__PURE__ */ new Set(["progress", "mode", "speed", "caret", "fade", "rise"]);
+var FOREIGN_FIELD_HINTS = {
+  top: {
+    duration: "a scene has no length \u2014 loop authored change with `timeline: { loop: true, duration }`, or give a sequence segment a `duration`",
+    loop: "use `timeline: { loop: true, duration, keys }`",
+    fps: "a scene is a pure function of time \u2014 there is no frame rate to set",
+    frameRate: "a scene is a pure function of time \u2014 there is no frame rate to set",
+    bpm: "there is no tempo unit \u2014 write times in ms (one beat = 60000 / bpm)",
+    tempo: "there is no tempo unit \u2014 write times in ms (one beat = 60000 / bpm)",
+    camera: "use a `groups.<name>.transform` (a camera over its member layers) or a layer `transform`",
+    keyframes: "use `timeline: { keys: [{ t, path, value, dur, ease }] }`",
+    palette: "colours live on sprites (`color`, or `colors` for a seeded per-entity pick)"
+  },
+  layer: {
+    delay: "use `life.enter` (ms before the layer fades in)",
+    stagger: "use `life.stagger` (ms between successive entities' entrances)",
+    duration: "use `life.exit` to end a layer (ms), or a sequence segment's `duration`",
+    ease: "eases live on timeline keys and steers (`ease: 'out'`), or on drift/rise/wander motion (`motion.ease`)",
+    easing: "eases live on timeline keys and steers (`ease: 'out'`), or on drift/rise/wander motion (`motion.ease`)",
+    rotation: "use `rotate` (static degrees), `spin` (degrees/sec) or `rock` (a swing back and forth)",
+    wobble: "use `rock` (a swing back and forth) or the motion's `bob` / `sway`",
+    sway: "use `rock` (a swing back and forth), or `sway` on a rise motion",
+    scale: "use `transform.scale` (paint, glides) or `grow` (breathing)",
+    fade: "use `life.fade` (ms) or the layer's paint `opacity`",
+    blur: "there is no blur \u2014 soften with `soft: true` (circle/polygon), `rect.feather`, `trail` or `ghosting`",
+    glow: "glow is `blend: 'lighter'` over soft circles",
+    keyframes: "use the scene's `timeline` (keys on this layer's paths)",
+    animation: "use the scene's `timeline` (keys on this layer's paths)"
+  },
+  key: {
+    duration: "use `dur` (the glide length, ms)",
+    delay: "use `t` (when the glide starts, ms)",
+    time: "use `t` (when the glide starts, ms)",
+    at: "use `t` (when the glide starts, ms)",
+    start: "use `t` (when the glide starts, ms)",
+    easing: "use `ease` ('smooth' | 'linear' | 'step' | 'in' | 'out' | 'spring')",
+    to: "use `value`",
+    target: "use `value`",
+    from: "a key glides from wherever its path is \u2014 set the starting value on the base spec"
+  },
+  motion: {
+    delay: "use the layer's `life.enter`",
+    easing: "use `ease: { type: 'settle' | 'buoyant', tau }` on drift / rise / wander",
+    duration: "only `path` motion has a `duration` (ms per lap)"
+  }
+};
+function unknownMessage(where, k, plain) {
+  const hint = Object.prototype.hasOwnProperty.call(FOREIGN_FIELD_HINTS[where], k) ? FOREIGN_FIELD_HINTS[where][k] : void 0;
+  return hint ? `${plain} \u2014 ${hint}` : plain;
+}
 var KNOWN_REVEAL_CARET = /* @__PURE__ */ new Set(["blink", "color"]);
-var KNOWN_DRIFT = /* @__PURE__ */ new Set(["type", "speed", "angle", "bidirectional", "bob", "ease"]);
-var KNOWN_RISE = /* @__PURE__ */ new Set(["type", "speed", "sway", "ease"]);
-var KNOWN_BOUNCE = /* @__PURE__ */ new Set(["type", "speed"]);
-var KNOWN_STATIC = /* @__PURE__ */ new Set(["type"]);
-var KNOWN_ORBIT = /* @__PURE__ */ new Set(["type", "speed", "radius", "center"]);
-var KNOWN_WANDER = /* @__PURE__ */ new Set(["type", "speed", "angle", "meander", "coherence", "ease"]);
-var KNOWN_WARP = /* @__PURE__ */ new Set(["type", "speed", "center"]);
-var KNOWN_PATH = /* @__PURE__ */ new Set(["type", "points", "duration", "curve", "closed", "scatter"]);
+var MOTION_FIELDS = {
+  drift: ["speed", "angle", "bidirectional", "bob", "ease"],
+  rise: ["speed", "sway", "ease"],
+  bounce: ["speed"],
+  static: [],
+  orbit: ["speed", "radius", "center"],
+  wander: ["speed", "angle", "meander", "coherence", "ease"],
+  warp: ["speed", "center"],
+  path: ["points", "duration", "curve", "closed", "scatter"]
+};
+var motionKnown = (t) => /* @__PURE__ */ new Set(["type", ...MOTION_FIELDS[t]]);
+var KNOWN_DRIFT = motionKnown("drift");
+var KNOWN_RISE = motionKnown("rise");
+var KNOWN_BOUNCE = motionKnown("bounce");
+var KNOWN_STATIC = motionKnown("static");
+var KNOWN_ORBIT = motionKnown("orbit");
+var KNOWN_WANDER = motionKnown("wander");
+var KNOWN_WARP = motionKnown("warp");
+var KNOWN_PATH = motionKnown("path");
 var KNOWN_BG_SOLID = /* @__PURE__ */ new Set(["type", "color"]);
 var KNOWN_BG_GRADIENT = /* @__PURE__ */ new Set(["type", "stops", "band", "drift"]);
 var KNOWN_BG_FIELD = /* @__PURE__ */ new Set(["type", "scale", "octaves", "warp", "quantize", "bands", "drift", "seed"]);
 var KNOWN_FIELD_DRIFT = /* @__PURE__ */ new Set(["period", "amount"]);
-var LAYER_PROPS_ON_SPRITE = /* @__PURE__ */ new Set(["blend", "trail", "alpha", "pulse", "spin", "grow", "region", "links", "flip", "wrap", "key", "emit", "clock", "life", "layout", "rotate"]);
+var LAYER_PROPS_ON_SPRITE = /* @__PURE__ */ new Set(["blend", "trail", "alpha", "pulse", "spin", "grow", "region", "links", "flip", "wrap", "key", "emit", "clock", "life", "layout", "rotate", "rock"]);
 function unknownKeys(obj, known) {
   return Object.keys(obj).filter((k) => !known.has(k));
 }
@@ -1522,7 +1739,16 @@ function ignoredPropertyPaths(spec) {
   if (!isObj(spec)) return [];
   return (validateSpecCore(spec, false).warnings ?? []).filter((w) => w.code === "unknown-property" || w.code === "misplaced-property").map((w) => w.path.replace(/\[(\d+)\]/g, ".$1"));
 }
-function validateSpecPaths(spec, paths) {
+function validateSpecPaths(spec, paths, keyed = false) {
+  if (!keyed) return specPathsValid(spec, paths);
+  keyedPathDepth++;
+  try {
+    return specPathsValid(spec, paths);
+  } finally {
+    keyedPathDepth--;
+  }
+}
+function specPathsValid(spec, paths) {
   const layers = /* @__PURE__ */ new Set();
   let background = false;
   let finish = false;
@@ -1594,7 +1820,7 @@ function validateSpecCore(spec, checkApplied = true) {
     err("ghosting", `must be a number 0..${LIMITS.maxGhosting}`);
   }
   for (const k of unknownKeys(spec, KNOWN_TOP)) {
-    warn(k, "unknown-property", `unknown top-level property '${k}' \u2014 will be ignored`);
+    warn(k, "unknown-property", unknownMessage("top", k, `unknown top-level property '${k}' \u2014 will be ignored`));
   }
   if (spec.background !== void 0) validateBackground(spec.background, err, warn);
   if (spec.finish !== void 0) validateFinish(spec.finish, "finish", err, warn);
@@ -1666,6 +1892,14 @@ function validateGroups(groups, err, warn, spec) {
   }
 }
 function validateTimeline(spec, errOuter, warn, checkApplied = true) {
+  keyedPathDepth++;
+  try {
+    validateTimelineKeys(spec, errOuter, warn, checkApplied);
+  } finally {
+    keyedPathDepth--;
+  }
+}
+function validateTimelineKeys(spec, errOuter, warn, checkApplied) {
   let failed = false;
   const err = (p, m) => {
     failed = true;
@@ -1688,13 +1922,13 @@ function validateTimeline(spec, errOuter, warn, checkApplied = true) {
   tl.keys.forEach((key, i) => {
     const p = `timeline.keys[${i}]`;
     if (!isObj(key)) return err(p, "must be an object {t, path, value, ease?, dur?}");
-    for (const k of unknownKeys(key, KNOWN_TIMELINE_KEY)) warn(`${p}.${k}`, "unknown-property", `unknown key property '${k}' \u2014 will be ignored`);
+    for (const k of unknownKeys(key, KNOWN_TIMELINE_KEY)) warn(`${p}.${k}`, "unknown-property", unknownMessage("key", k, `unknown key property '${k}' \u2014 will be ignored`));
     let ok = true;
     if (!isNum(key.t) || key.t < 0) {
       err(`${p}.t`, "must be a number of ms >= 0");
       ok = false;
     }
-    if (key.ease !== void 0 && key.ease !== "step" && key.ease !== "linear" && key.ease !== "smooth") err(`${p}.ease`, "must be 'step' | 'linear' | 'smooth'");
+    if (key.ease !== void 0 && !GLIDE_EASES.has(key.ease)) err(`${p}.ease`, "must be 'step' | 'linear' | 'smooth' | 'in' | 'out' | 'spring'");
     if (key.dur !== void 0 && (!isNum(key.dur) || key.dur < 0 || key.dur > LIMITS.maxTimelineKeyDur)) {
       err(`${p}.dur`, `must be a number of ms, 0..${LIMITS.maxTimelineKeyDur}`);
     }
@@ -1732,6 +1966,12 @@ function validateTimeline(spec, errOuter, warn, checkApplied = true) {
         const o1 = key.value.origin ?? "viewport";
         if (o0 !== o1) warn(`${p}.value`, "timeline-origin-steps", `this key changes the transform's origin (${String(o0)} \u2192 ${String(o1)}): the pivot switches on the key's first frame, so the layer jumps \u2014 keep one origin per layer`);
       }
+      if (cp.endsWith(".color")) {
+        const owner = readSpecPath(base, cp.slice(0, -".color".length));
+        if (isObj(owner) && owner.gradient !== void 0) {
+          warn(`${p}.path`, "timeline-key-no-effect", `'${key.path}' is overridden by ${cp.includes(".parts.") ? "that part's" : "the sprite's"} gradient, so this key changes nothing on screen \u2014 key its gradient's stops (\`\u2026gradient.stops.N.color\`) instead`);
+        }
+      }
       if (structuralSignature(applied) !== baseSig) {
         warn(`${p}.path`, "timeline-structural-key", `'${key.path}' is structural (placement, count, motion, size\u2026): the scene rebuilds at this key and entities re-seed \u2014 a pop, not a glide. Animate paint (colour, opacity, transform, polygon points) instead`);
       }
@@ -1875,7 +2115,7 @@ function validateLayer(layer, path, err, warn, spec) {
     } else if (k === "depth") {
       warn(`${path}.depth`, "unknown-property", `'depth' is not a layer property \u2014 use motion type 'warp' for true perspective depth, or fake parallax with size/speed/alpha across layers`);
     } else {
-      warn(`${path}.${k}`, "unknown-property", `unknown layer property '${k}' \u2014 will be ignored`);
+      warn(`${path}.${k}`, "unknown-property", unknownMessage("layer", k, `unknown layer property '${k}' \u2014 will be ignored`));
     }
   }
   if (!isNum(layer.count) || !Number.isInteger(layer.count) || layer.count < 1) {
@@ -2038,14 +2278,17 @@ function validateLayer(layer, path, err, warn, spec) {
       if (lay.gap !== void 0) {
         if (isNum(lay.gap)) {
           if (!gapOk(lay.gap)) err(`${path}.layout.gap`, "must be > 0 (viewport units of min(w,h), or px)");
-        } else if (lay.type === "table" && isObj(lay.gap)) {
+        } else if (isObj(lay.gap)) {
           if (lay.gap.x !== void 0 && !gapOk(lay.gap.x)) err(`${path}.layout.gap.x`, "must be > 0");
           if (lay.gap.y !== void 0 && !gapOk(lay.gap.y)) err(`${path}.layout.gap.y`, "must be > 0");
           for (const k of unknownKeys(lay.gap, /* @__PURE__ */ new Set(["x", "y"]))) {
             warn(`${path}.layout.gap.${k}`, "unknown-property", `unknown gap property '${k}' \u2014 will be ignored`);
           }
+          if (lay.type === "list" && lay.gap.x !== void 0) {
+            warn(`${path}.layout.gap.x`, "no-effect", "a list is one column, so gap.x has no effect; gap.y is its row pitch (use a table for columns)");
+          }
         } else {
-          err(`${path}.layout.gap`, lay.type === "table" ? "must be a number > 0 or { x?, y? }" : "must be a number > 0");
+          err(`${path}.layout.gap`, "must be a number > 0 or { x?, y? }");
         }
       }
       for (const k of unknownKeys(lay, new Set(lay.type === "list" ? ["type", "gap"] : ["type", "columns", "gap"]))) {
@@ -2096,6 +2339,26 @@ function validateLayer(layer, path, err, warn, spec) {
       if (layer.life.fade !== void 0 && (!isNum(layer.life.fade) || layer.life.fade < 0)) {
         err(`${path}.life.fade`, "must be >= 0 (ms)");
       }
+      if (layer.life.stagger !== void 0 && (!isNum(layer.life.stagger) || layer.life.stagger < 0 || layer.life.stagger > LIMITS.maxLifeStagger)) {
+        err(`${path}.life.stagger`, `must be 0..${LIMITS.maxLifeStagger} ms (between successive entities' entrances)`);
+      }
+      for (const k of unknownKeys(layer.life, /* @__PURE__ */ new Set(["enter", "exit", "fade", "stagger"]))) {
+        warn(`${path}.life.${k}`, "unknown-property", `unknown life property '${k}' \u2014 will be ignored`);
+      }
+    }
+  }
+  if (layer.rock !== void 0) {
+    if (!isObj(layer.rock)) err(`${path}.rock`, "must be an object { amp, period }");
+    else {
+      if (!isNum(layer.rock.amp) || layer.rock.amp <= 0 || layer.rock.amp > LIMITS.maxRockAmp) {
+        err(`${path}.rock.amp`, `must be > 0 and <= ${LIMITS.maxRockAmp} (degrees either side of rest)`);
+      }
+      if (!isNum(layer.rock.period) || layer.rock.period < LIMITS.minRockPeriod) {
+        err(`${path}.rock.period`, `must be >= ${LIMITS.minRockPeriod} ms (one swing there and back)`);
+      }
+      for (const k of unknownKeys(layer.rock, /* @__PURE__ */ new Set(["amp", "period"]))) {
+        warn(`${path}.rock.${k}`, "unknown-property", `unknown rock property '${k}' \u2014 will be ignored`);
+      }
     }
   }
   if (layer.trail !== void 0) {
@@ -2157,6 +2420,9 @@ function validateLayer(layer, path, err, warn, spec) {
         if (isObj(layer.grow) && isNum(layer.grow.period) && layer.grow.period < floor) {
           err(`${path}.grow.period`, `must be >= ${floor} ms when the layer has a clock (period / rate >= ${LIMITS.minClockedPeriod})`);
         }
+        if (isObj(layer.rock) && isNum(layer.rock.period) && layer.rock.period < floor) {
+          err(`${path}.rock.period`, `must be >= ${floor} ms when the layer has a clock (period / rate >= ${LIMITS.minClockedPeriod})`);
+        }
         const sp = layer.sprite;
         if (isObj(sp) && isObj(sp.cycle) && isNum(sp.cycle.period) && sp.cycle.period < floor) {
           err(`${path}.sprite.cycle.period`, `must be >= ${floor} ms when the layer has a clock (period / rate >= ${LIMITS.minClockedPeriod})`);
@@ -2288,6 +2554,7 @@ function validateSprite(sprite, path, err, warn, spec) {
     if (sprite.curve !== void 0 && sprite.curve !== "smooth" && sprite.curve !== "linear") err(`${path}.curve`, "must be 'smooth' | 'linear'");
     if (sprite.taper !== void 0 && typeof sprite.taper !== "boolean") err(`${path}.taper`, "must be a boolean");
     if (sprite.orient !== void 0 && typeof sprite.orient !== "boolean") err(`${path}.orient`, "must be a boolean");
+    if (sprite.draw !== void 0) validateDraw(sprite.draw, `${path}.draw`, err, warn);
     color(sprite.color, `${path}.color`, err);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "textBlock") {
@@ -2328,6 +2595,22 @@ function validateSprite(sprite, path, err, warn, spec) {
       err(`${path}.opacity`, "must be a number between 0 and 1");
     }
     validateTextRole(sprite, path, err);
+    if (sprite.number !== void 0) {
+      const n = sprite.number;
+      if (!isObj(n)) err(`${path}.number`, "must be { value, decimals?, prefix?, suffix?, grouping? }");
+      else {
+        if (!isNum(n.value)) err(`${path}.number.value`, "must be a finite number");
+        if (n.decimals !== void 0 && (!isNum(n.decimals) || !Number.isInteger(n.decimals) || n.decimals < 0 || n.decimals > LIMITS.maxTextNumberDecimals)) {
+          err(`${path}.number.decimals`, `must be a whole number 0..${LIMITS.maxTextNumberDecimals}`);
+        }
+        for (const k of ["prefix", "suffix"]) {
+          const v = n[k];
+          if (v !== void 0 && (!isStr(v) || v.length > LIMITS.maxTextAffix)) err(`${path}.number.${k}`, `must be a string of at most ${LIMITS.maxTextAffix} characters`);
+        }
+        if (n.grouping !== void 0 && typeof n.grouping !== "boolean") err(`${path}.number.grouping`, "must be a boolean");
+        for (const k of unknownKeys(n, KNOWN_TEXT_NUMBER)) warn(`${path}.number.${k}`, "unknown-property", `unknown number property '${k}' \u2014 will be ignored`);
+      }
+    }
     if (sprite.reveal !== void 0) {
       const rv = sprite.reveal;
       if (typeof rv !== "object" || rv === null || Array.isArray(rv)) {
@@ -2348,6 +2631,10 @@ function validateSprite(sprite, path, err, warn, spec) {
         if (rv.speed !== void 0 && (!isNum(rv.speed) || rv.speed < 0 || rv.speed > LIMITS.maxRevealSpeed)) {
           err(`${path}.reveal.speed`, `must be between 0 and ${LIMITS.maxRevealSpeed} (graphemes/sec)`);
         }
+        if (rv.rise !== void 0) {
+          if (!isNum(rv.rise) || rv.rise < 0 || rv.rise > LIMITS.maxRevealRise) err(`${path}.reveal.rise`, `must be 0..${LIMITS.maxRevealRise} (em below the line a glyph rises from)`);
+          else if (rv.mode !== "glyphFade") warn(`${path}.reveal.rise`, "unknown-property", "rise applies to mode 'glyphFade' only \u2014 will be ignored");
+        }
         if (rv.caret !== void 0 && typeof rv.caret !== "boolean") {
           const caret = rv.caret;
           if (typeof caret !== "object" || caret === null || Array.isArray(caret)) {
@@ -2416,6 +2703,12 @@ function validateMotion(motion, path, err, warn, spec) {
     else if (v[0] < 0) err(p, "speed lower bound must be >= 0");
     else if (v[1] > speedCap) err(p, `speed exceeds cap ${isViewport ? speedCap.toFixed(2) + " viewport-units/sec" : LIMITS.maxSpeed + " px/sec"}`);
   };
+  const wobbleCap = isViewport ? LIMITS.maxWobble : LIMITS.maxWobble * refVp;
+  const wobbleCheck = (v, p, name, axis) => {
+    if (!isNum(v) || Math.abs(v) <= wobbleCap) return;
+    const px = isViewport ? ` (\u2248${Math.round(Math.abs(v) * refVp)} px at ${refVp} px)` : "";
+    warn(p, "motion-amplitude", `${name} ${v} is a ${axis} swing of ${isViewport ? `${Math.abs(v)}\xD7 min(w, h)` : `${Math.abs(v)} px`}${px} each way, so entities leave the frame \u2014 ${name} is in ${isViewport ? "min(w, h) units, not px" : "px"}; typical ${isViewport ? "0.002\u20130.02" : "2\u201320 px"}, at most ${isViewport ? wobbleCap : Math.round(wobbleCap) + " px"} before this warning`);
+  };
   let knownSet;
   if (motion.type === "drift") {
     knownSet = KNOWN_DRIFT;
@@ -2423,6 +2716,7 @@ function validateMotion(motion, path, err, warn, spec) {
     if (motion.angle !== void 0 && !isNum(motion.angle)) err(`${path}.angle`, "must be a number (degrees)");
     if (motion.bidirectional !== void 0 && typeof motion.bidirectional !== "boolean") err(`${path}.bidirectional`, "must be a boolean");
     if (motion.bob !== void 0 && !isNum(motion.bob)) err(`${path}.bob`, "must be a number");
+    else wobbleCheck(motion.bob, `${path}.bob`, "bob", "vertical");
     validateEase(motion.ease, `${path}.ease`, err, warn);
     if (isRange(motion.speed) && motion.speed[1] < 1 && !isViewport) {
       warn(`${path}.speed`, "near-zero-speed", `max speed is ${motion.speed[1]} px/sec \u2014 entities will appear frozen. Typical range: 10\u2013200 px/sec`);
@@ -2431,6 +2725,7 @@ function validateMotion(motion, path, err, warn, spec) {
     knownSet = KNOWN_RISE;
     speedOk(motion.speed, `${path}.speed`);
     if (motion.sway !== void 0 && !isNum(motion.sway)) err(`${path}.sway`, "must be a number");
+    else wobbleCheck(motion.sway, `${path}.sway`, "sway", "horizontal");
     validateEase(motion.ease, `${path}.ease`, err, warn);
     if (isRange(motion.speed) && motion.speed[1] < 1 && !isViewport) {
       warn(`${path}.speed`, "near-zero-speed", `max speed is ${motion.speed[1]} px/sec \u2014 entities will appear frozen. Typical range: 5\u201380 px/sec`);
@@ -2530,20 +2825,23 @@ function validateMotion(motion, path, err, warn, spec) {
     return;
   }
   for (const k of unknownKeys(motion, knownSet)) {
-    warn(`${path}.${k}`, "unknown-property", `unknown motion property '${k}' \u2014 will be ignored`);
+    warn(`${path}.${k}`, "unknown-property", unknownMessage("motion", k, `unknown motion property '${k}' \u2014 will be ignored`));
   }
 }
 var isPair = (v, lim = 2) => Array.isArray(v) && v.length === 2 && isNum(v[0]) && isNum(v[1]) && Math.abs(v[0]) <= lim && Math.abs(v[1]) <= lim;
 var MAX_PATH_PARTS = 256;
 var pathVerdicts = /* @__PURE__ */ new Map();
 var pathVerdictBytes = 0;
+var NO_AREA = "must enclose an area (at least 3 points), or set fill: false and a stroke for line art";
+var NO_LINE = "must draw at least one line (2+ points)";
+var keyedPathDepth = 0;
 function pathGeometryProblem(d, rule, filled) {
   const key = `${rule}|${filled ? 1 : 0}|${d}`;
   const hit = pathVerdicts.get(key);
   if (hit !== void 0) return hit;
   const flat = flattenPath(d, rule);
   const inBox = ([x, y]) => Math.abs(x) <= 1.0001 && Math.abs(y) <= 1.0001;
-  const problem = flat.error ? `not a usable path: ${flat.error}` : filled && flat.points.length < 3 ? "must enclose an area (at least 3 points), or set fill: false and a stroke for line art" : !filled && flat.lines.length === 0 ? "must draw at least one line (2+ points)" : flat.points.length > MAX_PATH_POINTS ? `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}` : !flat.points.every(inBox) || !flat.lines.every((l) => l.points.every(inBox)) ? "must stay inside the -1..1 unit box (curves included)" : null;
+  const problem = flat.error ? `not a usable path: ${flat.error}` : flat.points.length > MAX_PATH_POINTS ? `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}` : !flat.points.every(inBox) || !flat.lines.every((l) => l.points.every(inBox)) ? "must stay inside the -1..1 unit box (curves included)" : filled && flat.points.length < 3 ? NO_AREA : !filled && flat.lines.length === 0 ? NO_LINE : null;
   if (pathVerdicts.size >= 1024 || pathVerdictBytes + key.length > 2e6) {
     pathVerdicts.clear();
     pathVerdictBytes = 0;
@@ -2557,14 +2855,13 @@ function validatePathPiece(piece, path, err, warn) {
     err(`${path}.path`, "must be an SVG path d string (1..65536 chars) in the -1..1 unit box");
   } else {
     const problem = pathGeometryProblem(piece.path, piece.fillRule ?? "auto", piece.fill !== false);
-    if (problem) err(`${path}.path`, problem);
+    if (problem && !(keyedPathDepth > 0 && (problem === NO_AREA || problem === NO_LINE))) err(`${path}.path`, problem);
   }
   if (piece.fill !== void 0 && typeof piece.fill !== "boolean") err(`${path}.fill`, "must be a boolean");
   if (piece.fill === false && piece.stroke === void 0) err(`${path}.fill`, "fill: false draws nothing without a stroke");
   if (piece.gradient !== void 0) validatePathGradient(piece.gradient, `${path}.gradient`, err);
-  if (piece.stroke !== void 0) validatePathStroke(piece.stroke, `${path}.stroke`, err);
+  if (piece.stroke !== void 0) validatePathStroke(piece.stroke, `${path}.stroke`, err, warn);
   if (piece.fillRule !== void 0 && !["auto", "nonzero", "evenodd"].includes(piece.fillRule)) err(`${path}.fillRule`, "must be 'auto' | 'nonzero' | 'evenodd'");
-  void warn;
 }
 function validatePathGradient(g, path, err) {
   if (!isObj(g)) return err(path, "must be { type: 'linear', from, to, stops } or { type: 'radial', center, radius, stops }");
@@ -2589,13 +2886,38 @@ function validatePathGradient(g, path, err) {
     if (st.opacity !== void 0 && (!isNum(st.opacity) || st.opacity < 0 || st.opacity > 1)) err(`${path}.stops[${i}].opacity`, "must be 0..1");
   });
 }
-function validatePathStroke(st, path, err) {
-  if (!isObj(st)) return err(path, "must be { color, width, opacity?, join?, cap? }");
+function validatePathStroke(st, path, err, warn) {
+  if (!isObj(st)) return err(path, "must be { color, width, opacity?, join?, cap?, draw? }");
   color(st.color, `${path}.color`, err);
   if (!isNum(st.width) || st.width <= 0 || st.width > 0.5) err(`${path}.width`, "must be > 0 and <= 0.5 (unit-box units: 0.01 is 1% of the drawing's half-size)");
   if (st.opacity !== void 0 && (!isNum(st.opacity) || st.opacity < 0 || st.opacity > 1)) err(`${path}.opacity`, "must be 0..1");
   if (st.join !== void 0 && !["round", "miter", "bevel"].includes(st.join)) err(`${path}.join`, "must be 'round' | 'miter' | 'bevel'");
   if (st.cap !== void 0 && !["round", "butt", "square"].includes(st.cap)) err(`${path}.cap`, "must be 'round' | 'butt' | 'square'");
+  if (st.draw !== void 0) validateDraw(st.draw, `${path}.draw`, err, warn);
+}
+function validateWipe(tr, path, err, warn) {
+  if (tr.shape !== void 0 && tr.shape !== "circle" && tr.shape !== "line") err(`${path}.shape`, "must be 'circle' | 'line'");
+  if (tr.origin !== void 0) {
+    const o = tr.origin;
+    if (!isObj(o) || !isNum(o.x) || !isNum(o.y) || o.x < 0 || o.x > 1 || o.y < 0 || o.y > 1) err(`${path}.origin`, "must be { x, y } with each 0..1 (where the iris opens)");
+    else if (tr.shape === "line") err(`${path}.origin`, "applies to shape 'circle' only \u2014 a line wipe sweeps along `angle`");
+  }
+  if (tr.angle !== void 0) {
+    if (!isNum(tr.angle) || Math.abs(tr.angle) > 360) err(`${path}.angle`, "must be degrees, -360..360 (0 = left to right, 90 = top to bottom)");
+    else if (tr.shape !== "line") err(`${path}.angle`, "applies to shape 'line' only \u2014 an iris opens from `origin`");
+  }
+  if (tr.feather !== void 0 && (!isNum(tr.feather) || tr.feather < 0 || tr.feather > 1)) err(`${path}.feather`, "must be 0..1 (the edge width, as a fraction of the distance it travels)");
+  for (const k of Object.keys(tr)) {
+    if (!["type", "dur", "shape", "origin", "angle", "feather"].includes(k)) warn(`${path}.${k}`, "unknown-property", `unknown wipe property '${k}' \u2014 will be ignored`);
+  }
+}
+function validateDraw(d, path, err, warn) {
+  if (!isObj(d)) return err(path, "must be { start?, end? } \u2014 fractions of the line, 0..1");
+  for (const k of ["start", "end"]) {
+    const v = d[k];
+    if (v !== void 0 && (!isNum(v) || v < 0 || v > 1)) err(`${path}.${k}`, "must be 0..1 (a fraction of the line's length)");
+  }
+  for (const k of Object.keys(d)) if (k !== "start" && k !== "end") warn(`${path}.${k}`, "unknown-property", `unknown draw property '${k}' \u2014 draw takes start and end; will be ignored`);
 }
 function validateShapePoints(points, path, min, err) {
   if (!Array.isArray(points) || points.length < min || points.length > LIMITS.maxShapePoints) {
@@ -2691,16 +3013,17 @@ function validateSequence(seq) {
     if (s.transition !== void 0) {
       if (!isObj(s.transition)) {
         err(`${p}.transition`, "must be an object");
-      } else if (s.transition.type === "morph" || s.transition.type === "fade") {
+      } else if (s.transition.type === "morph" || s.transition.type === "fade" || s.transition.type === "wipe") {
         if (!isNum(s.transition.dur) || s.transition.dur < LIMITS.minTransitionDur || s.transition.dur > LIMITS.maxTransitionDur) {
           err(`${p}.transition.dur`, `must be a number between ${LIMITS.minTransitionDur} and ${LIMITS.maxTransitionDur}`);
         }
+        if (s.transition.type === "wipe") validateWipe(s.transition, `${p}.transition`, err, (wp, code, message) => void warnings.push({ path: wp, code, message }));
       } else if (s.transition.type !== "cut") {
-        err(`${p}.transition.type`, "must be 'cut', 'morph' or 'fade'");
+        err(`${p}.transition.type`, "must be 'cut', 'morph', 'fade' or 'wipe'");
       }
       if (isObj(s.transition) && s.transition.text !== void 0) {
         if (s.transition.type !== "morph") {
-          err(`${p}.transition.text`, "is a morph option (fade already cross-fades whole frames; cut has no window)");
+          err(`${p}.transition.text`, "is a morph option (fade and wipe already change whole frames; cut has no window)");
         } else if (s.transition.text !== "step" && s.transition.text !== "crossfade" && s.transition.text !== "dip") {
           err(`${p}.transition.text`, "must be 'step' | 'crossfade' | 'dip'");
         }
@@ -3095,11 +3418,29 @@ function buildEntities(layer, rng, w, h, scale = 1, countScale = 1) {
       out[out.length - 1].pulsePhase = clockPhase - (x0 * Math.cos(ang) + y0 * Math.sin(ang)) / wl * Math.PI * 2;
     }
   }
+  if (layer.rock) {
+    const amp = layer.rock.amp * Math.PI / 180;
+    for (const ent of out) {
+      const ph = rng.range(0, Math.PI * 2);
+      ent.rock = { amp, period: layer.rock.period, phase: layer.clock ? clockPhase : ph };
+    }
+  }
   if (layer.emit) {
     for (let i = 0; i < out.length; i++) out[i].emit = emitParams(layer.emit, i, out.length);
   }
   return out;
 }
+function textBlockText(s) {
+  const n = s.number;
+  if (!n) return s.text;
+  const d = Math.max(0, Math.min(LIMITS.maxTextNumberDecimals, Math.round(n.decimals ?? 0)));
+  const v = Number.isFinite(n.value) ? n.value : 0;
+  const fixed = Math.abs(v).toFixed(d);
+  const [whole, frac] = fixed.split(".");
+  const grouped = n.grouping === false ? whole : whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const neg = v < 0 && Number(fixed) !== 0;
+  return `${n.prefix ?? ""}${neg ? "-" : ""}${grouped}${frac !== void 0 ? `.${frac}` : ""}${n.suffix ?? ""}`;
+}
 function warpZ(e, t) {
   const wp = e.warp;
   return wrap(wp.z0 - wp.vz * (t / 1e3), WARP_NEAR, 1);
@@ -3154,12 +3495,14 @@ function sizeAt(e, t) {
   return s > 0 ? s : 0.1;
 }
 function rotationAt(e, t) {
-  const base = e.rotate ?? 0;
+  let base = e.rotate ?? 0;
+  if (e.rock) base += e.rock.amp * Math.sin(clockTime(e, t) * 2 * Math.PI / e.rock.period + e.rock.phase);
   if (!e.spinSpeed) return base;
   return base + e.spinPhase + e.spinSpeed * (t / 1e3);
 }
 function lifeAlphaAt(life, t) {
   if (!life) return 1;
+  if (life.stagger) return life.enter !== void 0 && t < life.enter ? 0 : 1;
   const fade = life.fade ?? 1e3;
   let a = 1;
   if (life.enter !== void 0) {
@@ -3171,16 +3514,20 @@ function lifeAlphaAt(life, t) {
   }
   return a;
 }
+function lifeStaggerAt(life, t, i) {
+  if (!life?.stagger) return 1;
+  return lifeAlphaAt({ enter: life.enter, exit: life.exit, fade: life.fade }, t - i * life.stagger);
+}
 function wrap(v, min, max) {
-  const range = max - min;
-  return ((v - min) % range + range) % range + min;
+  const range2 = max - min;
+  return ((v - min) % range2 + range2) % range2 + min;
 }
 function reflect(v, min, max) {
-  const range = max - min;
-  if (range <= 0) return min;
-  const period = 2 * range;
+  const range2 = max - min;
+  if (range2 <= 0) return min;
+  const period = 2 * range2;
   const p = ((v - min) % period + period) % period;
-  return min + (p < range ? p : period - p);
+  return min + (p < range2 ? p : period - p);
 }
 function catmullRom2(p0, p1, p2, p3, u) {
   const u2 = u * u;
@@ -3394,6 +3741,26 @@ function textMetricsClassFor(font) {
   return font && MONO_FAMILY_RE.test(font) ? "mono" : "proportional";
 }
 var MONO_ADVANCE_EM = 0.6;
+var FULL_WIDTH_EM = 1;
+function isCombiningKana(cp) {
+  return cp === 12441 || cp === 12442;
+}
+function isFullWidth(cp) {
+  if (isCombiningKana(cp)) return false;
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo leading consonants
+  cp >= 11904 && cp <= 12350 || // CJK radicals, Kangxi, CJK symbols & punctuation
+  cp >= 12353 && cp <= 13311 || // kana, Bopomofo, Hangul compat Jamo, enclosed CJK, CJK compat
+  cp >= 13312 && cp <= 19903 || // CJK Ext A
+  cp >= 19968 && cp <= 40959 || // CJK Unified Ideographs
+  cp >= 40960 && cp <= 42191 || // Yi
+  cp >= 43360 && cp <= 43391 || // Hangul Jamo Ext A
+  cp >= 44032 && cp <= 55203 || // Hangul syllables
+  cp >= 63744 && cp <= 64255 || // CJK compatibility ideographs
+  cp >= 65072 && cp <= 65103 || // CJK compatibility forms
+  cp >= 65281 && cp <= 65376 || // fullwidth ASCII variants
+  cp >= 65504 && cp <= 65510 || // fullwidth signs
+  cp >= 131072 && cp <= 262141;
+}
 function charWidthEm(ch, metrics = "proportional") {
   if (metrics === "mono") return MONO_ADVANCE_EM;
   if (ch === " " || ch === "	") return 0.3;
@@ -3402,9 +3769,25 @@ function charWidthEm(ch, metrics = "proportional") {
   return 0.55;
 }
 function textWidthEm(str, metrics = "proportional") {
-  if (metrics === "mono") return graphemeClusters(str).length * MONO_ADVANCE_EM;
+  if (metrics === "mono") {
+    let w2 = 0;
+    for (const c of graphemeClusters(str)) {
+      const cp = c.codePointAt(0);
+      if (!isCombiningKana(cp)) w2 += isFullWidth(cp) ? FULL_WIDTH_EM : MONO_ADVANCE_EM;
+    }
+    return w2;
+  }
   let w = 0;
-  for (let i = 0; i < str.length; i++) w += charWidthEm(str[i], metrics);
+  for (let i = 0; i < str.length; i++) {
+    const cp = str.codePointAt(i);
+    if (isCombiningKana(cp)) continue;
+    if (isFullWidth(cp)) {
+      w += FULL_WIDTH_EM;
+      if (cp > 65535) i++;
+      continue;
+    }
+    w += charWidthEm(str[i], metrics);
+  }
   return w;
 }
 function breakTextBlock(text, maxWidthEm, metrics = "proportional") {
@@ -3986,7 +4369,7 @@ function manifestFor(spec) {
 var clamp014 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
 var EXPIRED = /* @__PURE__ */ Symbol("expired");
 function overrideHeldAt(o, t) {
-  const k = o.dur > 0 ? easeSmooth(clamp014((t - o.t0) / o.dur)) : 1;
+  const k = o.dur > 0 ? easeGlide(o.ease, clamp014((t - o.t0) / o.dur)) : 1;
   return k >= 1 ? o.to : lerpValue(o.from, o.to, k, false, o.leaf);
 }
 function overrideValueAt(o, t, timelineValue) {
@@ -3995,9 +4378,20 @@ function overrideValueAt(o, t, timelineValue) {
   return EXPIRED;
 }
 var steerId = (d) => `${d.t}|${JSON.stringify(d.value)}`;
-function armOverride(authored, path, from, to, now, glide) {
+function armOverride(authored, path, from, to, now, glide, ease2) {
   const next = nextKeyAfter(authored, path, now);
-  return { leaf: path.slice(path.lastIndexOf(".") + 1), from, to, t0: now, dur: glide, until: next ? next.at : Number.POSITIVE_INFINITY, outDur: next ? next.dur : 0 };
+  const o = { leaf: path.slice(path.lastIndexOf(".") + 1), from, to, t0: now, dur: glide, until: next ? next.at : Number.POSITIVE_INFINITY, outDur: next ? next.dur : 0 };
+  if (ease2) o.ease = ease2;
+  return o;
+}
+function outgoingCounter(from, now) {
+  if (from.number && now.number) return { text: from.text, number: { ...now.number, prefix: from.number.prefix, suffix: from.number.suffix } };
+  return { text: textBlockText(from), number: void 0 };
+}
+function steerEase(deltas) {
+  let best;
+  for (const d of deltas) if (!best || (d.dur ?? DEFAULT_STEER_DUR) > (best.dur ?? DEFAULT_STEER_DUR)) best = d;
+  return best?.ease !== void 0 && STEER_EASES.has(best.ease) ? best.ease : void 0;
 }
 function applyOverridesAt(resolved, overrides, t, expired) {
   if (overrides.size === 0) return resolved;
@@ -4027,7 +4421,7 @@ function overridesStayValid(authored, overrides, now) {
     const state = JSON.stringify(groups.map((g) => readSpecPath(r, g))) + "|" + [...held.keys()].join(",");
     if (seen.has(state)) continue;
     seen.add(state);
-    if (!validateSpecPaths(r, paths)) return false;
+    if (!validateSpecPaths(r, paths, true)) return false;
   }
   return true;
 }
@@ -4070,6 +4464,34 @@ function softFill(g, color2, r) {
   grad.addColorStop(1, hexToRgba(color2, 0));
   return grad;
 }
+function wipeMask(g, w, k, cw, ch) {
+  const f = Math.max(0, Math.min(1, w.feather ?? 0.08));
+  if ((w.shape ?? "circle") === "line") {
+    const a = (w.angle ?? 0) * Math.PI / 180;
+    const ux = Math.cos(a);
+    const uy = Math.sin(a);
+    const proj = [0, cw * ux, ch * uy, cw * ux + ch * uy];
+    const p0 = Math.min(...proj);
+    const span = Math.max(...proj) - p0;
+    const fw2 = Math.max(1, f * span);
+    const lead = p0 + k * (span + fw2);
+    const trail = lead - fw2;
+    const g22 = g.createLinearGradient(ux * trail, uy * trail, ux * lead, uy * lead);
+    g22.addColorStop(0, "rgba(0,0,0,1)");
+    g22.addColorStop(1, "rgba(0,0,0,0)");
+    return g22;
+  }
+  const ox = Math.max(0, Math.min(1, w.origin?.x ?? 0.5)) * cw;
+  const oy = Math.max(0, Math.min(1, w.origin?.y ?? 0.5)) * ch;
+  const reach = Math.max(Math.hypot(ox, oy), Math.hypot(cw - ox, oy), Math.hypot(ox, ch - oy), Math.hypot(cw - ox, ch - oy));
+  const fw = Math.max(1, f * reach);
+  const outer = Math.max(1e-3, k * (reach + fw));
+  const inner = Math.max(0, outer - fw);
+  const g2 = g.createRadialGradient(ox, oy, inner, ox, oy, Math.max(outer, inner + 1e-3));
+  g2.addColorStop(0, "rgba(0,0,0,1)");
+  g2.addColorStop(1, "rgba(0,0,0,0)");
+  return g2;
+}
 var SpecInstance = class {
   constructor(spec, ctx, opts = {}) {
     this.spec = spec;
@@ -4560,21 +4982,27 @@ var SpecInstance = class {
         }
       }
       const st = part.stroke;
-      if (st && part.flat.lines.length) {
+      const lines = st ? strokeLines(part) : part.flat.lines;
+      if (st && lines.length) {
         g.globalAlpha = a0 * part.opacity * (st.opacity ?? 1);
         g.strokeStyle = st.color;
         g.lineJoin = st.join ?? "round";
         g.lineCap = st.cap ?? "round";
         if (fr.uniform) {
           g.lineWidth = st.width * r / fr.sx;
-          if (cache.stroke === void 0) cache.stroke = typeof Path2D === "undefined" ? null : ringPath2D(part.flat.lines);
-          if (cache.stroke) g.stroke(cache.stroke);
-          else {
-            traceLines(g, part.flat.lines);
+          if (lines !== part.flat.lines) {
+            traceLines(g, lines);
             g.stroke();
+          } else {
+            if (cache.stroke === void 0) cache.stroke = typeof Path2D === "undefined" ? null : ringPath2D(part.flat.lines);
+            if (cache.stroke) g.stroke(cache.stroke);
+            else {
+              traceLines(g, part.flat.lines);
+              g.stroke();
+            }
           }
         } else {
-          const scaled = part.flat.lines.map((l) => ({ closed: l.closed, points: l.points.map(([x, y]) => [x * fr.sx, y * fr.sy]) }));
+          const scaled = lines.map((l) => ({ closed: l.closed, points: l.points.map(([x, y]) => [x * fr.sx, y * fr.sy]) }));
           g.save();
           g.scale(1 / fr.sx, 1 / fr.sy);
           g.lineWidth = st.width * r;
@@ -4999,7 +5427,8 @@ var SpecInstance = class {
     }
     if (sprite.kind === "stroke") {
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
-      const pts = strokeSamples(sprite, sz / 2);
+      const pts = strokeDrawnSamples(sprite, sz / 2);
+      if (pts.length < 2) return;
       const lw = strokeWidthPx(sprite, unitScale);
       ctx.save();
       ctx.translate(p.x, p.y);
@@ -5010,7 +5439,7 @@ var SpecInstance = class {
       ctx.lineCap = "round";
       ctx.lineJoin = "round";
       if (sprite.taper) {
-        const outline = strokeOutline(pts, lw);
+        const outline = strokeOutline(pts, lw, true, strokeDrawnAt(sprite, sz / 2, pts));
         ctx.fillStyle = resolvedColor;
         ctx.beginPath();
         ctx.moveTo(outline[0].x, outline[0].y);
@@ -5057,7 +5486,7 @@ var SpecInstance = class {
       const lh = (sprite.lineHeight ?? 1.4) * fsPx;
       const maxWPx = sprite.maxWidth * unitScale2;
       const maxWEm = maxWPx / fsPx;
-      const lines = breakTextBlock(sprite.text, maxWEm, textMetricsClassFor(sprite.font));
+      const lines = breakTextBlock(textBlockText(sprite), maxWEm, textMetricsClassFor(sprite.font));
       const align = sprite.align ?? "left";
       const reveal = sprite.reveal;
       const rs = reveal ? revealState(lines, reveal, t) : null;
@@ -5079,6 +5508,7 @@ var SpecInstance = class {
       if (rs?.glyphAlphas) {
         ctx.textAlign = "left";
         const baseAlpha = ctx.globalAlpha;
+        const riseEm = Math.max(0, Math.min(LIMITS.maxRevealRise, reveal.rise ?? 0));
         for (let li = 0; li < lines.length; li++) {
           const alphas = rs.glyphAlphas[li] ?? [];
           if (alphas.length > 0 && alphas[0] <= 0) break;
@@ -5097,7 +5527,7 @@ var SpecInstance = class {
             const a = alphas[gi] ?? 0;
             if (a <= 0) break;
             ctx.globalAlpha = baseAlpha * a;
-            ctx.fillText(clusters[gi], x0 + ctx.measureText(prefix).width, li * lh);
+            ctx.fillText(clusters[gi], x0 + ctx.measureText(prefix).width, li * lh + riseEm * fsPx * (1 - a));
             prefix += clusters[gi];
           }
         }
@@ -5152,7 +5582,7 @@ var SpecInstance = class {
     const tr = this.transition;
     if (!tr) return;
     const k = tr.dur <= 0 ? 1 : (t - tr.startT) / tr.dur;
-    this.effSpec = k >= 1 ? tr.to : lerpSpec(tr.from, tr.to, easeSmooth(k));
+    this.effSpec = k >= 1 ? tr.to : lerpSpec(tr.from, tr.to, easeGlide(tr.ease, k));
     if (k >= 1) this.transition = null;
     const sig = structuralSignature(this.effSpec);
     if (sig !== this.lastStructural) this.rebuild();
@@ -5181,6 +5611,8 @@ var SpecInstance = class {
       startT: this.lastT,
       dur
     };
+    const ease2 = steerEase(deltas);
+    if (ease2) this.transition.ease = ease2;
     if (this.paused) {
       this.transition = null;
       this.effSpec = target;
@@ -5226,7 +5658,7 @@ var SpecInstance = class {
     });
   }
   drawLinks(built, t, lifeA, parentE) {
-    const { links } = built.layer;
+    const { links, life } = built.layer;
     if (!links) return;
     const { ctx } = this;
     const motionWraps = ["drift", "rise", "wander"].includes(built.layer.motion.type);
@@ -5251,6 +5683,7 @@ var SpecInstance = class {
         } else resolvedColor = "#e6e8ef";
       }
       let a = links.alpha ?? alphaAt(ei, t);
+      if (life?.stagger) a *= Math.min(lifeStaggerAt(life, t, i), lifeStaggerAt(life, t, j));
       if (links.falloff && Number.isFinite(maxDistPx)) a *= Math.max(0, 1 - dist / maxDistPx);
       ctx.globalAlpha = a * lifeA;
       ctx.strokeStyle = resolvedColor;
@@ -5313,15 +5746,19 @@ var SpecInstance = class {
     ctx.globalCompositeOperation = built.layer.blend ?? "source-over";
     this.drawLinks(built, t, lifeA, parentE);
     const override = this.paintOverrides?.get(li) ?? null;
-    for (const e of built.entities) {
-      this.drawTrail(built, e, t, lifeA, parentE);
+    const life = built.layer.life;
+    for (let ei = 0; ei < built.entities.length; ei++) {
+      const e = built.entities[ei];
+      const entA = life?.stagger ? lifeA * lifeStaggerAt(life, t, ei) : lifeA;
+      if (entA <= 0) continue;
+      this.drawTrail(built, e, t, entA, parentE);
       if (override === null) {
-        this.drawEntity(built, e, t, lifeA, parentE);
+        this.drawEntity(built, e, t, entA, parentE);
         continue;
       }
       const [aOut, aIn] = override.mode === "dip" ? [Math.max(0, 1 - 2 * override.k), Math.max(0, 2 * override.k - 1)] : [1 - override.k, override.k];
-      if (aOut > 0) this.drawEntity(built, e, t, lifeA, parentE, { sprite: override.outgoing, alpha: aOut });
-      if (aIn > 0) this.drawEntity(built, e, t, lifeA, parentE, { alpha: aIn });
+      if (aOut > 0) this.drawEntity(built, e, t, entA, parentE, { sprite: override.outgoing, alpha: aOut });
+      if (aIn > 0) this.drawEntity(built, e, t, entA, parentE, { alpha: aIn });
     }
     if (tf || gtf) ctx.restore();
   }
@@ -5374,10 +5811,12 @@ var SpecInstance = class {
     if (group?.opacity !== void 0) lifeA *= clamp014(group.opacity);
     let sig = `${pathPaintSig(built.layer.sprite)}:${lifeA.toFixed(4)}:${JSON.stringify(built.layer.transform ?? null)}:${JSON.stringify(group?.transform ?? null)}`;
     const parentE = this.parentEntityFor(built);
-    for (const e of built.entities) {
+    const life = built.layer.life;
+    built.entities.forEach((e, ei) => {
       const p = this.entityPos(e, t, parentE);
-      sig += `|${p.x.toFixed(2)},${p.y.toFixed(2)},${sizeAt(e, t).toFixed(3)},${rotationAt(e, t).toFixed(5)},${alphaAt(e, t).toFixed(4)},${e.colorIndex}`;
-    }
+      const a = life?.stagger ? alphaAt(e, t) * lifeStaggerAt(life, t, ei) : alphaAt(e, t);
+      sig += `|${p.x.toFixed(2)},${p.y.toFixed(2)},${sizeAt(e, t).toFixed(3)},${rotationAt(e, t).toFixed(5)},${a.toFixed(4)},${e.colorIndex}`;
+    });
     return sig;
   }
   plateSig(a, b) {
@@ -5529,11 +5968,12 @@ var SpecInstance = class {
     }
     const next = new Map(this.overrides);
     const armed = [];
+    const batchEase = steerEase([...latest.values()]);
     for (const [path, d] of latest) {
       const id = steerId(d);
       if (this.seenSteers.get(path) === id) continue;
       armed.push([path, id]);
-      next.set(path, armOverride(this.authored, path, glide > 0 ? readSpecPath(shown, path) : d.value, d.value, now, glide));
+      next.set(path, armOverride(this.authored, path, glide > 0 ? readSpecPath(shown, path) : d.value, d.value, now, glide, batchEase));
     }
     if (armed.length === 0) return true;
     if (!overridesStayValid(this.authored, next, now)) return false;
@@ -5903,16 +6343,80 @@ var SequenceInstance = class {
       if (!textStringsDiffer(specA, specB, i)) continue;
       const from = specA.layers[i].sprite;
       const now = lerped.layers[i].sprite;
-      const outgoing = from.kind === "text" && now.kind === "text" ? { ...now, strings: from.strings } : from.kind === "textBlock" && now.kind === "textBlock" ? { ...now, text: from.text } : now;
+      const outgoing = from.kind === "text" && now.kind === "text" ? { ...now, strings: from.strings } : from.kind === "textBlock" && now.kind === "textBlock" ? { ...now, ...outgoingCounter(from, now) } : now;
       if (outgoing === now) continue;
       (map ??= /* @__PURE__ */ new Map()).set(i, mode === "dip" ? { outgoing, k, mode } : { outgoing, k });
     }
     return map;
   }
-  /** Length of the fade out of segment `from`, or 0 (no fade, or a tier that plays it as cut). */
+  /** Length of the fade (or wipe) out of segment `from`, or 0 (none, or a tier that plays it as cut). */
   fadeDur(from) {
     const tr = this.seq.segments[from]?.transition;
-    return this.fadeEnabled && tr?.type === "fade" ? tr.dur : 0;
+    return this.fadeEnabled && (tr?.type === "fade" || tr?.type === "wipe") ? tr.dur : 0;
+  }
+  /** The wipe out of segment `from`, when that is its transition. */
+  wipeOf(from) {
+    const tr = this.seq.segments[from]?.transition;
+    return tr?.type === "wipe" ? tr : null;
+  }
+  wipeScratch = null;
+  wipeScratchIn = null;
+  /** `canvas` masked to one side of the wipe edge at progress `k`, on a scratch canvas of its own. */
+  wipeSide(slot, canvas, wipe, k, side) {
+    const cw = Math.max(1, canvas.width);
+    const ch = Math.max(1, canvas.height);
+    const scratch = this[slot] ??= createSceneCanvas(cw, ch);
+    if (scratch.width !== cw) scratch.width = cw;
+    if (scratch.height !== ch) scratch.height = ch;
+    const g = scratch.getContext("2d");
+    if (!g) return null;
+    g.save();
+    g.setTransform(1, 0, 0, 1, 0, 0);
+    g.globalCompositeOperation = "copy";
+    g.drawImage(canvas, 0, 0);
+    g.globalCompositeOperation = side === "out" ? "destination-out" : "destination-in";
+    g.fillStyle = wipeMask(g, wipe, k, cw, ch);
+    g.fillRect(0, 0, cw, ch);
+    g.restore();
+    return scratch;
+  }
+  /**
+   * Composite one side of a transition out of segment `from` at eased
+   * progress `k`. A fade draws the outgoing at 1 − k (and, over a bed, the
+   * incoming at k). A wipe draws each side through the moving edge instead:
+   * the outgoing everywhere the edge has not yet passed, the incoming where
+   * it has — the canvas is masked on a scratch copy (`destination-out` /
+   * `destination-in` with the edge's gradient), then drawn. `other`: the
+   * opposite side's canvas, when it is drawn too (a wipe over a bed) — the
+   * two masked sides are summed (`lighter`) on the scratch first, so a soft
+   * edge keeps matching marks opaque instead of letting the bed show through.
+   */
+  compositeTransition(canvas, k, from, side, other) {
+    const wipe = this.wipeOf(from);
+    if (!wipe) {
+      if (other) this.composite(other, side === "out" ? k : 1 - k);
+      return this.composite(canvas, side === "out" ? 1 - k : k);
+    }
+    const main = this.childCtx.surface?.getContext("2d");
+    if (!main) return;
+    const scratch = this.wipeSide("wipeScratch", canvas, wipe, k, side);
+    if (!scratch) return this.composite(canvas, side === "out" ? 1 - k : k);
+    if (other) {
+      const rest = this.wipeSide("wipeScratchIn", other, wipe, k, side === "out" ? "in" : "out");
+      const g = scratch.getContext("2d");
+      if (rest && g) {
+        g.save();
+        g.setTransform(1, 0, 0, 1, 0, 0);
+        g.globalCompositeOperation = "lighter";
+        g.drawImage(rest, 0, 0);
+        g.restore();
+      }
+    }
+    main.save();
+    main.globalAlpha = 1;
+    main.globalCompositeOperation = "source-over";
+    main.drawImage(scratch, 0, 0, this.childCtx.width, this.childCtx.height);
+    main.restore();
   }
   /** Sum of every timed segment — the lap length under `loop: true`. */
   timedTotal() {
@@ -6178,15 +6682,14 @@ var SequenceInstance = class {
         if (!this.fadingIn) this.fadingIn = this.offscreenChild(index, useMorphSeed ? chainRoot : index);
         this.renderOffscreen(this.fadingIn, localT, effSeed);
         const out = this.renderOutgoing(fadeFrom, localT, seed);
-        this.composite(this.fadingIn.canvas, k);
-        this.composite(out.canvas, 1 - k);
+        this.compositeTransition(out.canvas, k, fadeFrom, "out", this.fadingIn.canvas);
         return;
       }
       const child = useMorphSeed ? this.ensureChild(index, this.childScene(chainRoot)) : this.ensureChild(index);
       child.renderFrame(localT, effSeed);
       if (fadeActive) {
         const out = this.renderOutgoing(fadeFrom, localT, seed);
-        this.composite(out.canvas, 1 - easeSmooth(localT / this.fadeDur(fadeFrom)));
+        this.compositeTransition(out.canvas, easeSmooth(localT / this.fadeDur(fadeFrom)), fadeFrom, "out");
       }
     }
   }
@@ -6836,7 +7339,9 @@ function textFontPx(s, size, fontScale) {
 function textBox(s, e, p, fontScale, unitScale) {
   const fh = textFontPx(s, e.size, fontScale);
   const str = s.strings[e.spriteIndex] ?? s.strings[0] ?? "";
-  const est = Math.max(fh, 0.62 * fh * Math.min(str.length, 48));
+  const head = Array.from(str).slice(0, 48);
+  const wide = head.reduce((n, c) => n + (isFullWidth(c.codePointAt(0)) ? 1 : 0), 0);
+  const est = Math.max(fh, fh * (0.62 * head.length + 0.38 * wide));
   const fw = s.maxWidth ? Math.min(est, s.maxWidth * unitScale) : est;
   const align = s.align ?? "center";
   const baseline = s.baseline ?? "middle";
@@ -6853,7 +7358,7 @@ function textBlockBox(s, _e, p, w, h) {
   const lh = (s.lineHeight ?? 1.4) * fsPx;
   const maxWPx = s.maxWidth * unitScale;
   const maxWEm = maxWPx / fsPx;
-  const lines = breakTextBlock(s.text, maxWEm, textMetricsClassFor(s.font));
+  const lines = breakTextBlock(textBlockText(s), maxWEm, textMetricsClassFor(s.font));
   const totalH = lines.length * lh;
   const maxLineW = lines.reduce((m, l) => Math.max(m, l.widthEm), 0) * fsPx;
   const align = s.align ?? "left";
@@ -6870,7 +7375,7 @@ function textBlockRevealFraction(s, w, h, t) {
   if (!s.reveal) return 1;
   const unitScale = Math.min(w, h);
   const maxWEm = s.maxWidth * unitScale / (s.fontSize * unitScale);
-  const lines = breakTextBlock(s.text, maxWEm, textMetricsClassFor(s.font));
+  const lines = breakTextBlock(textBlockText(s), maxWEm, textMetricsClassFor(s.font));
   const rs = revealState(lines, s.reveal, t);
   if (rs.glyphAlphas) {
     let sum = 0;
@@ -7113,7 +7618,7 @@ function luminanceGrid(spec, opts = {}) {
       if (!part.stroke) return [];
       const hw = part.stroke.width * radius / 2;
       const out = [];
-      for (const l of part.flat.lines) {
+      for (const l of strokeLines(part)) {
         const m = l.points.map(([u, v]) => mapUnit(u, v));
         const n = l.closed ? m.length : m.length - 1;
         for (let i = 0; i < n; i++) {
@@ -7207,9 +7712,12 @@ function luminanceGrid(spec, opts = {}) {
     for (const { layer, entities } of scene.layers) {
       const lifeA = layer.opacity === void 0 && layer.group === void 0 ? lifeAlphaAt(layer.life, tPass) : lifeAlphaAt(layer.life, tPass) * paintOpacity(spec, layer);
       if (lifeA <= 0) continue;
-      for (const e of entities) {
-        splatTrail(layer, e, tPass, lifeA, alphaScale, entities.length);
-        const a = Math.min(1, alphaAt(e, tPass) * lifeA) * alphaScale;
+      for (let ei = 0; ei < entities.length; ei++) {
+        const e = entities[ei];
+        const entA = layer.life?.stagger ? lifeA * lifeStaggerAt(layer.life, tPass, ei) : lifeA;
+        if (entA <= 0) continue;
+        splatTrail(layer, e, tPass, entA, alphaScale, entities.length);
+        const a = Math.min(1, alphaAt(e, tPass) * entA) * alphaScale;
         if (a <= 4e-3) continue;
         const lum = spriteLuma(layer, e);
         const p = posOf(scene, e, tPass);
@@ -7220,7 +7728,7 @@ function luminanceGrid(spec, opts = {}) {
           continue;
         }
         if (s.kind === "stroke") {
-          const pts = strokeSamples(s, sz / 2);
+          const pts = strokeDrawnSamples(s, sz / 2);
           let angle = rotationAt(e, tPass) + paintRotation(spec, layer);
           if (s.orient) angle += headingAt(e, tPass, w, h) ?? 0;
           const ca = Math.cos(angle);
@@ -7236,6 +7744,7 @@ function luminanceGrid(spec, opts = {}) {
             compose(r * cols + c, lum, a * Math.min(1, lw * taper / cellH), layer.blend);
           };
           const step = Math.min(cellW, cellH) / 2;
+          if (pts.length < 2) continue;
           stampAt(pts[0], 0);
           for (let i = 1; i < pts.length; i++) {
             const q0 = pts[i - 1];
@@ -7331,13 +7840,15 @@ function luminanceGrid(spec, opts = {}) {
         for (const edge of edges) {
           const pi = positions[edge.i];
           const pj = positions[edge.j];
+          const env = layer.life?.stagger ? Math.min(lifeStaggerAt(layer.life, tPass, edge.i), lifeStaggerAt(layer.life, tPass, edge.j)) : 1;
+          if (env <= 0) continue;
           const steps = Math.max(1, Math.ceil(edge.dist / Math.min(cellW, cellH)));
           for (let i = 0; i <= steps; i++) {
             const k = i / steps;
             const c = Math.floor((pi.x + (pj.x - pi.x) * k) / cellW);
             const r = Math.floor((pi.y + (pj.y - pi.y) * k) / cellH);
             if (c < 0 || c >= cols || r < 0 || r >= rows) continue;
-            compose(r * cols + c, lum, wgt, layer.blend);
+            compose(r * cols + c, lum, wgt * env, layer.blend);
           }
         }
       }
@@ -7395,6 +7906,57 @@ function finishGrid(cols, rows, cells, bgRow, bgCells) {
     colProfile
   };
 }
+function layerCellFootprints(spec, opts = {}) {
+  const scene = buildScene(spec, opts);
+  const cols = Math.max(8, Math.min(200, opts.cols ?? 80));
+  const rows = Math.max(8, Math.min(200, opts.rows ?? 48));
+  const { w, h, scale } = scene;
+  const cellW = w / cols;
+  const cellH = h / rows;
+  const fontScale = fontScaleFor(spec, w, h);
+  return scene.layers.map(({ layer, entities }) => {
+    if (layer.motion.type !== "static" || layer.emit || layer.links || layer.trail) return null;
+    const s = layer.sprite;
+    const k = layer.transform !== void 0 || layer.group !== void 0 ? paintSize(spec, layer) : 1;
+    const cells = /* @__PURE__ */ new Set();
+    for (const e of entities) {
+      if (e.orbitParent || e.cyclePeriod > 0) return null;
+      const p = posOf(scene, e, 0);
+      const grow = 1 + Math.abs(e.growAmp);
+      const sz = e.size * grow * k;
+      const per = e.size > 0 ? sz / e.size : 1;
+      let reach;
+      if (s.kind === "circle" || s.kind === "ring") reach = sz / 2;
+      else if (s.kind === "polygon" && isPathPolygon(s)) {
+        const fr = pathFrame(s, sz / 2, w, h);
+        reach = 0;
+        for (const part of pathParts(s)) {
+          const { cx, cy, hw, hh } = part.box;
+          const dx = Math.max(Math.abs(cx - hw - fr.ox), Math.abs(cx + hw - fr.ox)) * fr.sx;
+          const dy = Math.max(Math.abs(cy - hh - fr.oy), Math.abs(cy + hh - fr.oy)) * fr.sy;
+          reach = Math.max(reach, Math.hypot(dx, dy) + (part.stroke?.width ?? 0) * sz / 4);
+        }
+      } else if (s.kind === "polygon") reach = polygonPoints(s, sz / 2).reduce((m, q) => Math.max(m, Math.hypot(q.x, q.y)), sz / 2);
+      else if (s.kind === "rect") reach = Math.hypot(sz, (e.size2 ?? e.size) * per) / 2;
+      else if (s.kind === "bar") {
+        const b = barBox(s.direction ?? "right", sz * barFraction(s, e.barIndex ?? 0), e.size2 !== void 0 ? e.size2 * per : sz * 0.2);
+        reach = Math.hypot(Math.abs(b.cx) + b.halfX, Math.abs(b.cy) + b.halfY);
+      } else if (s.kind === "streak") reach = sz + (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale;
+      else if (s.kind === "stroke") reach = strokeSamples(s, sz / 2).reduce((m, q) => Math.max(m, Math.hypot(q.x, q.y)), 0) + strokeWidthPx(s, scale);
+      else if (s.kind === "text" || s.kind === "textBlock") {
+        const b = s.kind === "text" ? textBox(s, e, p, fontScale, scale) : textBlockBox(s, e, p, w, h);
+        reach = Math.hypot(Math.abs(b.cx - p.x) + b.halfX, Math.abs(b.cy - p.y) + b.halfY) * grow * Math.max(1, k);
+      } else reach = sz;
+      if (!Number.isFinite(reach) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return null;
+      const c0 = Math.max(0, Math.floor((p.x - reach - 1) / cellW));
+      const c1 = Math.min(cols - 1, Math.floor((p.x + reach + 1) / cellW));
+      const r0 = Math.max(0, Math.floor((p.y - reach - 1) / cellH));
+      const r1 = Math.min(rows - 1, Math.floor((p.y + reach + 1) / cellH));
+      for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) cells.add(r * cols + c);
+    }
+    return [...cells].sort((a, b) => a - b);
+  });
+}
 var DITHER = [
   [0.5 / 8, 4.5 / 8],
   [2.5 / 8, 6.5 / 8],
@@ -7457,7 +8019,7 @@ function textSprites(spec, opts = {}) {
       const s2 = layer.sprite;
       const unitScale = Math.min(scene.w, scene.h);
       const sizePx2 = s2.fontSize * unitScale;
-      const info = { layerIndex, key: layer.key, strings: [s2.text], count: entities.length, sizePx: Math.round(sizePx2) };
+      const info = { layerIndex, key: layer.key, strings: [textBlockText(s2)], count: entities.length, sizePx: Math.round(sizePx2) };
       if (s2.reveal) info.revealed = Math.round(textBlockRevealFraction(s2, scene.w, scene.h, t) * 100) / 100;
       out.push(info);
       return;
@@ -7551,8 +8113,9 @@ function rawDominance(spec, opts = {}) {
     const areaScale = painted ? paintSize(spec, layer) ** 2 : 1;
     let area = 0;
     let lumAcc = 0;
-    for (const e of entities) {
-      const a = alphaAt(e, t) * lifeA;
+    for (let ei = 0; ei < entities.length; ei++) {
+      const e = entities[ei];
+      const a = alphaAt(e, t) * lifeA * lifeStaggerAt(layer.life, t, ei);
       const sz = sizeAt(e, t);
       const s = layer.sprite;
       let entArea;
@@ -7573,7 +8136,7 @@ function rawDominance(spec, opts = {}) {
         entArea = sz * barFraction(s, e.barIndex ?? 0) * th;
       } else if (s.kind === "stroke") {
         const meanTaper = s.taper ? 0.64 : 1;
-        entArea = pathLength(strokeSamples(s, sz / 2)) * strokeWidthPx(s, scale) * meanTaper * LINE_SALIENCE;
+        entArea = pathLength(strokeDrawnSamples(s, sz / 2)) * strokeWidthPx(s, scale) * meanTaper * LINE_SALIENCE;
       } else if (s.kind === "text") {
         const box = textBox(s, e, { x: 0, y: 0 }, fontScaleFor(spec, w, h), scale);
         entArea = box.halfX * 2 * box.halfY * 2 * 0.55;
@@ -7600,7 +8163,10 @@ function rawDominance(spec, opts = {}) {
       const la = (layer.links.alpha ?? 0.6) * lifeA;
       const defaultWidth = scale === 1 ? 1 : 1 / LIMITS.referenceViewport;
       const lw = (layer.links.width ?? defaultWidth) * scale;
-      for (const edge of edges) area += edge.dist * lw * la * LINE_SALIENCE;
+      for (const edge of edges) {
+        const env = layer.life?.stagger ? Math.min(lifeStaggerAt(layer.life, t, edge.i), lifeStaggerAt(layer.life, t, edge.j)) : 1;
+        area += edge.dist * lw * la * LINE_SALIENCE * env;
+      }
     }
     const meanLuma = entities.length ? lumAcc / entities.length : 0;
     const contrast = Math.abs(meanLuma - bgMean) + 0.1;
@@ -7707,10 +8273,11 @@ function sceneColour(spec, opts = {}) {
       wb += c.b * weight;
       wsum += weight;
     };
-    for (const e of entities) {
+    for (let ei = 0; ei < entities.length; ei++) {
+      const e = entities[ei];
       const sz = sizeAt(e, t);
       const s = layer.sprite;
-      const a = alphaAt(e, t) * lifeA * onScreenFraction(scene, s, e, sz, k, t, paintRotation(spec, layer));
+      const a = alphaAt(e, t) * lifeA * lifeStaggerAt(layer.life, t, ei) * onScreenFraction(scene, s, e, sz, k, t, paintRotation(spec, layer));
       if (a <= 0) continue;
       if (s.kind === "polygon" && isPathPolygon(s)) {
         const fr = pathFrame(s, sz / 2, scene.w, scene.h);
@@ -7922,25 +8489,89 @@ function perceiveSequenceFrame(seq, T, opts = {}) {
 
 // src/flash-timeline.ts
 import { analyzeFlashes, srgbToLinear as srgbToLinear2 } from "@idle-screens/validator";
-var LUMA_PATH = /(^|\.)(opacity|alpha|color|colors|stops|bands|gradient|stroke|fill|background)(\.|$)|(^|\.)(sprite|parts?)$|^layers\.\d+$/;
+var LUMA_PATH = /(^|\.)(opacity|alpha|color|colors|stops|bands|gradient|stroke|fill|background|draw)(\.|$)|(^|\.)(sprite|parts?)$|^layers\.\d+$/;
 var MIN_BOUNDARIES = 7;
 var MAX_SAMPLES = 64;
 var MAX_TOTAL_SAMPLES = 512;
 var WINDOW = 1e3;
-function lumaKeyTimes(spec) {
+var COLS = 16;
+var ROWS = 9;
+var AREA_THRESHOLD = 0.25;
+function lumaTracks(spec) {
   const tl = spec.timeline;
-  if (!tl) return { times: [], lap: 0 };
+  if (!tl) return { tracks: [], lap: 0 };
   const lap = tl.loop && tl.duration ? tl.duration : 0;
-  const bounds = [];
+  const tracks = [];
   for (const [path, keys] of timelineTracks(spec)) {
     if (!LUMA_PATH.test(path)) continue;
+    const bounds = [];
     for (const k of keys) {
       const dur = k.dur ?? DEFAULT_KEY_DUR;
       bounds.push(k.t);
       if (dur > 0) bounds.push(k.t + dur);
     }
+    tracks.push({ path, times: lap ? [...bounds, ...bounds.map((b) => b + lap)] : bounds });
+  }
+  return { tracks, lap };
+}
+function lumaKeyTimes(spec) {
+  const { tracks, lap } = lumaTracks(spec);
+  return { times: [...new Set(tracks.flatMap((tr) => tr.times))].sort((a, b) => a - b), lap };
+}
+var PAINT_LEAF = /(^|\.)(opacity|alpha|color|fill)(\.\d+)?$|(^|\.)gradient(\.|$)|(^|\.)draw\.(start|end)$/;
+function pathCells(spec) {
+  const layers = spec.layers ?? [];
+  const volatile = /* @__PURE__ */ new Set();
+  const members = (g) => layers.flatMap((l, i) => l.group === g ? [i] : []);
+  const reach = /* @__PURE__ */ new Map();
+  for (const path of timelineTracks(spec).keys()) {
+    const [root, id, ...rest] = path.split(".");
+    const leaf = rest.join(".");
+    let to;
+    if (root === "layers" && /^\d+$/.test(id ?? "")) {
+      const n = Number(id);
+      to = [n];
+      if (!PAINT_LEAF.test(leaf)) {
+        if (rest[0] === "transform") volatile.add(n);
+        else for (let i = n; i < layers.length; i++) volatile.add(i);
+      }
+    } else if (root === "groups" && id !== void 0) {
+      to = members(id);
+      if (leaf !== "opacity") for (const i of to) volatile.add(i);
+    } else if (root === "background") to = "all";
+    else return null;
+    if (LUMA_PATH.test(path)) reach.set(path, to);
+  }
+  if (reach.size === 0) return /* @__PURE__ */ new Map();
+  const footprints = layerCellFootprints(withoutTimeline(spec), { cols: COLS, rows: ROWS });
+  const out = /* @__PURE__ */ new Map();
+  for (const [path, to] of reach) {
+    if (to === "all" || to.some((i) => volatile.has(i) || !footprints[i])) out.set(path, null);
+    else out.set(path, [...new Set(to.flatMap((i) => footprints[i]))]);
+  }
+  return out;
+}
+function cellsThatCanFlash(tracks, cellsOf, from, to) {
+  const perCell = Array.from({ length: COLS * ROWS }, () => []);
+  for (const tr of tracks) {
+    const ts = tr.times.filter((t) => t >= from && t <= to);
+    if (ts.length === 0) continue;
+    const cells = cellsOf.get(tr.path);
+    if (cells === null || cells === void 0) for (const list of perCell) list.push(...ts);
+    else for (const c of cells) perCell[c].push(...ts);
+  }
+  let n = 0;
+  for (const list of perCell) {
+    if (list.length < MIN_BOUNDARIES) continue;
+    const ts = [...new Set(list)].sort((a, b) => a - b);
+    for (let i = 0; i + MIN_BOUNDARIES - 1 < ts.length; i++) {
+      if (ts[i + MIN_BOUNDARIES - 1] - ts[i] <= WINDOW + 2) {
+        n++;
+        break;
+      }
+    }
   }
-  return { times: [...new Set(lap ? [...bounds, ...bounds.map((b) => b + lap)] : bounds)].sort((a, b) => a - b), lap };
+  return n;
 }
 function flashSampleTimes(boundaries) {
   const ts = /* @__PURE__ */ new Set();
@@ -7955,7 +8586,8 @@ function flashSampleTimes(boundaries) {
 function timelineFlashReport(spec) {
   const pass = { fails: false, flashesPerSecond: 0, flashingArea: 0, at: null };
   if (!spec.timeline) return pass;
-  const { times, lap } = lumaKeyTimes(spec);
+  const { tracks, lap } = lumaTracks(spec);
+  const times = [...new Set(tracks.flatMap((tr) => tr.times))].sort((a, b) => a - b);
   const dense = [];
   for (let i = 0, e = 0; i < times.length; i++) {
     while (e < times.length && times[e] < times[i] + WINDOW) e++;
@@ -7970,12 +8602,14 @@ function timelineFlashReport(spec) {
   dense.sort((a, b) => b.n - a.n);
   let budget = MAX_TOTAL_SAMPLES;
   let worst = pass;
+  const cellsOf = pathCells(spec);
   for (const w of dense) {
+    if (cellsOf && cellsThatCanFlash(tracks, cellsOf, w.from, w.to) < Math.ceil(AREA_THRESHOLD * COLS * ROWS)) continue;
     const sampleTimes = flashSampleTimes(times.filter((t) => t >= w.from && t <= w.to));
     for (let from = 0; from < sampleTimes.length - 1; ) {
       const chunk = sampleTimes.slice(from, from + MAX_SAMPLES);
       if (chunk.length < 2) break;
-      if (chunk.length > budget) return { ...worst, fails: true, at: lap ? w.from % lap : w.from, incomplete: true };
+      if (chunk.length > budget) return { ...worst, fails: true, at: lap ? w.from % lap : w.from, incomplete: true, boundariesPerSecond: w.n };
       budget -= chunk.length;
       const samples = chunk.map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: 16, rows: 9 }).cells.flat().map((v) => srgbToLinear2(v * 255)) }));
       const r = analyzeFlashes(samples);
@@ -7998,6 +8632,102 @@ function timelineFlashReport(spec) {
   return worst;
 }
 
+// src/period.ts
+var MAX_SCENE_PERIOD = 36e5;
+var PERIOD_LEAF = /(^|\.)(period|rate|every|duration|spin|speed|blink|drift)$/;
+var gcd = (a, b) => {
+  while (b) [a, b] = [b, a % b];
+  return a;
+};
+function toRatio(ms) {
+  for (let q = 1; q <= 1e3; q++) {
+    const p = ms * q;
+    if (Math.abs(p - Math.round(p)) < 1e-6) {
+      const n = Math.round(p);
+      const g = gcd(n, q);
+      return [n / g, q / g];
+    }
+  }
+  return null;
+}
+var range = (r) => r === void 0 ? null : typeof r === "number" ? r : r[0] === r[1] ? r[0] : NaN;
+function scenePeriod(spec) {
+  const parts = [];
+  const reasons = [];
+  const add = (label, ms) => {
+    if (!(ms > 0) || !Number.isFinite(ms)) return;
+    const ratio = toRatio(ms);
+    if (!ratio) reasons.push(`${label} repeats every ${Number(ms.toFixed(3))} ms, which has no exact ratio to combine`);
+    else parts.push([label, ratio[0], ratio[1]]);
+  };
+  const tl = spec.timeline;
+  if (tl && tl.keys.length > 0) {
+    const keyed = tl.keys.filter((k) => PERIOD_LEAF.test(String(k.path)));
+    if (keyed.length > 0) reasons.push(`timeline keys animate ${[...new Set(keyed.map((k) => String(k.path)))].join(", ")}, which sets the scene's own period`);
+    if (tl.loop && (tl.duration ?? 0) > 0) add("timeline", tl.duration);
+    else reasons.push("timeline does not loop (it plays once, then holds)");
+  }
+  const bg = spec.background;
+  if (bg && bg.type !== "solid" && bg.drift) {
+    const { period } = bg.drift;
+    const field = bg.type === "field" && bg.drift.amount !== 0;
+    const r = field ? toRatio(period) : null;
+    add("background drift", r ? r[0] / gcd(r[0], FIELD_BUCKET_MS) * FIELD_BUCKET_MS : period);
+  }
+  if (spec.finish?.animate && ((spec.finish.grain ?? 0) > 0 || (spec.finish.dither ?? 0) > 0)) reasons.push("finish.animate steps the grain without repeating");
+  spec.layers.forEach((layer, i) => {
+    const at = `layers[${i}]${layer.key ? ` (${layer.key})` : ""}`;
+    const rate = layer.clock?.rate ?? 1;
+    const life = layer.life;
+    if (life && (life.exit !== void 0 || life.enter !== void 0 && ((life.enter ?? 0) > 0 || (life.fade ?? 1e3) > 0))) reasons.push(`${at} life builds in or out once`);
+    if (layer.pulse) add(`${at} pulse`, layer.pulse.period / rate);
+    if (layer.grow) add(`${at} grow`, layer.grow.period / rate);
+    if (layer.rock) add(`${at} rock`, layer.rock.period / rate);
+    if (layer.emit) add(`${at} emit`, layer.emit.every);
+    const spin = range(layer.spin);
+    if (spin !== null) {
+      if (Number.isNaN(spin)) reasons.push(`${at} spin range gives each entity its own speed`);
+      else if (spin !== 0) add(`${at} spin`, 36e4 / Math.abs(spin));
+    }
+    const sp = layer.sprite;
+    if ((sp.kind === "emoji" || sp.kind === "text") && sp.cycle && spriteVariants(sp) > 1) add(`${at} cycle`, sp.cycle.period * spriteVariants(sp) / rate);
+    if (sp.kind === "textBlock" && sp.reveal) {
+      if ((sp.reveal.speed ?? 0) > 0) reasons.push(`${at} reveal types itself once`);
+      if (sp.reveal.caret) {
+        const hz = Math.min(3, sp.reveal.caret === true ? 1.2 : sp.reveal.caret.blink ?? 1.2);
+        if (hz > 0) add(`${at} caret`, 1e3 / hz);
+      }
+    }
+    const m = layer.motion;
+    if (m.type === "path") add(`${at} path`, m.duration);
+    else if (m.type === "orbit") {
+      const s = range(m.speed);
+      if (s === null || Number.isNaN(s)) reasons.push(`${at} orbit speed range gives each entity its own lap`);
+      else if (s !== 0) add(`${at} orbit`, 36e4 / Math.abs(s));
+    } else if (m.type !== "static") {
+      if (m.type === "drift" && m.ease?.type === "settle" && !layer.emit) reasons.push(`${at} drift settles once`);
+      else reasons.push(`${at} ${m.type} motion travels at seeded per-entity speeds`);
+    }
+  });
+  const labelled = parts.map(([l, n, d]) => `${l}: ${Number((n / d).toFixed(3))} ms`);
+  if (reasons.length > 0) return { period: null, parts: labelled, reasons };
+  if (parts.length === 0) return { period: 0, parts: labelled, reasons };
+  let num = 1;
+  let den = 0;
+  for (const [, n, d] of parts) {
+    num = num / gcd(num, n) * n;
+    den = gcd(den, d);
+    if (num / den > MAX_SCENE_PERIOD) {
+      return { period: null, parts: labelled, reasons: [`its parts share no cycle shorter than ${MAX_SCENE_PERIOD / 6e4} min`] };
+    }
+  }
+  if (num % den !== 0) return { period: null, parts: labelled, reasons: [`its parts repeat together every ${Number((num / den).toFixed(3))} ms, not a whole number of milliseconds`] };
+  return { period: num / den, parts: labelled, reasons };
+}
+function periodWithoutTimeline(spec) {
+  return scenePeriod(withoutTimeline(spec));
+}
+
 // src/advise.ts
 var LOW_CONTRAST_FLOOR = 0.05;
 var SPARSE_DECLARED_MAX_COVERAGE = 0.02;
@@ -8006,9 +8736,9 @@ var READ_SAFE_AREA = 0.05;
 var ADDITIVE_INK_CEILING = 1;
 var CALM_MAX_SPIN = 90;
 var NEAR_FLASH_MAX_BOUNDARIES = 10;
-function edgeAnchored(range) {
-  if (!range) return false;
-  const [a, b] = range;
+function edgeAnchored(range2) {
+  if (!range2) return false;
+  const [a, b] = range2;
   return (a <= 0.02 || b >= 0.98) && b - a <= 0.6;
 }
 function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
@@ -8137,7 +8867,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
         const fsPx = layer.sprite.fontSize * scale;
         const lh = (layer.sprite.lineHeight ?? 1.4) * fsPx;
         const maxWPx = layer.sprite.maxWidth * scale;
-        const lines = breakTextBlock(layer.sprite.text, maxWPx / fsPx, textMetricsClassFor(layer.sprite.font));
+        const lines = breakTextBlock(textBlockText(layer.sprite), maxWPx / fsPx, textMetricsClassFor(layer.sprite.font));
         pixArea = maxWPx * lines.length * lh * 0.55 * (layer.sprite.opacity ?? 1);
       } else if (layer.sprite.kind === "text") {
         const b = textBoxAt(layer.sprite, e, positionAt(e, 0, w, h), spec, w, h);
@@ -8236,6 +8966,20 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       message: `the timeline flickers ${flicker.flashesPerSecond} times a second over ${Math.round(flicker.area * 100)}% of the frame around ${Math.round(flicker.at)} ms \u2014 at or near WCAG 2.3.1's limit of 3; space opposing luminance changes \u2265 500 ms apart, or lower the contrast between the two states`
     });
   }
+  if (authored.timeline?.loop && (authored.timeline.duration ?? 0) > 0) {
+    const lap = Math.round(authored.timeline.duration);
+    const rest = periodWithoutTimeline(authored);
+    if (rest.period !== null && rest.period > 0 && lap % rest.period !== 0) {
+      let a = lap;
+      let b = rest.period;
+      while (b) [a, b] = [b, a % b];
+      warnings.push({
+        path: "timeline.duration",
+        code: "loop-seam",
+        message: `the timeline loops every ${lap} ms but the rest of the scene repeats every ${rest.period} ms (${rest.parts.join(", ")}), so the whole scene only repeats every ${lap / a * rest.period} ms \u2014 make the lap a multiple of ${rest.period} ms for one lap to loop`
+      });
+    }
+  }
   for (let li = 0; li < spec.layers.length; li++) {
     if (hidden?.[li]) continue;
     const layer = spec.layers[li];
@@ -8312,7 +9056,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       const raw = rot ? { ...unturned, ...mapBox(turn, unturned) } : unturned;
       const baseAlpha = Math.max(0, Math.min(1, e.alpha - e.pulseAmp)) * (s.kind === "textBlock" ? s.opacity ?? 1 : 1);
       const alpha = layer.opacity === void 0 && layer.group === void 0 ? baseAlpha : baseAlpha * paintOpacity(spec, layer);
-      const str = s.kind === "textBlock" ? s.text : s.strings[e.spriteIndex] ?? s.strings[0] ?? "";
+      const str = s.kind === "textBlock" ? textBlockText(s) : s.strings[e.spriteIndex] ?? s.strings[0] ?? "";
       textBoxes.push({ li, label, alpha, str, ...box, rawW: raw.x1 - raw.x0, rawH: raw.y1 - raw.y0 });
     }
   }
@@ -8638,7 +9382,7 @@ function textBlockBoxAt(s, p, w, h) {
   const fsPx = s.fontSize * unit;
   const lh = (s.lineHeight ?? 1.4) * fsPx;
   const maxWPx = s.maxWidth * unit;
-  const lines = breakTextBlock(s.text, maxWPx / fsPx, textMetricsClassFor(s.font));
+  const lines = breakTextBlock(textBlockText(s), maxWPx / fsPx, textMetricsClassFor(s.font));
   const maxLineW = lines.reduce((mx, l) => Math.max(mx, l.widthEm), 0) * fsPx;
   const totalH = lines.length * lh;
   const align = s.align ?? "left";
@@ -8679,13 +9423,15 @@ function adviseSequence(seq, viewport = { width: 1920, height: 1080 }) {
     }
   }
   const fadeBound = seq.loop ? seq.segments.length : seq.segments.length - 1;
-  const fades = seq.segments.slice(0, fadeBound).filter((s) => s.transition?.type === "fade").length;
+  const live = (s) => s.transition?.type === "fade" || s.transition?.type === "wipe";
+  const fades = seq.segments.slice(0, fadeBound).filter(live).length;
   if (fades > 0) {
-    const first = seq.segments.slice(0, fadeBound).findIndex((s) => s.transition?.type === "fade");
+    const first = seq.segments.slice(0, fadeBound).findIndex(live);
+    const wipes = seq.segments.slice(0, fadeBound).some((s) => s.transition?.type === "wipe");
     warnings.push({
       path: `segments[${first}].transition`,
       code: "fade-degrades-on-low-tier",
-      message: `informational: ${fades} fade transition${fades === 1 ? "" : "s"} declared \u2014 viewers on the 'basic' or 'minimal' capability tier render fade as cut (two live segments for dur is over that budget); the show still plays`
+      message: wipes ? `informational: ${fades} fade/wipe transition${fades === 1 ? "" : "s"} declared \u2014 viewers on the 'basic' or 'minimal' capability tier render them as cuts (two live segments for dur is over that budget); the show still plays` : `informational: ${fades} fade transition${fades === 1 ? "" : "s"} declared \u2014 viewers on the 'basic' or 'minimal' capability tier render fade as cut (two live segments for dur is over that budget); the show still plays`
     });
   }
   for (let i = 0; i < seq.segments.length - 1; i++) {
@@ -8693,7 +9439,7 @@ function adviseSequence(seq, viewport = { width: 1920, height: 1080 }) {
     const lumaA = backgroundLuma(resolveTimelineAt(seq.segments[i].scene, seq.segments[i].duration ?? 0));
     const lumaB = backgroundLuma(resolveTimelineAt(seq.segments[i + 1].scene, 0));
     const delta = Math.abs(lumaA - lumaB);
-    if (delta > 0.5 && tr?.type !== "fade") {
+    if (delta > 0.5 && tr?.type !== "fade" && tr?.type !== "wipe") {
       warnings.push({
         path: `segments[${i}]`,
         code: "boundary-luminance-jump",
@@ -11190,6 +11936,74 @@ var TYPED_CUE_SPEC = {
   ]
 };
 
+// src/examples/ink-tide.ts
+var INK_TIDE_SPEC = {
+  schemaVersion: 1,
+  id: "ink-tide",
+  label: "Ink Tide",
+  seed: 31,
+  motionIntensity: "calm",
+  background: { type: "gradient", stops: [{ at: 0, color: "#f1e9d8" }, { at: 1, color: "#e2d6bd" }] },
+  layers: [
+    {
+      key: "ink",
+      count: 1,
+      position: { x: 0.5, y: 0.48 },
+      motion: { type: "static" },
+      sprite: {
+        kind: "polygon",
+        radius: [0.4, 0.4],
+        color: "#2b2622",
+        fill: false,
+        // One pen run: the ridge, the shoreline, then the moon.
+        path: "M -1 0.32 L -0.64 -0.12 L -0.44 0.06 L -0.08 -0.46 L 0.2 -0.1 L 0.4 -0.26 L 1 0.32 M -0.96 0.5 C -0.5 0.4 -0.2 0.58 0.1 0.5 C 0.4 0.42 0.7 0.58 0.96 0.5 M 0.62 -0.66 A 0.12 0.12 0 1 1 0.619 -0.66",
+        stroke: { color: "#2b2622", width: 0.01, cap: "round", join: "round", draw: { start: 0, end: 1 } }
+      }
+    },
+    {
+      key: "boat",
+      count: 1,
+      position: { x: 0.5, y: 0.5, dx: 0.12, dy: 0.17 },
+      motion: { type: "static" },
+      sprite: { kind: "polygon", radius: [0.035, 0.035], color: "#2b2622", points: [[-1, -0.15], [1, -0.15], [0.62, 0.3], [-0.62, 0.3]] },
+      rock: { amp: 6, period: 6e3 },
+      clock: { phase: 0 }
+    },
+    {
+      key: "caption",
+      count: 1,
+      position: { x: 0.5, y: 0.86 },
+      motion: { type: "static" },
+      sprite: {
+        kind: "textBlock",
+        text: "the tide goes out and leaves the sky behind",
+        maxWidth: 1.2,
+        fontSize: 0.032,
+        anchor: "center",
+        align: "center",
+        color: "#5a4f45",
+        font: "italic Georgia, 'Times New Roman', serif",
+        opacity: 1,
+        reveal: { progress: 1, mode: "glyphFade", fade: 0.3, rise: 0.4 }
+      }
+    }
+  ],
+  timeline: {
+    loop: true,
+    duration: 3e4,
+    keys: [
+      { t: 0, path: "ink.sprite.stroke.draw.end", value: 1, dur: 12e3, ease: "out" },
+      { t: 9e3, path: "caption.sprite.reveal.progress", value: 1, dur: 4e3, ease: "out" },
+      { t: 2e4, path: "ink.sprite.stroke.draw.start", value: 1, dur: 7e3, ease: "in" },
+      { t: 21e3, path: "caption.sprite.opacity", value: 0, dur: 3e3 },
+      { t: 29e3, path: "ink.sprite.stroke.draw.end", value: 0, dur: 0 },
+      { t: 29e3, path: "ink.sprite.stroke.draw.start", value: 0, dur: 0 },
+      { t: 29200, path: "caption.sprite.reveal.progress", value: 0, dur: 0 },
+      { t: 29400, path: "caption.sprite.opacity", value: 1, dur: 0 }
+    ]
+  }
+};
+
 // src/examples/index.ts
 var SCHEMA_EXAMPLES = [
   { id: "aquarium", label: "Aquarium", spec: AQUARIUM_SPEC },
@@ -11219,7 +12033,8 @@ var SCHEMA_EXAMPLES = [
   { id: "phase-duet", label: "Phase Duet", spec: PHASE_DUET_SPEC },
   { id: "web-work", label: "Web Work", spec: WEB_WORK_SPEC },
   { id: "shard-fall", label: "Shard Fall", spec: SHARD_FALL_SPEC },
-  { id: "murmur", label: "Murmur", spec: MURMUR_SPEC }
+  { id: "murmur", label: "Murmur", spec: MURMUR_SPEC },
+  { id: "ink-tide", label: "Ink Tide", spec: INK_TIDE_SPEC }
 ];
 var EXAMPLE_SEQUENCES = [
   { id: "three-movements", label: "Three Movements", sequence: THREE_MOVEMENTS_SEQUENCE }
@@ -11255,6 +12070,8 @@ export {
   LOBBY_TALK_SPEC,
   MATRIX_RAIN_SPEC,
   MAX_PATH_POINTS,
+  MAX_SCENE_PERIOD,
+  MOTION_FIELDS,
   MURMUR_SPEC,
   NOSTALGHIA_CANDLE_SPEC,
   ORRERY_SPEC,
@@ -11271,6 +12088,7 @@ export {
   SIGNAL_BOARD_SPEC,
   SNOWFALL_SPEC,
   SPARSE_NIGHT_SPEC,
+  STEER_EASES,
   THERMAL_FIELD_SPEC,
   THREE_MOVEMENTS_SEQUENCE,
   TYPED_CUE_SPEC,
@@ -11302,6 +12120,8 @@ export {
   describeScene,
   diffScenes,
   dominanceRanking,
+  drawSpan,
+  easeGlide,
   easeSmooth,
   emitEnvelope,
   emitWindow,
@@ -11320,13 +12140,17 @@ export {
   headingAt,
   hexToRgb255,
   ignoredPropertyPaths,
+  isCombiningKana,
+  isFullWidth,
   isPathPolygon,
   latticeHash,
+  layerCellFootprints,
   layerCohesion,
   lerpPathD,
   lerpSpec,
   lerpValue,
   lifeAlphaAt,
+  lifeStaggerAt,
   linkEdges,
   linkMaxDistPx,
   linkPairs,
@@ -11341,6 +12165,7 @@ export {
   pathParts,
   perceiveScene,
   perceiveSequenceFrame,
+  periodWithoutTimeline,
   pickScreenOp,
   positionAt,
   presentWithFinish,
@@ -11354,6 +12179,7 @@ export {
   rgb255Luma,
   rotationAt,
   sceneColour,
+  scenePeriod,
   seamCauseOf,
   seamsWorthWarning,
   segmentRenderSeed,
@@ -11365,8 +12191,11 @@ export {
   spriteIndexAt,
   spriteVariants,
   steerablePaths,
+  strokeDrawnSamples,
+  strokeLines,
   structuralSignature,
   textBlockAnchorOffset,
+  textBlockText,
   textMetricsClassFor,
   textSprites,
   textStringsDiffer,
@@ -11377,9 +12206,12 @@ export {
   timelineSampleTimes,
   timelineSampleTimesAfter,
   timelineTracks,
+  trimLines,
+  trimPolyline,
   validateSequence,
   validateSpec,
   validateSpecPaths,
+  wipeMask,
   withoutTimeline
 };
 //# sourceMappingURL=index.js.map