@idle-screens/schema 3.13.0 → 3.14.0

package/dist/index.js

@@ -255,6 +255,35 @@ function applyDeltasToSpec(spec, deltas) {
   }
   return copy;
 }
+function applyDeltasShared(spec, deltas) {
+  const out = { ...spec };
+  const copied = new WeakSet([out]);
+  for (const d of deltas) {
+    const cp = canonicalSpecPath(out, d.path);
+    if (!cp) continue;
+    const parts = cp.split(".");
+    let node = out;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const k = parts[i];
+      const child = node[k];
+      if (!child || typeof child !== "object") {
+        node = null;
+        break;
+      }
+      if (!copied.has(child)) {
+        const clone = Array.isArray(child) ? child.slice() : { ...child };
+        copied.add(clone);
+        node[k] = clone;
+      }
+      node = node[k];
+    }
+    if (node) {
+      const last = parts[parts.length - 1];
+      node[Array.isArray(node) ? Number(last) : last] = d.value;
+    }
+  }
+  return out;
+}
 var HEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
 function hexToRgb(hex) {
   const h = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
@@ -641,7 +670,7 @@ function evalTrack(keys, start, tt, leaf) {
   }
   return at(tt);
 }
-function resolveTimelineAt(spec, t) {
+function resolveTimelineAt(spec, t, shared = false) {
   const tl = spec.timeline;
   if (!tl) return spec;
   const base = withoutTimeline(spec);
@@ -653,7 +682,7 @@ function resolveTimelineAt(spec, t) {
     const start = tl.loop ? keys[keys.length - 1].value : readSpecPath(base, path);
     deltas.push({ t: 0, path, value: evalTrack(keys, start, tt, path.slice(path.lastIndexOf(".") + 1)) });
   }
-  return applyDeltasToSpec(base, deltas);
+  return shared ? applyDeltasShared(base, deltas) : applyDeltasToSpec(base, deltas);
 }
 function nextKeyAfter(spec, path, t) {
   const tl = spec.timeline;
@@ -934,6 +963,41 @@ function pathParts(s) {
   spriteParts.set(s, { key, parts });
   return parts;
 }
+function partInkArea(part, sx, sy, r) {
+  if (part.opacity <= 0) return { fill: 0, stroke: 0 };
+  const fill = part.fill ? polygonArea(part.flat.points.map(([x, y]) => ({ x: x * sx, y: y * sy }))) * part.opacity : 0;
+  let stroke = 0;
+  if (part.stroke && part.stroke.width > 0) {
+    for (const l of part.flat.lines) {
+      const pts = l.points.map(([x, y]) => ({ x: x * sx, y: y * sy }));
+      if (l.closed && pts.length > 1) pts.push(pts[0]);
+      stroke += pathLength(pts) * part.stroke.width * r;
+    }
+    stroke *= (part.stroke.opacity ?? 1) * part.opacity;
+  }
+  return { fill, stroke };
+}
+function gradientStopWeights(stops) {
+  const at = stops.map((st) => Math.min(1, Math.max(0, st.at)));
+  const order = at.map((_, i) => i).sort((a, b) => at[a] - at[b]);
+  const out = new Array(stops.length).fill(0);
+  order.forEach((i, rank) => {
+    const prev = rank > 0 ? at[order[rank - 1]] : null;
+    const next = rank < order.length - 1 ? at[order[rank + 1]] : null;
+    const a = at[i];
+    out[i] = (prev === null ? a : (a - prev) / 2) + (next === null ? 1 - a : (next - a) / 2);
+  });
+  const sum = out.reduce((x, y) => x + y, 0);
+  return sum > 0 ? out.map((x) => x / sum) : out.map(() => 1 / Math.max(1, stops.length));
+}
+function pathInkArea(s, sx, sy, r) {
+  let area = 0;
+  for (const part of pathParts(s)) {
+    const a = partInkArea(part, sx, sy, r);
+    area += a.fill + a.stroke;
+  }
+  return area;
+}
 function pathFrame(s, r, w, h) {
   const span = s.span ?? "box";
   const sx = span === "width" || span === "screen" ? w / 2 : r;
@@ -1456,7 +1520,7 @@ function validateSpec(spec) {
 }
 function ignoredPropertyPaths(spec) {
   if (!isObj(spec)) return [];
-  return (validateSpecCore(spec).warnings ?? []).filter((w) => w.code === "unknown-property" || w.code === "misplaced-property").map((w) => w.path.replace(/\[(\d+)\]/g, ".$1"));
+  return (validateSpecCore(spec, false).warnings ?? []).filter((w) => w.code === "unknown-property" || w.code === "misplaced-property").map((w) => w.path.replace(/\[(\d+)\]/g, ".$1"));
 }
 function validateSpecPaths(spec, paths) {
   const layers = /* @__PURE__ */ new Set();
@@ -1494,7 +1558,7 @@ function validateSpecPaths(spec, paths) {
   }
   return ok;
 }
-function validateSpecCore(spec) {
+function validateSpecCore(spec, checkApplied = true) {
   const errors = [];
   const warnings = [];
   const err = (path, message) => void errors.push({ path, message });
@@ -1563,7 +1627,7 @@ function validateSpecCore(spec) {
     });
     if (total > LIMITS.maxTotal) err("layers", `total entities ${total} exceeds cap ${LIMITS.maxTotal}`);
   }
-  if (spec.timeline !== void 0 && errors.length === 0) validateTimeline(spec, err, warn);
+  if (spec.timeline !== void 0 && errors.length === 0) validateTimeline(spec, err, warn, checkApplied);
   return { valid: errors.length === 0, errors, warnings };
 }
 function validateTransform(tf, path, err, warn, spec, anchorOk) {
@@ -1601,7 +1665,7 @@ function validateGroups(groups, err, warn, spec) {
     if (g.transform !== void 0) validateTransform(g.transform, `${p}.transform`, err, warn, spec, false);
   }
 }
-function validateTimeline(spec, errOuter, warn) {
+function validateTimeline(spec, errOuter, warn, checkApplied = true) {
   let failed = false;
   const err = (p, m) => {
     failed = true;
@@ -1655,20 +1719,22 @@ function validateTimeline(spec, errOuter, warn) {
     if (!ok || !cp) return;
     const t = key.t;
     latest = Math.max(latest, t);
-    const applied = applyDeltasToSpec(base, [{ t: 0, path: cp, value: key.value }]);
-    const r = validateSpecPaths(applied, [cp]) ? { valid: true, errors: [] } : validateSpec(applied);
-    if (!r.valid) {
-      for (const e of r.errors) err(`${p}.value`, `applied at '${key.path}' \u2192 ${e.path || "<root>"}: ${e.message}`);
-      return;
-    }
-    if (isObj(key.value) && cp.endsWith("transform")) {
-      const before = readSpecPath(base, cp);
-      const o0 = isObj(before) ? before.origin ?? "viewport" : "viewport";
-      const o1 = key.value.origin ?? "viewport";
-      if (o0 !== o1) warn(`${p}.value`, "timeline-origin-steps", `this key changes the transform's origin (${String(o0)} \u2192 ${String(o1)}): the pivot switches on the key's first frame, so the layer jumps \u2014 keep one origin per layer`);
-    }
-    if (structuralSignature(applied) !== baseSig) {
-      warn(`${p}.path`, "timeline-structural-key", `'${key.path}' is structural (placement, count, motion, size\u2026): the scene rebuilds at this key and entities re-seed \u2014 a pop, not a glide. Animate paint (colour, opacity, transform, polygon points) instead`);
+    if (checkApplied) {
+      const applied = applyDeltasShared(base, [{ t: 0, path: cp, value: key.value }]);
+      const r = validateSpecPaths(applied, [cp]) ? { valid: true, errors: [] } : validateSpec(structuredClone(applied));
+      if (!r.valid) {
+        for (const e of r.errors) err(`${p}.value`, `applied at '${key.path}' \u2192 ${e.path || "<root>"}: ${e.message}`);
+        return;
+      }
+      if (isObj(key.value) && cp.endsWith("transform")) {
+        const before = readSpecPath(base, cp);
+        const o0 = isObj(before) ? before.origin ?? "viewport" : "viewport";
+        const o1 = key.value.origin ?? "viewport";
+        if (o0 !== o1) warn(`${p}.value`, "timeline-origin-steps", `this key changes the transform's origin (${String(o0)} \u2192 ${String(o1)}): the pivot switches on the key's first frame, so the layer jumps \u2014 keep one origin per layer`);
+      }
+      if (structuralSignature(applied) !== baseSig) {
+        warn(`${p}.path`, "timeline-structural-key", `'${key.path}' is structural (placement, count, motion, size\u2026): the scene rebuilds at this key and entities re-seed \u2014 a pop, not a glide. Animate paint (colour, opacity, transform, polygon points) instead`);
+      }
     }
     const list = times.get(cp) ?? [];
     list.push(t);
@@ -1694,16 +1760,16 @@ function validateTimeline(spec, errOuter, warn) {
       if (wrapGap < minGap) err("timeline.keys", `keys on '${path}' at ${distinct[distinct.length - 1]} ms and ${distinct[0]} ms (next lap) are closer than ${minGap} ms across the loop wrap (flash safety)`);
     }
   }
-  if (failed) return;
+  if (failed || !checkApplied) return;
   const keyed = [...timelineTracks(spec).keys()];
   const seen = /* @__PURE__ */ new Set();
   for (const t of timelineSampleTimes(spec, true, 120)) {
-    const r = resolveTimelineAt(spec, t);
+    const r = resolveTimelineAt(spec, t, true);
     const state = JSON.stringify(keyed.map((p) => readSpecPath(r, p)));
     if (seen.has(state)) continue;
     seen.add(state);
     if (validateSpecPaths(r, keyed)) continue;
-    const e = validateSpec(r).errors[0];
+    const e = validateSpec(structuredClone(r)).errors[0];
     err("timeline", `at t = ${Math.round(t)} ms the keys combine into an invalid scene \u2014 ${e ? `${e.path || "<root>"}: ${e.message}` : "invalid"}`);
     return;
   }
@@ -2469,17 +2535,29 @@ function validateMotion(motion, path, err, warn, spec) {
 }
 var isPair = (v, lim = 2) => Array.isArray(v) && v.length === 2 && isNum(v[0]) && isNum(v[1]) && Math.abs(v[0]) <= lim && Math.abs(v[1]) <= lim;
 var MAX_PATH_PARTS = 256;
+var pathVerdicts = /* @__PURE__ */ new Map();
+var pathVerdictBytes = 0;
+function pathGeometryProblem(d, rule, filled) {
+  const key = `${rule}|${filled ? 1 : 0}|${d}`;
+  const hit = pathVerdicts.get(key);
+  if (hit !== void 0) return hit;
+  const flat = flattenPath(d, rule);
+  const inBox = ([x, y]) => Math.abs(x) <= 1.0001 && Math.abs(y) <= 1.0001;
+  const problem = flat.error ? `not a usable path: ${flat.error}` : filled && flat.points.length < 3 ? "must enclose an area (at least 3 points), or set fill: false and a stroke for line art" : !filled && flat.lines.length === 0 ? "must draw at least one line (2+ points)" : flat.points.length > MAX_PATH_POINTS ? `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}` : !flat.points.every(inBox) || !flat.lines.every((l) => l.points.every(inBox)) ? "must stay inside the -1..1 unit box (curves included)" : null;
+  if (pathVerdicts.size >= 1024 || pathVerdictBytes + key.length > 2e6) {
+    pathVerdicts.clear();
+    pathVerdictBytes = 0;
+  }
+  pathVerdicts.set(key, problem);
+  pathVerdictBytes += key.length;
+  return problem;
+}
 function validatePathPiece(piece, path, err, warn) {
   if (typeof piece.path !== "string" || piece.path.length === 0 || piece.path.length > 65536) {
     err(`${path}.path`, "must be an SVG path d string (1..65536 chars) in the -1..1 unit box");
   } else {
-    const flat = flattenPath(piece.path, piece.fillRule ?? "auto");
-    const filled = piece.fill !== false;
-    if (flat.error) err(`${path}.path`, `not a usable path: ${flat.error}`);
-    else if (filled && flat.points.length < 3) err(`${path}.path`, "must enclose an area (at least 3 points), or set fill: false and a stroke for line art");
-    else if (!filled && flat.lines.length === 0) err(`${path}.path`, "must draw at least one line (2+ points)");
-    else if (flat.points.length > MAX_PATH_POINTS) err(`${path}.path`, `flattens to ${flat.points.length} points; at most ${MAX_PATH_POINTS}`);
-    else if ([...flat.points, ...flat.lines.flatMap((l) => l.points)].some(([x, y]) => Math.abs(x) > 1.0001 || Math.abs(y) > 1.0001)) err(`${path}.path`, "must stay inside the -1..1 unit box (curves included)");
+    const problem = pathGeometryProblem(piece.path, piece.fillRule ?? "auto", piece.fill !== false);
+    if (problem) err(`${path}.path`, problem);
   }
   if (piece.fill !== void 0 && typeof piece.fill !== "boolean") err(`${path}.fill`, "must be a boolean");
   if (piece.fill === false && piece.stroke === void 0) err(`${path}.fill`, "fill: false draws nothing without a stroke");
@@ -3510,6 +3588,10 @@ function paintOpacity(spec, layer) {
   const g = groupOf(spec, layer);
   return g?.opacity === void 0 ? own : own * clamp01(g.opacity);
 }
+function paintRotation(spec, layer) {
+  const deg = (layer.transform?.rotate ?? 0) + (groupOf(spec, layer)?.transform?.rotate ?? 0);
+  return deg * Math.PI / 180;
+}
 function paintSize(spec, layer) {
   return transformSize(layer.transform) * transformSize(groupOf(spec, layer)?.transform);
 }
@@ -6253,6 +6335,7 @@ function compileSequence(spec) {
 
 // src/advise.ts
 import { createRng as createRng3 } from "@idle-screens/core";
+import { analyzeFlashes as analyzeFlashes2, srgbToLinear as srgbToLinear3 } from "@idle-screens/validator";
 
 // src/luma.ts
 function fieldRenderedRgbs(bg) {
@@ -6301,6 +6384,26 @@ function spriteLuma(layer, e) {
   if (s.kind === "text" || s.kind === "textBlock") return hexLuma(s.color ?? "#e6e8ef");
   return 0.75;
 }
+function spriteInks(layer, e) {
+  const s = layer.sprite;
+  if (s.kind === "polygon" && isPathPolygon(s)) {
+    const base = s.colors?.[e.colorIndex] ?? s.color;
+    const inks = [];
+    for (const part of pathParts(s)) {
+      if (part.opacity <= 0) continue;
+      if (part.fill) {
+        if (part.gradient) for (const st of part.gradient.stops) {
+          if ((st.opacity ?? 1) > 0) inks.push(st.color);
+        }
+        else inks.push(part.color ?? base);
+      }
+      if (part.stroke && part.stroke.width > 0 && (part.stroke.opacity ?? 1) > 0) inks.push(part.stroke.color);
+    }
+    return inks;
+  }
+  const hex = spriteHex(layer, e);
+  return hex === null ? null : [hex];
+}
 function spriteHex(layer, e) {
   const s = layer.sprite;
   if (isShapedSprite(s)) {
@@ -6416,6 +6519,23 @@ var WASH_ALPHA_MAX = 0.45;
 var COHESION_T = 5e3;
 var OUTLINE_SAMPLES = 24;
 var MAX_TRACED = 240;
+function discSamples(cx, cy, r, n) {
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  return Array.from({ length: n }, (_, i) => {
+    const rr = r * Math.sqrt((i + 0.5) / n);
+    return { x: cx + rr * Math.cos(i * golden), y: cy + rr * Math.sin(i * golden) };
+  });
+}
+function gridSamples(uw, vh, n, map) {
+  if (!(uw > 0) || !(vh > 0)) return [];
+  const nv = Math.min(n, Math.max(8, Math.round(Math.sqrt(n * vh / uw))));
+  const nu = Math.max(8, Math.round(n / nv));
+  const out = [];
+  for (let i = 0; i < nu; i++) {
+    for (let j = 0; j < nv; j++) out.push(map(((i + 0.5) / nu - 0.5) * uw, ((j + 0.5) / nv - 0.5) * vh));
+  }
+  return out;
+}
 var EDGE_INSET = 1e-4;
 function circleShape(cx, cy, r) {
   return {
@@ -6424,6 +6544,7 @@ function circleShape(cx, cy, r) {
     br: r,
     area: Math.PI * r * r,
     contains: (x, y) => (x - cx) * (x - cx) + (y - cy) * (y - cy) < r * r,
+    interior: (n) => discSamples(cx, cy, r, n),
     outline: (n) => Array.from({ length: n }, (_, i) => {
       const a = i / n * Math.PI * 2;
       const inner = r * (1 - EDGE_INSET);
@@ -6457,12 +6578,21 @@ function polyShape(cx, cy, raw) {
   const step = Math.min(br * EDGE_INSET, shortest * 0.25);
   const area = polygonArea(abs);
   if (!(area > 0)) return null;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of abs) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
   return {
     cx,
     cy,
     br,
     area,
     contains: inside2,
+    // Its bounding box's grid, kept to the cells inside the outline.
+    interior: (n) => gridSamples(x1 - x0, y1 - y0, n, (u, v) => ({ x: (x0 + x1) / 2 + u, y: (y0 + y1) / 2 + v })).filter((p) => inside2(p.x, p.y)),
     /**
      * `n` points spread along the perimeter by ARC LENGTH, not one share per
      * edge — a long skinny rectangle has two edges carrying almost all of its
@@ -6512,12 +6642,13 @@ function rectShape(cx, cy, halfW, halfH, rot) {
   const cos = Math.cos(rot);
   const sin = Math.sin(rot);
   const corner = (lx, ly) => ({ x: cx + lx * cos - ly * sin, y: cy + lx * sin + ly * cos });
-  return polyShape(cx, cy, [
+  const shape = polyShape(cx, cy, [
     corner(-halfW, -halfH),
     corner(halfW, -halfH),
     corner(halfW, halfH),
     corner(-halfW, halfH)
   ]);
+  return shape && { ...shape, interior: (n) => gridSamples(halfW * 2, halfH * 2, n, corner) };
 }
 function polygonShape(cx, cy, pts, rot) {
   const cos = Math.cos(rot);
@@ -6577,8 +6708,7 @@ function cohesionOf(layers, t, w, h) {
       seamCause
     };
     if (lifeAlphaAt(layer.life, t) <= 0) return { ...base, overlap: null, reads: null };
-    const shapes = entities.map((e) => shapeOf(layer, e, t, w, h));
-    const solid = shapes.filter((x) => x !== null && x.area > 0);
+    const solid = solidShapes(layer, entities, t, w, h);
     if (solid.length < 2) return { ...base, overlap: null, reads: null };
     const stride = Math.max(1, Math.ceil(solid.length / MAX_TRACED));
     let covered = 0;
@@ -6610,11 +6740,54 @@ function cohesionOf(layers, t, w, h) {
     return { ...base, overlap, reads };
   });
 }
-function seamsWorthWarning(layer, c, entityCount) {
+function solidShapes(layer, entities, t, w, h) {
+  return entities.map((e) => shapeOf(layer, e, t, w, h)).filter((x) => x !== null && x.area > 0);
+}
+var AREA_SAMPLES = 128;
+var TILED_AREA_MAX = 0.15;
+function buriedAreaOf(layer, entities, t, w, h) {
+  if (lifeAlphaAt(layer.life, t) <= 0) return null;
+  const solid = solidShapes(layer, entities, t, w, h);
+  if (solid.length < 2) return null;
+  const stride = Math.max(1, Math.ceil(solid.length / MAX_TRACED));
+  let covered = 0;
+  let traced = 0;
+  for (let i = 0; i < solid.length; i += stride) {
+    const pts = solid[i].interior(AREA_SAMPLES);
+    if (pts.length === 0) continue;
+    let hit = 0;
+    for (const p of pts) {
+      for (let j = 0; j < solid.length; j++) {
+        if (j === i) continue;
+        const other = solid[j];
+        const dx = p.x - other.cx;
+        const dy = p.y - other.cy;
+        if (dx * dx + dy * dy > other.br * other.br) continue;
+        if (other.contains(p.x, p.y)) {
+          hit++;
+          break;
+        }
+      }
+    }
+    covered += hit / pts.length;
+    traced++;
+  }
+  return traced === 0 ? null : Number((covered / traced).toFixed(4));
+}
+function seamsWorthWarning(layer, c, entityCount, buriedArea) {
   if (c.reads !== "seamed" || entityCount < 6) return false;
   const [lo, hi] = layer.alpha ?? [1, 1];
   if ((lo + hi) / 2 < WASH_ALPHA_MAX) return false;
-  return layer.blend !== "lighter" && layer.blend !== "screen";
+  if (layer.blend === "lighter" || layer.blend === "screen") return false;
+  if (buriedArea && paletteIsTheOnlySeam(layer)) {
+    const a = buriedArea();
+    if (a !== null && a < TILED_AREA_MAX) return false;
+  }
+  return true;
+}
+function paletteIsTheOnlySeam(layer) {
+  if (seamCauseOf(layer) === null) return false;
+  return seamCauseOf({ ...layer, sprite: { ...layer.sprite, colors: void 0 } }) === null;
 }
 
 // src/perceive.ts
@@ -6917,7 +7090,7 @@ function luminanceGrid(spec, opts = {}) {
   };
   const splatPolygonOutline = (layer, s, e, p, sz, a, lum, tPass) => {
     const radius = sz / 2;
-    const rot = rotationAt(e, tPass);
+    const rot = rotationAt(e, tPass) + paintRotation(spec, layer);
     const cr = Math.cos(rot);
     const sr = Math.sin(rot);
     const fr = isPathPolygon(s) ? pathFrame(s, radius, w, h) : { sx: radius, sy: radius, ox: 0, oy: 0, uniform: true };
@@ -7048,7 +7221,7 @@ function luminanceGrid(spec, opts = {}) {
         }
         if (s.kind === "stroke") {
           const pts = strokeSamples(s, sz / 2);
-          let angle = rotationAt(e, tPass);
+          let angle = rotationAt(e, tPass) + paintRotation(spec, layer);
           if (s.orient) angle += headingAt(e, tPass, w, h) ?? 0;
           const ca = Math.cos(angle);
           const sa = Math.sin(angle);
@@ -7077,7 +7250,7 @@ function luminanceGrid(spec, opts = {}) {
           continue;
         }
         if (s.kind === "streak") {
-          const heading = (headingAt(e, tPass, w, h) ?? 0) + rotationAt(e, tPass);
+          const heading = (headingAt(e, tPass, w, h) ?? 0) + (rotationAt(e, tPass) + paintRotation(spec, layer));
           const steps = Math.max(2, Math.ceil(sz / Math.min(cellW, cellH)));
           const wgt = Math.min(1, (s.width ?? (scale === 1 ? 2 : 2e-3)) * scale / cellH);
           for (let i = 0; i <= steps; i++) {
@@ -7112,7 +7285,7 @@ function luminanceGrid(spec, opts = {}) {
           if (len <= 0) continue;
           const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
           const box = barBox(s.direction ?? "right", len, th);
-          const rot = rotationAt(e, tPass);
+          const rot = rotationAt(e, tPass) + paintRotation(spec, layer);
           const cr = Math.cos(rot);
           const sr = Math.sin(rot);
           centerX = p.x + box.cx * cr - box.cy * sr;
@@ -7311,6 +7484,42 @@ function rankDominance(raw) {
     factors: r.factors
   }));
 }
+function onScreenFraction(scene, s, e, sz, k, t, paintRot = 0) {
+  if (s.kind === "text" || s.kind === "textBlock") return 1;
+  const { w, h } = scene;
+  const p = posOf(scene, e, t);
+  let cx = p.x, cy = p.y, hx = sz / 2 * k, hy = hx;
+  if (s.kind === "bar") {
+    const len = sz * barFraction(s, e.barIndex ?? 0);
+    const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
+    const b = barBox(s.direction ?? "right", len * k, th * k);
+    if (!(b.halfX > 0) || !(b.halfY > 0)) return 1;
+    const rot = rotationAt(e, t);
+    const cr = Math.cos(rot), sr = Math.sin(rot);
+    cx = p.x + b.cx * cr - b.cy * sr;
+    cy = p.y + b.cx * sr + b.cy * cr;
+    const ex = Math.abs(b.halfX * cr) + Math.abs(b.halfY * sr);
+    const ey = Math.abs(b.halfX * sr) + Math.abs(b.halfY * cr);
+    const fx2 = Math.max(0, Math.min(cx + ex, w) - Math.max(cx - ex, 0)) / (2 * ex);
+    const fy2 = Math.max(0, Math.min(cy + ey, h) - Math.max(cy - ey, 0)) / (2 * ey);
+    return fx2 * fy2;
+  }
+  if (s.kind === "polygon" && isPathPolygon(s)) {
+    const fr = pathFrame(s, sz / 2, w, h);
+    const rot = rotationAt(e, t) + paintRot;
+    const cr = Math.cos(rot), sr = Math.sin(rot);
+    const ox = -fr.ox * fr.sx * k, oy = -fr.oy * fr.sy * k;
+    cx += ox * cr - oy * sr;
+    cy += ox * sr + oy * cr;
+    const qx = fr.sx * k, qy = fr.sy * k;
+    hx = Math.abs(qx * cr) + Math.abs(qy * sr);
+    hy = Math.abs(qx * sr) + Math.abs(qy * cr);
+  }
+  if (!(hx > 0) || !(hy > 0)) return 1;
+  const fx = Math.max(0, Math.min(cx + hx, w) - Math.max(cx - hx, 0)) / (2 * hx);
+  const fy = Math.max(0, Math.min(cy + hy, h) - Math.max(cy - hy, 0)) / (2 * hy);
+  return fx * fy;
+}
 function rawDominance(spec, opts = {}) {
   spec = resolveTimelineAt(spec, opts.t ?? 5e3);
   const scene = buildScene(spec, opts);
@@ -7354,8 +7563,12 @@ function rawDominance(spec, opts = {}) {
         const h2 = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz;
         const f = s.feather ? (1 - s.feather / 2) * (1 - s.feather / 2) : 1;
         entArea = sz * h2 * f;
-      } else if (s.kind === "polygon") entArea = polygonArea(polygonPoints(s, sz / 2));
-      else if (s.kind === "bar") {
+      } else if (s.kind === "polygon") {
+        if (isPathPolygon(s)) {
+          const fr = pathFrame(s, sz / 2, w, h);
+          entArea = pathInkArea(s, fr.sx, fr.sy, sz / 2);
+        } else entArea = polygonArea(polygonPoints(s, sz / 2));
+      } else if (s.kind === "bar") {
         const th = e.size2 !== void 0 ? e.size2 * (e.size > 0 ? sz / e.size : 1) : sz * 0.2;
         entArea = sz * barFraction(s, e.barIndex ?? 0) * th;
       } else if (s.kind === "stroke") {
@@ -7368,6 +7581,7 @@ function rawDominance(spec, opts = {}) {
         const box = textBlockBox(s, e, { x: 0, y: 0 }, w, h);
         entArea = box.halfX * 2 * box.halfY * 2 * 0.55 * textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1);
       } else entArea = sz * sz * 0.55;
+      entArea *= onScreenFraction(scene, s, e, sz, painted ? paintSize(spec, layer) : 1, t, painted ? paintRotation(spec, layer) : 0);
       area += painted ? entArea * areaScale * a : entArea * a;
       if (layer.trail) {
         const fade = layer.trail.fade ?? 1;
@@ -7412,6 +7626,7 @@ function motionStats(spec, opts = {}) {
   const unit = Math.min(w, h);
   return scene0.layers.map(({ layer, entities }, layerIndex) => {
     const entities1 = scene1.layers[layerIndex]?.entities ?? entities;
+    const spinVisible = layer.sprite.kind !== "circle" && layer.sprite.kind !== "ring";
     let acc = 0;
     let max = 0;
     let n = 0;
@@ -7425,7 +7640,8 @@ function motionStats(spec, opts = {}) {
       const dy = p1.y - p0.y;
       if (Math.abs(dx) > w / 2 || Math.abs(dy) > h / 2) return;
       const dist = Math.sqrt(dx * dx + dy * dy);
-      const speed = dist / dt * 1e3;
+      const turn = spinVisible ? Math.abs(rotationAt(entities1[i] ?? e, t + dt) - rotationAt(e, t)) * (sizeAt(e, t) / 3) * paintSize(spec, layer) : 0;
+      const speed = Math.sqrt(dist * dist + turn * turn) / dt * 1e3;
       acc += speed;
       max = Math.max(max, speed);
       n++;
@@ -7482,17 +7698,36 @@ function sceneColour(spec, opts = {}) {
   let wsum = 0;
   for (const { layer, entities } of scene.layers) {
     const lifeA = lifeAlphaAt(layer.life, t) * (layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer));
-    for (const e of entities) {
-      const hex = spriteHex(layer, e);
-      if (hex === null) continue;
-      const sz = sizeAt(e, t);
-      const weight = alphaAt(e, t) * lifeA * (layer.sprite.kind === "circle" ? Math.PI * (sz / 2) * (sz / 2) : sz * sz);
-      if (weight <= 0) continue;
+    const k = layer.transform !== void 0 || layer.group !== void 0 ? paintSize(spec, layer) : 1;
+    const add = (hex, weight) => {
+      if (weight <= 0) return;
       const c = hexRgb(hex);
       wr += c.r * weight;
       wg += c.g * weight;
       wb += c.b * weight;
       wsum += weight;
+    };
+    for (const e of entities) {
+      const sz = sizeAt(e, t);
+      const s = layer.sprite;
+      const a = alphaAt(e, t) * lifeA * onScreenFraction(scene, s, e, sz, k, t, paintRotation(spec, layer));
+      if (a <= 0) continue;
+      if (s.kind === "polygon" && isPathPolygon(s)) {
+        const fr = pathFrame(s, sz / 2, scene.w, scene.h);
+        const base = s.colors?.[e.colorIndex] ?? s.color;
+        for (const part of pathParts(s)) {
+          const ink = partInkArea(part, fr.sx, fr.sy, sz / 2);
+          if (part.gradient) {
+            const gw = gradientStopWeights(part.gradient.stops);
+            part.gradient.stops.forEach((st, i) => add(st.color, a * ink.fill * (st.opacity ?? 1) * gw[i]));
+          } else add(part.color ?? base, a * ink.fill);
+          if (part.stroke) add(part.stroke.color, a * ink.stroke);
+        }
+        continue;
+      }
+      const hex = spriteHex(layer, e);
+      if (hex === null) continue;
+      add(hex, a * (s.kind === "circle" ? Math.PI * (sz / 2) * (sz / 2) : sz * sz));
     }
   }
   const bg = backgroundRgb(spec);
@@ -7685,12 +7920,92 @@ function perceiveSequenceFrame(seq, T, opts = {}) {
   };
 }
 
+// src/flash-timeline.ts
+import { analyzeFlashes, srgbToLinear as srgbToLinear2 } from "@idle-screens/validator";
+var LUMA_PATH = /(^|\.)(opacity|alpha|color|colors|stops|bands|gradient|stroke|fill|background)(\.|$)|(^|\.)(sprite|parts?)$|^layers\.\d+$/;
+var MIN_BOUNDARIES = 7;
+var MAX_SAMPLES = 64;
+var MAX_TOTAL_SAMPLES = 512;
+var WINDOW = 1e3;
+function lumaKeyTimes(spec) {
+  const tl = spec.timeline;
+  if (!tl) return { times: [], lap: 0 };
+  const lap = tl.loop && tl.duration ? tl.duration : 0;
+  const bounds = [];
+  for (const [path, keys] of timelineTracks(spec)) {
+    if (!LUMA_PATH.test(path)) continue;
+    for (const k of keys) {
+      const dur = k.dur ?? DEFAULT_KEY_DUR;
+      bounds.push(k.t);
+      if (dur > 0) bounds.push(k.t + dur);
+    }
+  }
+  return { times: [...new Set(lap ? [...bounds, ...bounds.map((b) => b + lap)] : bounds)].sort((a, b) => a - b), lap };
+}
+function flashSampleTimes(boundaries) {
+  const ts = /* @__PURE__ */ new Set();
+  boundaries.forEach((t, i) => {
+    ts.add(t - 1);
+    ts.add(t + 1);
+    const next = boundaries[i + 1];
+    if (next !== void 0 && next - t > 4) ts.add((t + next) / 2);
+  });
+  return [...ts].sort((a, b) => a - b);
+}
+function timelineFlashReport(spec) {
+  const pass = { fails: false, flashesPerSecond: 0, flashingArea: 0, at: null };
+  if (!spec.timeline) return pass;
+  const { times, lap } = lumaKeyTimes(spec);
+  const dense = [];
+  for (let i = 0, e = 0; i < times.length; i++) {
+    while (e < times.length && times[e] < times[i] + WINDOW) e++;
+    if (e - i < MIN_BOUNDARIES) continue;
+    const last = dense[dense.length - 1];
+    if (last && times[i] <= last.to) {
+      last.to = Math.max(last.to, times[e - 1]);
+      last.n = Math.max(last.n, e - i);
+    } else dense.push({ from: times[i], to: times[e - 1], n: e - i });
+  }
+  if (dense.length === 0) return pass;
+  dense.sort((a, b) => b.n - a.n);
+  let budget = MAX_TOTAL_SAMPLES;
+  let worst = pass;
+  for (const w of dense) {
+    const sampleTimes = flashSampleTimes(times.filter((t) => t >= w.from && t <= w.to));
+    for (let from = 0; from < sampleTimes.length - 1; ) {
+      const chunk = sampleTimes.slice(from, from + MAX_SAMPLES);
+      if (chunk.length < 2) break;
+      if (chunk.length > budget) return { ...worst, fails: true, at: lap ? w.from % lap : w.from, incomplete: true };
+      budget -= chunk.length;
+      const samples = chunk.map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: 16, rows: 9 }).cells.flat().map((v) => srgbToLinear2(v * 255)) }));
+      const r = analyzeFlashes(samples);
+      if (r.general.worstTileFlashesPerSecond > worst.flashesPerSecond || !worst.fails && r.general.fails) {
+        worst = {
+          fails: r.general.fails,
+          flashesPerSecond: r.general.worstTileFlashesPerSecond,
+          flashingArea: r.general.flashingAreaFraction,
+          at: lap ? w.from % lap : w.from
+        };
+      }
+      if (worst.fails) return worst;
+      if (from + MAX_SAMPLES >= sampleTimes.length) break;
+      const resume = chunk[chunk.length - 1] - WINDOW;
+      let next = from + 1;
+      while (sampleTimes[next] < resume) next++;
+      from = next;
+    }
+  }
+  return worst;
+}
+
 // src/advise.ts
 var LOW_CONTRAST_FLOOR = 0.05;
 var SPARSE_DECLARED_MAX_COVERAGE = 0.02;
 var READ_LEGIBILITY_FLOOR = 4.5;
 var READ_SAFE_AREA = 0.05;
 var ADDITIVE_INK_CEILING = 1;
+var CALM_MAX_SPIN = 90;
+var NEAR_FLASH_MAX_BOUNDARIES = 10;
 function edgeAnchored(range) {
   if (!range) return false;
   const [a, b] = range;
@@ -7698,6 +8013,7 @@ function edgeAnchored(range) {
 }
 function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
   const hidden = hiddenLayers(spec);
+  const authored = spec;
   spec = resolveTimelineAt(spec, opts.t ?? COHESION_T);
   const warnings = [];
   const w = viewport.width;
@@ -7724,7 +8040,7 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     if (isStaticText) textLayerCount++;
     if (layer.motion.type !== "static") motionLayerCount++;
     const coh = cohesion[li];
-    if (seamsWorthWarning(layer, coh, entities.length)) {
+    if (seamsWorthWarning(layer, coh, entities.length, () => buriedAreaOf(layer, entities, opts.t ?? COHESION_T, w, h))) {
       const s = layer.sprite;
       const softEdged = (s.kind === "circle" || s.kind === "polygon") && s.soft || s.kind === "rect" && !!s.feather;
       warnings.push({
@@ -7772,13 +8088,17 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
         return { rgb, luma: 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b };
       });
       const seps = entities.map((e) => {
-        const hex = spriteHex(layer, e);
-        if (hex === null) return Infinity;
-        const ink = { rgb: hexRgb(hex), luma: hexLuma(hex) };
-        const sep = Math.max(...plates.map((bg) => colourSeparation(layer, ink, bg)));
-        if (sep >= LOW_CONTRAST_FLOOR || layer.blend === "lighter" || layer.blend === "screen") return sep;
-        const under = groundUnder(spec, allEntities, li, hidden, positionAt(e, 0, w, h), w, h);
-        return under ? colourSeparation(layer, ink, under) : sep;
+        const inks = spriteInks(layer, e);
+        if (inks === null || inks.length === 0) return Infinity;
+        return Math.max(...inks.map((hex) => {
+          const ink = { rgb: hexRgb(hex), luma: hexLuma(hex) };
+          const sep = Math.max(...plates.map((bg) => colourSeparation(layer, ink, bg)));
+          if (sep >= LOW_CONTRAST_FLOOR || layer.blend === "lighter" || layer.blend === "screen") return sep;
+          const at = positionAt(e, 0, w, h);
+          const under = groundUnder(spec, allEntities, li, hidden, at, w, h);
+          const framed = holeFrame(spec, allEntities, li, hidden, at, w, h);
+          return Math.max(under ? colourSeparation(layer, ink, under) : sep, framed ? colourSeparation(layer, ink, framed) : sep);
+        }));
       });
       const best = Math.max(...seps);
       if (best < LOW_CONTRAST_FLOOR) {
@@ -7807,7 +8127,10 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       if (layer.sprite.kind === "circle") {
         pixArea = Math.PI * r * r;
       } else if (layer.sprite.kind === "polygon") {
-        pixArea = polygonArea(polygonPoints(layer.sprite, r));
+        if (isPathPolygon(layer.sprite)) {
+          const fr = pathFrame(layer.sprite, r, w, h);
+          pixArea = pathInkArea(layer.sprite, fr.sx, fr.sy, r);
+        } else pixArea = polygonArea(polygonPoints(layer.sprite, r));
       } else if (layer.sprite.kind === "bar") {
         pixArea = e.size * barFraction(layer.sprite, e.barIndex ?? 0) * (e.size2 ?? e.size * 0.2);
       } else if (layer.sprite.kind === "textBlock") {
@@ -7889,6 +8212,30 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       });
     }
   }
+  if (spec.motionIntensity === "calm") {
+    for (let li = 0; li < spec.layers.length; li++) {
+      if (hidden?.[li]) continue;
+      const layer = spec.layers[li];
+      if (!layer.spin || layer.sprite.kind === "circle" || layer.sprite.kind === "ring") continue;
+      const entities = allEntities[li];
+      if (entities.length === 0) continue;
+      const rate = entities.reduce((s, e) => s + Math.abs(e.spinSpeed), 0) / entities.length * (180 / Math.PI);
+      if (rate <= CALM_MAX_SPIN) continue;
+      warnings.push({
+        path: `layers[${li}].spin`,
+        code: "motion-intensity-mismatch",
+        message: `declared motionIntensity: 'calm' but ${layer.key ? `\`${layer.key}\`` : `layers[${li}]`} spins at ~${Math.round(rate)}\xB0/s on average \u2014 that reads busy, not calm (calm spins sit at \u2264 ${CALM_MAX_SPIN}\xB0/s); slow the spin or declare 'moderate' / 'energetic'`
+      });
+    }
+  }
+  const flicker = nearLimitFlash(authored);
+  if (flicker) {
+    warnings.push({
+      path: "timeline",
+      code: "flash-near-limit",
+      message: `the timeline flickers ${flicker.flashesPerSecond} times a second over ${Math.round(flicker.area * 100)}% of the frame around ${Math.round(flicker.at)} ms \u2014 at or near WCAG 2.3.1's limit of 3; space opposing luminance changes \u2265 500 ms apart, or lower the contrast between the two states`
+    });
+  }
   for (let li = 0; li < spec.layers.length; li++) {
     if (hidden?.[li]) continue;
     const layer = spec.layers[li];
@@ -7956,9 +8303,13 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     const label = layer.key ? `\`${layer.key}\`` : `layers[${li}]`;
     for (const e of allEntities[li]) {
       const p = positionAt(e, 0, w, h);
-      const raw = s.kind === "textBlock" ? textBlockBoxAt(s, p, w, h) : textBoxAt(s, e, p, spec, w, h);
+      const unturned = s.kind === "textBlock" ? textBlockBoxAt(s, p, w, h) : textBoxAt(s, e, p, spec, w, h);
+      const rot = rotationAt(e, 0);
+      const turn = (q) => ({ x: p.x + (q.x - p.x) * Math.cos(rot) - (q.y - p.y) * Math.sin(rot), y: p.y + (q.x - p.x) * Math.sin(rot) + (q.y - p.y) * Math.cos(rot) });
       const map = paintMap(spec, layer, w, h, scale);
-      const box = map ? { ...raw, ...mapBox(map, raw) } : raw;
+      const both = rot && map ? (q) => map(turn(q)) : rot ? turn : map;
+      const box = both ? { ...unturned, ...mapBox(both, unturned) } : unturned;
+      const raw = rot ? { ...unturned, ...mapBox(turn, unturned) } : unturned;
       const baseAlpha = Math.max(0, Math.min(1, e.alpha - e.pulseAmp)) * (s.kind === "textBlock" ? s.opacity ?? 1 : 1);
       const alpha = layer.opacity === void 0 && layer.group === void 0 ? baseAlpha : baseAlpha * paintOpacity(spec, layer);
       const str = s.kind === "textBlock" ? s.text : s.strings[e.spriteIndex] ?? s.strings[0] ?? "";
@@ -8080,20 +8431,34 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     for (const box of boxes) {
       const cy = (box.y0 + box.y1) / 2;
       const cx = (box.x0 + box.x1) / 2;
-      const groundRgb = backgroundRgbAt(spec, cy, h, scale, cx, w, opts.backgroundSeed ?? opts.seed, opts.t ?? COHESION_T);
-      const ground = legibilityRatio(textPlate(groundRgb, box.alpha), groundRgb);
-      const lit = brightestAdditivePlate(spec, allEntities, groundRgb, box, w, h);
-      const plate = lit ? legibilityRatio(textPlate(lit.rgb, box.alpha), lit.rgb) : Infinity;
-      if (!worst || Math.min(ground, plate) < Math.min(worst.ground, worst.plate)) {
-        worst = { ground, plate, plateLabel: lit?.label ?? null };
+      const bgAt = (x, y) => backgroundRgbAt(spec, y, h, scale, x, w, opts.backgroundSeed ?? opts.seed, opts.t ?? COHESION_T);
+      const ix = (box.x1 - box.x0) * 0.02;
+      const iy = (box.y1 - box.y0) * 0.02;
+      const probes = [[cx, cy], [box.x0 + ix, box.y0 + iy], [box.x1 - ix, box.y0 + iy], [box.x0 + ix, box.y1 - iy], [box.x1 - ix, box.y1 - iy]];
+      const grounds = [];
+      let bare = false;
+      for (const [x, y] of probes) {
+        const under = groundUnder(spec, allEntities, box.li, hidden, { x, y }, w, h, bgAt(x, y));
+        if (under) grounds.push({ rgb: under.rgb, onSolid: true });
+        else bare = true;
+      }
+      if (bare) grounds.push({ rgb: bgAt(cx, cy), onSolid: false });
+      for (const g of grounds) {
+        const ground = legibilityRatio(textPlate(g.rgb, box.alpha), g.rgb);
+        const lit = brightestAdditivePlate(spec, allEntities, g.rgb, box, w, h);
+        const plate = lit ? legibilityRatio(textPlate(lit.rgb, box.alpha), lit.rgb) : Infinity;
+        if (!worst || Math.min(ground, plate) < Math.min(worst.ground, worst.plate)) {
+          worst = { ground, plate, plateLabel: lit?.label ?? null, onSolid: g.onSolid };
+        }
       }
     }
     if (worst && Math.min(worst.ground, worst.plate) < READ_LEGIBILITY_FLOOR) {
       const under = worst.plateLabel ? ` and ${worst.plate.toFixed(1)}:1 under ${worst.plateLabel} at its brightest` : "";
+      const against = worst.onSolid ? "against the solid layer painted under it" : "against the background at the box centre";
       warnings.push({
         path: `layers[${b.li}].sprite`,
         code: "text-legibility",
-        message: `${b.label} is declared role: 'read' but its colour reads at ${worst.ground.toFixed(1)}:1 against the background at the box centre${under} \u2014 below ${READ_LEGIBILITY_FLOOR}:1; brighten the text, darken the ground under it, or declare role: 'atmosphere' if it is texture`
+        message: `${b.label} is declared role: 'read' but its colour reads at ${worst.ground.toFixed(1)}:1 ${against}${under} \u2014 below ${READ_LEGIBILITY_FLOOR}:1; brighten the text, darken the ground under it, or declare role: 'atmosphere' if it is texture`
       });
     }
     const edges = [];
@@ -8116,6 +8481,21 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
   }
   return warnings;
 }
+function nearLimitFlash(spec) {
+  if (!spec.timeline) return null;
+  const { times, lap } = lumaKeyTimes(spec);
+  let best = null;
+  for (let i = 0, e = 0; i < times.length; i++) {
+    while (e < times.length && times[e] < times[i] + 1e3) e++;
+    if (e - i >= 4 && (!best || e - i > best.n)) best = { from: i, n: e - i };
+  }
+  if (!best) return null;
+  const window = times.slice(best.from, best.from + Math.min(best.n, NEAR_FLASH_MAX_BOUNDARIES));
+  const samples = flashSampleTimes(window).map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: 16, rows: 9 }).cells.flat().map((v) => srgbToLinear3(v * 255)) }));
+  const r = analyzeFlashes2(samples, { maxFlashesPerSecond: 1 }).general;
+  if (!r.fails) return null;
+  return { flashesPerSecond: r.worstTileFlashesPerSecond, area: r.flashingAreaFraction, at: lap ? window[0] % lap : window[0] };
+}
 function brightestAdditivePlate(spec, allEntities, ground, box, w, h) {
   let best = null;
   for (let lj = 0; lj < spec.layers.length; lj++) {
@@ -8143,19 +8523,49 @@ function brightestAdditivePlate(spec, allEntities, ground, box, w, h) {
   }
   return best ? { rgb: best.rgb, label: best.label } : null;
 }
-function groundUnder(spec, allEntities, li, hidden, pt, w, h) {
-  let plate = backgroundRgb(spec);
+function holeFrame(spec, allEntities, li, hidden, pt, w, h) {
+  for (let lj = li + 1; lj < spec.layers.length; lj++) {
+    if (hidden?.[lj]) continue;
+    const layer = spec.layers[lj];
+    const sp = layer.sprite;
+    if (sp.kind !== "polygon" || !isPathPolygon(sp) || sp.soft) continue;
+    if (layer.motion.type !== "static" || layer.blend !== void 0 || layer.transform !== void 0 || groupOf(spec, layer)?.transform !== void 0) continue;
+    if (flattenSprite(sp).subpaths < 2) continue;
+    const a = layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer);
+    for (const e of allEntities[lj]) {
+      if (e.spinSpeed !== 0 || e.rotate || e.alpha * a < 0.9) continue;
+      const c = positionAt(e, 0, w, h);
+      const fr = pathFrame(sp, e.size / 2, w, h);
+      const pts = flattenSprite(sp).points.map(([u, v]) => ({ x: (u - fr.ox) * fr.sx, y: (v - fr.oy) * fr.sy }));
+      if (pts.length < 3) continue;
+      const dx = pt.x - c.x;
+      const dy = pt.y - c.y;
+      if (dx < Math.min(...pts.map((q) => q.x)) || dx > Math.max(...pts.map((q) => q.x))) continue;
+      if (dy < Math.min(...pts.map((q) => q.y)) || dy > Math.max(...pts.map((q) => q.y))) continue;
+      if (pointInPolygon(dx, dy, pts)) continue;
+      const ink = spriteInks(layer, e)?.[0];
+      if (ink === void 0) continue;
+      const rgb = hexRgb(ink);
+      return { rgb, luma: 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b };
+    }
+  }
+  return null;
+}
+function groundUnder(spec, allEntities, li, hidden, pt, w, h, base = backgroundRgb(spec)) {
+  let plate = base;
   let covered = false;
   for (let lj = 0; lj < li; lj++) {
     if (hidden?.[lj]) continue;
     const layer = spec.layers[lj];
     const sp = layer.sprite;
     if (layer.motion.type !== "static" || layer.blend !== void 0 || layer.transform !== void 0 || groupOf(spec, layer)?.transform !== void 0) continue;
+    if (layer.life !== void 0 || layer.emit !== void 0) continue;
     if ((sp.kind === "circle" || sp.kind === "polygon") && sp.soft) continue;
     if (sp.kind !== "circle" && sp.kind !== "rect" && sp.kind !== "polygon") continue;
+    if (sp.kind === "polygon" && isPathPolygon(sp)) continue;
     const a = layer.opacity === void 0 && layer.group === void 0 ? 1 : paintOpacity(spec, layer);
     for (const e of allEntities[lj]) {
-      if (e.spinSpeed !== 0 || e.alpha * a <= 0) continue;
+      if (e.spinSpeed !== 0 || e.pulseAmp > 0 || e.growAmp > 0 || e.alpha * a <= 0) continue;
       const hex = spriteHex(layer, e);
       if (hex === null) continue;
       const c = positionAt(e, 0, w, h);
@@ -8208,7 +8618,7 @@ function isOutlineStack(a, b) {
   if (fs <= 0 || Math.abs(a.fs - b.fs) > 0.1 * Math.max(a.fs, b.fs)) return false;
   const dx = (a.x0 + a.x1) / 2 - (b.x0 + b.x1) / 2;
   const dy = (a.y0 + a.y1) / 2 - (b.y0 + b.y1) / 2;
-  return Math.hypot(dx, dy) <= OUTLINE_STACK_OFFSET * fs;
+  return Math.max(Math.abs(dx), Math.abs(dy)) <= OUTLINE_STACK_OFFSET * fs;
 }
 function textBoxAt(s, e, p, spec, w, h) {
   const m = s.font ? /(\d{1,5}(?:\.\d{1,4})?|\.\d{1,4})px/.exec(s.font) : null;
@@ -10871,6 +11281,7 @@ export {
   adviseSequence,
   adviseSpec,
   alphaAt,
+  applyDeltasShared,
   applyDeltasToSpec,
   assertValidSequence,
   assertValidSpec,
@@ -10879,6 +11290,7 @@ export {
   bedRenderSeed,
   breakTextBlock,
   buildEntities,
+  buriedAreaOf,
   canMorph,
   canWrapMorph,
   canonicalSpecPath,
@@ -10960,6 +11372,7 @@ export {
   textStringsDiffer,
   textStringsOf,
   textWidthEm,
+  timelineFlashReport,
   timelineLocalTime,
   timelineSampleTimes,
   timelineSampleTimesAfter,