@idle-screens/schema 3.12.1 → 3.14.0

package/dist/index.js

@@ -255,6 +255,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;
@@ -290,6 +319,10 @@ function lerpValue(from, to, k, specRoot = false, rootKey) {
     if (typeof a === "string" && typeof b === "string" && HEX.test(a) && HEX.test(b)) {
       return lerpHex(a, b, kk);
     }
+    if (key === "path" && typeof a === "string" && typeof b === "string" && a !== b) {
+      const m = lerpPathD(a, b, kk);
+      if (m !== null) return m;
+    }
     if (Array.isArray(a) && Array.isArray(b) && a.length === b.length) {
       return b.map((bv, i) => walk(a[i], bv, i));
     }
@@ -306,6 +339,33 @@ function lerpValue(from, to, k, specRoot = false, rootKey) {
   };
   return walk(from, to, rootKey, specRoot);
 }
+var PATH_TOKEN = /[a-zA-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g;
+function lerpPathD(a, b, k) {
+  const ta = a.match(PATH_TOKEN) ?? [];
+  const tb = b.match(PATH_TOKEN) ?? [];
+  if (ta.length !== tb.length) return null;
+  const out = [];
+  let cmd = "";
+  let argIndex = 0;
+  for (let i = 0; i < ta.length; i++) {
+    const x = ta[i], y = tb[i];
+    const isCmdA = /^[a-zA-Z]$/.test(x), isCmdB = /^[a-zA-Z]$/.test(y);
+    if (isCmdA !== isCmdB) return null;
+    if (isCmdA) {
+      if (x !== y) return null;
+      cmd = x.toUpperCase();
+      argIndex = 0;
+      out.push(x);
+      continue;
+    }
+    const va = Number(x), vb = Number(y);
+    const flag = cmd === "A" && (argIndex % 7 === 3 || argIndex % 7 === 4);
+    argIndex++;
+    const v = va + (vb - va) * k;
+    out.push(flag ? String(Math.round(v)) : String(+v.toFixed(5)));
+  }
+  return out.join(" ");
+}
 function textStringsOf(sprite) {
   if (sprite.kind === "text") return sprite.strings;
   if (sprite.kind === "textBlock") return [sprite.text];
@@ -362,7 +422,7 @@ function steerablePaths(spec) {
   if (!spec || typeof spec !== "object") return [];
   const SKIP = /* @__PURE__ */ new Set(["kind", "type", "key", "schemaVersion", "id", "label", "seed", "units", "motionIntensity", "mode", "curve", "layer", "group", "origin"]);
   const SKIP_ROOT = /* @__PURE__ */ new Set(["timeline"]);
-  const INDEXED = /* @__PURE__ */ new Set(["layers", "stops", "bands"]);
+  const INDEXED = /* @__PURE__ */ new Set(["layers", "stops", "bands", "parts"]);
   const layers = spec.layers;
   const shadowedRootKeys = new Set(
     Array.isArray(layers) ? layers.map((l) => l && typeof l === "object" ? l.key : void 0).filter((k) => typeof k === "string" && STEERABLE_ROOT_KEYS.has(k)) : []
@@ -610,7 +670,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);
@@ -622,7 +682,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;
@@ -674,6 +734,689 @@ function timelineSampleTimesAfter(spec, now, dense = false, only) {
   return local.filter((s) => s > now);
 }
 
+// src/shapes.ts
+function isShapedSprite(s) {
+  return s.kind === "circle" || s.kind === "ring" || s.kind === "streak" || s.kind === "rect" || s.kind === "polygon" || s.kind === "stroke" || s.kind === "bar";
+}
+function barFraction(s, index) {
+  const n = s.values.length;
+  if (n === 0) return 0;
+  const v = s.values[(index % n + n) % n] ?? 0;
+  const max = s.max ?? s.values.reduce((m, x) => Math.max(m, x), 0);
+  if (!(max > 0)) return 0;
+  return Math.max(0, Math.min(1, v / max));
+}
+function barBox(direction, len, thick) {
+  switch (direction) {
+    case "left":
+      return { cx: -len / 2, cy: 0, halfX: len / 2, halfY: thick / 2 };
+    case "up":
+      return { cx: 0, cy: -len / 2, halfX: thick / 2, halfY: len / 2 };
+    case "down":
+      return { cx: 0, cy: len / 2, halfX: thick / 2, halfY: len / 2 };
+    default:
+      return { cx: len / 2, cy: 0, halfX: len / 2, halfY: thick / 2 };
+  }
+}
+var DEFAULT_POLYGON_SIDES = 6;
+var STROKE_SAMPLES = 24;
+function polygonPoints(s, radius) {
+  if (isPathPolygon(s)) {
+    const unit = flattenSprite(s);
+    if (unit.points.length >= 3) return unit.points.map(([x, y]) => ({ x: x * radius, y: y * radius }));
+  }
+  if (s.points && s.points.length >= 3) {
+    return s.points.map(([x, y]) => ({ x: x * radius, y: y * radius }));
+  }
+  const n = Math.max(3, Math.round(s.sides ?? DEFAULT_POLYGON_SIDES));
+  const out = [];
+  for (let k = 0; k < n; k++) {
+    const a = -Math.PI / 2 + 2 * Math.PI * k / n;
+    out.push({ x: Math.cos(a) * radius, y: Math.sin(a) * radius });
+  }
+  return out;
+}
+function polygonArea(pts) {
+  let a = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const p = pts[i];
+    const q = pts[(i + 1) % pts.length];
+    a += p.x * q.y - q.x * p.y;
+  }
+  return Math.abs(a) / 2;
+}
+function polygonFill(s, radius) {
+  if (radius <= 0) return 0;
+  const disc = Math.PI * radius * radius;
+  return Math.min(1, polygonArea(polygonPoints(s, radius)) / disc);
+}
+function catmullRom(p0, p1, p2, p3, u) {
+  const u2 = u * u;
+  const u3 = u2 * u;
+  return 0.5 * (2 * p1 + (-p0 + p2) * u + (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 + (-p0 + 3 * p1 - 3 * p2 + p3) * u3);
+}
+function strokeSamples(s, halfSize, n) {
+  const pts = s.points.map(([x, y]) => ({ x: x * halfSize, y: y * halfSize }));
+  const m = pts.length;
+  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);
+  const at = (k) => pts[Math.max(0, Math.min(m - 1, k))];
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const u = i / (n - 1) * segs;
+    const seg = Math.min(segs - 1, Math.floor(u));
+    const local = u - seg;
+    const p1 = at(seg);
+    const p2 = at(seg + 1);
+    if (!smooth) {
+      out.push({ x: p1.x + (p2.x - p1.x) * local, y: p1.y + (p2.y - p1.y) * local });
+    } else {
+      const p0 = at(seg - 1);
+      const p3 = at(seg + 2);
+      out.push({ x: catmullRom(p0.x, p1.x, p2.x, p3.x, local), y: catmullRom(p0.y, p1.y, p2.y, p3.y, local) });
+    }
+  }
+  return out;
+}
+function pathLength(pts) {
+  let l = 0;
+  for (let i = 1; i < pts.length; i++) {
+    const dx = pts[i].x - pts[i - 1].x;
+    const dy = pts[i].y - pts[i - 1].y;
+    l += Math.sqrt(dx * dx + dy * dy);
+  }
+  return l;
+}
+function strokeTaper(u) {
+  return Math.max(0.15, Math.sin(Math.PI * Math.max(0, Math.min(1, u))));
+}
+function strokeWidthPx(s, scale) {
+  return Math.max(0.5, (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale);
+}
+function featherRamp(u, feather) {
+  const band = Math.max(0, Math.min(1, feather)) / 2;
+  const d = Math.min(u, 1 - u);
+  if (band <= 0) return d >= 0 ? 1 : 0;
+  return Math.max(0, Math.min(1, d / band));
+}
+var FEATHER_MASK_SIZE = 128;
+function ribbonSides(pts, half) {
+  const n = pts.length;
+  const left = [];
+  const right = [];
+  if (n < 2) return { left, right };
+  const dir = (a, b) => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const l = Math.hypot(dx, dy);
+    return l > 1e-9 ? { x: dx / l, y: dy / l } : { x: 1, y: 0 };
+  };
+  for (let i = 0; i < n; i++) {
+    const tIn = i > 0 ? dir(pts[i - 1], pts[i]) : dir(pts[0], pts[1]);
+    const tOut = i < n - 1 ? dir(pts[i], pts[i + 1]) : tIn;
+    let tx = tIn.x + tOut.x;
+    let ty = tIn.y + tOut.y;
+    const tl = Math.hypot(tx, ty);
+    if (tl < 1e-9) {
+      tx = tOut.x;
+      ty = tOut.y;
+    } else {
+      tx /= tl;
+      ty /= tl;
+    }
+    const hw = half[i] / Math.max(0.5, tx * tOut.x + ty * tOut.y);
+    const p = pts[i];
+    left.push({ x: p.x - ty * hw, y: p.y + tx * hw });
+    right.push({ x: p.x + ty * hw, y: p.y - tx * hw });
+  }
+  return { left, right };
+}
+function strokeOutline(pts, lw, taper = true) {
+  const n = pts.length;
+  if (n < 2) return [];
+  const half = (i) => Math.max(0.5, taper ? lw * strokeTaper(i / (n - 1)) : lw) / 2;
+  const dir = (a, b) => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const l = Math.hypot(dx, dy);
+    return l > 1e-9 ? { x: dx / l, y: dy / l } : { x: 1, y: 0 };
+  };
+  const { left, right } = ribbonSides(pts, Array.from({ length: n }, (_, i) => half(i)));
+  const cap = (c, r, from) => {
+    const out = [];
+    const steps = 6;
+    for (let k = 1; k < steps; k++) {
+      const a = from - Math.PI * k / steps;
+      out.push({ x: c.x + Math.cos(a) * r, y: c.y + Math.sin(a) * r });
+    }
+    return out;
+  };
+  const endT = dir(pts[n - 2], pts[n - 1]);
+  const startT = dir(pts[0], pts[1]);
+  const endA = Math.atan2(endT.y, endT.x) + Math.PI / 2;
+  const startA = Math.atan2(startT.y, startT.x) - Math.PI / 2;
+  return [
+    ...left,
+    ...cap(pts[n - 1], half(n - 1), endA),
+    ...right.reverse(),
+    ...cap(pts[0], half(0), startA)
+  ];
+}
+var MAX_PATH_POINTS = 4096;
+var MAX_SCENE_PATH_POINTS = 16384;
+var PATH_TOLERANCE = 5e-4;
+var pathCache = { auto: /* @__PURE__ */ new Map(), nonzero: /* @__PURE__ */ new Map(), evenodd: /* @__PURE__ */ new Map() };
+function flattenPath(d, rule = "auto") {
+  const cache = pathCache[rule] ?? pathCache.auto;
+  const hit = cache.get(d);
+  if (hit) return hit;
+  let out;
+  try {
+    const parsed = parseAndFlatten(d);
+    const rings = parsed.rings.map(simplifyRing).filter((r) => r.length >= 3);
+    const lines = parsed.lines.map((l) => ({ points: l.closed ? simplifyRing(l.points) : simplifyLine(l.points), closed: l.closed }));
+    out = { points: rule === "auto" ? joinRings(rings) : bridge(rings), subpaths: rings.length, lines };
+  } catch (e) {
+    out = { points: [], subpaths: 0, lines: [], error: e instanceof Error ? e.message : String(e) };
+  }
+  if (cache.size > 256) cache.clear();
+  cache.set(d, out);
+  return out;
+}
+var spriteFlat = /* @__PURE__ */ new WeakMap();
+function flattenSprite(s) {
+  const d = s.parts ? s.parts.filter((p) => p.fill !== false).map((p) => p.path).join(" ") : s.path ?? "";
+  const rule = s.parts ? "auto" : s.fillRule ?? "auto";
+  const hit = spriteFlat.get(s);
+  if (hit && hit.d === d && hit.rule === rule) return hit.flat;
+  const flat = flattenPath(d, rule);
+  spriteFlat.set(s, { d, rule, flat });
+  return flat;
+}
+function polygonFillRule(s) {
+  return typeof s.path === "string" && s.fillRule === "evenodd" ? "evenodd" : "nonzero";
+}
+function isPathPolygon(s) {
+  return s.kind === "polygon" && (typeof s.path === "string" || Array.isArray(s.parts));
+}
+var spriteParts = /* @__PURE__ */ new WeakMap();
+function pathParts(s) {
+  const key = s.parts ?? s.path;
+  const hit = spriteParts.get(s);
+  if (hit && hit.key === key) return hit.parts;
+  const src = s.parts ?? (typeof s.path === "string" ? [{ path: s.path, fillRule: s.fillRule, fill: s.fill, gradient: s.gradient, stroke: s.stroke }] : []);
+  const parts = src.map((p) => {
+    const flat = flattenPath(p.path, p.fillRule ?? "auto");
+    return {
+      flat,
+      color: s.parts ? p.color ?? null : null,
+      fill: p.fill !== false,
+      rule: p.fillRule === "evenodd" ? "evenodd" : "nonzero",
+      gradient: p.gradient,
+      stroke: p.stroke,
+      opacity: p.opacity ?? 1,
+      box: boxOfFlat(flat)
+    };
+  });
+  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 part.flat.lines) {
+      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;
+  const sy = span === "height" || span === "screen" ? h / 2 : r;
+  const [ox, oy] = s.origin ?? [0, 0];
+  return { sx, sy, ox, oy, uniform: sx === sy };
+}
+var flatBoxes = /* @__PURE__ */ new WeakMap();
+function boxOfFlat(flat) {
+  const hit = flatBoxes.get(flat);
+  if (hit) return hit;
+  let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+  for (const [x, y] of flat.points.length ? flat.points : flat.lines.flatMap((l) => l.points)) {
+    x0 = Math.min(x0, x);
+    x1 = Math.max(x1, x);
+    y0 = Math.min(y0, y);
+    y1 = Math.max(y1, y);
+  }
+  if (!Number.isFinite(x0)) {
+    x0 = -1;
+    x1 = 1;
+    y0 = -1;
+    y1 = 1;
+  }
+  const box = { cx: (x0 + x1) / 2, cy: (y0 + y1) / 2, hw: Math.max((x1 - x0) / 2, 1e-6), hh: Math.max((y1 - y0) / 2, 1e-6) };
+  flatBoxes.set(flat, box);
+  return box;
+}
+var pathIds = /* @__PURE__ */ new Map();
+var pathSeq = 0;
+var paintSigs = /* @__PURE__ */ new WeakMap();
+function pathPaintSig(s) {
+  const hit = paintSigs.get(s);
+  if (hit !== void 0) return hit;
+  const sig = JSON.stringify(s, (k, v) => {
+    if (k !== "path" || typeof v !== "string") return v;
+    let id = pathIds.get(v);
+    if (id === void 0) {
+      if (pathIds.size > 4096) pathIds.clear();
+      id = ++pathSeq;
+      pathIds.set(v, id);
+    }
+    return `#${id}`;
+  });
+  paintSigs.set(s, sig);
+  return sig;
+}
+function gradientSpace(part, u, v) {
+  if (part.gradient?.units !== "part") return [u, v];
+  return [(u - part.box.cx) / part.box.hw, (v - part.box.cy) / part.box.hh];
+}
+function segmentsFor(chord, curvature) {
+  const n = Math.ceil(Math.sqrt(Math.max(curvature, chord * 0.05) / (4 * PATH_TOLERANCE)));
+  return Math.max(2, Math.min(64, n));
+}
+function parseAndFlatten(d) {
+  const tokens = d.match(/[a-zA-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g) ?? [];
+  let i = 0;
+  const num = () => {
+    const t = tokens[i++];
+    if (t === void 0 || /^[a-zA-Z]$/.test(t)) throw new Error("expected a number");
+    return Number(t);
+  };
+  const flag = () => {
+    const t = tokens[i];
+    if (t !== void 0 && /^[01]{2,}/.test(t)) {
+      tokens[i] = t.slice(1);
+      return Number(t[0]);
+    }
+    return num();
+  };
+  const rings = [];
+  let ring = [];
+  let cx = 0, cy = 0, sx = 0, sy = 0;
+  let lastCtrl = null;
+  let lastCmd = "";
+  const push = (x, y) => {
+    ring.push([x, y]);
+    cx = x;
+    cy = y;
+  };
+  const lines = [];
+  const close = (closed = false) => {
+    if (ring.length >= 2) lines.push({ points: ring.slice(), closed });
+    if (ring.length >= 3) rings.push(ring);
+    ring = [];
+  };
+  const cubic = (x1, y1, x2, y2, x, y) => {
+    const dev = Math.hypot(x1 - cx, y1 - cy) + Math.hypot(x2 - x1, y2 - y1) + Math.hypot(x - x2, y - y2) - Math.hypot(x - cx, y - cy);
+    const n = segmentsFor(Math.hypot(x - cx, y - cy), dev * 4);
+    const x0 = cx, y0 = cy;
+    for (let k = 1; k <= n; k++) {
+      const t = k / n, u = 1 - t;
+      push(
+        u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x,
+        u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y
+      );
+    }
+    lastCtrl = [x2, y2];
+  };
+  const quad = (x1, y1, x, y) => {
+    const dev = Math.hypot(x1 - cx, y1 - cy) + Math.hypot(x - x1, y - y1) - Math.hypot(x - cx, y - cy);
+    const n = segmentsFor(Math.hypot(x - cx, y - cy), dev * 4);
+    const x0 = cx, y0 = cy;
+    for (let k = 1; k <= n; k++) {
+      const t = k / n, u = 1 - t;
+      push(u * u * x0 + 2 * u * t * x1 + t * t * x, u * u * y0 + 2 * u * t * y1 + t * t * y);
+    }
+    lastCtrl = [x1, y1];
+  };
+  const arc = (rx, ry, phiDeg, large, sweep, x, y) => {
+    const x0 = cx, y0 = cy;
+    if (rx === 0 || ry === 0 || x0 === x && y0 === y) {
+      push(x, y);
+      return;
+    }
+    rx = Math.abs(rx);
+    ry = Math.abs(ry);
+    const phi = phiDeg * Math.PI / 180, cp = Math.cos(phi), sp = Math.sin(phi);
+    const dx = (x0 - x) / 2, dy = (y0 - y) / 2;
+    const x1p = cp * dx + sp * dy, y1p = -sp * dx + cp * dy;
+    const lam = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+    if (lam > 1) {
+      rx *= Math.sqrt(lam);
+      ry *= Math.sqrt(lam);
+    }
+    const num2 = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+    const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+    let co = Math.sqrt(Math.max(0, num2 / den));
+    if (large === sweep) co = -co;
+    const cxp = co * rx * y1p / ry, cyp = -co * ry * x1p / rx;
+    const ccx = cp * cxp - sp * cyp + (x0 + x) / 2, ccy = sp * cxp + cp * cyp + (y0 + y) / 2;
+    const ang = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    const t1 = ang(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+    let dt = ang((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+    if (!sweep && dt > 0) dt -= 2 * Math.PI;
+    if (sweep && dt < 0) dt += 2 * Math.PI;
+    const r = Math.max(rx, ry);
+    const n = Math.max(2, Math.min(96, Math.ceil(Math.abs(dt) / (2 * Math.acos(Math.max(0, 1 - PATH_TOLERANCE / r))))));
+    for (let k = 1; k <= n; k++) {
+      const t = t1 + dt * k / n;
+      const ex = rx * Math.cos(t), ey = ry * Math.sin(t);
+      push(cp * ex - sp * ey + ccx, sp * ex + cp * ey + ccy);
+    }
+  };
+  while (i < tokens.length) {
+    let cmd = tokens[i];
+    if (/^[a-zA-Z]$/.test(cmd)) i++;
+    else if (lastCmd) cmd = lastCmd === "M" ? "L" : lastCmd === "m" ? "l" : lastCmd;
+    else throw new Error("path must start with M");
+    const rel = cmd === cmd.toLowerCase() && cmd !== "z" ? true : false;
+    const ox = rel ? cx : 0, oy = rel ? cy : 0;
+    const C = cmd.toUpperCase();
+    const prevCmd = lastCmd.toUpperCase();
+    if (C !== "S" && C !== "T") lastCtrl = null;
+    switch (C) {
+      case "M": {
+        close();
+        const x = num() + ox, y = num() + oy;
+        push(x, y);
+        sx = x;
+        sy = y;
+        break;
+      }
+      case "L":
+        push(num() + ox, num() + oy);
+        break;
+      case "H":
+        push(num() + ox, cy);
+        break;
+      case "V":
+        push(cx, num() + oy);
+        break;
+      case "C": {
+        const a = num() + ox, b = num() + oy, c = num() + ox, e = num() + oy;
+        cubic(a, b, c, e, num() + ox, num() + oy);
+        break;
+      }
+      case "S": {
+        const r = lastCtrl && (prevCmd === "C" || prevCmd === "S") ? [2 * cx - lastCtrl[0], 2 * cy - lastCtrl[1]] : [cx, cy];
+        const c = num() + ox, e = num() + oy;
+        cubic(r[0], r[1], c, e, num() + ox, num() + oy);
+        break;
+      }
+      case "Q": {
+        const a = num() + ox, b = num() + oy;
+        quad(a, b, num() + ox, num() + oy);
+        break;
+      }
+      case "T": {
+        const r = lastCtrl && (prevCmd === "Q" || prevCmd === "T") ? [2 * cx - lastCtrl[0], 2 * cy - lastCtrl[1]] : [cx, cy];
+        quad(r[0], r[1], num() + ox, num() + oy);
+        break;
+      }
+      case "A": {
+        const rx = num(), ry = num(), ph = num(), la = flag(), sw = flag();
+        arc(rx, ry, ph, la, sw, num() + ox, num() + oy);
+        break;
+      }
+      case "Z":
+        cx = sx;
+        cy = sy;
+        close(true);
+        break;
+      default:
+        throw new Error(`unsupported path command '${cmd}'`);
+    }
+    lastCmd = cmd;
+  }
+  close();
+  for (const r of rings) {
+    const a = r[0], b = r[r.length - 1];
+    if (Math.hypot(a[0] - b[0], a[1] - b[1]) < 1e-9) r.pop();
+  }
+  for (const l of lines) {
+    const a = l.points[0], b = l.points[l.points.length - 1];
+    if (l.closed && l.points.length > 2 && Math.hypot(a[0] - b[0], a[1] - b[1]) < 1e-9) l.points.pop();
+  }
+  return { rings, lines };
+}
+function simplifyLine(r) {
+  if (r.length <= 2) return r;
+  const keep = new Uint8Array(r.length);
+  keep[0] = 1;
+  keep[r.length - 1] = 1;
+  const stack = [[0, r.length - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    const A = r[a], B = r[b];
+    const dx = B[0] - A[0], dy = B[1] - A[1], len = Math.hypot(dx, dy);
+    let best = -1, bd = 0;
+    for (let k = a + 1; k < b; k++) {
+      const P = r[k];
+      const d = len > 1e-12 ? Math.abs(dx * (A[1] - P[1]) - dy * (A[0] - P[0])) / len : Math.hypot(P[0] - A[0], P[1] - A[1]);
+      if (d > bd) {
+        bd = d;
+        best = k;
+      }
+    }
+    if (best >= 0 && bd > PATH_TOLERANCE) {
+      keep[best] = 1;
+      stack.push([a, best], [best, b]);
+    }
+  }
+  return r.filter((_, k) => keep[k] === 1);
+}
+function simplifyRing(r) {
+  if (r.length <= 4) return r;
+  let far = 0, fd = -1;
+  for (let k = 1; k < r.length; k++) {
+    const d = (r[k][0] - r[0][0]) ** 2 + (r[k][1] - r[0][1]) ** 2;
+    if (d > fd) {
+      fd = d;
+      far = k;
+    }
+  }
+  const keep = new Uint8Array(r.length);
+  keep[0] = 1;
+  keep[far] = 1;
+  const at = (k) => r[k % r.length];
+  const stack = [[0, far], [far, r.length]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    const A = at(a), B = at(b);
+    const dx = B[0] - A[0], dy = B[1] - A[1], len = Math.hypot(dx, dy);
+    let best = -1, bd = 0;
+    for (let k = a + 1; k < b; k++) {
+      const P = at(k);
+      const d = len > 1e-12 ? Math.abs(dx * (A[1] - P[1]) - dy * (A[0] - P[0])) / len : Math.hypot(P[0] - A[0], P[1] - A[1]);
+      if (d > bd) {
+        bd = d;
+        best = k;
+      }
+    }
+    if (best >= 0 && bd > PATH_TOLERANCE) {
+      keep[best % r.length] = 1;
+      stack.push([a, best], [best, b]);
+    }
+  }
+  return r.filter((_, k) => keep[k] === 1);
+}
+function signedArea(r) {
+  let a = 0;
+  for (let k = 0; k < r.length; k++) {
+    const p = r[k], q = r[(k + 1) % r.length];
+    a += p[0] * q[1] - q[0] * p[1];
+  }
+  return a / 2;
+}
+function inside(pt, r) {
+  let c = false;
+  for (let k = 0, j = r.length - 1; k < r.length; j = k++) {
+    const a = r[k], b = r[j];
+    if (a[1] > pt[1] !== b[1] > pt[1] && pt[0] < (b[0] - a[0]) * (pt[1] - a[1]) / (b[1] - a[1]) + a[0]) c = !c;
+  }
+  return c;
+}
+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;
+}
+function boxOf(r) {
+  const b = { x0: Infinity, x1: -Infinity, y0: Infinity, y1: -Infinity };
+  for (const [x, y] of r) {
+    b.x0 = Math.min(b.x0, x);
+    b.x1 = Math.max(b.x1, x);
+    b.y0 = Math.min(b.y0, y);
+    b.y1 = Math.max(b.y1, y);
+  }
+  return b;
+}
+function joinRings(rings) {
+  if (rings.length === 0) return [];
+  const boxes = rings.map(boxOf);
+  const areas = rings.map((r) => Math.abs(signedArea(r)));
+  const order = rings.map((_, i) => i).sort((p, q) => areas[q] - areas[p]);
+  const mult = new Array(rings.length).fill(0);
+  const net = new Array(rings.length).fill(0);
+  const done = [];
+  for (const n of order) {
+    const containers = done.filter((m) => areas[m] > areas[n] && containsRing(rings[m], boxes[m], rings[n], boxes[n]));
+    const around = containers.reduce((sum, m) => sum + mult[m], 0);
+    let want = 1;
+    if (containers.length) {
+      const parent = containers.reduce((p, m) => areas[m] < areas[p] ? m : p);
+      want = net[parent] !== 0 ? 0 : 1;
+    }
+    net[n] = want;
+    mult[n] = want - around;
+    done.push(n);
+  }
+  const traced = [];
+  const trace = (r, m) => {
+    const o = Math.sign(signedArea(r)) === Math.sign(m) ? r : r.slice().reverse();
+    for (let k = 0; k < Math.abs(m); k++) traced.push(o);
+  };
+  for (let n = 0; n < rings.length; n++) {
+    if (mult[n] !== 0) trace(rings[n], mult[n]);
+  }
+  const holes = rings.map((_, n) => n).filter((n) => net[n] === 0 && mult[n] !== 0 && isConvex(rings[n]));
+  for (let m = 0; m < rings.length; m++) {
+    if (mult[m] <= 0) continue;
+    const bm = boxes[m];
+    const crossing = holes.filter((n) => {
+      const bn = boxes[n];
+      if (n === m || bm.x1 <= bn.x0 || bm.x0 >= bn.x1 || bm.y1 <= bn.y0 || bm.y0 >= bn.y1) return false;
+      return !containsRing(rings[m], bm, rings[n], bn) && !containsRing(rings[n], bn, rings[m], bm);
+    });
+    for (const n of crossing) {
+      if (crossing.some((o) => o !== n && areas[o] > areas[n] && containsRing(rings[o], boxes[o], rings[n], boxes[n]))) continue;
+      const piece = clipToConvex(rings[m], rings[n]);
+      if (piece.length >= 3 && Math.abs(signedArea(piece)) > 1e-9) trace(piece, -mult[m]);
+    }
+  }
+  return bridge(traced);
+}
+function isConvex(r) {
+  let sign = 0;
+  for (let k = 0; k < r.length; k++) {
+    const a = r[k], b = r[(k + 1) % r.length], c = r[(k + 2) % r.length];
+    const z = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
+    if (Math.abs(z) < 1e-12) continue;
+    if (sign === 0) sign = Math.sign(z);
+    else if (Math.sign(z) !== sign) return false;
+  }
+  return true;
+}
+function clipToConvex(subject, clip) {
+  const o = Math.sign(signedArea(clip)) || 1;
+  let out = subject;
+  for (let k = 0; k < clip.length && out.length; k++) {
+    const a = clip[k], b = clip[(k + 1) % clip.length];
+    const side = (p) => o * ((b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]));
+    const cut = (p, q) => {
+      const sp = side(p), sq = side(q), t = sp / (sp - sq);
+      return [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t];
+    };
+    const next = [];
+    for (let i = 0; i < out.length; i++) {
+      const p = out[i], q = out[(i + 1) % out.length];
+      const pin = side(p) >= 0, qin = side(q) >= 0;
+      if (pin) next.push(p);
+      if (pin !== qin) next.push(cut(p, q));
+    }
+    out = next;
+  }
+  return out;
+}
+function bridge(rings) {
+  if (rings.length === 0) return [];
+  let ring = rings[0].slice();
+  for (let n = 1; n < rings.length; n++) {
+    const sub = rings[n];
+    let bi = 0, bj = 0, best = Infinity;
+    for (let a = 0; a < ring.length; a++) {
+      for (let b = 0; b < sub.length; b++) {
+        const dd = (ring[a][0] - sub[b][0]) ** 2 + (ring[a][1] - sub[b][1]) ** 2;
+        if (dd < best) {
+          best = dd;
+          bi = a;
+          bj = b;
+        }
+      }
+    }
+    const rot = sub.slice(bj).concat(sub.slice(0, bj));
+    ring = ring.slice(0, bi + 1).concat(rot, [rot[0], ring[bi]], ring.slice(bi + 1));
+  }
+  return ring;
+}
+function pathDrawCost(s) {
+  let c = 0;
+  for (const p of pathParts(s)) {
+    if (p.fill) c += p.flat.points.length * (p.gradient ? 2 : 1);
+    if (p.stroke) for (const l of p.flat.lines) c += l.points.length * 3;
+  }
+  return c;
+}
+
 // src/validate.ts
 var HEX2 = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
 var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -719,7 +1462,8 @@ var KNOWN_RING = /* @__PURE__ */ new Set(["kind", "radius", "color", "width", "c
 var KNOWN_STREAK = /* @__PURE__ */ new Set(["kind", "length", "color", "width", "colors", "colorWeights"]);
 var KNOWN_RECT = /* @__PURE__ */ new Set(["kind", "width", "aspect", "color", "feather", "colors", "colorWeights"]);
 var KNOWN_BAR = /* @__PURE__ */ new Set(["kind", "values", "length", "thickness", "color", "max", "direction", "colors", "colorWeights"]);
-var KNOWN_POLYGON = /* @__PURE__ */ new Set(["kind", "radius", "color", "sides", "points", "soft", "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_EMOJI = /* @__PURE__ */ new Set(["kind", "glyphs", "cycle"]);
 var KNOWN_TEXT = /* @__PURE__ */ new Set(["kind", "strings", "color", "font", "align", "baseline", "maxWidth", "cycle", "role"]);
@@ -776,7 +1520,7 @@ 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) {
   const layers = /* @__PURE__ */ new Set();
@@ -814,7 +1558,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 });
@@ -859,6 +1603,23 @@ function validateSpecCore(spec) {
     err("layers", "must be a non-empty array");
   } else {
     if (spec.layers.length > LIMITS.maxLayers) err("layers", `at most ${LIMITS.maxLayers} layers`);
+    {
+      let pathPoints = 0;
+      for (const l of spec.layers) {
+        const sp = isObj(l) ? l.sprite : void 0;
+        if (!sp || sp.kind !== "polygon") continue;
+        const pieces = Array.isArray(sp.parts) ? sp.parts : typeof sp.path === "string" ? [sp] : [];
+        const n = typeof l.count === "number" && l.count > 0 ? l.count : 1;
+        for (const pc of pieces) {
+          if (!isObj(pc) || typeof pc.path !== "string") continue;
+          const fl = flattenPath(pc.path, pc.fillRule ?? "auto");
+          pathPoints += ((pc.fill === false ? 0 : fl.points.length) + (isObj(pc.stroke) ? fl.lines.reduce((m, x) => m + x.points.length, 0) : 0)) * n;
+        }
+      }
+      if (pathPoints > MAX_SCENE_PATH_POINTS) {
+        err("layers", `path outlines total ${pathPoints} points (flattened points \xD7 count); the scene budget is ${MAX_SCENE_PATH_POINTS}`);
+      }
+    }
     let total = 0;
     spec.layers.forEach((layer, i) => {
       total += isObj(layer) && isNum(layer.count) ? layer.count : 0;
@@ -866,7 +1627,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) {
@@ -904,7 +1665,7 @@ 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) {
   let failed = false;
   const err = (p, m) => {
     failed = true;
@@ -958,20 +1719,22 @@ 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 (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);
@@ -997,16 +1760,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;
   }
@@ -1232,10 +1995,20 @@ function validateLayer(layer, path, err, warn, spec) {
   if (layer.links !== void 0) {
     if (!isObj(layer.links)) err(`${path}.links`, "must be an object");
     else {
-      if (!isNum(layer.links.k) || !Number.isInteger(layer.links.k) || layer.links.k < 1 || layer.links.k > LIMITS.maxLinksK) {
-        err(`${path}.links.k`, `must be an integer 1..${LIMITS.maxLinksK}`);
+      const chain = layer.links.mode === "chain";
+      if (!chain || layer.links.k !== void 0) {
+        if (!isNum(layer.links.k) || !Number.isInteger(layer.links.k) || layer.links.k < 1 || layer.links.k > LIMITS.maxLinksK) {
+          err(`${path}.links.k`, `must be an integer 1..${LIMITS.maxLinksK}`);
+        }
+      }
+      if (!chain || layer.links.maxDist !== void 0 || layer.links.falloff === true) {
+        positiveScalar(
+          layer.links.maxDist,
+          `${path}.links.maxDist`,
+          err,
+          chain && layer.links.maxDist === void 0 ? "is required (> 0) when a chain sets falloff: true \u2014 it is the fade distance" : void 0
+        );
       }
-      positiveScalar(layer.links.maxDist, `${path}.links.maxDist`, err);
       if (layer.links.color !== void 0) color(layer.links.color, `${path}.links.color`, err);
       if (layer.links.alpha !== void 0 && (!isNum(layer.links.alpha) || layer.links.alpha < 0 || layer.links.alpha > 1)) {
         err(`${path}.links.alpha`, "must be 0..1");
@@ -1476,6 +2249,34 @@ function validateSprite(sprite, path, err, warn, spec) {
       err(`${path}.sides`, `must be an integer ${LIMITS.minPolygonSides}..${LIMITS.maxPolygonSides}`);
     }
     if (sprite.points !== void 0) validateShapePoints(sprite.points, `${path}.points`, 3, err);
+    if (sprite.parts !== void 0) {
+      for (const k of ["path", "points", "sides", "gradient", "stroke", "fill", "fillRule"]) {
+        if (sprite[k] !== void 0) err(`${path}.${k}`, `with parts, put ${k} on each part (or drop parts)`);
+      }
+      if (!Array.isArray(sprite.parts) || sprite.parts.length === 0 || sprite.parts.length > MAX_PATH_PARTS) {
+        err(`${path}.parts`, `must be 1..${MAX_PATH_PARTS} parts, each { path, color?, gradient?, stroke?, fill?, fillRule?, opacity? }`);
+      } else {
+        sprite.parts.forEach((part, i) => {
+          const pp = `${path}.parts[${i}]`;
+          if (!isObj(part)) return err(pp, "must be { path, color?, gradient?, stroke?, fill?, fillRule?, opacity? }");
+          validatePathPiece(part, pp, err, warn);
+          if (part.color !== void 0) color(part.color, `${pp}.color`, err);
+          if (part.opacity !== void 0 && (!isNum(part.opacity) || part.opacity < 0 || part.opacity > 1)) err(`${pp}.opacity`, "must be 0..1");
+          for (const k of unknownKeys(part, KNOWN_PATH_PART)) warn(`${pp}.${k}`, "unknown-property", `unknown part property '${k}' \u2014 will be ignored`);
+        });
+      }
+    } else if (sprite.path !== void 0) {
+      if (sprite.points !== void 0 || sprite.sides !== void 0) err(`${path}.path`, "use path, points or sides, not more than one");
+      validatePathPiece(sprite, path, err, warn);
+    } else {
+      for (const k of ["gradient", "stroke", "fill"]) if (sprite[k] !== void 0) err(`${path}.${k}`, `${k} applies only to a polygon with a path (or parts)`);
+      if (sprite.fillRule !== void 0) warn(`${path}.fillRule`, "unknown-property", "fillRule applies only to a path \u2014 ignored");
+    }
+    if (sprite.span !== void 0 || sprite.origin !== void 0) {
+      if (sprite.path === void 0 && sprite.parts === void 0) err(`${path}.span`, "span and origin apply only to a polygon with a path (or parts)");
+      if (sprite.span !== void 0 && !["box", "width", "height", "screen"].includes(sprite.span)) err(`${path}.span`, "must be 'box' | 'width' | 'height' | 'screen'");
+      if (sprite.origin !== void 0 && !(Array.isArray(sprite.origin) && sprite.origin.length === 2 && sprite.origin.every((v) => isNum(v) && Math.abs(v) <= 1))) err(`${path}.origin`, "must be [x, y] in the unit box (-1..1): the point placed at the position");
+    }
     if (sprite.soft !== void 0 && typeof sprite.soft !== "boolean") err(`${path}.soft`, "must be a boolean");
     color(sprite.color, `${path}.color`, err);
     validatePalette(sprite, path, err);
@@ -1732,6 +2533,70 @@ function validateMotion(motion, path, err, warn, spec) {
     warn(`${path}.${k}`, "unknown-property", `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;
+function pathGeometryProblem(d, rule, filled) {
+  const key = `${rule}|${filled ? 1 : 0}|${d}`;
+  const hit = pathVerdicts.get(key);
+  if (hit !== void 0) return hit;
+  const flat = flattenPath(d, rule);
+  const inBox = ([x, y]) => Math.abs(x) <= 1.0001 && Math.abs(y) <= 1.0001;
+  const problem = flat.error ? `not a usable path: ${flat.error}` : filled && flat.points.length < 3 ? "must enclose an area (at least 3 points), or set fill: false and a stroke for line art" : !filled && flat.lines.length === 0 ? "must draw at least one line (2+ points)" : flat.points.length > MAX_PATH_POINTS ? `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}` : !flat.points.every(inBox) || !flat.lines.every((l) => l.points.every(inBox)) ? "must stay inside the -1..1 unit box (curves included)" : null;
+  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 problem = pathGeometryProblem(piece.path, piece.fillRule ?? "auto", piece.fill !== false);
+    if (problem) 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.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 }");
+  if (g.type === "linear") {
+    if (!isPair(g.from)) err(`${path}.from`, "must be [x, y] in unit-box coordinates (-2..2)");
+    if (!isPair(g.to)) err(`${path}.to`, "must be [x, y] in unit-box coordinates (-2..2)");
+  } else if (g.type === "radial") {
+    if (!isPair(g.center)) err(`${path}.center`, "must be [x, y] in unit-box coordinates (-2..2)");
+    if (!isNum(g.radius) || g.radius <= 0 || g.radius > 4) err(`${path}.radius`, "must be > 0 and <= 4 (unit-box units)");
+    if (g.focus !== void 0 && !isPair(g.focus)) err(`${path}.focus`, "must be [x, y] in unit-box coordinates (-2..2)");
+  } else {
+    return err(`${path}.type`, "must be 'linear' | 'radial'");
+  }
+  if (g.units !== void 0 && g.units !== "box" && g.units !== "part") err(`${path}.units`, "must be 'box' (the drawing's unit box, default) | 'part' (the part's own box, -1..1)");
+  if (!Array.isArray(g.stops) || g.stops.length < 2 || g.stops.length > 8) return err(`${path}.stops`, "must be 2..8 stops");
+  let last = -Infinity;
+  g.stops.forEach((st, i) => {
+    if (!isObj(st)) return err(`${path}.stops[${i}]`, "must be { at, color, opacity? }");
+    if (!isNum(st.at) || st.at < 0 || st.at > 1 || st.at < last) err(`${path}.stops[${i}].at`, "must be 0..1, not decreasing");
+    else last = st.at;
+    color(st.color, `${path}.stops[${i}].color`, 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? }");
+  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'");
+}
 function validateShapePoints(points, path, min, err) {
   if (!Array.isArray(points) || points.length < min || points.length > LIMITS.maxShapePoints) {
     return err(path, `must be ${min}..${LIMITS.maxShapePoints} [x, y] pairs in unit coordinates (-1..1)`);
@@ -1900,199 +2765,32 @@ function validateSequence(seq) {
           code: "morph-nothing-morphable",
           message: `segments ${i}\u2192${i + 1} differ only in values morph cannot interpolate (strings such as textBlock.text step on the first frame): the morph will look like a cut \u2014 fade text via colour or reveal.progress`
         });
-      }
-    }
-  }
-  if (errors.length === 0 && seq.wrapMorph === true) {
-    const sq = seq;
-    const last = sq.segments.length - 1;
-    const lastTr = sq.segments[last]?.transition;
-    let why = null;
-    if (sq.loop !== true) why = "the sequence does not loop";
-    else if (last < 1) why = "there is only one segment";
-    else if (lastTr?.type !== "morph") why = "the last segment declares no morph transition";
-    else if (structuralSignature(sq.segments[last].scene) !== structuralSignature(sq.segments[0].scene)) why = `segment ${last} and segment 0 differ structurally`;
-    else if (morphChainRoot(sq, last) !== 0) why = `the lap is not one morph chain (segment ${morphChainRoot(sq, last)} starts a new chain), so the wrap would jump seeds`;
-    if (why || !canWrapMorph(sq)) {
-      warnings.push({ path: "wrapMorph", code: "wrap-morph-inactive", message: `wrapMorph has no effect: ${why ?? "the wrap cannot morph"} \u2014 the wrap stays a cut` });
-    }
-  }
-  return { valid: errors.length === 0, errors, warnings };
-}
-function assertValidSequence(seq) {
-  const r = validateSequence(seq);
-  if (!r.valid) {
-    throw new Error(`invalid sequence:
-${r.errors.map((e) => `  ${e.path || "<root>"}: ${e.message}`).join("\n")}`);
-  }
-  return seq;
-}
-
-// src/shapes.ts
-function isShapedSprite(s) {
-  return s.kind === "circle" || s.kind === "ring" || s.kind === "streak" || s.kind === "rect" || s.kind === "polygon" || s.kind === "stroke" || s.kind === "bar";
-}
-function barFraction(s, index) {
-  const n = s.values.length;
-  if (n === 0) return 0;
-  const v = s.values[(index % n + n) % n] ?? 0;
-  const max = s.max ?? s.values.reduce((m, x) => Math.max(m, x), 0);
-  if (!(max > 0)) return 0;
-  return Math.max(0, Math.min(1, v / max));
-}
-function barBox(direction, len, thick) {
-  switch (direction) {
-    case "left":
-      return { cx: -len / 2, cy: 0, halfX: len / 2, halfY: thick / 2 };
-    case "up":
-      return { cx: 0, cy: -len / 2, halfX: thick / 2, halfY: len / 2 };
-    case "down":
-      return { cx: 0, cy: len / 2, halfX: thick / 2, halfY: len / 2 };
-    default:
-      return { cx: len / 2, cy: 0, halfX: len / 2, halfY: thick / 2 };
-  }
-}
-var DEFAULT_POLYGON_SIDES = 6;
-var STROKE_SAMPLES = 24;
-function polygonPoints(s, radius) {
-  if (s.points && s.points.length >= 3) {
-    return s.points.map(([x, y]) => ({ x: x * radius, y: y * radius }));
-  }
-  const n = Math.max(3, Math.round(s.sides ?? DEFAULT_POLYGON_SIDES));
-  const out = [];
-  for (let k = 0; k < n; k++) {
-    const a = -Math.PI / 2 + 2 * Math.PI * k / n;
-    out.push({ x: Math.cos(a) * radius, y: Math.sin(a) * radius });
-  }
-  return out;
-}
-function polygonArea(pts) {
-  let a = 0;
-  for (let i = 0; i < pts.length; i++) {
-    const p = pts[i];
-    const q = pts[(i + 1) % pts.length];
-    a += p.x * q.y - q.x * p.y;
-  }
-  return Math.abs(a) / 2;
-}
-function polygonFill(s, radius) {
-  if (radius <= 0) return 0;
-  const disc = Math.PI * radius * radius;
-  return Math.min(1, polygonArea(polygonPoints(s, radius)) / disc);
-}
-function catmullRom(p0, p1, p2, p3, u) {
-  const u2 = u * u;
-  const u3 = u2 * u;
-  return 0.5 * (2 * p1 + (-p0 + p2) * u + (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 + (-p0 + 3 * p1 - 3 * p2 + p3) * u3);
-}
-function strokeSamples(s, halfSize, n) {
-  const pts = s.points.map(([x, y]) => ({ x: x * halfSize, y: y * halfSize }));
-  const m = pts.length;
-  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);
-  const at = (k) => pts[Math.max(0, Math.min(m - 1, k))];
-  const out = [];
-  for (let i = 0; i < n; i++) {
-    const u = i / (n - 1) * segs;
-    const seg = Math.min(segs - 1, Math.floor(u));
-    const local = u - seg;
-    const p1 = at(seg);
-    const p2 = at(seg + 1);
-    if (!smooth) {
-      out.push({ x: p1.x + (p2.x - p1.x) * local, y: p1.y + (p2.y - p1.y) * local });
-    } else {
-      const p0 = at(seg - 1);
-      const p3 = at(seg + 2);
-      out.push({ x: catmullRom(p0.x, p1.x, p2.x, p3.x, local), y: catmullRom(p0.y, p1.y, p2.y, p3.y, local) });
-    }
-  }
-  return out;
-}
-function pathLength(pts) {
-  let l = 0;
-  for (let i = 1; i < pts.length; i++) {
-    const dx = pts[i].x - pts[i - 1].x;
-    const dy = pts[i].y - pts[i - 1].y;
-    l += Math.sqrt(dx * dx + dy * dy);
-  }
-  return l;
-}
-function strokeTaper(u) {
-  return Math.max(0.15, Math.sin(Math.PI * Math.max(0, Math.min(1, u))));
-}
-function strokeWidthPx(s, scale) {
-  return Math.max(0.5, (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale);
-}
-function featherRamp(u, feather) {
-  const band = Math.max(0, Math.min(1, feather)) / 2;
-  const d = Math.min(u, 1 - u);
-  if (band <= 0) return d >= 0 ? 1 : 0;
-  return Math.max(0, Math.min(1, d / band));
-}
-var FEATHER_MASK_SIZE = 128;
-function ribbonSides(pts, half) {
-  const n = pts.length;
-  const left = [];
-  const right = [];
-  if (n < 2) return { left, right };
-  const dir = (a, b) => {
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const l = Math.hypot(dx, dy);
-    return l > 1e-9 ? { x: dx / l, y: dy / l } : { x: 1, y: 0 };
-  };
-  for (let i = 0; i < n; i++) {
-    const tIn = i > 0 ? dir(pts[i - 1], pts[i]) : dir(pts[0], pts[1]);
-    const tOut = i < n - 1 ? dir(pts[i], pts[i + 1]) : tIn;
-    let tx = tIn.x + tOut.x;
-    let ty = tIn.y + tOut.y;
-    const tl = Math.hypot(tx, ty);
-    if (tl < 1e-9) {
-      tx = tOut.x;
-      ty = tOut.y;
-    } else {
-      tx /= tl;
-      ty /= tl;
-    }
-    const hw = half[i] / Math.max(0.5, tx * tOut.x + ty * tOut.y);
-    const p = pts[i];
-    left.push({ x: p.x - ty * hw, y: p.y + tx * hw });
-    right.push({ x: p.x + ty * hw, y: p.y - tx * hw });
-  }
-  return { left, right };
-}
-function strokeOutline(pts, lw, taper = true) {
-  const n = pts.length;
-  if (n < 2) return [];
-  const half = (i) => Math.max(0.5, taper ? lw * strokeTaper(i / (n - 1)) : lw) / 2;
-  const dir = (a, b) => {
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const l = Math.hypot(dx, dy);
-    return l > 1e-9 ? { x: dx / l, y: dy / l } : { x: 1, y: 0 };
-  };
-  const { left, right } = ribbonSides(pts, Array.from({ length: n }, (_, i) => half(i)));
-  const cap = (c, r, from) => {
-    const out = [];
-    const steps = 6;
-    for (let k = 1; k < steps; k++) {
-      const a = from - Math.PI * k / steps;
-      out.push({ x: c.x + Math.cos(a) * r, y: c.y + Math.sin(a) * r });
+      }
     }
-    return out;
-  };
-  const endT = dir(pts[n - 2], pts[n - 1]);
-  const startT = dir(pts[0], pts[1]);
-  const endA = Math.atan2(endT.y, endT.x) + Math.PI / 2;
-  const startA = Math.atan2(startT.y, startT.x) - Math.PI / 2;
-  return [
-    ...left,
-    ...cap(pts[n - 1], half(n - 1), endA),
-    ...right.reverse(),
-    ...cap(pts[0], half(0), startA)
-  ];
+  }
+  if (errors.length === 0 && seq.wrapMorph === true) {
+    const sq = seq;
+    const last = sq.segments.length - 1;
+    const lastTr = sq.segments[last]?.transition;
+    let why = null;
+    if (sq.loop !== true) why = "the sequence does not loop";
+    else if (last < 1) why = "there is only one segment";
+    else if (lastTr?.type !== "morph") why = "the last segment declares no morph transition";
+    else if (structuralSignature(sq.segments[last].scene) !== structuralSignature(sq.segments[0].scene)) why = `segment ${last} and segment 0 differ structurally`;
+    else if (morphChainRoot(sq, last) !== 0) why = `the lap is not one morph chain (segment ${morphChainRoot(sq, last)} starts a new chain), so the wrap would jump seeds`;
+    if (why || !canWrapMorph(sq)) {
+      warnings.push({ path: "wrapMorph", code: "wrap-morph-inactive", message: `wrapMorph has no effect: ${why ?? "the wrap cannot morph"} \u2014 the wrap stays a cut` });
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function assertValidSequence(seq) {
+  const r = validateSequence(seq);
+  if (!r.valid) {
+    throw new Error(`invalid sequence:
+${r.errors.map((e) => `  ${e.path || "<root>"}: ${e.message}`).join("\n")}`);
+  }
+  return seq;
 }
 
 // src/simulate.ts
@@ -2616,9 +3314,13 @@ function wrapDist(pi, pj, doWrap, w, h) {
   }
   return Math.sqrt(dx * dx + dy * dy);
 }
+function linkMaxDistPx(links, scale) {
+  return links.maxDist === void 0 ? Infinity : links.maxDist * scale;
+}
 function linkEdges(links, positions, maxDistPx, doWrap, w, h) {
   const n = positions.length;
   const mode = links.mode ?? "nearest";
+  const k = links.k ?? 1;
   if (mode === "chain") {
     const out = [];
     for (let i = 0; i < n - 1; i++) {
@@ -2632,7 +3334,7 @@ function linkEdges(links, positions, maxDistPx, doWrap, w, h) {
     const edges = /* @__PURE__ */ new Set();
     const out = [];
     for (let i = 0; i < n; i++) {
-      for (let mIdx = 1; mIdx <= links.k; mIdx++) {
+      for (let mIdx = 1; mIdx <= k; mIdx++) {
         const j = (i + mIdx * stride) % n;
         if (j === i) continue;
         const dist = wrapDist(positions[i], positions[j], doWrap, w, h);
@@ -2646,7 +3348,7 @@ function linkEdges(links, positions, maxDistPx, doWrap, w, h) {
     }
     return out;
   }
-  return linkPairs(positions, links.k, maxDistPx, doWrap, w, h).map(([i, j]) => ({
+  return linkPairs(positions, k, maxDistPx, doWrap, w, h).map(([i, j]) => ({
     i,
     j,
     dist: wrapDist(positions[i], positions[j], doWrap, w, h)
@@ -2886,6 +3588,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);
 }
@@ -3325,6 +4031,45 @@ function overridesStayValid(authored, overrides, now) {
   }
   return true;
 }
+var PATH_BLIT_MIN_POINTS = 128;
+var PLATE_MIN_POINTS = 2500;
+var PATH_BLIT_PER_SPRITE = 8;
+var PATH_SLOT_MAX = 96;
+var PATH_SPRITE_PER_SPRITE = 96;
+var PATH_SPRITE_MAX_PIXELS = 512 * 512;
+var PATH_BLIT_MIN_DENSITY = 1500;
+var PATH_BLIT_MAX_PIXELS = 16e6;
+function ringPath2D(lines) {
+  const p2 = new Path2D();
+  for (const l of lines) {
+    if (l.points.length < 2) continue;
+    p2.moveTo(l.points[0][0], l.points[0][1]);
+    for (let i = 1; i < l.points.length; i++) p2.lineTo(l.points[i][0], l.points[i][1]);
+    if (l.closed) p2.closePath();
+  }
+  return p2;
+}
+function traceLines(g, lines) {
+  g.beginPath();
+  for (const l of lines) {
+    if (l.points.length < 2) continue;
+    g.moveTo(l.points[0][0], l.points[0][1]);
+    for (let i = 1; i < l.points.length; i++) g.lineTo(l.points[i][0], l.points[i][1]);
+    if (l.closed) g.closePath();
+  }
+}
+function pathGradientFill(g, gr) {
+  const grad = gr.type === "linear" ? g.createLinearGradient(gr.from[0], gr.from[1], gr.to[0], gr.to[1]) : g.createRadialGradient((gr.focus ?? gr.center)[0], (gr.focus ?? gr.center)[1], 0, gr.center[0], gr.center[1], gr.radius);
+  for (const st of gr.stops) grad.addColorStop(st.at, st.opacity === void 0 ? st.color : hexToRgba(st.color, st.opacity));
+  return grad;
+}
+function softFill(g, color2, r) {
+  const grad = g.createRadialGradient(0, 0, 0, 0, 0, r);
+  grad.addColorStop(0, color2);
+  grad.addColorStop(0.35, hexToRgba(color2, 0.75));
+  grad.addColorStop(1, hexToRgba(color2, 0));
+  return grad;
+}
 var SpecInstance = class {
   constructor(spec, ctx, opts = {}) {
     this.spec = spec;
@@ -3435,6 +4180,20 @@ var SpecInstance = class {
   paintSeq = 0;
   /** Per layer: ribbon area painted this frame (px²), and whether its trails ribbon (see ribbonAllowed). */
   ribbonBudget = /* @__PURE__ */ new WeakMap();
+  /**
+   * Render-once cache for path polygons (polygon.path). A detailed drawing is
+   * rasterised once per (colour, device size, rotation, sub-pixel offset)
+   * into its own bitmap and copied 1:1 at a whole-pixel offset every frame
+   * after — so a static 7,000-point drawing costs a blit, not a re-fill.
+   * Keyed by the sprite object, so a steer or republish (a new spec object)
+   * starts clean. A drawing whose key keeps changing (spinning, trailing,
+   * growing) stops being cached and draws from a reused Path2D instead.
+   */
+  pathBlits = /* @__PURE__ */ new Map();
+  /** Test/bench switch: `globalThis.__idleNoPathCache = true` before compiling draws every path directly. */
+  noPathCache = globalThis.__idleNoPathCache === true;
+  /** Device pixels held by every pathBlits bitmap — capped so a TV never pays more than PATH_BLIT_MAX_PIXELS of memory. */
+  pathBlitPixels = 0;
   featherTints = /* @__PURE__ */ new Map();
   /**
    * The presentation pass when this instance applies a `finish`: the
@@ -3713,6 +4472,277 @@ var SpecInstance = class {
     return rb.ribbon;
   }
   /** A fresh 2D canvas (DOM or Offscreen), or null where none can be made. */
+  /**
+   * A drawing's cache slot, keyed by what it draws (pathPaintSig), not by the
+   * sprite object — glides and timelines replace that object every frame.
+   * Least-recently-used slots are evicted past PATH_SLOT_MAX, and their
+   * bitmaps' pixels returned to the budget.
+   */
+  pathSlot(sprite) {
+    const sig = pathPaintSig(sprite);
+    let slot = this.pathBlits.get(sig);
+    if (slot) {
+      this.pathBlits.delete(sig);
+      this.pathBlits.set(sig, slot);
+      return slot;
+    }
+    if (this.pathBlits.size >= PATH_SLOT_MAX) {
+      const [oldSig, old] = this.pathBlits.entries().next().value;
+      for (const ent of old.entries.values()) this.pathBlitPixels -= ent.px;
+      this.pathBlits.delete(oldSig);
+    }
+    slot = { entries: /* @__PURE__ */ new Map(), flushes: 0, off: false };
+    this.pathBlits.set(sig, slot);
+    return slot;
+  }
+  /**
+   * Whether a layer's path drawing looks the same as last frame — the caches
+   * serve only steady drawings; one that is gliding (colour, gradient, shape)
+   * draws directly until it settles, instead of rasterising a bitmap a frame.
+   */
+  // Keyed by the layer's place in the scene, never the per-layer record: a
+  // scene that animates a baked field (alpha, size) rebuilds every record
+  // every frame, and a drawing beside it is still steady.
+  pathSteady = /* @__PURE__ */ new Map();
+  drawingSteady(built, sprite) {
+    const sig = pathPaintSig(sprite);
+    const li = this.layers.indexOf(built);
+    const prev = this.pathSteady.get(li);
+    if (prev && prev.seq === this.paintSeq && prev.sig === sig) return prev.steady;
+    const steady = prev !== void 0 && prev.sig === sig;
+    this.pathSteady.set(li, { sig, seq: this.paintSeq, steady });
+    return steady;
+  }
+  /**
+   * Draw a path polygon in its own unit box: the caller has moved to the
+   * entity and rotated; this scales by r. Parts paint back to front (a single
+   * `path` is one part). Each fill is its gradient (drawing-box coordinates,
+   * or with units 'part' the part's own box, filled under that box's
+   * transform so a radial reads as the part's ellipse), the soft radial
+   * falloff, or flat colour; each stroke traces the part's subpaths as drawn,
+   * width in unit-box units. Outlines are Path2Ds built once per sprite.
+   */
+  drawPathUnit(g, sprite, color2, fr, r) {
+    const slot = this.pathSlot(sprite);
+    const parts = pathParts(sprite);
+    if (!slot.parts2d) slot.parts2d = parts.map(() => ({}));
+    if (fr.ox || fr.oy) g.translate(-fr.ox * fr.sx, -fr.oy * fr.sy);
+    g.scale(fr.sx, fr.sy);
+    const a0 = g.globalAlpha;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const cache = slot.parts2d[i];
+      const pc = part.color ?? color2;
+      if (part.fill && part.flat.points.length >= 3) {
+        g.globalAlpha = a0 * part.opacity;
+        if (part.gradient?.units === "part") {
+          const { cx, cy, hw, hh } = part.box;
+          if (cache.fillPart === void 0) {
+            cache.fillPart = typeof Path2D === "undefined" ? null : ringPath2D([{ points: part.flat.points.map(([x, y]) => [(x - cx) / hw, (y - cy) / hh]), closed: true }]);
+          }
+          g.save();
+          g.transform(hw, 0, 0, hh, cx, cy);
+          g.fillStyle = pathGradientFill(g, part.gradient);
+          if (cache.fillPart) g.fill(cache.fillPart, part.rule);
+          else {
+            traceLines(g, [{ points: part.flat.points.map(([x, y]) => [(x - cx) / hw, (y - cy) / hh]), closed: true }]);
+            g.fill(part.rule);
+          }
+          g.restore();
+        } else {
+          g.fillStyle = part.gradient ? pathGradientFill(g, part.gradient) : sprite.soft && !sprite.parts ? softFill(g, pc, 1) : pc;
+          if (cache.fill === void 0) cache.fill = typeof Path2D === "undefined" ? null : ringPath2D([{ points: part.flat.points, closed: true }]);
+          if (cache.fill) g.fill(cache.fill, part.rule);
+          else {
+            traceLines(g, [{ points: part.flat.points, closed: true }]);
+            g.fill(part.rule);
+          }
+        }
+      }
+      const st = part.stroke;
+      if (st && part.flat.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);
+            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]) }));
+          g.save();
+          g.scale(1 / fr.sx, 1 / fr.sy);
+          g.lineWidth = st.width * r;
+          traceLines(g, scaled);
+          g.stroke();
+          g.restore();
+        }
+      }
+    }
+    g.globalAlpha = a0;
+  }
+  /**
+   * Draw a path polygon from its render-once bitmap. False when it cannot be
+   * blitted exactly — a rotated or skewed layer transform, a bitmap past the
+   * memory cap, a drawing too sparse for its area, or one that keeps
+   * changing — and the caller draws it directly.
+   */
+  blitPath(sprite, p, r, rot, color2, fr) {
+    const ctx = this.ctx;
+    const slot = this.pathSlot(sprite);
+    if (slot.off) return false;
+    if (slot.sprite) return this.spriteBlit(sprite, slot, p, r, rot, color2, fr);
+    const m = ctx.getTransform();
+    if (Math.abs(m.b) > 1e-9 || Math.abs(m.c) > 1e-9 || Math.abs(m.a - m.d) > 1e-9 || !(m.a > 0)) {
+      slot.sprite = true;
+      return this.spriteBlit(sprite, slot, p, r, rot, color2, fr);
+    }
+    const k = m.a;
+    const dx = k * p.x + m.e;
+    const dy = k * p.y + m.f;
+    const ix = Math.floor(dx);
+    const iy = Math.floor(dy);
+    const fx = Math.round((dx - ix) * 8) / 8;
+    const fy = Math.round((dy - iy) * 8) / 8;
+    const key = `${color2}|${(r * k).toFixed(3)}|${(fr.sx * k).toFixed(3)}|${(fr.sy * k).toFixed(3)}|${fr.ox},${fr.oy}|${rot.toFixed(5)}|${fx}|${fy}`;
+    let hit = slot.entries.get(key);
+    if (!hit) {
+      if (slot.entries.size >= PATH_BLIT_PER_SPRITE) {
+        for (const old of slot.entries.values()) this.pathBlitPixels -= old.px;
+        slot.entries.clear();
+        if (++slot.flushes > 1) {
+          slot.sprite = true;
+          slot.flushes = 0;
+          return this.spriteBlit(sprite, slot, p, r, rot, color2, fr);
+        }
+      }
+      const c = Math.cos(rot);
+      const sn = Math.sin(rot);
+      const s = r * k;
+      let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+      const grow = (u) => {
+        const ux = (u[0] - fr.ox) * fr.sx * k, uy = (u[1] - fr.oy) * fr.sy * k;
+        const x = ux * c - uy * sn;
+        const y = ux * sn + uy * c;
+        if (x < x0) x0 = x;
+        if (x > x1) x1 = x;
+        if (y < y0) y0 = y;
+        if (y > y1) y1 = y;
+      };
+      let sw = 0;
+      for (const part of pathParts(sprite)) {
+        if (part.fill) for (const u of part.flat.points) grow(u);
+        if (part.stroke) {
+          sw = Math.max(sw, part.stroke.width);
+          for (const l of part.flat.lines) for (const u of l.points) grow(u);
+        }
+      }
+      const pad = 2 + Math.ceil(sw * s);
+      const bx = Math.floor(fx + x0) - pad;
+      const by = Math.floor(fy + y0) - pad;
+      const w = Math.ceil(fx + x1) - bx + pad;
+      const h = Math.ceil(fy + y1) - by + pad;
+      if (!(w > 0 && h > 0) || !Number.isFinite(w + h)) return false;
+      if (pathDrawCost(sprite) / (w * h / 1e6) < PATH_BLIT_MIN_DENSITY) {
+        slot.off = true;
+        return false;
+      }
+      if (this.pathBlitPixels + w * h > PATH_BLIT_MAX_PIXELS) return false;
+      const made = this.makeCanvas(1);
+      if (!made) return false;
+      made.canvas.width = w;
+      made.canvas.height = h;
+      const g = made.ctx;
+      g.setTransform(k, 0, 0, k, fx - bx, fy - by);
+      if (rot) g.rotate(rot);
+      this.drawPathUnit(g, sprite, color2, fr, r);
+      hit = { canvas: made.canvas, x0: bx, y0: by, px: w * h };
+      this.pathBlitPixels += hit.px;
+      slot.entries.set(key, hit);
+    }
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.drawImage(hit.canvas, ix + hit.x0, iy + hit.y0);
+    ctx.restore();
+    return true;
+  }
+  /**
+   * The moving-sprite cache: for a drawing whose exact key keeps changing. It
+   * is rasterised once per colour, UNROTATED, at a device radius rounded UP to
+   * the next 1/8-octave step (so it is only ever shrunk, never enlarged), then
+   * drawn every frame at its true sub-pixel position, rotation and size under
+   * the context's own transform, with smoothing. Not pixel-exact like the
+   * still cache (edges resample by well under a pixel), but a 7-part drifting
+   * balloon costs one image draw instead of seven fills and strokes.
+   */
+  spriteBlit(sprite, slot, p, r, rot, color2, fr) {
+    const ctx = this.ctx;
+    if (!fr.uniform || fr.sx !== r) return false;
+    const m = ctx.getTransform();
+    const k = Math.sqrt(Math.abs(m.a * m.d - m.b * m.c));
+    const s = r * k;
+    if (!(s >= 1)) return false;
+    const bucket = 2 ** (Math.ceil(Math.log2(s) * 8) / 8);
+    const key = `S|${color2}|${bucket.toFixed(3)}`;
+    let hit = slot.entries.get(key);
+    if (!hit) {
+      if (slot.entries.size >= PATH_SPRITE_PER_SPRITE) {
+        for (const old of slot.entries.values()) this.pathBlitPixels -= old.px;
+        slot.entries.clear();
+        if (++slot.flushes > 2) {
+          slot.off = true;
+          return false;
+        }
+      }
+      let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity, sw = 0;
+      const grow = (u2) => {
+        if (u2[0] < x0) x0 = u2[0];
+        if (u2[0] > x1) x1 = u2[0];
+        if (u2[1] < y0) y0 = u2[1];
+        if (u2[1] > y1) y1 = u2[1];
+      };
+      for (const part of pathParts(sprite)) {
+        if (part.fill) for (const u2 of part.flat.points) grow([u2[0] - fr.ox, u2[1] - fr.oy]);
+        if (part.stroke) {
+          sw = Math.max(sw, part.stroke.width);
+          for (const l of part.flat.lines) for (const u2 of l.points) grow([u2[0] - fr.ox, u2[1] - fr.oy]);
+        }
+      }
+      const pad = 2 + Math.ceil(sw * bucket);
+      const ox = Math.ceil(-x0 * bucket) + pad;
+      const oy = Math.ceil(-y0 * bucket) + pad;
+      const w = ox + Math.ceil(x1 * bucket) + pad;
+      const h = oy + Math.ceil(y1 * bucket) + pad;
+      if (!(w > 0 && h > 0) || !Number.isFinite(w + h)) return false;
+      if (w * h > PATH_SPRITE_MAX_PIXELS) {
+        slot.off = true;
+        return false;
+      }
+      if (this.pathBlitPixels + w * h > PATH_BLIT_MAX_PIXELS) return false;
+      const made = this.makeCanvas(1);
+      if (!made) return false;
+      made.canvas.width = w;
+      made.canvas.height = h;
+      made.ctx.setTransform(1, 0, 0, 1, ox, oy);
+      this.drawPathUnit(made.ctx, sprite, color2, { sx: bucket, sy: bucket, ox: fr.ox, oy: fr.oy, uniform: true }, bucket);
+      hit = { canvas: made.canvas, x0: ox, y0: oy, px: w * h };
+      this.pathBlitPixels += hit.px;
+      slot.entries.set(key, hit);
+    }
+    const u = r / bucket;
+    ctx.save();
+    ctx.translate(p.x, p.y);
+    if (rot) ctx.rotate(rot);
+    ctx.imageSmoothingEnabled = true;
+    ctx.drawImage(hit.canvas, -hit.x0 * u, -hit.y0 * u, hit.canvas.width * u, hit.canvas.height * u);
+    ctx.restore();
+    return true;
+  }
   makeCanvas(n) {
     try {
       const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(n, n);
@@ -3944,24 +4974,26 @@ var SpecInstance = class {
     if (sprite.kind === "polygon") {
       const r = sz / 2;
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
-      const pts = polygonPoints(sprite, r);
+      if (isPathPolygon(sprite)) {
+        const fr = pathFrame(sprite, r, this.w, this.h);
+        if (pathDrawCost(sprite) >= PATH_BLIT_MIN_POINTS && !this.noPathCache && this.drawingSteady(built, sprite) && this.blitPath(sprite, p, r, rot, resolvedColor, fr)) return;
+        ctx.save();
+        ctx.translate(p.x, p.y);
+        if (rot) ctx.rotate(rot);
+        if (r > 0 && fr.sx > 0 && fr.sy > 0) this.drawPathUnit(ctx, sprite, resolvedColor, fr, r);
+        ctx.restore();
+        return;
+      }
       ctx.save();
       ctx.translate(p.x, p.y);
       if (rot) ctx.rotate(rot);
-      if (sprite.soft) {
-        const g = ctx.createRadialGradient(0, 0, 0, 0, 0, r);
-        g.addColorStop(0, resolvedColor);
-        g.addColorStop(0.35, hexToRgba(resolvedColor, 0.75));
-        g.addColorStop(1, hexToRgba(resolvedColor, 0));
-        ctx.fillStyle = g;
-      } else {
-        ctx.fillStyle = resolvedColor;
-      }
+      ctx.fillStyle = sprite.soft ? softFill(ctx, resolvedColor, r) : resolvedColor;
+      const pts = polygonPoints(sprite, r);
       ctx.beginPath();
       ctx.moveTo(pts[0].x, pts[0].y);
       for (let i = 1; i < pts.length; i++) ctx.lineTo(pts[i].x, pts[i].y);
       ctx.closePath();
-      ctx.fill();
+      ctx.fill(polygonFillRule(sprite));
       ctx.restore();
       return;
     }
@@ -4200,9 +5232,9 @@ var SpecInstance = class {
     const motionWraps = ["drift", "rise", "wander"].includes(built.layer.motion.type);
     const wrap2 = built.layer.wrap !== false && motionWraps;
     const positions = built.entities.map((e) => this.entityPos(e, t, parentE));
-    const maxDistPx = links.maxDist * (this.effSpec.units === "px" ? 1 : Math.min(this.w, this.h));
-    const edges = linkEdges(links, positions, maxDistPx, wrap2, this.w, this.h);
     const unitScale = this.effSpec.units === "px" ? 1 : Math.min(this.w, this.h);
+    const maxDistPx = linkMaxDistPx(links, unitScale);
+    const edges = linkEdges(links, positions, maxDistPx, wrap2, this.w, this.h);
     const defaultWidth = unitScale === 1 ? 1 : 1 / LIMITS.referenceViewport;
     const lw = (links.width ?? defaultWidth) * unitScale;
     ctx.lineWidth = lw;
@@ -4219,7 +5251,7 @@ var SpecInstance = class {
         } else resolvedColor = "#e6e8ef";
       }
       let a = links.alpha ?? alphaAt(ei, t);
-      if (links.falloff) a *= Math.max(0, 1 - dist / maxDistPx);
+      if (links.falloff && Number.isFinite(maxDistPx)) a *= Math.max(0, 1 - dist / maxDistPx);
       ctx.globalAlpha = a * lifeA;
       ctx.strokeStyle = resolvedColor;
       let dx = pj.x - pi.x;
@@ -4246,38 +5278,212 @@ var SpecInstance = class {
       this.drawBackground(t);
     }
     ctx.globalAlpha = 1;
-    for (let li = 0; li < this.layers.length; li++) {
-      const built = this.layers[li];
-      const opacity = built.layer.opacity;
-      const group = built.layer.group === void 0 ? void 0 : this.effSpec.groups?.[built.layer.group];
-      let lifeA = opacity === void 0 ? lifeAlphaAt(built.layer.life, t) : lifeAlphaAt(built.layer.life, t) * clamp014(opacity);
-      if (group?.opacity !== void 0) lifeA *= clamp014(group.opacity);
-      if (lifeA <= 0) continue;
-      const parentE = this.parentEntityFor(built);
-      const tf = built.layer.transform;
-      const gtf = group?.transform;
-      if (tf || gtf) {
-        ctx.save();
-        if (gtf) this.applyLayerTransform(gtf, null);
-        if (tf) this.applyLayerTransform(tf, built.layer);
-      }
-      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);
-        if (override === null) {
-          this.drawEntity(built, e, t, lifeA, parentE);
+    const n = this.layers.length;
+    for (let li = 0; li < n; li++) {
+      if (!this.noPathCache && this.plateable(li, t)) {
+        let j = li;
+        while (j + 1 < n && this.plateable(j + 1, t)) j++;
+        if (j > li && this.runPoints(li, j) >= PLATE_MIN_POINTS && this.paintPlate(li, j, t)) {
+          li = j;
           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 (tf || gtf) ctx.restore();
+      this.paintLayer(li, t);
+    }
+    ctx.globalAlpha = 1;
+    ctx.globalCompositeOperation = "source-over";
+  }
+  /** Paint layer `li` at time t onto this.ctx (the scene canvas, or a plate being rebuilt). */
+  paintLayer(li, t) {
+    const { ctx } = this;
+    const built = this.layers[li];
+    const opacity = built.layer.opacity;
+    const group = built.layer.group === void 0 ? void 0 : this.effSpec.groups?.[built.layer.group];
+    let lifeA = opacity === void 0 ? lifeAlphaAt(built.layer.life, t) : lifeAlphaAt(built.layer.life, t) * clamp014(opacity);
+    if (group?.opacity !== void 0) lifeA *= clamp014(group.opacity);
+    if (lifeA <= 0) return;
+    const parentE = this.parentEntityFor(built);
+    const tf = built.layer.transform;
+    const gtf = group?.transform;
+    if (tf || gtf) {
+      ctx.save();
+      if (gtf) this.applyLayerTransform(gtf, null);
+      if (tf) this.applyLayerTransform(tf, built.layer);
+    }
+    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);
+      if (override === null) {
+        this.drawEntity(built, e, t, lifeA, 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 (tf || gtf) ctx.restore();
+  }
+  /**
+   * Static plates. Consecutive path-polygon layers painted source-over, with
+   * no trails, links or text overrides, are composited into ONE full-frame
+   * bitmap and copied once per frame while nothing they draw has changed —
+   * the change test is the drawn values themselves (each entity's position,
+   * size, rotation, alpha and colour, the layer's life alpha and transforms),
+   * so anything animated simply repaints its plate that frame. Source-over is
+   * associative, so the plate over the frame equals the layers over it.
+   */
+  plates = /* @__PURE__ */ new Map();
+  /** Outline points a run of path layers fills per frame (points × entities). */
+  runPoints(a, b) {
+    let n = 0;
+    for (let li = a; li <= b; li++) {
+      const built = this.layers[li];
+      const sp = built.layer.sprite;
+      if (sp.kind === "polygon" && isPathPolygon(sp)) n += pathDrawCost(sp) * built.entities.length;
     }
+    return n;
+  }
+  /** Last drawn-value signature per layer, for plate stability. */
+  layerSigs = /* @__PURE__ */ new Map();
+  /**
+   * A layer joins a plate only if it can (path polygon, source-over, no
+   * trails/links/text override) AND nothing it draws changed since the last
+   * frame — so a pulsing or moving layer splits the run and paints live, while
+   * the static layers around it keep their plates.
+   */
+  plateable(li, t) {
+    const built = this.layers[li];
+    const l = built.layer;
+    const sp = l.sprite;
+    if (!isPathPolygon(sp)) return false;
+    if ((l.blend ?? "source-over") !== "source-over") return false;
+    if (l.trail || l.links || this.paintOverrides?.has(li)) return false;
+    if (built.entities.length > 64) return false;
+    const sig = this.layerSig(li, t);
+    const prev = this.layerSigs.get(li);
+    this.layerSigs.set(li, sig);
+    return prev === sig;
+  }
+  layerSig(li, t) {
+    const built = this.layers[li];
+    const group = built.layer.group === void 0 ? void 0 : this.effSpec.groups?.[built.layer.group];
+    const opacity = built.layer.opacity;
+    let lifeA = opacity === void 0 ? lifeAlphaAt(built.layer.life, t) : lifeAlphaAt(built.layer.life, t) * clamp014(opacity);
+    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 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}`;
+    }
+    return sig;
+  }
+  plateSig(a, b) {
+    let sig = `${a}-${b}`;
+    for (let li = a; li <= b; li++) sig += `#${this.layerSigs.get(li)}`;
+    return sig;
+  }
+  /** Max |point| of a path polygon's unit outline (its reach as a fraction of the entity radius). */
+  pathReach = /* @__PURE__ */ new WeakMap();
+  reachOf(sp) {
+    let r = this.pathReach.get(sp);
+    if (r === void 0) {
+      r = 0;
+      let sw = 0;
+      for (const part of pathParts(sp)) {
+        for (const [x, y] of part.flat.points) r = Math.max(r, Math.hypot(x, y));
+        for (const l of part.flat.lines) for (const [x, y] of l.points) r = Math.max(r, Math.hypot(x, y));
+        if (part.stroke) sw = Math.max(sw, part.stroke.width);
+      }
+      r += sw;
+      this.pathReach.set(sp, r || 1);
+    }
+    return r || 1;
+  }
+  /**
+   * Device-pixel box a run of layers can paint into, or null for "the whole
+   * frame" (a layer/group transform moves things in ways this does not model).
+   */
+  runBox(a, b, t) {
+    const m = this.ctx.getTransform();
+    if (Math.abs(m.b) > 1e-9 || Math.abs(m.c) > 1e-9) return null;
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (let li = a; li <= b; li++) {
+      const built = this.layers[li];
+      const group = built.layer.group === void 0 ? void 0 : this.effSpec.groups?.[built.layer.group];
+      if (built.layer.transform || group?.transform) return null;
+      const reach = this.reachOf(built.layer.sprite);
+      const parentE = this.parentEntityFor(built);
+      for (const e of built.entities) {
+        const p = this.entityPos(e, t, parentE);
+        const sp = built.layer.sprite;
+        const fr = pathFrame(sp, sizeAt(e, t) / 2, this.w, this.h);
+        const ext = Math.max(fr.sx, fr.sy) * (reach + Math.hypot(fr.ox, fr.oy));
+        x0 = Math.min(x0, p.x - ext);
+        x1 = Math.max(x1, p.x + ext);
+        y0 = Math.min(y0, p.y - ext);
+        y1 = Math.max(y1, p.y + ext);
+      }
+    }
+    const W = this.canvas.width, H = this.canvas.height;
+    const bx = Math.max(0, Math.floor(m.a * x0 + m.e) - 2);
+    const by = Math.max(0, Math.floor(m.d * y0 + m.f) - 2);
+    const bw = Math.min(W, Math.ceil(m.a * x1 + m.e) + 2) - bx;
+    const bh = Math.min(H, Math.ceil(m.d * y1 + m.f) + 2) - by;
+    return bw > 0 && bh > 0 ? { x: bx, y: by, w: bw, h: bh } : { x: 0, y: 0, w: 0, h: 0 };
+  }
+  /** Paint layers a..b from their plate, rebuilding it if anything drawn changed. False = paint them normally. */
+  paintPlate(a, b, t) {
+    const sig = this.plateSig(a, b);
+    let plate = this.plates.get(a);
+    if (!plate || plate.sig !== sig || plate.end !== b || plate.frameW !== this.canvas.width || plate.frameH !== this.canvas.height) {
+      const box = this.runBox(a, b, t) ?? { x: 0, y: 0, w: this.canvas.width, h: this.canvas.height };
+      if (!plate) {
+        if (this.plates.size >= 4) this.plates.delete(this.plates.keys().next().value);
+        const made = this.makeCanvas(1);
+        if (!made) return false;
+        plate = { ...made, end: b, sig: "", box, frameW: 0, frameH: 0 };
+        this.plates.set(a, plate);
+      }
+      plate.box = box;
+      plate.frameW = this.canvas.width;
+      plate.frameH = this.canvas.height;
+      if (box.w === 0 || box.h === 0) {
+        plate.sig = sig;
+        plate.end = b;
+        return true;
+      }
+      if (plate.canvas.width !== box.w) plate.canvas.width = box.w;
+      if (plate.canvas.height !== box.h) plate.canvas.height = box.h;
+      const pc = plate.ctx;
+      pc.setTransform(1, 0, 0, 1, 0, 0);
+      pc.globalAlpha = 1;
+      pc.globalCompositeOperation = "source-over";
+      pc.clearRect(0, 0, box.w, box.h);
+      const m = this.ctx.getTransform();
+      pc.setTransform(m.a, m.b, m.c, m.d, m.e - box.x, m.f - box.y);
+      const self = this;
+      const main = self.ctx;
+      self.ctx = pc;
+      try {
+        for (let li = a; li <= b; li++) this.paintLayer(li, t);
+      } finally {
+        self.ctx = main;
+      }
+      plate.sig = sig;
+      plate.end = b;
+    }
+    if (plate.box.w === 0 || plate.box.h === 0) return true;
+    const ctx = this.ctx;
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
     ctx.globalAlpha = 1;
     ctx.globalCompositeOperation = "source-over";
+    ctx.drawImage(plate.canvas, plate.box.x, plate.box.y);
+    ctx.restore();
+    return true;
   }
   /**
    * A `transform`, in min(w,h) units (px under `units: 'px'`), about the
@@ -5129,6 +6335,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) {
@@ -5150,12 +6357,53 @@ function hexLuma(hex) {
 }
 function spriteLuma(layer, e) {
   const s = layer.sprite;
+  if (s.kind === "polygon" && isPathPolygon(s)) {
+    const base = s.colors?.[e.colorIndex] ?? s.color;
+    let sum = 0, wsum = 0;
+    for (const part of pathParts(s)) {
+      const pc = hexLuma(part.color ?? base);
+      let l;
+      if (!part.fill) l = part.stroke ? hexLuma(part.stroke.color) : pc;
+      else if (part.gradient) {
+        let g = 0;
+        for (const st of part.gradient.stops) {
+          const o = st.opacity ?? 1;
+          g += hexLuma(st.color) * o + pc * (1 - o);
+        }
+        l = g / part.gradient.stops.length;
+      } else l = pc;
+      const w = Math.max(1e-4, part.fill ? polygonArea(part.flat.points.map(([x, y]) => ({ x, y }))) : part.box.hw * part.box.hh * 0.1) * part.opacity;
+      sum += l * w;
+      wsum += w;
+    }
+    if (wsum > 0) return sum / wsum;
+  }
   if (isShapedSprite(s)) {
     return hexLuma(s.colors?.[e.colorIndex] ?? s.color);
   }
   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)) {
@@ -5271,6 +6519,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 {
@@ -5279,6 +6544,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);
@@ -5294,7 +6560,7 @@ function polyShape(cx, cy, raw) {
   if (abs.length < 3) return null;
   let br = 0;
   for (const p of abs) br = Math.max(br, Math.hypot(p.x - cx, p.y - cy));
-  const inside = (x, y) => {
+  const inside2 = (x, y) => {
     let hit = false;
     for (let i = 0, j = abs.length - 1; i < abs.length; j = i++) {
       const a = abs[i];
@@ -5312,12 +6578,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: inside,
+    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
@@ -5346,13 +6621,13 @@ function polyShape(cx, cy, raw) {
         for (let t = step; t > 0; t /= 8) {
           const qx1 = px - uy * t;
           const qy1 = py + ux * t;
-          if (inside(qx1, qy1)) {
+          if (inside2(qx1, qy1)) {
             out.push({ x: qx1, y: qy1 });
             break;
           }
           const qx2 = px + uy * t;
           const qy2 = py - ux * t;
-          if (inside(qx2, qy2)) {
+          if (inside2(qx2, qy2)) {
             out.push({ x: qx2, y: qy2 });
             break;
           }
@@ -5367,12 +6642,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);
@@ -5432,8 +6708,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;
@@ -5465,16 +6740,58 @@ 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
 import { createRng as createRng2 } from "@idle-screens/core";
-var GLOW_SPREAD = 2.4;
 var LINE_SALIENCE = 3.5;
 var GHOST_TAPS = 12;
 var POLYGON_OUTLINE_CELLS = 3;
@@ -5509,11 +6826,18 @@ function posOf(scene, e, t) {
   const map = scene.transforms?.get(e);
   return map ? map(p) : p;
 }
-function textBox(s, e, p) {
+function fontScaleFor(spec, w, h) {
+  return spec.units === "px" ? 1 : Math.min(w, h) / (spec.referenceViewport ?? LIMITS.referenceViewport);
+}
+function textFontPx(s, size, fontScale) {
   const m = s.font ? /(\d+(?:\.\d+)?)px/.exec(s.font) : null;
-  const fh = m ? Number(m[1]) : e.size;
+  return m ? Number(m[1]) * fontScale : size;
+}
+function textBox(s, e, p, fontScale, unitScale) {
+  const fh = textFontPx(s, e.size, fontScale);
   const str = s.strings[e.spriteIndex] ?? s.strings[0] ?? "";
-  const fw = Math.max(fh, 0.62 * fh * Math.min(str.length, 48));
+  const est = Math.max(fh, 0.62 * fh * Math.min(str.length, 48));
+  const fw = s.maxWidth ? Math.min(est, s.maxWidth * unitScale) : est;
   const align = s.align ?? "center";
   const baseline = s.baseline ?? "middle";
   return {
@@ -5559,7 +6883,24 @@ function textBlockRevealFraction(s, w, h, t) {
   }
   return rs.progress;
 }
-function polygonCellCoverage(pts, cellW, cellH, c0, c1, r0, r1) {
+function gradientAt(gr, u, v) {
+  let t;
+  if (gr.type === "linear") {
+    const dx = gr.to[0] - gr.from[0], dy = gr.to[1] - gr.from[1];
+    const len2 = dx * dx + dy * dy || 1;
+    t = ((u - gr.from[0]) * dx + (v - gr.from[1]) * dy) / len2;
+  } else {
+    t = Math.hypot(u - gr.center[0], v - gr.center[1]) / gr.radius;
+  }
+  const st = gr.stops;
+  t = Math.max(st[0].at, Math.min(st[st.length - 1].at, t));
+  let k = 0;
+  while (k < st.length - 2 && t > st[k + 1].at) k++;
+  const A = st[k], B = st[Math.min(k + 1, st.length - 1)];
+  const w = B.at > A.at ? (t - A.at) / (B.at - A.at) : 0;
+  return { luma: hexLuma(A.color) * (1 - w) + hexLuma(B.color) * w, opacity: (A.opacity ?? 1) * (1 - w) + (B.opacity ?? 1) * w };
+}
+function polygonCellCoverage(pts, cellW, cellH, c0, c1, r0, r1, evenodd = false) {
   const nc = c1 - c0 + 1;
   const cov = new Float64Array(nc * (r1 - r0 + 1));
   const xMin = c0 * cellW;
@@ -5592,30 +6933,52 @@ function polygonCellCoverage(pts, cellW, cellH, c0, c1, r0, r1) {
       hits.sort((m, n) => m.x - n.x);
       let wind = 0;
       let start = 0;
+      const filled = (w) => evenodd ? (w & 1) !== 0 : w !== 0;
       for (const hit of hits) {
-        const before = wind;
+        const before = filled(wind);
         wind += hit.dir;
-        if (before === 0 && wind !== 0) start = hit.x;
-        else if (before !== 0 && wind === 0) addSpan(r - r0, start, hit.x);
+        const after = filled(wind);
+        if (!before && after) start = hit.x;
+        else if (before && !after) addSpan(r - r0, start, hit.x);
       }
     }
   }
   return cov;
 }
-function distanceToOutline(pts, x, y) {
-  let best = Infinity;
-  for (let i = 0; i < pts.length; i++) {
-    const p = pts[i];
-    const q = pts[(i + 1) % pts.length];
-    const ex = q.x - p.x;
-    const ey = q.y - p.y;
-    const len2 = ex * ex + ey * ey;
-    const u = len2 > 0 ? Math.max(0, Math.min(1, ((x - p.x) * ex + (y - p.y) * ey) / len2)) : 0;
-    const dx = x - (p.x + ex * u);
-    const dy = y - (p.y + ey * u);
-    best = Math.min(best, dx * dx + dy * dy);
-  }
-  return Math.sqrt(best);
+function softProfile(u) {
+  if (u <= 0) return 1;
+  if (u >= 1) return 0;
+  return u <= 0.35 ? 1 - 0.25 * u / 0.35 : 0.75 * (1 - (u - 0.35) / 0.65);
+}
+var SOFT_DISC_MEAN = 0.3783;
+function discCellInk(cx, cy, rOuter, rInner, soft, x0, y0, cw, ch) {
+  const nx = Math.max(x0, Math.min(cx, x0 + cw)) - cx;
+  const ny = Math.max(y0, Math.min(cy, y0 + ch)) - cy;
+  const near = Math.hypot(nx, ny);
+  const fx = Math.max(Math.abs(x0 - cx), Math.abs(x0 + cw - cx));
+  const fy = Math.max(Math.abs(y0 - cy), Math.abs(y0 + ch - cy));
+  const far = Math.hypot(fx, fy);
+  if (near >= rOuter || far <= rInner) return 0;
+  if (far <= rOuter && near >= rInner) return soft ? softProfile(Math.hypot(x0 + cw / 2 - cx, y0 + ch / 2 - cy) / rOuter) : 1;
+  if (cx - rOuter >= x0 && cx + rOuter <= x0 + cw && cy - rOuter >= y0 && cy + rOuter <= y0 + ch) {
+    return Math.PI * (soft ? rOuter * rOuter * SOFT_DISC_MEAN : rOuter * rOuter - rInner * rInner) / (cw * ch);
+  }
+  const bx0 = Math.max(x0, cx - rOuter);
+  const by0 = Math.max(y0, cy - rOuter);
+  const sx = Math.min(x0 + cw, cx + rOuter) - bx0;
+  const sy = Math.min(y0 + ch, cy + rOuter) - by0;
+  if (sx <= 0 || sy <= 0) return 0;
+  const step = Math.max(rOuter / 4, 1e-6);
+  const ni = Math.max(4, Math.min(16, Math.ceil(sx / step)));
+  const nj = Math.max(4, Math.min(16, Math.ceil(sy / step)));
+  let ink = 0;
+  for (let j = 0; j < nj; j++) {
+    for (let i = 0; i < ni; i++) {
+      const d = Math.hypot(bx0 + (i + 0.5) * sx / ni - cx, by0 + (j + 0.5) * sy / nj - cy);
+      if (d <= rOuter && d >= rInner) ink += soft ? softProfile(d / rOuter) : 1;
+    }
+  }
+  return ink / (ni * nj) * sx * sy / (cw * ch);
 }
 function luminanceGrid(spec, opts = {}) {
   spec = resolveTimelineAt(spec, opts.t ?? 5e3);
@@ -5712,11 +7075,14 @@ function luminanceGrid(spec, opts = {}) {
       const r1 = Math.min(rows - 1, Math.floor((pos.y + rad) / cellH));
       for (let r = r0; r <= r1; r++) {
         for (let c = c0; c <= c1; c++) {
-          const dx = (c + 0.5) * cellW - pos.x;
-          const dy = (r + 0.5) * cellH - pos.y;
-          const d = Math.sqrt(dx * dx + dy * dy);
-          if (d > rad + Math.min(cellW, cellH) / 2) continue;
-          const wgt = soft ? Math.max(0.1, 1 - d / Math.max(rad, 1e-6)) : 1;
+          let wgt = 1;
+          if (soft) {
+            wgt = discCellInk(pos.x, pos.y, rad, 0, true, c * cellW, r * cellH, cellW, cellH);
+            if (wgt <= 0) continue;
+          } else {
+            const d = Math.hypot((c + 0.5) * cellW - pos.x, (r + 0.5) * cellH - pos.y);
+            if (d > rad + Math.min(cellW, cellH) / 2) continue;
+          }
           compose(r * cols + c, lum, Math.min(1, a * wgt), layer.blend);
         }
       }
@@ -5724,20 +7090,15 @@ 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 pts = polygonPoints(s, radius).map((q) => ({ x: p.x + q.x * cr - q.y * sr, y: p.y + q.x * sr + q.y * cr }));
-    const additive = layer.blend === "lighter" || layer.blend === "screen";
-    const glow = !!s.soft && additive;
-    let band = 0;
-    if (glow) {
-      const perimeter = pts.reduce((acc, q, i) => {
-        const n = pts[(i + 1) % pts.length];
-        return acc + Math.hypot(n.x - q.x, n.y - q.y);
-      }, 0);
-      band = perimeter > 0 ? (GLOW_SPREAD - 1) * (2 * polygonArea(pts) / perimeter) : 0;
-    }
+    const fr = isPathPolygon(s) ? pathFrame(s, radius, w, h) : { sx: radius, sy: radius, ox: 0, oy: 0, uniform: true };
+    const mapUnit = (u, v) => {
+      const qx = (u - fr.ox) * fr.sx, qy = (v - fr.oy) * fr.sy;
+      return { x: p.x + qx * cr - qy * sr, y: p.y + qx * sr + qy * cr };
+    };
+    const pts = isPathPolygon(s) ? flattenSprite(s).points.map(([u, v]) => mapUnit(u, v)) : polygonPoints(s, radius).map((q) => ({ x: p.x + q.x * cr - q.y * sr, y: p.y + q.x * sr + q.y * cr }));
     let minX = Infinity;
     let maxX = -Infinity;
     let minY = Infinity;
@@ -5748,34 +7109,97 @@ function luminanceGrid(spec, opts = {}) {
       minY = Math.min(minY, q.y);
       maxY = Math.max(maxY, q.y);
     }
-    const c0 = Math.max(0, Math.floor((minX - band) / cellW));
-    const c1 = Math.min(cols - 1, Math.floor((maxX + band) / cellW));
-    const r0 = Math.max(0, Math.floor((minY - band) / cellH));
-    const r1 = Math.min(rows - 1, Math.floor((maxY + band) / cellH));
+    const strokeQuadsPx = (part) => {
+      if (!part.stroke) return [];
+      const hw = part.stroke.width * radius / 2;
+      const out = [];
+      for (const l of part.flat.lines) {
+        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++) {
+          const A = m[i], B = m[(i + 1) % m.length];
+          const dx = B.x - A.x, dy = B.y - A.y, len = Math.hypot(dx, dy) || 1;
+          const nx = -dy / len * hw, ny = dx / len * hw;
+          out.push([{ x: A.x + nx, y: A.y + ny }, { x: B.x + nx, y: B.y + ny }, { x: B.x - nx, y: B.y - ny }, { x: A.x - nx, y: A.y - ny }]);
+        }
+      }
+      return out;
+    };
+    if (isPathPolygon(s)) {
+      for (const part of pathParts(s)) for (const quad of strokeQuadsPx(part)) for (const q of quad) {
+        minX = Math.min(minX, q.x);
+        maxX = Math.max(maxX, q.x);
+        minY = Math.min(minY, q.y);
+        maxY = Math.max(maxY, q.y);
+      }
+    }
+    const c0 = Math.max(0, Math.floor(minX / cellW));
+    const c1 = Math.min(cols - 1, Math.floor(maxX / cellW));
+    const r0 = Math.max(0, Math.floor(minY / cellH));
+    const r1 = Math.min(rows - 1, Math.floor(maxY / cellH));
     if (c0 > c1 || r0 > r1) return;
-    const cov = polygonCellCoverage(pts, cellW, cellH, c0, c1, r0, r1);
     const nc = c1 - c0 + 1;
-    for (let r = r0; r <= r1; r++) {
-      for (let c = c0; c <= c1; c++) {
-        const f = cov[(r - r0) * nc + (c - c0)];
-        const x = (c + 0.5) * cellW;
-        const y = (r + 0.5) * cellH;
-        let wgt;
-        if (glow) {
-          const outX = Math.max(0, minX - x, x - maxX);
-          const outY = Math.max(0, minY - y, y - maxY);
-          if (f >= 1) wgt = 1;
-          else if (outX * outX + outY * outY >= band * band) wgt = f;
-          else {
-            const k = band > 0 ? Math.max(0, 1 - distanceToOutline(pts, x, y) / band) : 0;
-            wgt = f + (1 - f) * k * k;
+    const unitAt = (x, y) => {
+      const dx = x - p.x, dy = y - p.y;
+      return [(dx * cr + dy * sr) / Math.max(fr.sx, 1e-6) + fr.ox, (-dx * sr + dy * cr) / Math.max(fr.sy, 1e-6) + fr.oy];
+    };
+    const parts = isPathPolygon(s) ? pathParts(s) : null;
+    const fillPass = (ring, rule, partLum, partA, part) => {
+      const cov = polygonCellCoverage(ring, cellW, cellH, c0, c1, r0, r1, rule);
+      for (let r = r0; r <= r1; r++) {
+        for (let c = c0; c <= c1; c++) {
+          const f = cov[(r - r0) * nc + (c - c0)];
+          if (!(f > 0)) continue;
+          const x = (c + 0.5) * cellW;
+          const y = (r + 0.5) * cellH;
+          let cl = partLum, ca = 1;
+          if (part?.gradient) {
+            const [u, v] = unitAt(x, y);
+            const [gu, gv] = gradientSpace(part, u, v);
+            const g = gradientAt(part.gradient, gu, gv);
+            cl = g.luma;
+            ca = g.opacity;
+          }
+          const wgt = s.soft && !parts ? f * softProfile(Math.hypot(x - p.x, y - p.y) / Math.max(radius, 1e-6)) : f;
+          if (wgt > 0) compose(r * cols + c, cl, a * partA * ca * Math.min(1, wgt), layer.blend);
+        }
+      }
+    };
+    if (!parts) {
+      fillPass(pts, polygonFillRule(s) === "evenodd", lum, 1, null);
+      return;
+    }
+    for (const part of parts) {
+      const partLum = part.color ? hexLuma(part.color) : lum;
+      if (part.fill && part.flat.points.length >= 3) {
+        fillPass(part.flat.points.map(([u, v]) => mapUnit(u, v)), part.rule === "evenodd", partLum, part.opacity, part);
+      }
+      if (part.stroke) {
+        const sa = (part.stroke.opacity ?? 1) * part.opacity;
+        const sl = hexLuma(part.stroke.color);
+        const scov = new Float64Array(nc * (r1 - r0 + 1));
+        for (const qp of strokeQuadsPx(part)) {
+          let qx0 = Infinity, qx1 = -Infinity, qy0 = Infinity, qy1 = -Infinity;
+          for (const q of qp) {
+            qx0 = Math.min(qx0, q.x);
+            qx1 = Math.max(qx1, q.x);
+            qy0 = Math.min(qy0, q.y);
+            qy1 = Math.max(qy1, q.y);
+          }
+          const a0 = Math.max(c0, Math.floor(qx0 / cellW)), a1 = Math.min(c1, Math.floor(qx1 / cellW));
+          const b0 = Math.max(r0, Math.floor(qy0 / cellH)), b1 = Math.min(r1, Math.floor(qy1 / cellH));
+          if (a0 > a1 || b0 > b1) continue;
+          const qc = polygonCellCoverage(qp, cellW, cellH, a0, a1, b0, b1);
+          const qn = a1 - a0 + 1;
+          for (let r = b0; r <= b1; r++) for (let c = a0; c <= a1; c++) {
+            const i = (r - r0) * nc + (c - c0);
+            scov[i] = Math.min(1, scov[i] + qc[(r - b0) * qn + (c - a0)]);
           }
-        } else if (s.soft) {
-          wgt = f * Math.max(0.1, 1 - Math.hypot(x - p.x, y - p.y) / Math.max(radius, 1e-6));
-        } else {
-          wgt = f;
         }
-        if (wgt > 0) compose(r * cols + c, lum, a * Math.min(1, wgt), layer.blend);
+        for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+          const f = scov[(r - r0) * nc + (c - c0)];
+          if (f > 0) compose(r * cols + c, sl, a * sa * f, layer.blend);
+        }
       }
     }
   };
@@ -5791,13 +7215,13 @@ function luminanceGrid(spec, opts = {}) {
         const p = posOf(scene, e, tPass);
         const sz = layer.transform || layer.group !== void 0 ? sizeAt(e, tPass) * paintSize(spec, layer) : sizeAt(e, tPass);
         const s = layer.sprite;
-        if (s.kind === "polygon" && sz >= POLYGON_OUTLINE_CELLS * Math.min(cellW, cellH)) {
+        if (s.kind === "polygon" && (sz >= POLYGON_OUTLINE_CELLS * Math.min(cellW, cellH) || isPathPolygon(s) && ((s.span ?? "box") !== "box" || s.origin !== void 0))) {
           splatPolygonOutline(layer, s, e, p, sz, a, lum, tPass);
           continue;
         }
         if (s.kind === "stroke") {
           const pts = strokeSamples(s, sz / 2);
-          let angle = rotationAt(e, tPass);
+          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);
@@ -5826,7 +7250,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++) {
@@ -5845,7 +7269,7 @@ function luminanceGrid(spec, opts = {}) {
         let halfX = sz / 2;
         let halfY = s.kind === "rect" ? (e.size2 ?? sz) * (e.size > 0 ? sz / e.size : 1) / 2 : sz / 2;
         if (s.kind === "text") {
-          const box = textBox(s, e, p);
+          const box = textBox(s, e, p, fontScaleFor(spec, w, h), scale);
           centerX = box.cx;
           centerY = box.cy;
           halfX = box.halfX;
@@ -5861,7 +7285,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;
@@ -5872,45 +7296,24 @@ function luminanceGrid(spec, opts = {}) {
         const circular = s.kind === "circle" || s.kind === "ring" || s.kind === "polygon";
         const soft = (s.kind === "circle" || s.kind === "polygon") && !!s.soft;
         const shapeWeight = s.kind === "polygon" ? polygonFill(s, sz / 2) : s.kind === "rect" && s.feather ? (1 - s.feather / 2) * (1 - s.feather / 2) : 1;
-        const additive = layer.blend === "lighter" || layer.blend === "screen";
-        const glow = soft && additive;
-        const reachX = glow ? halfX * GLOW_SPREAD : halfX;
-        const reachY = glow ? halfY * GLOW_SPREAD : halfY;
-        const c0 = Math.max(0, Math.floor((centerX - reachX) / cellW));
-        const c1 = Math.min(cols - 1, Math.floor((centerX + reachX) / cellW));
-        const r0 = Math.max(0, Math.floor((centerY - reachY) / cellH));
-        const r1 = Math.min(rows - 1, Math.floor((centerY + reachY) / cellH));
+        const c0 = Math.max(0, Math.floor((centerX - halfX) / cellW));
+        const c1 = Math.min(cols - 1, Math.floor((centerX + halfX) / cellW));
+        const r0 = Math.max(0, Math.floor((centerY - halfY) / cellH));
+        const r1 = Math.min(rows - 1, Math.floor((centerY + halfY) / cellH));
         const inkWeight = (s.kind === "text" || s.kind === "emoji" || s.kind === "textBlock" ? 0.55 : 1) * (s.kind === "textBlock" ? textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1) : 1);
-        const byArea = s.kind === "rect" || s.kind === "bar";
+        const byArea = s.kind === "rect" || s.kind === "bar" || s.kind === "text" || s.kind === "emoji" || s.kind === "textBlock";
         for (let r = r0; r <= r1; r++) {
           const fy = byArea ? Math.max(0, Math.min((r + 1) * cellH, centerY + halfY) - Math.max(r * cellH, centerY - halfY)) / cellH : 1;
           if (fy <= 0) continue;
           for (let c = c0; c <= c1; c++) {
-            const dx = (c + 0.5) * cellW - centerX;
-            const dy = (r + 0.5) * cellH - centerY;
             if (circular) {
-              const d = Math.sqrt(dx * dx + dy * dy);
-              const reach = glow ? reachX : halfX;
-              if (d > reach + Math.min(cellW, cellH) / 2) continue;
-              if (s.kind === "ring") {
-                const strokeW = (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale;
-                if (d < halfX - strokeW) continue;
-              }
-              let wgt;
-              if (glow) {
-                const core = halfX;
-                if (d <= core) wgt = 1;
-                else {
-                  const f = Math.max(0, 1 - (d - core) / Math.max(reachX - core, 1e-6));
-                  wgt = f * f;
-                }
-              } else {
-                wgt = soft ? Math.max(0.1, 1 - d / Math.max(halfX, 1e-6)) : 1;
-              }
+              const inner = s.kind === "ring" ? Math.max(0, halfX - (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale) : 0;
+              const wgt = discCellInk(centerX, centerY, halfX, inner, soft, c * cellW, r * cellH, cellW, cellH);
+              if (wgt <= 0) continue;
               compose(r * cols + c, lum, a * wgt * shapeWeight, layer.blend);
             } else if (byArea) {
               const fx = Math.max(0, Math.min((c + 1) * cellW, centerX + halfX) - Math.max(c * cellW, centerX - halfX)) / cellW;
-              if (fx > 0) compose(r * cols + c, lum, a * shapeWeight * fx * fy, layer.blend);
+              if (fx > 0) compose(r * cols + c, lum, a * inkWeight * shapeWeight * fx * fy, layer.blend);
             } else {
               compose(r * cols + c, lum, a * inkWeight * shapeWeight, layer.blend);
             }
@@ -5919,9 +7322,8 @@ function luminanceGrid(spec, opts = {}) {
       }
       if (layer.links) {
         const positions = entities.map((e) => posOf(scene, e, tPass));
-        const maxDistPx = layer.links.maxDist * scale;
         const motionWraps = ["drift", "rise", "wander"].includes(layer.motion.type);
-        const edges = linkEdges(layer.links, positions, maxDistPx, layer.wrap !== false && motionWraps, w, h);
+        const edges = linkEdges(layer.links, positions, linkMaxDistPx(layer.links, scale), layer.wrap !== false && motionWraps, w, h);
         const la = Math.min(1, (layer.links.alpha ?? 0.6) * lifeA);
         const lum = layer.links.color ? hexLuma(layer.links.color) : 0.7;
         const defaultWidth = scale === 1 ? 1 : 1 / LIMITS.referenceViewport;
@@ -6062,8 +7464,7 @@ function textSprites(spec, opts = {}) {
     }
     if (layer.sprite.kind !== "text") return;
     const s = layer.sprite;
-    const m = s.font ? /(\d+(?:\.\d+)?)px/.exec(s.font) : null;
-    const sizePx = m ? Number(m[1]) : entities[0] ? sizeAt(entities[0], t) : 0;
+    const sizePx = textFontPx(s, entities[0] ? sizeAt(entities[0], t) : 0, fontScaleFor(spec, scene.w, scene.h));
     out.push({ layerIndex, key: layer.key, strings: [...s.strings], count: entities.length, sizePx: Math.round(sizePx) });
   });
   return out;
@@ -6083,6 +7484,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);
@@ -6126,20 +7563,25 @@ 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;
       } else if (s.kind === "text") {
-        const box = textBox(s, e, { x: 0, y: 0 });
+        const box = textBox(s, e, { x: 0, y: 0 }, fontScaleFor(spec, w, h), scale);
         entArea = box.halfX * 2 * box.halfY * 2 * 0.55;
       } else if (s.kind === "textBlock") {
         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;
@@ -6154,7 +7596,7 @@ function rawDominance(spec, opts = {}) {
     if (layer.links && entities.length > 1) {
       const positions = entities.map((e) => posOf(scene, e, t));
       const motionWraps = ["drift", "rise", "wander"].includes(layer.motion.type);
-      const edges = linkEdges(layer.links, positions, layer.links.maxDist * scale, layer.wrap !== false && motionWraps, w, h);
+      const edges = linkEdges(layer.links, positions, linkMaxDistPx(layer.links, scale), layer.wrap !== false && motionWraps, w, h);
       const la = (layer.links.alpha ?? 0.6) * lifeA;
       const defaultWidth = scale === 1 ? 1 : 1 / LIMITS.referenceViewport;
       const lw = (layer.links.width ?? defaultWidth) * scale;
@@ -6184,6 +7626,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;
@@ -6197,7 +7640,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++;
@@ -6254,17 +7698,36 @@ 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 (const e of entities) {
+      const sz = sizeAt(e, t);
+      const s = layer.sprite;
+      const a = alphaAt(e, t) * lifeA * onScreenFraction(scene, s, e, sz, k, t, paintRotation(spec, layer));
+      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);
@@ -6457,12 +7920,92 @@ function perceiveSequenceFrame(seq, T, opts = {}) {
   };
 }
 
+// src/flash-timeline.ts
+import { analyzeFlashes, srgbToLinear as srgbToLinear2 } from "@idle-screens/validator";
+var LUMA_PATH = /(^|\.)(opacity|alpha|color|colors|stops|bands|gradient|stroke|fill|background)(\.|$)|(^|\.)(sprite|parts?)$|^layers\.\d+$/;
+var MIN_BOUNDARIES = 7;
+var MAX_SAMPLES = 64;
+var MAX_TOTAL_SAMPLES = 512;
+var WINDOW = 1e3;
+function lumaKeyTimes(spec) {
+  const tl = spec.timeline;
+  if (!tl) return { times: [], lap: 0 };
+  const lap = tl.loop && tl.duration ? tl.duration : 0;
+  const bounds = [];
+  for (const [path, keys] of timelineTracks(spec)) {
+    if (!LUMA_PATH.test(path)) continue;
+    for (const k of keys) {
+      const dur = k.dur ?? DEFAULT_KEY_DUR;
+      bounds.push(k.t);
+      if (dur > 0) bounds.push(k.t + dur);
+    }
+  }
+  return { times: [...new Set(lap ? [...bounds, ...bounds.map((b) => b + lap)] : bounds)].sort((a, b) => a - b), lap };
+}
+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 { times, lap } = lumaKeyTimes(spec);
+  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;
+  for (const w of dense) {
+    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 };
+      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/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;
+var CALM_MAX_SPIN = 90;
+var NEAR_FLASH_MAX_BOUNDARIES = 10;
 function edgeAnchored(range) {
   if (!range) return false;
   const [a, b] = range;
@@ -6470,6 +8013,7 @@ function edgeAnchored(range) {
 }
 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;
@@ -6496,7 +8040,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({
@@ -6544,13 +8088,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) {
@@ -6579,7 +8127,10 @@ 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") {
@@ -6608,8 +8159,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     }
     if (layer.links) {
       const positions = entities.map((e) => positionAt(e, 0, w, h));
-      const maxDistPx = layer.links.maxDist * scale;
-      const edges = linkEdges(layer.links, positions, maxDistPx, layer.wrap !== false, w, h);
+      const edges = linkEdges(layer.links, positions, linkMaxDistPx(layer.links, scale), layer.wrap !== false, w, h);
       const defaultWidth = scale === 1 ? 1 : 1 / LIMITS.referenceViewport;
       const lwPx = (layer.links.width ?? defaultWidth) * scale;
       const la = layer.links.alpha ?? 1;
@@ -6662,15 +8212,39 @@ 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`
+    });
+  }
   for (let li = 0; li < spec.layers.length; li++) {
     if (hidden?.[li]) continue;
     const layer = spec.layers[li];
     if (!layer.links || layer.links.mode === "chain") continue;
     const entities = allEntities[li];
     const positions = entities.map((e) => positionAt(e, 0, w, h));
-    const maxDist = layer.links.maxDist * scale;
-    const pairs = linkPairs(positions, layer.links.k, maxDist, layer.wrap !== false, w, h);
-    const maxPossible = Math.min(entities.length * layer.links.k, entities.length * (entities.length - 1) / 2);
+    const k = layer.links.k ?? 1;
+    const pairs = linkPairs(positions, k, linkMaxDistPx(layer.links, scale), layer.wrap !== false, w, h);
+    const maxPossible = Math.min(entities.length * k, entities.length * (entities.length - 1) / 2);
     if (maxPossible > 0 && pairs.length / maxPossible < 0.1) {
       warnings.push({
         path: `layers[${li}].links`,
@@ -6729,9 +8303,13 @@ 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] ?? "";
@@ -6853,20 +8431,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 = [];
@@ -6889,6 +8481,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++) {
@@ -6916,38 +8523,68 @@ 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);
       const dx = pt.x - c.x;
       const dy = pt.y - c.y;
-      let inside = false;
-      if (sp.kind === "circle") inside = Math.hypot(dx, dy) <= e.size / 2;
+      let inside2 = false;
+      if (sp.kind === "circle") inside2 = Math.hypot(dx, dy) <= e.size / 2;
       else if (sp.kind === "rect") {
         const rot = ((e.rotate ?? 0) % Math.PI + Math.PI) % Math.PI;
         const quarter = Math.abs(rot - Math.PI / 2) < 0.01;
         if (rot > 0.01 && rot < Math.PI - 0.01 && !quarter) continue;
         const hx = (quarter ? e.size2 ?? e.size : e.size) / 2;
         const hy = (quarter ? e.size : e.size2 ?? e.size) / 2;
-        inside = Math.abs(dx) <= hx && Math.abs(dy) <= hy;
+        inside2 = Math.abs(dx) <= hx && Math.abs(dy) <= hy;
       } else {
         if (e.rotate) continue;
-        inside = pointInPolygon(dx, dy, polygonPoints(sp, e.size / 2));
+        inside2 = pointInPolygon(dx, dy, polygonPoints(sp, e.size / 2));
       }
-      if (!inside) continue;
+      if (!inside2) continue;
       plate = sourceOverPlate(plate, hexRgb(hex), Math.min(1, e.alpha * a));
       covered = true;
     }
@@ -6955,13 +8592,13 @@ function groundUnder(spec, allEntities, li, hidden, pt, w, h) {
   return covered ? { rgb: plate, luma: 0.2126 * plate.r + 0.7152 * plate.g + 0.0722 * plate.b } : null;
 }
 function pointInPolygon(x, y, pts) {
-  let inside = false;
+  let inside2 = false;
   for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
     const a = pts[i];
     const b = pts[j];
-    if (a.y > y !== b.y > y && x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+    if (a.y > y !== b.y > y && x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x) inside2 = !inside2;
   }
-  return inside;
+  return inside2;
 }
 function entityReachesBox(e, r, box, w, h) {
   if (e.motion === "static") {
@@ -6981,7 +8618,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;
@@ -7113,10 +8750,10 @@ function describeScene(spec, options = {}) {
       let connectedComponents = null;
       let isolatedNodes = null;
       if (layer.links) {
-        const maxDist = layer.links.maxDist * scale;
-        const pairs = linkPairs(positions, layer.links.k, maxDist, layer.wrap !== false, w, h);
+        const n = entities.length;
+        const pairs = linkEdges(layer.links, positions, linkMaxDistPx(layer.links, scale), layer.wrap !== false, w, h).map(({ i, j }) => [i, j]);
         linksDrawn = pairs.length;
-        linksExpected = Math.min(entities.length * layer.links.k, entities.length * (entities.length - 1) / 2);
+        linksExpected = layer.links.mode === "chain" ? Math.max(0, n - 1) + (layer.links.closed && n > 2 ? 1 : 0) : Math.min(n * (layer.links.k ?? 1), n * (n - 1) / 2);
         const parent = Array.from({ length: entities.length }, (_, i) => i);
         const find = (x) => {
           while (parent[x] !== x) {
@@ -9617,6 +11254,7 @@ export {
   LIMITS,
   LOBBY_TALK_SPEC,
   MATRIX_RAIN_SPEC,
+  MAX_PATH_POINTS,
   MURMUR_SPEC,
   NOSTALGHIA_CANDLE_SPEC,
   ORRERY_SPEC,
@@ -9643,6 +11281,7 @@ export {
   adviseSequence,
   adviseSpec,
   alphaAt,
+  applyDeltasShared,
   applyDeltasToSpec,
   assertValidSequence,
   assertValidSpec,
@@ -9651,6 +11290,7 @@ export {
   bedRenderSeed,
   breakTextBlock,
   buildEntities,
+  buriedAreaOf,
   canMorph,
   canWrapMorph,
   canonicalSpecPath,
@@ -9672,6 +11312,7 @@ export {
   fieldRgbAt,
   fieldSampleTime,
   finishStrength,
+  flattenPath,
   grainOffset,
   grainTilePixels,
   graphemeClusters,
@@ -9679,12 +11320,15 @@ export {
   headingAt,
   hexToRgb255,
   ignoredPropertyPaths,
+  isPathPolygon,
   latticeHash,
   layerCohesion,
+  lerpPathD,
   lerpSpec,
   lerpValue,
   lifeAlphaAt,
   linkEdges,
+  linkMaxDistPx,
   linkPairs,
   luminanceGrid,
   manifestFor,
@@ -9693,6 +11337,8 @@ export {
   motionStats,
   nextKeyAfter,
   normalizeSeed,
+  pathFrame,
+  pathParts,
   perceiveScene,
   perceiveSequenceFrame,
   pickScreenOp,
@@ -9726,6 +11372,7 @@ export {
   textStringsDiffer,
   textStringsOf,
   textWidthEm,
+  timelineFlashReport,
   timelineLocalTime,
   timelineSampleTimes,
   timelineSampleTimesAfter,