@idle-screens/schema 3.13.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
@@ -255,6 +268,35 @@ function applyDeltasToSpec(spec, deltas) {
   }
   return copy;
 }
+function applyDeltasShared(spec, deltas) {
+  const out = { ...spec };
+  const copied = new WeakSet([out]);
+  for (const d of deltas) {
+    const cp = canonicalSpecPath(out, d.path);
+    if (!cp) continue;
+    const parts = cp.split(".");
+    let node = out;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const k = parts[i];
+      const child = node[k];
+      if (!child || typeof child !== "object") {
+        node = null;
+        break;
+      }
+      if (!copied.has(child)) {
+        const clone = Array.isArray(child) ? child.slice() : { ...child };
+        copied.add(clone);
+        node[k] = clone;
+      }
+      node = node[k];
+    }
+    if (node) {
+      const last = parts[parts.length - 1];
+      node[Array.isArray(node) ? Number(last) : last] = d.value;
+    }
+  }
+  return out;
+}
 var HEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
 function hexToRgb(hex) {
   const h = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
@@ -339,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) {
@@ -433,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,
@@ -468,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 }] : []
       ];
     })
   ]);
@@ -584,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}`;
 }
 
@@ -620,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;
@@ -641,7 +705,7 @@ function evalTrack(keys, start, tt, leaf) {
   }
   return at(tt);
 }
-function resolveTimelineAt(spec, t) {
+function resolveTimelineAt(spec, t, shared = false) {
   const tl = spec.timeline;
   if (!tl) return spec;
   const base = withoutTimeline(spec);
@@ -653,7 +717,7 @@ function resolveTimelineAt(spec, t) {
     const start = tl.loop ? keys[keys.length - 1].value : readSpecPath(base, path);
     deltas.push({ t: 0, path, value: evalTrack(keys, start, tt, path.slice(path.lastIndexOf(".") + 1)) });
   }
-  return applyDeltasToSpec(base, deltas);
+  return shared ? applyDeltasShared(base, deltas) : applyDeltasToSpec(base, deltas);
 }
 function nextKeyAfter(spec, path, t) {
   const tl = spec.timeline;
@@ -772,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++) {
@@ -791,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++) {
@@ -800,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))));
 }
@@ -844,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;
@@ -934,6 +1094,41 @@ function pathParts(s) {
   spriteParts.set(s, { key, parts });
   return parts;
 }
+function partInkArea(part, sx, sy, r) {
+  if (part.opacity <= 0) return { fill: 0, stroke: 0 };
+  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 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;
+    }
+    stroke *= (part.stroke.opacity ?? 1) * part.opacity;
+  }
+  return { fill, stroke };
+}
+function gradientStopWeights(stops) {
+  const at = stops.map((st) => Math.min(1, Math.max(0, st.at)));
+  const order = at.map((_, i) => i).sort((a, b) => at[a] - at[b]);
+  const out = new Array(stops.length).fill(0);
+  order.forEach((i, rank) => {
+    const prev = rank > 0 ? at[order[rank - 1]] : null;
+    const next = rank < order.length - 1 ? at[order[rank + 1]] : null;
+    const a = at[i];
+    out[i] = (prev === null ? a : (a - prev) / 2) + (next === null ? 1 - a : (next - a) / 2);
+  });
+  const sum = out.reduce((x, y) => x + y, 0);
+  return sum > 0 ? out.map((x) => x / sum) : out.map(() => 1 / Math.max(1, stops.length));
+}
+function pathInkArea(s, sx, sy, r) {
+  let area = 0;
+  for (const part of pathParts(s)) {
+    const a = partInkArea(part, sx, sy, r);
+    area += a.fill + a.stroke;
+  }
+  return area;
+}
 function pathFrame(s, r, w, h) {
   const span = s.span ?? "box";
   const sx = span === "width" || span === "screen" ? w / 2 : r;
@@ -1231,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 };
@@ -1383,6 +1601,7 @@ var KNOWN_LAYER = /* @__PURE__ */ new Set([
   "emit",
   "clock",
   "rotate",
+  "rock",
   "opacity",
   "transform",
   "group"
@@ -1393,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"]);
@@ -1400,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));
 }
@@ -1456,9 +1737,18 @@ function validateSpec(spec) {
 }
 function ignoredPropertyPaths(spec) {
   if (!isObj(spec)) return [];
-  return (validateSpecCore(spec).warnings ?? []).filter((w) => w.code === "unknown-property" || w.code === "misplaced-property").map((w) => w.path.replace(/\[(\d+)\]/g, ".$1"));
+  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, keyed = false) {
+  if (!keyed) return specPathsValid(spec, paths);
+  keyedPathDepth++;
+  try {
+    return specPathsValid(spec, paths);
+  } finally {
+    keyedPathDepth--;
+  }
 }
-function validateSpecPaths(spec, paths) {
+function specPathsValid(spec, paths) {
   const layers = /* @__PURE__ */ new Set();
   let background = false;
   let finish = false;
@@ -1494,7 +1784,7 @@ function validateSpecPaths(spec, paths) {
   }
   return ok;
 }
-function validateSpecCore(spec) {
+function validateSpecCore(spec, checkApplied = true) {
   const errors = [];
   const warnings = [];
   const err = (path, message) => void errors.push({ path, message });
@@ -1530,7 +1820,7 @@ function validateSpecCore(spec) {
     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);
@@ -1563,7 +1853,7 @@ function validateSpecCore(spec) {
     });
     if (total > LIMITS.maxTotal) err("layers", `total entities ${total} exceeds cap ${LIMITS.maxTotal}`);
   }
-  if (spec.timeline !== void 0 && errors.length === 0) validateTimeline(spec, err, warn);
+  if (spec.timeline !== void 0 && errors.length === 0) validateTimeline(spec, err, warn, checkApplied);
   return { valid: errors.length === 0, errors, warnings };
 }
 function validateTransform(tf, path, err, warn, spec, anchorOk) {
@@ -1601,7 +1891,15 @@ function validateGroups(groups, err, warn, spec) {
     if (g.transform !== void 0) validateTransform(g.transform, `${p}.transform`, err, warn, spec, false);
   }
 }
-function validateTimeline(spec, errOuter, warn) {
+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;
@@ -1624,13 +1922,13 @@ function validateTimeline(spec, errOuter, warn) {
   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}`);
     }
@@ -1655,20 +1953,28 @@ function validateTimeline(spec, errOuter, warn) {
     if (!ok || !cp) return;
     const t = key.t;
     latest = Math.max(latest, t);
-    const applied = applyDeltasToSpec(base, [{ t: 0, path: cp, value: key.value }]);
-    const r = validateSpecPaths(applied, [cp]) ? { valid: true, errors: [] } : validateSpec(applied);
-    if (!r.valid) {
-      for (const e of r.errors) err(`${p}.value`, `applied at '${key.path}' \u2192 ${e.path || "<root>"}: ${e.message}`);
-      return;
-    }
-    if (isObj(key.value) && cp.endsWith("transform")) {
-      const before = readSpecPath(base, cp);
-      const o0 = isObj(before) ? before.origin ?? "viewport" : "viewport";
-      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 (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`);
+    if (checkApplied) {
+      const applied = applyDeltasShared(base, [{ t: 0, path: cp, value: key.value }]);
+      const r = validateSpecPaths(applied, [cp]) ? { valid: true, errors: [] } : validateSpec(structuredClone(applied));
+      if (!r.valid) {
+        for (const e of r.errors) err(`${p}.value`, `applied at '${key.path}' \u2192 ${e.path || "<root>"}: ${e.message}`);
+        return;
+      }
+      if (isObj(key.value) && cp.endsWith("transform")) {
+        const before = readSpecPath(base, cp);
+        const o0 = isObj(before) ? before.origin ?? "viewport" : "viewport";
+        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`);
+      }
     }
     const list = times.get(cp) ?? [];
     list.push(t);
@@ -1694,16 +2000,16 @@ function validateTimeline(spec, errOuter, warn) {
       if (wrapGap < minGap) err("timeline.keys", `keys on '${path}' at ${distinct[distinct.length - 1]} ms and ${distinct[0]} ms (next lap) are closer than ${minGap} ms across the loop wrap (flash safety)`);
     }
   }
-  if (failed) return;
+  if (failed || !checkApplied) return;
   const keyed = [...timelineTracks(spec).keys()];
   const seen = /* @__PURE__ */ new Set();
   for (const t of timelineSampleTimes(spec, true, 120)) {
-    const r = resolveTimelineAt(spec, t);
+    const r = resolveTimelineAt(spec, t, true);
     const state = JSON.stringify(keyed.map((p) => readSpecPath(r, p)));
     if (seen.has(state)) continue;
     seen.add(state);
     if (validateSpecPaths(r, keyed)) continue;
-    const e = validateSpec(r).errors[0];
+    const e = validateSpec(structuredClone(r)).errors[0];
     err("timeline", `at t = ${Math.round(t)} ms the keys combine into an invalid scene \u2014 ${e ? `${e.path || "<root>"}: ${e.message}` : "invalid"}`);
     return;
   }
@@ -1809,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) {
@@ -1972,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"]))) {
@@ -2030,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) {
@@ -2091,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})`);
@@ -2222,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") {
@@ -2262,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)) {
@@ -2282,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)) {
@@ -2350,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;
@@ -2357,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`);
@@ -2365,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`);
@@ -2464,29 +2825,43 @@ 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}` : 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;
+  }
+  pathVerdicts.set(key, problem);
+  pathVerdictBytes += key.length;
+  return problem;
+}
 function validatePathPiece(piece, path, err, warn) {
   if (typeof piece.path !== "string" || piece.path.length === 0 || piece.path.length > 65536) {
     err(`${path}.path`, "must be an SVG path d string (1..65536 chars) in the -1..1 unit box");
   } else {
-    const flat = flattenPath(piece.path, piece.fillRule ?? "auto");
-    const filled = piece.fill !== false;
-    if (flat.error) err(`${path}.path`, `not a usable path: ${flat.error}`);
-    else if (filled && flat.points.length < 3) err(`${path}.path`, "must enclose an area (at least 3 points), or set fill: false and a stroke for line art");
-    else if (!filled && flat.lines.length === 0) err(`${path}.path`, "must draw at least one line (2+ points)");
-    else if (flat.points.length > MAX_PATH_POINTS) err(`${path}.path`, `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}`);
-    else if ([...flat.points, ...flat.lines.flatMap((l) => l.points)].some(([x, y]) => Math.abs(x) > 1.0001 || Math.abs(y) > 1.0001)) err(`${path}.path`, "must stay inside the -1..1 unit box (curves included)");
+    const problem = pathGeometryProblem(piece.path, piece.fillRule ?? "auto", piece.fill !== false);
+    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 }");
@@ -2511,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) {
@@ -2613,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'");
         }
@@ -3017,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);
@@ -3076,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) {
@@ -3093,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;
@@ -3316,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;
@@ -3324,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") {
@@ -3510,6 +3971,10 @@ function paintOpacity(spec, layer) {
   const g = groupOf(spec, layer);
   return g?.opacity === void 0 ? own : own * clamp01(g.opacity);
 }
+function paintRotation(spec, layer) {
+  const deg = (layer.transform?.rotate ?? 0) + (groupOf(spec, layer)?.transform?.rotate ?? 0);
+  return deg * Math.PI / 180;
+}
 function paintSize(spec, layer) {
   return transformSize(layer.transform) * transformSize(groupOf(spec, layer)?.transform);
 }
@@ -3904,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) {
@@ -3913,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;
@@ -3945,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;
 }
@@ -3988,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;
@@ -4478,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;
@@ -4917,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);
@@ -4928,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);
@@ -4975,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;
@@ -4997,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;
@@ -5015,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];
           }
         }
@@ -5070,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();
@@ -5099,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;
@@ -5144,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);
@@ -5169,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;
@@ -5231,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();
   }
@@ -5292,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) {
@@ -5447,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;
@@ -5821,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() {
@@ -6096,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");
       }
     }
   }
@@ -6253,6 +6838,7 @@ function compileSequence(spec) {
 
 // src/advise.ts
 import { createRng as createRng3 } from "@idle-screens/core";
+import { analyzeFlashes as analyzeFlashes2, srgbToLinear as srgbToLinear3 } from "@idle-screens/validator";
 
 // src/luma.ts
 function fieldRenderedRgbs(bg) {
@@ -6301,6 +6887,26 @@ function spriteLuma(layer, e) {
   if (s.kind === "text" || s.kind === "textBlock") return hexLuma(s.color ?? "#e6e8ef");
   return 0.75;
 }
+function spriteInks(layer, e) {
+  const s = layer.sprite;
+  if (s.kind === "polygon" && isPathPolygon(s)) {
+    const base = s.colors?.[e.colorIndex] ?? s.color;
+    const inks = [];
+    for (const part of pathParts(s)) {
+      if (part.opacity <= 0) continue;
+      if (part.fill) {
+        if (part.gradient) for (const st of part.gradient.stops) {
+          if ((st.opacity ?? 1) > 0) inks.push(st.color);
+        }
+        else inks.push(part.color ?? base);
+      }
+      if (part.stroke && part.stroke.width > 0 && (part.stroke.opacity ?? 1) > 0) inks.push(part.stroke.color);
+    }
+    return inks;
+  }
+  const hex = spriteHex(layer, e);
+  return hex === null ? null : [hex];
+}
 function spriteHex(layer, e) {
   const s = layer.sprite;
   if (isShapedSprite(s)) {
@@ -6416,6 +7022,23 @@ var WASH_ALPHA_MAX = 0.45;
 var COHESION_T = 5e3;
 var OUTLINE_SAMPLES = 24;
 var MAX_TRACED = 240;
+function discSamples(cx, cy, r, n) {
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  return Array.from({ length: n }, (_, i) => {
+    const rr = r * Math.sqrt((i + 0.5) / n);
+    return { x: cx + rr * Math.cos(i * golden), y: cy + rr * Math.sin(i * golden) };
+  });
+}
+function gridSamples(uw, vh, n, map) {
+  if (!(uw > 0) || !(vh > 0)) return [];
+  const nv = Math.min(n, Math.max(8, Math.round(Math.sqrt(n * vh / uw))));
+  const nu = Math.max(8, Math.round(n / nv));
+  const out = [];
+  for (let i = 0; i < nu; i++) {
+    for (let j = 0; j < nv; j++) out.push(map(((i + 0.5) / nu - 0.5) * uw, ((j + 0.5) / nv - 0.5) * vh));
+  }
+  return out;
+}
 var EDGE_INSET = 1e-4;
 function circleShape(cx, cy, r) {
   return {
@@ -6424,6 +7047,7 @@ function circleShape(cx, cy, r) {
     br: r,
     area: Math.PI * r * r,
     contains: (x, y) => (x - cx) * (x - cx) + (y - cy) * (y - cy) < r * r,
+    interior: (n) => discSamples(cx, cy, r, n),
     outline: (n) => Array.from({ length: n }, (_, i) => {
       const a = i / n * Math.PI * 2;
       const inner = r * (1 - EDGE_INSET);
@@ -6457,12 +7081,21 @@ function polyShape(cx, cy, raw) {
   const step = Math.min(br * EDGE_INSET, shortest * 0.25);
   const area = polygonArea(abs);
   if (!(area > 0)) return null;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of abs) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
   return {
     cx,
     cy,
     br,
     area,
     contains: inside2,
+    // Its bounding box's grid, kept to the cells inside the outline.
+    interior: (n) => gridSamples(x1 - x0, y1 - y0, n, (u, v) => ({ x: (x0 + x1) / 2 + u, y: (y0 + y1) / 2 + v })).filter((p) => inside2(p.x, p.y)),
     /**
      * `n` points spread along the perimeter by ARC LENGTH, not one share per
      * edge — a long skinny rectangle has two edges carrying almost all of its
@@ -6512,12 +7145,13 @@ function rectShape(cx, cy, halfW, halfH, rot) {
   const cos = Math.cos(rot);
   const sin = Math.sin(rot);
   const corner = (lx, ly) => ({ x: cx + lx * cos - ly * sin, y: cy + lx * sin + ly * cos });
-  return polyShape(cx, cy, [
+  const shape = polyShape(cx, cy, [
     corner(-halfW, -halfH),
     corner(halfW, -halfH),
     corner(halfW, halfH),
     corner(-halfW, halfH)
   ]);
+  return shape && { ...shape, interior: (n) => gridSamples(halfW * 2, halfH * 2, n, corner) };
 }
 function polygonShape(cx, cy, pts, rot) {
   const cos = Math.cos(rot);
@@ -6577,8 +7211,7 @@ function cohesionOf(layers, t, w, h) {
       seamCause
     };
     if (lifeAlphaAt(layer.life, t) <= 0) return { ...base, overlap: null, reads: null };
-    const shapes = entities.map((e) => shapeOf(layer, e, t, w, h));
-    const solid = shapes.filter((x) => x !== null && x.area > 0);
+    const solid = solidShapes(layer, entities, t, w, h);
     if (solid.length < 2) return { ...base, overlap: null, reads: null };
     const stride = Math.max(1, Math.ceil(solid.length / MAX_TRACED));
     let covered = 0;
@@ -6610,11 +7243,54 @@ function cohesionOf(layers, t, w, h) {
     return { ...base, overlap, reads };
   });
 }
-function seamsWorthWarning(layer, c, entityCount) {
+function solidShapes(layer, entities, t, w, h) {
+  return entities.map((e) => shapeOf(layer, e, t, w, h)).filter((x) => x !== null && x.area > 0);
+}
+var AREA_SAMPLES = 128;
+var TILED_AREA_MAX = 0.15;
+function buriedAreaOf(layer, entities, t, w, h) {
+  if (lifeAlphaAt(layer.life, t) <= 0) return null;
+  const solid = solidShapes(layer, entities, t, w, h);
+  if (solid.length < 2) return null;
+  const stride = Math.max(1, Math.ceil(solid.length / MAX_TRACED));
+  let covered = 0;
+  let traced = 0;
+  for (let i = 0; i < solid.length; i += stride) {
+    const pts = solid[i].interior(AREA_SAMPLES);
+    if (pts.length === 0) continue;
+    let hit = 0;
+    for (const p of pts) {
+      for (let j = 0; j < solid.length; j++) {
+        if (j === i) continue;
+        const other = solid[j];
+        const dx = p.x - other.cx;
+        const dy = p.y - other.cy;
+        if (dx * dx + dy * dy > other.br * other.br) continue;
+        if (other.contains(p.x, p.y)) {
+          hit++;
+          break;
+        }
+      }
+    }
+    covered += hit / pts.length;
+    traced++;
+  }
+  return traced === 0 ? null : Number((covered / traced).toFixed(4));
+}
+function seamsWorthWarning(layer, c, entityCount, buriedArea) {
   if (c.reads !== "seamed" || entityCount < 6) return false;
   const [lo, hi] = layer.alpha ?? [1, 1];
   if ((lo + hi) / 2 < WASH_ALPHA_MAX) return false;
-  return layer.blend !== "lighter" && layer.blend !== "screen";
+  if (layer.blend === "lighter" || layer.blend === "screen") return false;
+  if (buriedArea && paletteIsTheOnlySeam(layer)) {
+    const a = buriedArea();
+    if (a !== null && a < TILED_AREA_MAX) return false;
+  }
+  return true;
+}
+function paletteIsTheOnlySeam(layer) {
+  if (seamCauseOf(layer) === null) return false;
+  return seamCauseOf({ ...layer, sprite: { ...layer.sprite, colors: void 0 } }) === null;
 }
 
 // src/perceive.ts
@@ -6663,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";
@@ -6680,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";
@@ -6697,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;
@@ -6917,7 +7595,7 @@ function luminanceGrid(spec, opts = {}) {
   };
   const splatPolygonOutline = (layer, s, e, p, sz, a, lum, tPass) => {
     const radius = sz / 2;
-    const rot = rotationAt(e, tPass);
+    const rot = rotationAt(e, tPass) + paintRotation(spec, layer);
     const cr = Math.cos(rot);
     const sr = Math.sin(rot);
     const fr = isPathPolygon(s) ? pathFrame(s, radius, w, h) : { sx: radius, sy: radius, ox: 0, oy: 0, uniform: true };
@@ -6940,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++) {
@@ -7034,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);
@@ -7047,8 +7728,8 @@ function luminanceGrid(spec, opts = {}) {
           continue;
         }
         if (s.kind === "stroke") {
-          const pts = strokeSamples(s, sz / 2);
-          let angle = rotationAt(e, tPass);
+          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);
           const sa = Math.sin(angle);
@@ -7063,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];
@@ -7077,7 +7759,7 @@ function luminanceGrid(spec, opts = {}) {
           continue;
         }
         if (s.kind === "streak") {
-          const heading = (headingAt(e, tPass, w, h) ?? 0) + rotationAt(e, tPass);
+          const heading = (headingAt(e, tPass, w, h) ?? 0) + (rotationAt(e, tPass) + paintRotation(spec, layer));
           const steps = Math.max(2, Math.ceil(sz / Math.min(cellW, cellH)));
           const wgt = Math.min(1, (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale / cellH);
           for (let i = 0; i <= steps; i++) {
@@ -7112,7 +7794,7 @@ function luminanceGrid(spec, opts = {}) {
           if (len <= 0) continue;
           const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
           const box = barBox(s.direction ?? "right", len, th);
-          const rot = rotationAt(e, tPass);
+          const rot = rotationAt(e, tPass) + paintRotation(spec, layer);
           const cr = Math.cos(rot);
           const sr = Math.sin(rot);
           centerX = p.x + box.cx * cr - box.cy * sr;
@@ -7158,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);
           }
         }
       }
@@ -7222,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],
@@ -7284,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;
@@ -7311,6 +8046,42 @@ function rankDominance(raw) {
     factors: r.factors
   }));
 }
+function onScreenFraction(scene, s, e, sz, k, t, paintRot = 0) {
+  if (s.kind === "text" || s.kind === "textBlock") return 1;
+  const { w, h } = scene;
+  const p = posOf(scene, e, t);
+  let cx = p.x, cy = p.y, hx = sz / 2 * k, hy = hx;
+  if (s.kind === "bar") {
+    const len = sz * barFraction(s, e.barIndex ?? 0);
+    const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
+    const b = barBox(s.direction ?? "right", len * k, th * k);
+    if (!(b.halfX > 0) || !(b.halfY > 0)) return 1;
+    const rot = rotationAt(e, t);
+    const cr = Math.cos(rot), sr = Math.sin(rot);
+    cx = p.x + b.cx * cr - b.cy * sr;
+    cy = p.y + b.cx * sr + b.cy * cr;
+    const ex = Math.abs(b.halfX * cr) + Math.abs(b.halfY * sr);
+    const ey = Math.abs(b.halfX * sr) + Math.abs(b.halfY * cr);
+    const fx2 = Math.max(0, Math.min(cx + ex, w) - Math.max(cx - ex, 0)) / (2 * ex);
+    const fy2 = Math.max(0, Math.min(cy + ey, h) - Math.max(cy - ey, 0)) / (2 * ey);
+    return fx2 * fy2;
+  }
+  if (s.kind === "polygon" && isPathPolygon(s)) {
+    const fr = pathFrame(s, sz / 2, w, h);
+    const rot = rotationAt(e, t) + paintRot;
+    const cr = Math.cos(rot), sr = Math.sin(rot);
+    const ox = -fr.ox * fr.sx * k, oy = -fr.oy * fr.sy * k;
+    cx += ox * cr - oy * sr;
+    cy += ox * sr + oy * cr;
+    const qx = fr.sx * k, qy = fr.sy * k;
+    hx = Math.abs(qx * cr) + Math.abs(qy * sr);
+    hy = Math.abs(qx * sr) + Math.abs(qy * cr);
+  }
+  if (!(hx > 0) || !(hy > 0)) return 1;
+  const fx = Math.max(0, Math.min(cx + hx, w) - Math.max(cx - hx, 0)) / (2 * hx);
+  const fy = Math.max(0, Math.min(cy + hy, h) - Math.max(cy - hy, 0)) / (2 * hy);
+  return fx * fy;
+}
 function rawDominance(spec, opts = {}) {
   spec = resolveTimelineAt(spec, opts.t ?? 5e3);
   const scene = buildScene(spec, opts);
@@ -7342,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;
@@ -7354,13 +8126,17 @@ function rawDominance(spec, opts = {}) {
         const h2 = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz;
         const f = s.feather ? (1 - s.feather / 2) * (1 - s.feather / 2) : 1;
         entArea = sz * h2 * f;
-      } else if (s.kind === "polygon") entArea = polygonArea(polygonPoints(s, sz / 2));
-      else if (s.kind === "bar") {
+      } else if (s.kind === "polygon") {
+        if (isPathPolygon(s)) {
+          const fr = pathFrame(s, sz / 2, w, h);
+          entArea = pathInkArea(s, fr.sx, fr.sy, sz / 2);
+        } else entArea = polygonArea(polygonPoints(s, sz / 2));
+      } else if (s.kind === "bar") {
         const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
         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;
@@ -7368,6 +8144,7 @@ function rawDominance(spec, opts = {}) {
         const box = textBlockBox(s, e, { x: 0, y: 0 }, w, h);
         entArea = box.halfX * 2 * box.halfY * 2 * 0.55 * textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1);
       } else entArea = sz * sz * 0.55;
+      entArea *= onScreenFraction(scene, s, e, sz, painted ? paintSize(spec, layer) : 1, t, painted ? paintRotation(spec, layer) : 0);
       area += painted ? entArea * areaScale * a : entArea * a;
       if (layer.trail) {
         const fade = layer.trail.fade ?? 1;
@@ -7386,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;
@@ -7412,6 +8192,7 @@ function motionStats(spec, opts = {}) {
   const unit = Math.min(w, h);
   return scene0.layers.map(({ layer, entities }, layerIndex) => {
     const entities1 = scene1.layers[layerIndex]?.entities ?? entities;
+    const spinVisible = layer.sprite.kind !== "circle" && layer.sprite.kind !== "ring";
     let acc = 0;
     let max = 0;
     let n = 0;
@@ -7425,7 +8206,8 @@ function motionStats(spec, opts = {}) {
       const dy = p1.y - p0.y;
       if (Math.abs(dx) > w / 2 || Math.abs(dy) > h / 2) return;
       const dist = Math.sqrt(dx * dx + dy * dy);
-      const speed = dist / dt * 1e3;
+      const turn = spinVisible ? Math.abs(rotationAt(entities1[i] ?? e, t + dt) - rotationAt(e, t)) * (sizeAt(e, t) / 3) * paintSize(spec, layer) : 0;
+      const speed = Math.sqrt(dist * dist + turn * turn) / dt * 1e3;
       acc += speed;
       max = Math.max(max, speed);
       n++;
@@ -7482,17 +8264,37 @@ function sceneColour(spec, opts = {}) {
   let wsum = 0;
   for (const { layer, entities } of scene.layers) {
     const lifeA = lifeAlphaAt(layer.life, t) * (layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer));
-    for (const e of entities) {
-      const hex = spriteHex(layer, e);
-      if (hex === null) continue;
-      const sz = sizeAt(e, t);
-      const weight = alphaAt(e, t) * lifeA * (layer.sprite.kind === "circle" ? Math.PI * (sz / 2) * (sz / 2) : sz * sz);
-      if (weight <= 0) continue;
+    const k = layer.transform !== void 0 || layer.group !== void 0 ? paintSize(spec, layer) : 1;
+    const add = (hex, weight) => {
+      if (weight <= 0) return;
       const c = hexRgb(hex);
       wr += c.r * weight;
       wg += c.g * weight;
       wb += c.b * weight;
       wsum += weight;
+    };
+    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 * 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);
+        const base = s.colors?.[e.colorIndex] ?? s.color;
+        for (const part of pathParts(s)) {
+          const ink = partInkArea(part, fr.sx, fr.sy, sz / 2);
+          if (part.gradient) {
+            const gw = gradientStopWeights(part.gradient.stops);
+            part.gradient.stops.forEach((st, i) => add(st.color, a * ink.fill * (st.opacity ?? 1) * gw[i]));
+          } else add(part.color ?? base, a * ink.fill);
+          if (part.stroke) add(part.stroke.color, a * ink.stroke);
+        }
+        continue;
+      }
+      const hex = spriteHex(layer, e);
+      if (hex === null) continue;
+      add(hex, a * (s.kind === "circle" ? Math.PI * (sz / 2) * (sz / 2) : sz * sz));
     }
   }
   const bg = backgroundRgb(spec);
@@ -7685,19 +8487,263 @@ 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|draw)(\.|$)|(^|\.)(sprite|parts?)$|^layers\.\d+$/;
+var MIN_BOUNDARIES = 7;
+var MAX_SAMPLES = 64;
+var MAX_TOTAL_SAMPLES = 512;
+var WINDOW = 1e3;
+var COLS = 16;
+var ROWS = 9;
+var AREA_THRESHOLD = 0.25;
+function lumaTracks(spec) {
+  const tl = spec.timeline;
+  if (!tl) return { tracks: [], lap: 0 };
+  const lap = tl.loop && tl.duration ? tl.duration : 0;
+  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 n;
+}
+function flashSampleTimes(boundaries) {
+  const ts = /* @__PURE__ */ new Set();
+  boundaries.forEach((t, i) => {
+    ts.add(t - 1);
+    ts.add(t + 1);
+    const next = boundaries[i + 1];
+    if (next !== void 0 && next - t > 4) ts.add((t + next) / 2);
+  });
+  return [...ts].sort((a, b) => a - b);
+}
+function timelineFlashReport(spec) {
+  const pass = { fails: false, flashesPerSecond: 0, flashingArea: 0, at: null };
+  if (!spec.timeline) return pass;
+  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++;
+    if (e - i < MIN_BOUNDARIES) continue;
+    const last = dense[dense.length - 1];
+    if (last && times[i] <= last.to) {
+      last.to = Math.max(last.to, times[e - 1]);
+      last.n = Math.max(last.n, e - i);
+    } else dense.push({ from: times[i], to: times[e - 1], n: e - i });
+  }
+  if (dense.length === 0) return pass;
+  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, 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);
+      if (r.general.worstTileFlashesPerSecond > worst.flashesPerSecond || !worst.fails && r.general.fails) {
+        worst = {
+          fails: r.general.fails,
+          flashesPerSecond: r.general.worstTileFlashesPerSecond,
+          flashingArea: r.general.flashingAreaFraction,
+          at: lap ? w.from % lap : w.from
+        };
+      }
+      if (worst.fails) return worst;
+      if (from + MAX_SAMPLES >= sampleTimes.length) break;
+      const resume = chunk[chunk.length - 1] - WINDOW;
+      let next = from + 1;
+      while (sampleTimes[next] < resume) next++;
+      from = next;
+    }
+  }
+  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;
 var READ_LEGIBILITY_FLOOR = 4.5;
 var READ_SAFE_AREA = 0.05;
 var ADDITIVE_INK_CEILING = 1;
-function edgeAnchored(range) {
-  if (!range) return false;
-  const [a, b] = range;
+var CALM_MAX_SPIN = 90;
+var NEAR_FLASH_MAX_BOUNDARIES = 10;
+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 = {}) {
   const hidden = hiddenLayers(spec);
+  const authored = spec;
   spec = resolveTimelineAt(spec, opts.t ?? COHESION_T);
   const warnings = [];
   const w = viewport.width;
@@ -7724,7 +8770,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     if (isStaticText) textLayerCount++;
     if (layer.motion.type !== "static") motionLayerCount++;
     const coh = cohesion[li];
-    if (seamsWorthWarning(layer, coh, entities.length)) {
+    if (seamsWorthWarning(layer, coh, entities.length, () => buriedAreaOf(layer, entities, opts.t ?? COHESION_T, w, h))) {
       const s = layer.sprite;
       const softEdged = (s.kind === "circle" || s.kind === "polygon") && s.soft || s.kind === "rect" && !!s.feather;
       warnings.push({
@@ -7772,13 +8818,17 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
         return { rgb, luma: 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b };
       });
       const seps = entities.map((e) => {
-        const hex = spriteHex(layer, e);
-        if (hex === null) return Infinity;
-        const ink = { rgb: hexRgb(hex), luma: hexLuma(hex) };
-        const sep = Math.max(...plates.map((bg) => colourSeparation(layer, ink, bg)));
-        if (sep >= LOW_CONTRAST_FLOOR || layer.blend === "lighter" || layer.blend === "screen") return sep;
-        const under = groundUnder(spec, allEntities, li, hidden, positionAt(e, 0, w, h), w, h);
-        return under ? colourSeparation(layer, ink, under) : sep;
+        const inks = spriteInks(layer, e);
+        if (inks === null || inks.length === 0) return Infinity;
+        return Math.max(...inks.map((hex) => {
+          const ink = { rgb: hexRgb(hex), luma: hexLuma(hex) };
+          const sep = Math.max(...plates.map((bg) => colourSeparation(layer, ink, bg)));
+          if (sep >= LOW_CONTRAST_FLOOR || layer.blend === "lighter" || layer.blend === "screen") return sep;
+          const at = positionAt(e, 0, w, h);
+          const under = groundUnder(spec, allEntities, li, hidden, at, w, h);
+          const framed = holeFrame(spec, allEntities, li, hidden, at, w, h);
+          return Math.max(under ? colourSeparation(layer, ink, under) : sep, framed ? colourSeparation(layer, ink, framed) : sep);
+        }));
       });
       const best = Math.max(...seps);
       if (best < LOW_CONTRAST_FLOOR) {
@@ -7807,14 +8857,17 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       if (layer.sprite.kind === "circle") {
         pixArea = Math.PI * r * r;
       } else if (layer.sprite.kind === "polygon") {
-        pixArea = polygonArea(polygonPoints(layer.sprite, r));
+        if (isPathPolygon(layer.sprite)) {
+          const fr = pathFrame(layer.sprite, r, w, h);
+          pixArea = pathInkArea(layer.sprite, fr.sx, fr.sy, r);
+        } else pixArea = polygonArea(polygonPoints(layer.sprite, r));
       } else if (layer.sprite.kind === "bar") {
         pixArea = e.size * barFraction(layer.sprite, e.barIndex ?? 0) * (e.size2 ?? e.size * 0.2);
       } else if (layer.sprite.kind === "textBlock") {
         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);
@@ -7889,6 +8942,44 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       });
     }
   }
+  if (spec.motionIntensity === "calm") {
+    for (let li = 0; li < spec.layers.length; li++) {
+      if (hidden?.[li]) continue;
+      const layer = spec.layers[li];
+      if (!layer.spin || layer.sprite.kind === "circle" || layer.sprite.kind === "ring") continue;
+      const entities = allEntities[li];
+      if (entities.length === 0) continue;
+      const rate = entities.reduce((s, e) => s + Math.abs(e.spinSpeed), 0) / entities.length * (180 / Math.PI);
+      if (rate <= CALM_MAX_SPIN) continue;
+      warnings.push({
+        path: `layers[${li}].spin`,
+        code: "motion-intensity-mismatch",
+        message: `declared motionIntensity: 'calm' but ${layer.key ? `\`${layer.key}\`` : `layers[${li}]`} spins at ~${Math.round(rate)}\xB0/s on average \u2014 that reads busy, not calm (calm spins sit at \u2264 ${CALM_MAX_SPIN}\xB0/s); slow the spin or declare 'moderate' / 'energetic'`
+      });
+    }
+  }
+  const flicker = nearLimitFlash(authored);
+  if (flicker) {
+    warnings.push({
+      path: "timeline",
+      code: "flash-near-limit",
+      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];
@@ -7956,12 +9047,16 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     const label = layer.key ? `\`${layer.key}\`` : `layers[${li}]`;
     for (const e of allEntities[li]) {
       const p = positionAt(e, 0, w, h);
-      const raw = s.kind === "textBlock" ? textBlockBoxAt(s, p, w, h) : textBoxAt(s, e, p, spec, w, h);
+      const unturned = s.kind === "textBlock" ? textBlockBoxAt(s, p, w, h) : textBoxAt(s, e, p, spec, w, h);
+      const rot = rotationAt(e, 0);
+      const turn = (q) => ({ x: p.x + (q.x - p.x) * Math.cos(rot) - (q.y - p.y) * Math.sin(rot), y: p.y + (q.x - p.x) * Math.sin(rot) + (q.y - p.y) * Math.cos(rot) });
       const map = paintMap(spec, layer, w, h, scale);
-      const box = map ? { ...raw, ...mapBox(map, raw) } : raw;
+      const both = rot && map ? (q) => map(turn(q)) : rot ? turn : map;
+      const box = both ? { ...unturned, ...mapBox(both, unturned) } : unturned;
+      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 });
     }
   }
@@ -8080,20 +9175,34 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     for (const box of boxes) {
       const cy = (box.y0 + box.y1) / 2;
       const cx = (box.x0 + box.x1) / 2;
-      const groundRgb = backgroundRgbAt(spec, cy, h, scale, cx, w, opts.backgroundSeed ?? opts.seed, opts.t ?? COHESION_T);
-      const ground = legibilityRatio(textPlate(groundRgb, box.alpha), groundRgb);
-      const lit = brightestAdditivePlate(spec, allEntities, groundRgb, box, w, h);
-      const plate = lit ? legibilityRatio(textPlate(lit.rgb, box.alpha), lit.rgb) : Infinity;
-      if (!worst || Math.min(ground, plate) < Math.min(worst.ground, worst.plate)) {
-        worst = { ground, plate, plateLabel: lit?.label ?? null };
+      const bgAt = (x, y) => backgroundRgbAt(spec, y, h, scale, x, w, opts.backgroundSeed ?? opts.seed, opts.t ?? COHESION_T);
+      const ix = (box.x1 - box.x0) * 0.02;
+      const iy = (box.y1 - box.y0) * 0.02;
+      const probes = [[cx, cy], [box.x0 + ix, box.y0 + iy], [box.x1 - ix, box.y0 + iy], [box.x0 + ix, box.y1 - iy], [box.x1 - ix, box.y1 - iy]];
+      const grounds = [];
+      let bare = false;
+      for (const [x, y] of probes) {
+        const under = groundUnder(spec, allEntities, box.li, hidden, { x, y }, w, h, bgAt(x, y));
+        if (under) grounds.push({ rgb: under.rgb, onSolid: true });
+        else bare = true;
+      }
+      if (bare) grounds.push({ rgb: bgAt(cx, cy), onSolid: false });
+      for (const g of grounds) {
+        const ground = legibilityRatio(textPlate(g.rgb, box.alpha), g.rgb);
+        const lit = brightestAdditivePlate(spec, allEntities, g.rgb, box, w, h);
+        const plate = lit ? legibilityRatio(textPlate(lit.rgb, box.alpha), lit.rgb) : Infinity;
+        if (!worst || Math.min(ground, plate) < Math.min(worst.ground, worst.plate)) {
+          worst = { ground, plate, plateLabel: lit?.label ?? null, onSolid: g.onSolid };
+        }
       }
     }
     if (worst && Math.min(worst.ground, worst.plate) < READ_LEGIBILITY_FLOOR) {
       const under = worst.plateLabel ? ` and ${worst.plate.toFixed(1)}:1 under ${worst.plateLabel} at its brightest` : "";
+      const against = worst.onSolid ? "against the solid layer painted under it" : "against the background at the box centre";
       warnings.push({
         path: `layers[${b.li}].sprite`,
         code: "text-legibility",
-        message: `${b.label} is declared role: 'read' but its colour reads at ${worst.ground.toFixed(1)}:1 against the background at the box centre${under} \u2014 below ${READ_LEGIBILITY_FLOOR}:1; brighten the text, darken the ground under it, or declare role: 'atmosphere' if it is texture`
+        message: `${b.label} is declared role: 'read' but its colour reads at ${worst.ground.toFixed(1)}:1 ${against}${under} \u2014 below ${READ_LEGIBILITY_FLOOR}:1; brighten the text, darken the ground under it, or declare role: 'atmosphere' if it is texture`
       });
     }
     const edges = [];
@@ -8116,6 +9225,21 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
   }
   return warnings;
 }
+function nearLimitFlash(spec) {
+  if (!spec.timeline) return null;
+  const { times, lap } = lumaKeyTimes(spec);
+  let best = null;
+  for (let i = 0, e = 0; i < times.length; i++) {
+    while (e < times.length && times[e] < times[i] + 1e3) e++;
+    if (e - i >= 4 && (!best || e - i > best.n)) best = { from: i, n: e - i };
+  }
+  if (!best) return null;
+  const window = times.slice(best.from, best.from + Math.min(best.n, NEAR_FLASH_MAX_BOUNDARIES));
+  const samples = flashSampleTimes(window).map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: 16, rows: 9 }).cells.flat().map((v) => srgbToLinear3(v * 255)) }));
+  const r = analyzeFlashes2(samples, { maxFlashesPerSecond: 1 }).general;
+  if (!r.fails) return null;
+  return { flashesPerSecond: r.worstTileFlashesPerSecond, area: r.flashingAreaFraction, at: lap ? window[0] % lap : window[0] };
+}
 function brightestAdditivePlate(spec, allEntities, ground, box, w, h) {
   let best = null;
   for (let lj = 0; lj < spec.layers.length; lj++) {
@@ -8143,19 +9267,49 @@ function brightestAdditivePlate(spec, allEntities, ground, box, w, h) {
   }
   return best ? { rgb: best.rgb, label: best.label } : null;
 }
-function groundUnder(spec, allEntities, li, hidden, pt, w, h) {
-  let plate = backgroundRgb(spec);
+function holeFrame(spec, allEntities, li, hidden, pt, w, h) {
+  for (let lj = li + 1; lj < spec.layers.length; lj++) {
+    if (hidden?.[lj]) continue;
+    const layer = spec.layers[lj];
+    const sp = layer.sprite;
+    if (sp.kind !== "polygon" || !isPathPolygon(sp) || sp.soft) continue;
+    if (layer.motion.type !== "static" || layer.blend !== void 0 || layer.transform !== void 0 || groupOf(spec, layer)?.transform !== void 0) continue;
+    if (flattenSprite(sp).subpaths < 2) continue;
+    const a = layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer);
+    for (const e of allEntities[lj]) {
+      if (e.spinSpeed !== 0 || e.rotate || e.alpha * a < 0.9) continue;
+      const c = positionAt(e, 0, w, h);
+      const fr = pathFrame(sp, e.size / 2, w, h);
+      const pts = flattenSprite(sp).points.map(([u, v]) => ({ x: (u - fr.ox) * fr.sx, y: (v - fr.oy) * fr.sy }));
+      if (pts.length < 3) continue;
+      const dx = pt.x - c.x;
+      const dy = pt.y - c.y;
+      if (dx < Math.min(...pts.map((q) => q.x)) || dx > Math.max(...pts.map((q) => q.x))) continue;
+      if (dy < Math.min(...pts.map((q) => q.y)) || dy > Math.max(...pts.map((q) => q.y))) continue;
+      if (pointInPolygon(dx, dy, pts)) continue;
+      const ink = spriteInks(layer, e)?.[0];
+      if (ink === void 0) continue;
+      const rgb = hexRgb(ink);
+      return { rgb, luma: 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b };
+    }
+  }
+  return null;
+}
+function groundUnder(spec, allEntities, li, hidden, pt, w, h, base = backgroundRgb(spec)) {
+  let plate = base;
   let covered = false;
   for (let lj = 0; lj < li; lj++) {
     if (hidden?.[lj]) continue;
     const layer = spec.layers[lj];
     const sp = layer.sprite;
     if (layer.motion.type !== "static" || layer.blend !== void 0 || layer.transform !== void 0 || groupOf(spec, layer)?.transform !== void 0) continue;
+    if (layer.life !== void 0 || layer.emit !== void 0) continue;
     if ((sp.kind === "circle" || sp.kind === "polygon") && sp.soft) continue;
     if (sp.kind !== "circle" && sp.kind !== "rect" && sp.kind !== "polygon") continue;
+    if (sp.kind === "polygon" && isPathPolygon(sp)) continue;
     const a = layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer);
     for (const e of allEntities[lj]) {
-      if (e.spinSpeed !== 0 || e.alpha * a <= 0) continue;
+      if (e.spinSpeed !== 0 || e.pulseAmp > 0 || e.growAmp > 0 || e.alpha * a <= 0) continue;
       const hex = spriteHex(layer, e);
       if (hex === null) continue;
       const c = positionAt(e, 0, w, h);
@@ -8208,7 +9362,7 @@ function isOutlineStack(a, b) {
   if (fs <= 0 || Math.abs(a.fs - b.fs) > 0.1 * Math.max(a.fs, b.fs)) return false;
   const dx = (a.x0 + a.x1) / 2 - (b.x0 + b.x1) / 2;
   const dy = (a.y0 + a.y1) / 2 - (b.y0 + b.y1) / 2;
-  return Math.hypot(dx, dy) <= OUTLINE_STACK_OFFSET * fs;
+  return Math.max(Math.abs(dx), Math.abs(dy)) <= OUTLINE_STACK_OFFSET * fs;
 }
 function textBoxAt(s, e, p, spec, w, h) {
   const m = s.font ? /(\d{1,5}(?:\.\d{1,4})?|\.\d{1,4})px/.exec(s.font) : null;
@@ -8228,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";
@@ -8269,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++) {
@@ -8283,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",
@@ -10780,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 },
@@ -10809,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 }
@@ -10845,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,
@@ -10861,6 +12088,7 @@ export {
   SIGNAL_BOARD_SPEC,
   SNOWFALL_SPEC,
   SPARSE_NIGHT_SPEC,
+  STEER_EASES,
   THERMAL_FIELD_SPEC,
   THREE_MOVEMENTS_SEQUENCE,
   TYPED_CUE_SPEC,
@@ -10871,6 +12099,7 @@ export {
   adviseSequence,
   adviseSpec,
   alphaAt,
+  applyDeltasShared,
   applyDeltasToSpec,
   assertValidSequence,
   assertValidSpec,
@@ -10879,6 +12108,7 @@ export {
   bedRenderSeed,
   breakTextBlock,
   buildEntities,
+  buriedAreaOf,
   canMorph,
   canWrapMorph,
   canonicalSpecPath,
@@ -10890,6 +12120,8 @@ export {
   describeScene,
   diffScenes,
   dominanceRanking,
+  drawSpan,
+  easeGlide,
   easeSmooth,
   emitEnvelope,
   emitWindow,
@@ -10908,13 +12140,17 @@ export {
   headingAt,
   hexToRgb255,
   ignoredPropertyPaths,
+  isCombiningKana,
+  isFullWidth,
   isPathPolygon,
   latticeHash,
+  layerCellFootprints,
   layerCohesion,
   lerpPathD,
   lerpSpec,
   lerpValue,
   lifeAlphaAt,
+  lifeStaggerAt,
   linkEdges,
   linkMaxDistPx,
   linkPairs,
@@ -10929,6 +12165,7 @@ export {
   pathParts,
   perceiveScene,
   perceiveSequenceFrame,
+  periodWithoutTimeline,
   pickScreenOp,
   positionAt,
   presentWithFinish,
@@ -10942,6 +12179,7 @@ export {
   rgb255Luma,
   rotationAt,
   sceneColour,
+  scenePeriod,
   seamCauseOf,
   seamsWorthWarning,
   segmentRenderSeed,
@@ -10953,20 +12191,27 @@ export {
   spriteIndexAt,
   spriteVariants,
   steerablePaths,
+  strokeDrawnSamples,
+  strokeLines,
   structuralSignature,
   textBlockAnchorOffset,
+  textBlockText,
   textMetricsClassFor,
   textSprites,
   textStringsDiffer,
   textStringsOf,
   textWidthEm,
+  timelineFlashReport,
   timelineLocalTime,
   timelineSampleTimes,
   timelineSampleTimesAfter,
   timelineTracks,
+  trimLines,
+  trimPolyline,
   validateSequence,
   validateSpec,
   validateSpecPaths,
+  wipeMask,
   withoutTimeline
 };
 //# sourceMappingURL=index.js.map