@idle-screens/schema 3.12.0 → 3.13.0

package/dist/index.js

@@ -279,11 +279,21 @@ function lerpValue(from, to, k, specRoot = false, rootKey) {
   const walk = (a, b, key, root = false) => {
     if (typeof a === "number" && typeof b === "number") {
       const v = a + (b - a) * kk;
-      return key === "count" ? Math.max(1, Math.round(v)) : v;
+      if (key === "count") return Math.max(1, Math.round(v));
+      if (key === "octaves") return Math.round(v);
+      if (key === "quantize") {
+        const q = Math.round(v);
+        return q < 2 ? 0 : q;
+      }
+      return v;
     }
     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));
     }
@@ -300,6 +310,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];
@@ -356,7 +393,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)) : []
@@ -668,6 +705,654 @@ 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 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);
@@ -713,7 +1398,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"]);
@@ -853,6 +1539,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;
@@ -1226,10 +1929,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");
@@ -1470,6 +2183,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);
@@ -1726,6 +2467,58 @@ 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;
+function validatePathPiece(piece, path, err, warn) {
+  if (typeof piece.path !== "string" || piece.path.length === 0 || piece.path.length > 65536) {
+    err(`${path}.path`, "must be an SVG path d string (1..65536 chars) in the -1..1 unit box");
+  } else {
+    const flat = flattenPath(piece.path, piece.fillRule ?? "auto");
+    const filled = piece.fill !== false;
+    if (flat.error) err(`${path}.path`, `not a usable path: ${flat.error}`);
+    else if (filled && flat.points.length < 3) err(`${path}.path`, "must enclose an area (at least 3 points), or set fill: false and a stroke for line art");
+    else if (!filled && flat.lines.length === 0) err(`${path}.path`, "must draw at least one line (2+ points)");
+    else if (flat.points.length > MAX_PATH_POINTS) err(`${path}.path`, `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}`);
+    else if ([...flat.points, ...flat.lines.flatMap((l) => l.points)].some(([x, y]) => Math.abs(x) > 1.0001 || Math.abs(y) > 1.0001)) err(`${path}.path`, "must stay inside the -1..1 unit box (curves included)");
+  }
+  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)`);
@@ -1922,110 +2715,6 @@ ${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 featherAlphas(steps, additive) {
-  const out = [];
-  for (let k = 1; k <= steps; k++) out.push(additive ? 1 / steps : 1 / (steps - k + 1));
-  return out;
-}
-var FEATHER_STEPS = 6;
-
 // src/simulate.ts
 function entityScales(spec, w, h) {
   const scale = spec.units === "px" ? 1 : Math.min(w, h);
@@ -2547,9 +3236,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++) {
@@ -2563,7 +3256,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);
@@ -2577,7 +3270,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)
@@ -3088,6 +3781,79 @@ function screen(fp, pat, alpha, off, w, h) {
   p.restore();
 }
 
+// src/trail.ts
+function trailFillBudget(layerCount) {
+  return Math.max(4, Math.min(48, Math.floor(240 / Math.max(1, layerCount))));
+}
+function trailEchoes(trail, t, headAlpha, headSize, posAt, w, h, wrap2, fillBudget, minAlpha = 0, additive = false) {
+  const fade = trail.fade ?? 1;
+  const n = Math.min(Math.ceil(trail.length / 50), LIMITS.maxTrailSamples);
+  const alphaAtK = (k) => headAlpha * (1 - k * fade);
+  const radiusAtK = (k) => headSize / 2 * (1 - k * 0.7);
+  const jumps = (a, b) => wrap2 && (Math.abs(b.x - a.x) > w / 2 || Math.abs(b.y - a.y) > h / 2);
+  const head = posAt(t);
+  const base = [];
+  let prev = head;
+  for (let s = 1; s <= n; s++) {
+    const k = s / n;
+    const pastT = t - k * trail.length;
+    if (pastT < 0) break;
+    const pos = posAt(pastT);
+    if (jumps(prev, pos)) break;
+    prev = pos;
+    const a = alphaAtK(k);
+    if (a <= minAlpha) break;
+    const r = radiusAtK(k);
+    if (r < 0.2) break;
+    base.push({ t: pastT, x: pos.x, y: pos.y, k, alpha: a, r });
+  }
+  if (base.length === 0) return base;
+  const need = [];
+  let total = 0;
+  for (let i = 0; i < base.length; i++) {
+    const a = i === 0 ? head : base[i - 1];
+    const b = base[i];
+    const d = Math.hypot(b.x - a.x, b.y - a.y);
+    const m = d > b.r ? Math.ceil(d / b.r) - 1 : 0;
+    need.push(m);
+    total += m;
+  }
+  if (total === 0) return base;
+  const scale = total > fillBudget ? fillBudget / total : 1;
+  const out = [];
+  let last = head;
+  for (let i = 0; i < base.length; i++) {
+    const b = base[i];
+    const m = Math.floor(need[i] * scale);
+    if (m === 0) {
+      out.push(b);
+      last = b;
+      continue;
+    }
+    const a = i === 0 ? head : base[i - 1];
+    const spacing = Math.hypot(b.x - a.x, b.y - a.y) / (m + 1);
+    const share = (alpha, r) => {
+      const k = Math.min(1, spacing / (2 * r));
+      return additive ? alpha * k : 1 - Math.pow(1 - Math.min(1, alpha), k);
+    };
+    const t0 = i === 0 ? t : base[i - 1].t;
+    const k0 = i === 0 ? 0 : base[i - 1].k;
+    for (let j = 1; j <= m; j++) {
+      const f = j / (m + 1);
+      const tt = t0 + (b.t - t0) * f;
+      const k = k0 + (b.k - k0) * f;
+      const pos = posAt(tt);
+      if (jumps(last, pos)) continue;
+      last = pos;
+      const r = radiusAtK(k);
+      out.push({ t: tt, x: pos.x, y: pos.y, k, alpha: share(alphaAtK(k), r), r });
+    }
+    out.push({ ...b, alpha: share(b.alpha, b.r) });
+    last = b;
+  }
+  return out;
+}
+
 // src/compile.ts
 var DEFAULT_STEER_DUR = 1e3;
 function applyRetainedDeltas(spec, deltas) {
@@ -3183,6 +3949,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;
@@ -3285,6 +4090,29 @@ var SpecInstance = class {
   fieldShortSide;
   /** The `field` background's cached raster; null until a field is first painted. */
   field = null;
+  featherWhite = /* @__PURE__ */ new Map();
+  /** Per-entity pre-rendered feathered rects (see `blitFeather`), and the device pixels they hold. */
+  featherBlits = /* @__PURE__ */ new WeakMap();
+  featherBlitPx = 0;
+  featherBlitN = 0;
+  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
    * visible canvas plus the cached screen tiles. When set, `this.canvas` is
@@ -3449,36 +4277,81 @@ var SpecInstance = class {
     const trail = built.layer.trail;
     if (!trail) return;
     const { ctx, w, h } = this;
-    const fade = trail.fade ?? 1;
-    const n = Math.min(Math.ceil(trail.length / 50), LIMITS.maxTrailSamples);
     const headAlpha = alphaAt(e, t) * lifeA;
     const headSize = sizeAt(e, t);
     const sprite = built.layer.sprite;
+    const shaped = isShapedSprite(sprite) && sprite.kind !== "circle";
+    const isSoft = sprite.kind === "circle" && !!sprite.soft;
+    const hardCircle = sprite.kind === "circle" && !sprite.soft;
+    const ribbon = hardCircle && this.ribbonAllowed(built);
+    const posAt = (pt) => this.entityPos(e, pt, parentE);
+    const fill = shaped || hardCircle ? 0 : trailFillBudget(built.entities.length);
+    const echoes = trailEchoes(trail, t, headAlpha, headSize, posAt, w, h, built.layer.wrap !== false, fill, 0, built.layer.blend === "lighter");
+    if (echoes.length === 0) return;
+    const head = posAt(t);
+    if (hardCircle) {
+      const rb = this.ribbonBudget.get(built);
+      let prev = head;
+      let r0 = headSize / 2;
+      for (const ec of echoes) {
+        rb.area += Math.hypot(ec.x - prev.x, ec.y - prev.y) * (r0 + ec.r);
+        prev = ec;
+        r0 = ec.r;
+      }
+    }
+    if (shaped) {
+      for (const ec of echoes) this.drawEntity(built, e, ec.t, 1, parentE, void 0, { x: ec.x, y: ec.y, size: ec.r * 2, alpha: ec.alpha });
+      return;
+    }
     const resolvedColor = isShapedSprite(sprite) ? sprite.colors?.[e.colorIndex] ?? sprite.color : sprite.kind === "text" || sprite.kind === "textBlock" ? sprite.color ?? "#e6e8ef" : "#e6e8ef";
-    const isSoft = sprite.kind === "circle" && sprite.soft;
-    const wrap2 = built.layer.wrap !== false;
-    const head = this.entityPos(e, t, parentE);
-    let prevX = head.x;
-    let prevY = head.y;
-    for (let s = 1; s <= n; s++) {
-      const k = s / n;
-      const pastT = t - k * trail.length;
-      if (pastT < 0) break;
-      const pos = this.entityPos(e, pastT, parentE);
-      if (wrap2) {
-        const dx = pos.x - prevX;
-        const dy = pos.y - prevY;
-        if (Math.abs(dx) > w / 2 || Math.abs(dy) > h / 2) break;
-      }
-      prevX = pos.x;
-      prevY = pos.y;
-      const a = headAlpha * (1 - k * fade);
-      if (a <= 0) break;
-      const r = headSize / 2 * (1 - k * 0.7);
-      if (r < 0.2) break;
-      ctx.globalAlpha = a;
+    if (ribbon) {
+      const pts = [head];
+      const radii = [headSize / 2];
+      const alphas = [headAlpha];
+      let prevT = t;
+      for (const ec of echoes) {
+        const p0 = pts[pts.length - 1];
+        const r0 = radii[radii.length - 1];
+        const a0 = alphas[alphas.length - 1];
+        const sub = Math.max(1, Math.min(8, Math.ceil(Math.hypot(ec.x - p0.x, ec.y - p0.y) / 12)));
+        for (let j = 1; j < sub; j++) {
+          const f = j / sub;
+          pts.push(posAt(prevT + (ec.t - prevT) * f));
+          radii.push(r0 + (ec.r - r0) * f);
+          alphas.push(a0 + (ec.alpha - a0) * f);
+        }
+        pts.push(ec);
+        radii.push(ec.r);
+        alphas.push(ec.alpha);
+        prevT = ec.t;
+      }
+      const { left, right } = ribbonSides(pts, radii);
+      ctx.fillStyle = resolvedColor;
+      const tol = Math.max(4e-3, headAlpha * 0.04);
+      let from = 0;
+      while (from < pts.length - 1) {
+        const a0 = alphas[from + 1];
+        let to = from + 1;
+        let sum = a0;
+        while (to < pts.length - 1 && Math.abs(alphas[to + 1] - a0) <= tol) {
+          sum += alphas[to + 1];
+          to++;
+        }
+        ctx.globalAlpha = sum / (to - from);
+        ctx.beginPath();
+        ctx.moveTo(left[from].x, left[from].y);
+        for (let i = from + 1; i <= to; i++) ctx.lineTo(left[i].x, left[i].y);
+        for (let i = to; i >= from; i--) ctx.lineTo(right[i].x, right[i].y);
+        ctx.closePath();
+        ctx.fill();
+        from = to;
+      }
+      return;
+    }
+    for (const ec of echoes) {
+      ctx.globalAlpha = ec.alpha;
       if (isSoft) {
-        const g = ctx.createRadialGradient(pos.x, pos.y, 0, pos.x, pos.y, r);
+        const g = ctx.createRadialGradient(ec.x, ec.y, 0, ec.x, ec.y, ec.r);
         g.addColorStop(0, resolvedColor);
         g.addColorStop(0.35, hexToRgba(resolvedColor, 0.75));
         g.addColorStop(1, hexToRgba(resolvedColor, 0));
@@ -3487,18 +4360,473 @@ var SpecInstance = class {
         ctx.fillStyle = resolvedColor;
       }
       ctx.beginPath();
-      ctx.arc(pos.x, pos.y, r, 0, Math.PI * 2);
+      ctx.arc(ec.x, ec.y, ec.r, 0, Math.PI * 2);
       ctx.fill();
     }
   }
-  drawEntity(built, e, t, lifeA, parentE, paint) {
+  /**
+   * Whether this layer's hard-circle trails draw as ribbons this frame. A
+   * ribbon paints its trail's whole length, so a layer of many fast, long
+   * trails can paint far more pixels than its dots did — under `lighter` on
+   * a CPU rasteriser that was 2.4× the frame time (60 trails, 3 s, 0.4/s).
+   * Past a tenth of the viewport's area in ribbon (measured on the
+   * previous frame) the layer falls back to the time-sample discs it always
+   * drew; it returns to ribbons below 70 % of that, so a layer near the line
+   * does not flicker between the two.
+   */
+  ribbonAllowed(built) {
+    let rb = this.ribbonBudget.get(built);
+    if (!rb) {
+      rb = { seq: this.paintSeq, area: 0, ribbon: true };
+      this.ribbonBudget.set(built, rb);
+    }
+    if (rb.seq !== this.paintSeq) {
+      const budget = 0.1 * this.w * this.h;
+      if (rb.ribbon && rb.area > budget) rb.ribbon = false;
+      else if (!rb.ribbon && rb.area < 0.7 * budget) rb.ribbon = true;
+      rb.seq = this.paintSeq;
+      rb.area = 0;
+    }
+    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);
+      canvas.width = n;
+      canvas.height = n;
+      const c = canvas.getContext("2d");
+      return c ? { canvas, ctx: c } : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * A feathered rect from a per-entity bitmap of it, pre-rendered at device
+   * resolution with its rotation baked in, copied 1:1 at a whole-pixel
+   * offset. A smooth falloff is a sampled image draw — on a CPU rasteriser
+   * (a Raspberry Pi wall) ~3× the six flat fills it replaced, ~10× when
+   * rotated and stretched — while a 1:1 integer copy costs about one flat
+   * fill. The bitmap is rebuilt only when the rect's size, rotation or
+   * feather changes (in device pixels, to a quarter pixel / 0.06°), and
+   * re-tinted (one copy + one flat fill) only when its colour changes, so a
+   * drifting block or a colour glide stays cheap. A rect whose shape
+   * changes every frame (`grow`, `spin`), a canvas under a rotating or
+   * mirroring transform, or a scene past the 8 Mpx cache budget draws the
+   * stretched mask directly instead. Returns false when it did not draw.
+   */
+  blitFeather(e, p, sz, rh, rot, color2, feather) {
+    const ctx = this.ctx;
+    const m = typeof ctx.getTransform === "function" ? ctx.getTransform() : null;
+    if (!m || m.b !== 0 || m.c !== 0 || m.a <= 0 || m.d <= 0) return false;
+    const cos = Math.abs(Math.cos(rot));
+    const sin = Math.abs(Math.sin(rot));
+    const bw = Math.ceil((cos * sz + sin * rh) * m.a) + 2;
+    const bh = Math.ceil((sin * sz + cos * rh) * m.d) + 2;
+    const shapeKey = `${feather}|${Math.round(sz * m.a * 4)}|${Math.round(rh * m.d * 4)}|${Math.round(rot * 1e3)}|${bw}x${bh}`;
+    let b = this.featherBlits.get(e);
+    if (!b || b.shapeKey !== shapeKey) {
+      if (b) {
+        if (b.seenKey !== shapeKey) {
+          b.seenKey = shapeKey;
+          b.seenAt = this.paintSeq;
+        }
+        if (b.seenAt === this.paintSeq) return false;
+      }
+      const px = bw * bh;
+      const reuse = b && b.w === bw && b.h === bh;
+      if (!reuse && this.featherBlitPx + px - (b ? b.w * b.h : 0) > 8e6) return false;
+      const white = this.featherWhite.get(feather);
+      if (!white) return false;
+      const wc = reuse ? b.white : this.makeCanvas(1);
+      const tc = reuse ? b.tint : this.makeCanvas(1);
+      if (!wc || !tc) return false;
+      if (!reuse) {
+        wc.canvas.width = bw;
+        wc.canvas.height = bh;
+        tc.canvas.width = bw;
+        tc.canvas.height = bh;
+        this.featherBlitPx += px - (b ? b.w * b.h : 0);
+      }
+      const w2 = wc.ctx;
+      w2.setTransform(1, 0, 0, 1, 0, 0);
+      w2.clearRect(0, 0, bw, bh);
+      w2.translate(bw / 2, bh / 2);
+      w2.scale(m.a, m.d);
+      if (rot) w2.rotate(rot);
+      w2.imageSmoothingEnabled = true;
+      w2.drawImage(white, -sz / 2, -rh / 2, sz, rh);
+      w2.setTransform(1, 0, 0, 1, 0, 0);
+      b = { shapeKey, w: bw, h: bh, white: wc, tint: tc, tintKey: "", tintAt: 0, stagger: this.featherBlitN++ % 8, seenKey: shapeKey, seenAt: this.paintSeq };
+      this.featherBlits.set(e, b);
+    }
+    if (b.tintKey !== color2 && (b.tintKey === "" || this.paintSeq - b.tintAt >= 8)) {
+      const t2 = b.tint.ctx;
+      t2.setTransform(1, 0, 0, 1, 0, 0);
+      t2.globalCompositeOperation = "copy";
+      t2.drawImage(b.white.canvas, 0, 0);
+      t2.globalCompositeOperation = "source-in";
+      t2.fillStyle = color2;
+      t2.fillRect(0, 0, b.w, b.h);
+      t2.globalCompositeOperation = "source-over";
+      b.tintKey = color2;
+      b.tintAt = this.paintSeq - (b.stagger ?? 0);
+      b.stagger = 0;
+    }
+    const cx = m.a * p.x + m.e;
+    const cy = m.d * p.y + m.f;
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.drawImage(b.tint.canvas, Math.round(cx - b.w / 2), Math.round(cy - b.h / 2));
+    ctx.restore();
+    return true;
+  }
+  /**
+   * A feathered rect's mask in `color`: FEATHER_MASK_SIZE² texels of
+   * `featherRamp(u) × featherRamp(v)`, drawn stretched to the rect with
+   * smoothing on, so the falloff is continuous at any size (X383).
+   *
+   * The ramp itself is built ONCE per feather (a white alpha mask, the only
+   * per-pixel work). A colour is a cheap tint of it — clear, draw the mask,
+   * `source-in` fill — into a pooled canvas, cached per colour × feather.
+   * A colour glide or a palette larger than the pool re-tints a pooled
+   * canvas (three GPU draws) rather than rebuilding pixels in JS.
+   */
+  featherMask(color2, feather) {
+    const key = `${color2}|${feather}`;
+    const hit = this.featherTints.get(key);
+    if (hit) {
+      this.featherTints.delete(key);
+      this.featherTints.set(key, hit);
+      return hit.canvas;
+    }
+    const N = FEATHER_MASK_SIZE;
+    let white = this.featherWhite.get(feather);
+    if (!white) {
+      const made = this.makeCanvas(N);
+      if (!made) return null;
+      const img = made.ctx.createImageData(N, N);
+      const data = img.data;
+      const ramp = [];
+      for (let i = 0; i < N; i++) ramp.push(featherRamp((i + 0.5) / N, feather));
+      let o = 0;
+      for (let y = 0; y < N; y++) {
+        const ry = ramp[y];
+        for (let x = 0; x < N; x++) {
+          data[o++] = 255;
+          data[o++] = 255;
+          data[o++] = 255;
+          data[o++] = Math.round(255 * ry * ramp[x]);
+        }
+      }
+      made.ctx.putImageData(img, 0, 0);
+      if (this.featherWhite.size >= 8) this.featherWhite.delete(this.featherWhite.keys().next().value);
+      white = made.canvas;
+      this.featherWhite.set(feather, white);
+    }
+    let slot = null;
+    if (this.featherTints.size >= 48) {
+      const oldest = this.featherTints.keys().next().value;
+      slot = this.featherTints.get(oldest);
+      this.featherTints.delete(oldest);
+    } else {
+      slot = this.makeCanvas(N);
+      if (!slot) return null;
+    }
+    const tctx = slot.ctx;
+    tctx.globalCompositeOperation = "copy";
+    tctx.drawImage(white, 0, 0);
+    tctx.globalCompositeOperation = "source-in";
+    tctx.fillStyle = color2;
+    tctx.fillRect(0, 0, N, N);
+    tctx.globalCompositeOperation = "source-over";
+    this.featherTints.set(key, slot);
+    return slot.canvas;
+  }
+  /**
+   * Paint one entity at time `t`. `echo` paints a trail echo instead: the
+   * entity as it was at `t` (rotation, heading, values), but at the echo's
+   * position, size and alpha.
+   */
+  drawEntity(built, e, t, lifeA, parentE, paint, echo) {
     const { ctx } = this;
-    const p = this.entityPos(e, t, parentE);
+    const p = echo ? { x: echo.x, y: echo.y, flip: false } : this.entityPos(e, t, parentE);
     const sprite = paint?.sprite ?? built.layer.sprite;
-    const sz = sizeAt(e, t);
+    const sz = echo ? echo.size : sizeAt(e, t);
     const rot = rotationAt(e, t);
     const unitScale = this.effSpec.units === "px" ? 1 : Math.min(this.w, this.h);
-    ctx.globalAlpha = alphaAt(e, t) * lifeA * (paint?.alpha ?? 1);
+    ctx.globalAlpha = echo ? echo.alpha : alphaAt(e, t) * lifeA * (paint?.alpha ?? 1);
     if (sprite.kind === "ring") {
       const r = sz / 2;
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
@@ -3529,23 +4857,18 @@ var SpecInstance = class {
     if (sprite.kind === "rect") {
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
       const rh = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz;
+      const feather = sprite.feather ?? 0;
+      const mask = feather > 0 ? this.featherMask(resolvedColor, feather) : null;
+      if (mask && this.blitFeather(e, p, sz, rh, rot, resolvedColor, feather)) return;
       ctx.save();
       ctx.translate(p.x, p.y);
       if (rot) ctx.rotate(rot);
       ctx.fillStyle = resolvedColor;
-      const feather = sprite.feather ?? 0;
-      if (feather > 0) {
-        const base = ctx.globalAlpha;
-        const additive = built.layer.blend === "lighter";
-        const alphas = featherAlphas(FEATHER_STEPS, additive);
-        for (let j = 1; j <= FEATHER_STEPS; j++) {
-          const f = 1 - feather * (j - 1) / FEATHER_STEPS;
-          const fw = sz * f;
-          const fh = rh * f;
-          ctx.globalAlpha = base * alphas[j - 1];
-          ctx.fillRect(-fw / 2, -fh / 2, fw, fh);
-        }
-        ctx.globalAlpha = base;
+      if (mask) {
+        const prevSmooth = ctx.imageSmoothingEnabled;
+        ctx.imageSmoothingEnabled = true;
+        ctx.drawImage(mask, -sz / 2, -rh / 2, sz, rh);
+        ctx.imageSmoothingEnabled = prevSmooth;
       } else {
         ctx.fillRect(-sz / 2, -rh / 2, sz, rh);
       }
@@ -3569,24 +4892,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;
     }
@@ -3603,13 +4928,13 @@ var SpecInstance = class {
       ctx.lineCap = "round";
       ctx.lineJoin = "round";
       if (sprite.taper) {
-        for (let i = 1; i < pts.length; i++) {
-          ctx.lineWidth = Math.max(0.5, lw * strokeTaper((i - 0.5) / (pts.length - 1)));
-          ctx.beginPath();
-          ctx.moveTo(pts[i - 1].x, pts[i - 1].y);
-          ctx.lineTo(pts[i].x, pts[i].y);
-          ctx.stroke();
-        }
+        const outline = strokeOutline(pts, lw);
+        ctx.fillStyle = resolvedColor;
+        ctx.beginPath();
+        ctx.moveTo(outline[0].x, outline[0].y);
+        for (let i = 1; i < outline.length; i++) ctx.lineTo(outline[i].x, outline[i].y);
+        ctx.closePath();
+        ctx.fill();
       } else {
         ctx.lineWidth = lw;
         ctx.beginPath();
@@ -3825,9 +5150,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;
@@ -3844,7 +5169,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;
@@ -3863,6 +5188,7 @@ var SpecInstance = class {
    *  showing through — the ghosting smear. */
   paintFrame(t, bgAlpha) {
     const { ctx } = this;
+    this.paintSeq++;
     if (this.authored) this.resolveAuthored(t);
     if (!this.transparent) {
       ctx.globalAlpha = bgAlpha;
@@ -3870,39 +5196,213 @@ 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
    * viewport centre — or, with `origin: 'anchor'`, about `layer`'s own anchor
@@ -4774,6 +6274,27 @@ 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);
   }
@@ -4918,7 +6439,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];
@@ -4941,7 +6462,7 @@ function polyShape(cx, cy, raw) {
     cy,
     br,
     area,
-    contains: inside,
+    contains: inside2,
     /**
      * `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
@@ -4970,13 +6491,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;
           }
@@ -5098,7 +6619,6 @@ function seamsWorthWarning(layer, c, entityCount) {
 
 // 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;
@@ -5133,11 +6653,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 {
@@ -5183,7 +6710,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;
@@ -5216,30 +6760,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);
@@ -5300,42 +6866,50 @@ function luminanceGrid(spec, opts = {}) {
     else if (blend === "multiply") cells[idx] = cur * (1 - a * (1 - lum));
     else cells[idx] = cur * (1 - a) + lum * a;
   };
-  const splatTrail = (layer, e, tPass, lifeA, alphaScale) => {
+  const splatTrail = (layer, e, tPass, lifeA, alphaScale, layerCount) => {
     const trail = layer.trail;
     if (!trail) return;
-    const fade = trail.fade ?? 1;
-    const n = Math.min(Math.ceil(trail.length / 50), LIMITS.maxTrailSamples);
-    const headAlpha = alphaAt(e, tPass) * lifeA;
+    const headAlpha = alphaAt(e, tPass) * lifeA * alphaScale;
     const headSize = sizeAt(e, tPass);
     const lum = spriteLuma(layer, e);
     const soft = layer.sprite.kind === "circle" && !!layer.sprite.soft;
-    const wrapOn = layer.wrap !== false;
-    const head = posOf(scene, e, tPass);
-    let prevX = head.x;
-    let prevY = head.y;
-    for (let s = 1; s <= n; s++) {
-      const k = s / n;
-      const pastT = tPass - k * trail.length;
-      if (pastT < 0) break;
-      const pos = posOf(scene, e, pastT);
-      if (wrapOn && (Math.abs(pos.x - prevX) > w / 2 || Math.abs(pos.y - prevY) > h / 2)) break;
-      prevX = pos.x;
-      prevY = pos.y;
-      const a = headAlpha * (1 - k * fade) * alphaScale;
-      if (a <= 4e-3) break;
-      const rad = headSize / 2 * (1 - k * 0.7);
-      if (rad < 0.2) break;
+    const echoes = trailEchoes(
+      trail,
+      tPass,
+      headAlpha,
+      headSize,
+      (pt) => posOf(scene, e, pt),
+      w,
+      h,
+      layer.wrap !== false,
+      // As the renderer: a shape echoes at its time samples only; circles fill
+      // (a hard circle's ribbon reads, on the coarse grid, as filled discs).
+      isShapedSprite(layer.sprite) && layer.sprite.kind !== "circle" ? 0 : trailFillBudget(layerCount),
+      4e-3,
+      layer.blend === "lighter"
+    );
+    for (const ec of echoes) {
+      const a = ec.alpha;
+      const rad = ec.r;
+      if (layer.sprite.kind === "polygon" && rad * 2 >= POLYGON_OUTLINE_CELLS * Math.min(cellW, cellH)) {
+        splatPolygonOutline(layer, layer.sprite, e, ec, rad * 2, Math.min(1, a), lum, ec.t);
+        continue;
+      }
+      const pos = ec;
       const c0 = Math.max(0, Math.floor((pos.x - rad) / cellW));
       const c1 = Math.min(cols - 1, Math.floor((pos.x + rad) / cellW));
       const r0 = Math.max(0, Math.floor((pos.y - rad) / cellH));
       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);
         }
       }
@@ -5346,17 +6920,12 @@ function luminanceGrid(spec, opts = {}) {
     const rot = rotationAt(e, tPass);
     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;
@@ -5367,34 +6936,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;
           }
-        } 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;
+          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)]);
+          }
+        }
+        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);
         }
-        if (wgt > 0) compose(r * cols + c, lum, a * Math.min(1, wgt), layer.blend);
       }
     }
   };
@@ -5403,14 +7035,14 @@ function luminanceGrid(spec, opts = {}) {
       const lifeA = layer.opacity === void 0 && layer.group === void 0 ? lifeAlphaAt(layer.life, tPass) : lifeAlphaAt(layer.life, tPass) * paintOpacity(spec, layer);
       if (lifeA <= 0) continue;
       for (const e of entities) {
-        splatTrail(layer, e, tPass, lifeA, alphaScale);
+        splatTrail(layer, e, tPass, lifeA, alphaScale, entities.length);
         const a = Math.min(1, alphaAt(e, tPass) * lifeA) * alphaScale;
         if (a <= 4e-3) continue;
         const lum = spriteLuma(layer, e);
         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;
         }
@@ -5464,7 +7096,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;
@@ -5491,45 +7123,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);
             }
@@ -5538,9 +7149,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;
@@ -5681,8 +7291,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;
@@ -5753,7 +7362,7 @@ function rawDominance(spec, opts = {}) {
         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);
@@ -5773,7 +7382,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;
@@ -6227,8 +7836,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;
@@ -6287,9 +7895,9 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     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`,
@@ -6354,7 +7962,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       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] ?? "";
-      textBoxes.push({ li, label, alpha, str, ...box });
+      textBoxes.push({ li, label, alpha, str, ...box, rawW: raw.x1 - raw.x0, rawH: raw.y1 - raw.y0 });
     }
   }
   const asFraction = (b) => ({
@@ -6409,6 +8017,45 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       });
     }
   }
+  const cellFlagged = /* @__PURE__ */ new Set();
+  for (let i = 0; i < textBoxes.length; i++) {
+    const a = textBoxes[i];
+    if (cellFlagged.has(a.li)) continue;
+    const layer = spec.layers[a.li];
+    const layout = layer.layout;
+    if (layout?.type !== "list" && layout?.type !== "table") continue;
+    for (let j = i + 1; j < textBoxes.length; j++) {
+      const b = textBoxes[j];
+      if (b.li !== a.li) continue;
+      const ix = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0);
+      const iy = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0);
+      if (ix <= 0 || iy <= 0) continue;
+      const smaller = Math.min((a.x1 - a.x0) * (a.y1 - a.y0), (b.x1 - b.x0) * (b.y1 - b.y0));
+      if (smaller <= 0 || ix * iy / smaller <= 0.1) continue;
+      cellFlagged.add(a.li);
+      const cells = textBoxes.filter((x) => x.li === a.li);
+      const dflt = scale === 1 ? LIMITS.defaultListGapPx : LIMITS.defaultListGap;
+      const g = layout.gap ?? dflt;
+      const gx = typeof g === "number" ? g : g.x ?? dflt;
+      const gy = typeof g === "number" ? g : g.y ?? dflt;
+      const cols = layout.type === "list" ? 1 : Math.max(1, Math.round(layout.columns));
+      const unitPx = (v) => scale === 1 ? v : v * scale;
+      const fromPx = (px) => scale === 1 ? Math.ceil(px) : Math.ceil(px / scale * 100) / 100;
+      const maxW = cells.reduce((m, c) => Math.max(m, c.rawW), 0);
+      const maxH = cells.reduce((m, c) => Math.max(m, c.rawH), 0);
+      const fixes = [];
+      const across = cols > 1 && maxW > unitPx(gx);
+      if (across) fixes.push(`its labels are up to ~${Math.round(maxW)}px wide against a ${Math.round(unitPx(gx))}px column pitch (gap${typeof g === "number" ? "" : ".x"} ${gx}) \u2014 raise gap${typeof g === "number" ? "" : ".x"} to \u2265 ${fromPx(maxW * 1.1)}`);
+      if (!across || maxH > unitPx(gy)) fixes.push(`rows are ~${Math.round(maxH)}px tall against a ${Math.round(unitPx(gy))}px row pitch (gap${typeof g === "number" ? "" : ".y"} ${gy}) \u2014 raise gap${typeof g === "number" ? "" : ".y"} to \u2265 ${fromPx(maxH * 1.1)}`);
+      warnings.push({
+        path: `layers[${a.li}].layout.gap`,
+        code: "layout-text-overlap",
+        message: `${a.label} cells overlap at ${w}\xD7${h}: a ${layout.type}'s \`gap\` is the pitch between cell anchors, not the space between cells; ${fixes.join("; and ")}, or shrink the text`,
+        boxes: [asFraction(a), asFraction(b)]
+      });
+      break;
+    }
+  }
   const readFlagged = /* @__PURE__ */ new Set();
   for (const b of textBoxes) {
     if (readFlagged.has(b.li)) continue;
@@ -6514,20 +8161,20 @@ function groundUnder(spec, allEntities, li, hidden, pt, w, h) {
       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;
     }
@@ -6535,13 +8182,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") {
@@ -6693,10 +8340,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) {
@@ -9197,6 +10844,7 @@ export {
   LIMITS,
   LOBBY_TALK_SPEC,
   MATRIX_RAIN_SPEC,
+  MAX_PATH_POINTS,
   MURMUR_SPEC,
   NOSTALGHIA_CANDLE_SPEC,
   ORRERY_SPEC,
@@ -9252,6 +10900,7 @@ export {
   fieldRgbAt,
   fieldSampleTime,
   finishStrength,
+  flattenPath,
   grainOffset,
   grainTilePixels,
   graphemeClusters,
@@ -9259,12 +10908,15 @@ export {
   headingAt,
   hexToRgb255,
   ignoredPropertyPaths,
+  isPathPolygon,
   latticeHash,
   layerCohesion,
+  lerpPathD,
   lerpSpec,
   lerpValue,
   lifeAlphaAt,
   linkEdges,
+  linkMaxDistPx,
   linkPairs,
   luminanceGrid,
   manifestFor,
@@ -9273,6 +10925,8 @@ export {
   motionStats,
   nextKeyAfter,
   normalizeSeed,
+  pathFrame,
+  pathParts,
   perceiveScene,
   perceiveSequenceFrame,
   pickScreenOp,