@idle-screens/schema 3.15.0 → 3.16.1

package/dist/index.js

@@ -106,6 +106,8 @@ var LIMITS = {
   maxShapePoints: 24,
   // polygon.points / stroke.points
   maxTextNumberDecimals: 6,
+  maxTextNumberMinDigits: 12,
+  // a counter's zero-padded integer digits
   maxTextAffix: 64,
   // characters of a counter's prefix / suffix
   maxRevealRise: 1,
@@ -165,7 +167,7 @@ function readSpecPath(spec, path) {
   const loc = resolveSpecPath(spec, path);
   return loc ? loc.parent[loc.key] : void 0;
 }
-var TRANSFORM_IDENTITY = { x: 0, y: 0, scale: 1, scaleX: 1, rotate: 0 };
+var TRANSFORM_IDENTITY = { x: 0, y: 0, scale: 1, scaleX: 1, scaleY: 1, rotate: 0 };
 function alignTransform(a, b) {
   const isObj2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
   if (!isObj2(a) || !isObj2(b)) return [a, b];
@@ -916,8 +918,9 @@ function trimPolyline(pts, a, b) {
   }
   return out.length >= 2 ? out : [];
 }
-function trimLines(lines, a, b) {
-  const key = `${a}|${b}`;
+function trimLines(lines, a, b, mode = "run") {
+  const each = mode === "each";
+  const key = `${a}|${b}|${each ? "each" : "run"}`;
   let byLines = trimCache.get(lines);
   const hit = byLines?.get(key);
   if (hit) return hit;
@@ -928,7 +931,19 @@ function trimLines(lines, a, b) {
   });
   const total = lens.reduce((m, v) => m + v, 0);
   const out = [];
-  if (total > 0 && b > a) {
+  if (each && b > a) {
+    lines.forEach((l, i) => {
+      if (!(lens[i] > 0)) return;
+      if (a <= 0 && b >= 1) {
+        out.push(l);
+        return;
+      }
+      const pts = l.points.map(([x, y]) => ({ x, y }));
+      if (l.closed && pts.length > 1) pts.push(pts[0]);
+      const cut = trimPolyline(pts, a, b);
+      if (cut.length >= 2) out.push({ points: cut.map((q) => [q.x, q.y]), closed: false });
+    });
+  } else if (total > 0 && b > a) {
     const from = a * total;
     const to = b * total;
     let run = 0;
@@ -958,7 +973,7 @@ function trimLines(lines, a, b) {
 var trimCache = /* @__PURE__ */ new WeakMap();
 function strokeLines(part) {
   const span = drawSpan(part.stroke?.draw);
-  return span ? trimLines(part.flat.lines, span[0], span[1]) : part.flat.lines;
+  return span ? trimLines(part.flat.lines, span[0], span[1], part.stroke?.draw?.mode) : part.flat.lines;
 }
 function strokeTaper(u) {
   return Math.max(0.15, Math.sin(Math.PI * Math.max(0, Math.min(1, u))));
@@ -1058,7 +1073,7 @@ function flattenPath(d, rule = "auto") {
 }
 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 d = s.parts ? s.parts.filter((p) => p.fill !== false).map((p) => p.path).join(" ") : spritePathD(s) ?? "";
   const rule = s.parts ? "auto" : s.fillRule ?? "auto";
   const hit = spriteFlat.get(s);
   if (hit && hit.d === d && hit.rule === rule) return hit.flat;
@@ -1070,14 +1085,30 @@ 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));
+  return s.kind === "polygon" && (typeof s.path === "string" || Array.isArray(s.parts) || isPointsPath(s));
+}
+function isPointsPath(s) {
+  return s.kind === "polygon" && typeof s.path !== "string" && !Array.isArray(s.parts) && Array.isArray(s.points) && s.points.length >= 2 && (s.stroke !== void 0 || s.fill === false || s.gradient !== void 0);
+}
+var pointsDs = /* @__PURE__ */ new WeakMap();
+function pointsPathD(points) {
+  const hit = pointsDs.get(points);
+  if (hit !== void 0) return hit;
+  const d = `${points.map(([x, y], i) => `${i === 0 ? "M" : "L"} ${x} ${y}`).join(" ")} Z`;
+  pointsDs.set(points, d);
+  return d;
+}
+function spritePathD(s) {
+  if (typeof s.path === "string") return s.path;
+  return isPointsPath(s) ? pointsPathD(s.points) : void 0;
 }
 var spriteParts = /* @__PURE__ */ new WeakMap();
 function pathParts(s) {
-  const key = s.parts ?? s.path;
+  const key = s.parts ?? s.path ?? s.points;
   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 d = s.parts ? void 0 : spritePathD(s);
+  const src = s.parts ?? (d !== void 0 ? [{ path: d, fillRule: typeof s.path === "string" ? s.fillRule : void 0, fill: s.fill, gradient: s.gradient, stroke: s.stroke }] : []);
   const parts = src.map((p) => {
     const flat = flattenPath(p.path, p.fillRule ?? "auto");
     return {
@@ -1571,11 +1602,17 @@ function pathDrawCost(s) {
   return c;
 }
 
+// src/validate-hints.ts
+var SCALAR_ONLY = /not a \[min,max\] range/;
+var SCALAR_BOUND = /^must be (?:>|an? (?:positive |single |finite |whole )?(?:number|integer)\b|between -?\d|-?\d+(?:\.\d+)?\.\.-?\d+(?:\.\d+)?(?: \(|$))/;
+var scalarWanted = (m) => SCALAR_ONLY.test(m) || !m.includes("[") && SCALAR_BOUND.test(m);
+
 // 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);
 var isStr = (v) => typeof v === "string";
 var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+var validPointPairs = (v) => Array.isArray(v) && v.length >= 2 && v.every((p) => Array.isArray(p) && p.length === 2 && isNum(p[0]) && isNum(p[1]));
 var isRange = (v) => Array.isArray(v) && v.length === 2 && isNum(v[0]) && isNum(v[1]) && v[0] <= v[1];
 var KNOWN_TOP = /* @__PURE__ */ new Set(["schemaVersion", "id", "label", "seed", "motionIntensity", "density", "units", "referenceViewport", "background", "layers", "ghosting", "finish", "timeline", "groups"]);
 var KNOWN_FINISH = /* @__PURE__ */ new Set(["grain", "dither", "animate"]);
@@ -1606,7 +1643,7 @@ var KNOWN_LAYER = /* @__PURE__ */ new Set([
   "transform",
   "group"
 ]);
-var KNOWN_TRANSFORM = /* @__PURE__ */ new Set(["x", "y", "scale", "scaleX", "rotate", "origin"]);
+var KNOWN_TRANSFORM = /* @__PURE__ */ new Set(["x", "y", "scale", "scaleX", "scaleY", "rotate", "origin"]);
 var KNOWN_GROUP = /* @__PURE__ */ new Set(["transform", "opacity"]);
 var GROUP_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
 var KNOWN_POSITION = /* @__PURE__ */ new Set(["x", "y", "dx", "dy"]);
@@ -1624,7 +1661,7 @@ var KNOWN_STROKE = /* @__PURE__ */ new Set(["kind", "length", "points", "color",
 var KNOWN_EMOJI = /* @__PURE__ */ new Set(["kind", "glyphs", "cycle"]);
 var KNOWN_TEXT = /* @__PURE__ */ new Set(["kind", "strings", "color", "font", "align", "baseline", "maxWidth", "cycle", "role"]);
 var KNOWN_TEXT_BLOCK = /* @__PURE__ */ new Set(["kind", "text", "maxWidth", "fontSize", "lineHeight", "align", "color", "reveal", "anchor", "font", "opacity", "role", "number"]);
-var KNOWN_TEXT_NUMBER = /* @__PURE__ */ new Set(["value", "decimals", "prefix", "suffix", "grouping"]);
+var KNOWN_TEXT_NUMBER = /* @__PURE__ */ new Set(["value", "decimals", "prefix", "suffix", "grouping", "minDigits"]);
 var TEXT_ROLES = /* @__PURE__ */ new Set(["read", "atmosphere"]);
 var TEXT_BLOCK_ANCHORS = /* @__PURE__ */ new Set(["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"]);
 var FONT_SIZE_RE = /\d(?:px|pt|pc|em|rem|ex|ch|vw|vh|vmin|vmax|%)/i;
@@ -1702,6 +1739,15 @@ var KNOWN_BG_SOLID = /* @__PURE__ */ new Set(["type", "color"]);
 var KNOWN_BG_GRADIENT = /* @__PURE__ */ new Set(["type", "stops", "band", "drift"]);
 var KNOWN_BG_FIELD = /* @__PURE__ */ new Set(["type", "scale", "octaves", "warp", "quantize", "bands", "drift", "seed"]);
 var KNOWN_FIELD_DRIFT = /* @__PURE__ */ new Set(["period", "amount"]);
+var KNOWN_BG_STOP = /* @__PURE__ */ new Set(["at", "color"]);
+var KNOWN_BAND = /* @__PURE__ */ new Set(["color", "height"]);
+var KNOWN_BG_DRIFT = /* @__PURE__ */ new Set(["period", "amount"]);
+var KNOWN_PATH_STROKE = /* @__PURE__ */ new Set(["color", "width", "opacity", "join", "cap", "draw"]);
+var KNOWN_PATH_GRADIENT = {
+  linear: /* @__PURE__ */ new Set(["type", "from", "to", "stops", "units"]),
+  radial: /* @__PURE__ */ new Set(["type", "center", "radius", "focus", "stops", "units"])
+};
+var KNOWN_PATH_STOP = /* @__PURE__ */ new Set(["at", "color", "opacity"]);
 var LAYER_PROPS_ON_SPRITE = /* @__PURE__ */ new Set(["blend", "trail", "alpha", "pulse", "spin", "grow", "region", "links", "flip", "wrap", "key", "emit", "clock", "life", "layout", "rotate", "rock"]);
 function unknownKeys(obj, known) {
   return Object.keys(obj).filter((k) => !known.has(k));
@@ -1719,6 +1765,50 @@ function positiveScalar(v, path, err, msg = "must be > 0") {
   if (Array.isArray(v)) err(path, "must be a single number > 0, not a [min,max] range");
   else if (!isNum(v) || v <= 0) err(path, msg);
 }
+function valueAtPath(root, path) {
+  let v = root;
+  for (const seg of path.match(/[^.[\]]+/g) ?? []) {
+    if (Array.isArray(v) && /^\d+$/.test(seg)) v = v[Number(seg)];
+    else if (isObj(v)) v = v[seg];
+    else return void 0;
+  }
+  return v;
+}
+function echo(v) {
+  if (isNum(v)) return String(v);
+  if (Array.isArray(v) && v.length <= 4 && v.every(isNum)) return `[${v.join(", ")}]`;
+  const s = JSON.stringify(v) ?? String(v);
+  return s.length > 48 ? `${s.slice(0, 45)}\u2026` : s;
+}
+var RANGE_WANTED = /^must be a \[min,max\] range/;
+function shapeHint(spec, path, message) {
+  if (message.includes(" \u2014 got ")) return "";
+  const v = valueAtPath(spec, path);
+  if (v === void 0) return "";
+  if (RANGE_WANTED.test(message)) {
+    if (isNum(v)) {
+      const fits = message.includes("within 0..1") ? v >= 0 && v <= 1 : message.includes(">= 0") ? v >= 0 : !message.includes("positive") || v > 0;
+      return fits ? ` \u2014 got ${v}; write [${v}, ${v}]` : ` \u2014 got ${v}; a range is two numbers, [min, max]`;
+    }
+    if (isObj(v) && ("min" in v || "max" in v)) {
+      return ` \u2014 got {min, max}; write [${isNum(v.min) ? v.min : "min"}, ${isNum(v.max) ? v.max : "max"}]`;
+    }
+    if (Array.isArray(v) && v.length === 2 && isNum(v[0]) && isNum(v[1]) && v[0] > v[1]) {
+      return ` \u2014 got ${echo(v)}; the smaller number comes first: write [${v[1]}, ${v[0]}]`;
+    }
+    return ` \u2014 got ${echo(v)}`;
+  }
+  if (Array.isArray(v) && scalarWanted(message)) {
+    const segs = path.match(/[^.[\]]+/g) ?? [];
+    const key = segs[segs.length - 1] ?? path;
+    const parentKey = segs[segs.length - 2];
+    const parent = valueAtPath(spec, path.slice(0, path.lastIndexOf(".")));
+    const kind = isObj(parent) && isStr(parent.kind) ? parent.kind : void 0;
+    const noun = kind ? `${/^[aeiou]/i.test(kind) ? "an" : "a"} ${kind}'s \`${key}\`` : parentKey && !/^\d+$/.test(parentKey) && parentKey !== "sprite" ? `\`${parentKey}.${key}\`` : `\`${key}\``;
+    return ` \u2014 got ${echo(v)}; ${noun} is one number`;
+  }
+  return "";
+}
 function normalizeColors(spec) {
   if (!isObj(spec) || !Array.isArray(spec.layers)) return;
   for (const layer of spec.layers) {
@@ -1787,7 +1877,7 @@ function specPathsValid(spec, paths) {
 function validateSpecCore(spec, checkApplied = true) {
   const errors = [];
   const warnings = [];
-  const err = (path, message) => void errors.push({ path, message });
+  const err = (path, message) => void errors.push({ path, message: message + shapeHint(spec, path, message) });
   const warn = (path, code, message) => void warnings.push({ path, code, message });
   if (!isObj(spec)) return { valid: false, errors: [{ path: "", message: "spec must be an object" }], warnings: [] };
   if (spec.schemaVersion !== SCHEMA_VERSION) err("schemaVersion", `must be ${SCHEMA_VERSION}`);
@@ -1834,7 +1924,7 @@ function validateSpecCore(spec, checkApplied = true) {
       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 pieces = Array.isArray(sp.parts) ? sp.parts : typeof sp.path === "string" ? [sp] : isPointsPath(sp) && validPointPairs(sp.points) ? [{ ...sp, path: pointsPathD(sp.points), fillRule: void 0 }] : [];
         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;
@@ -1857,7 +1947,7 @@ function validateSpecCore(spec, checkApplied = true) {
   return { valid: errors.length === 0, errors, warnings };
 }
 function validateTransform(tf, path, err, warn, spec, anchorOk) {
-  if (!isObj(tf)) return err(path, "must be an object {x?, y?, scale?, scaleX?, rotate?, origin?}");
+  if (!isObj(tf)) return err(path, "must be an object {x?, y?, scale?, scaleX?, scaleY?, rotate?, origin?}");
   for (const k of unknownKeys(tf, KNOWN_TRANSFORM)) warn(`${path}.${k}`, "unknown-property", `unknown transform property '${k}' \u2014 will be ignored`);
   const [off, unit] = offsetBound(spec);
   const sc = LIMITS.maxLayerTransformScale;
@@ -1865,7 +1955,9 @@ function validateTransform(tf, path, err, warn, spec, anchorOk) {
     if (tf[axis] !== void 0 && (!isNum(tf[axis]) || Math.abs(tf[axis]) > off)) err(`${path}.${axis}`, `must be a number within \xB1${off} (${unit})`);
   }
   if (tf.scale !== void 0 && (!isNum(tf.scale) || tf.scale < 0 || tf.scale > sc)) err(`${path}.scale`, `must be a number 0..${sc}`);
-  if (tf.scaleX !== void 0 && (!isNum(tf.scaleX) || Math.abs(tf.scaleX) > sc)) err(`${path}.scaleX`, `must be a number within \xB1${sc} (negative mirrors)`);
+  for (const axis of ["scaleX", "scaleY"]) {
+    if (tf[axis] !== void 0 && (!isNum(tf[axis]) || Math.abs(tf[axis]) > sc)) err(`${path}.${axis}`, `must be a number within \xB1${sc} (negative mirrors)`);
+  }
   if (tf.rotate !== void 0 && (!isNum(tf.rotate) || Math.abs(tf.rotate) > LIMITS.maxLayerTransformRotate)) {
     err(`${path}.rotate`, `must be a number of degrees within \xB1${LIMITS.maxLayerTransformRotate}`);
   }
@@ -2014,9 +2106,12 @@ function validateTimelineKeys(spec, errOuter, warn, checkApplied) {
     return;
   }
 }
-function color(v, path, err) {
-  if (!isStr(v) || !HEX2.test(v)) err(path, "must be a hex colour like #0a3a52");
+function color(v, path, err, missing = "is required (a hex colour like #0a3a52)") {
+  if (v === void 0) err(path, missing);
+  else if (!isStr(v) || !HEX2.test(v)) err(path, "must be a hex colour like #0a3a52");
 }
+var SPRITE_COLOR_MISSING = "`color` is required (or a `colors` palette)";
+var POLYGON_COLOR_MISSING = `${SPRITE_COLOR_MISSING}; parts without their own colour inherit it, and a gradient or stroke does not stand in for it`;
 function validateFinish(f, path, err, warn) {
   if (!isObj(f)) return err(path, "must be an object");
   for (const k of ["grain", "dither"]) {
@@ -2041,6 +2136,7 @@ function validateBackground(bg, err, warn) {
       bg.stops.forEach((s, i) => {
         if (!isObj(s) || !isNum(s.at) || s.at < 0 || s.at > 1) err(`background.stops[${i}].at`, "must be 0..1");
         color(isObj(s) ? s.color : void 0, `background.stops[${i}].color`, err);
+        if (isObj(s)) for (const k of unknownKeys(s, KNOWN_BG_STOP)) warn(`background.stops[${i}].${k}`, "unknown-property", `unknown stop property '${k}' \u2014 will be ignored`);
       });
     }
     if (bg.drift !== void 0) {
@@ -2052,6 +2148,7 @@ function validateBackground(bg, err, warn) {
         if (bg.drift.amount !== void 0 && (!isNum(bg.drift.amount) || bg.drift.amount <= 0 || bg.drift.amount > LIMITS.maxDriftAmount)) {
           err("background.drift.amount", `must be > 0 and <= ${LIMITS.maxDriftAmount}`);
         }
+        for (const k of unknownKeys(bg.drift, KNOWN_BG_DRIFT)) warn(`background.drift.${k}`, "unknown-property", `unknown drift property '${k}' \u2014 will be ignored`);
       }
     }
     if (bg.band !== void 0) {
@@ -2059,6 +2156,7 @@ function validateBackground(bg, err, warn) {
       else {
         color(bg.band.color, "background.band.color", err);
         positiveScalar(bg.band.height, "background.band.height", err);
+        for (const k of unknownKeys(bg.band, KNOWN_BAND)) warn(`background.band.${k}`, "unknown-property", `unknown band property '${k}' \u2014 will be ignored`);
       }
     }
     for (const k of unknownKeys(bg, KNOWN_BG_GRADIENT)) {
@@ -2180,8 +2278,8 @@ function validateLayer(layer, path, err, warn, spec) {
   if (layer.pulse !== void 0) {
     if (!isObj(layer.pulse)) err(`${path}.pulse`, "must be an object");
     else {
-      if (!isNum(layer.pulse.amp) || layer.pulse.amp <= 0 || layer.pulse.amp > LIMITS.maxPulseAmp) {
-        err(`${path}.pulse.amp`, `must be within 0..${LIMITS.maxPulseAmp}`);
+      if (!isNum(layer.pulse.amp) || layer.pulse.amp < 0 || layer.pulse.amp > LIMITS.maxPulseAmp) {
+        err(`${path}.pulse.amp`, `must be a number from 0 (no pulse) to ${LIMITS.maxPulseAmp}`);
       }
       if (!isNum(layer.pulse.period) || layer.pulse.period < LIMITS.minPulsePeriod) {
         err(`${path}.pulse.period`, `must be >= ${LIMITS.minPulsePeriod} ms (flash-safety floor)`);
@@ -2466,19 +2564,19 @@ function validateSprite(sprite, path, err, warn, spec) {
   } else if (sprite.kind === "circle") {
     knownSet = KNOWN_CIRCLE;
     if (!isRange(sprite.radius) || sprite.radius[0] <= 0) err(`${path}.radius`, rangeMsg(spec));
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     if (sprite.soft !== void 0 && typeof sprite.soft !== "boolean") err(`${path}.soft`, "must be a boolean");
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "ring") {
     knownSet = KNOWN_RING;
     if (!isRange(sprite.radius) || sprite.radius[0] <= 0) err(`${path}.radius`, rangeMsg(spec));
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     if (sprite.width !== void 0) positiveScalar(sprite.width, `${path}.width`, err);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "streak") {
     knownSet = KNOWN_STREAK;
     if (!isRange(sprite.length) || sprite.length[0] <= 0) err(`${path}.length`, rangeMsg(spec));
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     if (sprite.width !== void 0) positiveScalar(sprite.width, `${path}.width`, err);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "rect") {
@@ -2490,7 +2588,7 @@ function validateSprite(sprite, path, err, warn, spec) {
     if (sprite.feather !== void 0 && (!isNum(sprite.feather) || sprite.feather < 0 || sprite.feather > 1)) {
       err(`${path}.feather`, "must be 0..1 (fraction of the half-size that fades out)");
     }
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "bar") {
     knownSet = KNOWN_BAR;
@@ -2503,7 +2601,7 @@ function validateSprite(sprite, path, err, warn, spec) {
     if (sprite.direction !== void 0 && !["right", "left", "up", "down"].includes(sprite.direction)) {
       err(`${path}.direction`, "must be 'right' | 'left' | 'up' | 'down'");
     }
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "polygon") {
     knownSet = KNOWN_POLYGON;
@@ -2534,8 +2632,11 @@ function validateSprite(sprite, path, err, warn, spec) {
     } 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 if (sprite.points !== void 0) {
+      validatePiecePaint(sprite, path, err, warn);
+      if (sprite.fillRule !== void 0) warn(`${path}.fillRule`, "unknown-property", "fillRule applies only to a path \u2014 ignored");
     } 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)`);
+      for (const k of ["gradient", "stroke", "fill"]) if (sprite[k] !== void 0) err(`${path}.${k}`, `${k} applies only to a polygon with a path, points 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) {
@@ -2544,7 +2645,7 @@ function validateSprite(sprite, path, err, warn, spec) {
       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);
+    color(sprite.color, `${path}.color`, err, POLYGON_COLOR_MISSING);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "stroke") {
     knownSet = KNOWN_STROKE;
@@ -2555,7 +2656,7 @@ function validateSprite(sprite, path, err, warn, spec) {
     if (sprite.taper !== void 0 && typeof sprite.taper !== "boolean") err(`${path}.taper`, "must be a boolean");
     if (sprite.orient !== void 0 && typeof sprite.orient !== "boolean") err(`${path}.orient`, "must be a boolean");
     if (sprite.draw !== void 0) validateDraw(sprite.draw, `${path}.draw`, err, warn);
-    color(sprite.color, `${path}.color`, err);
+    color(sprite.color, `${path}.color`, err, SPRITE_COLOR_MISSING);
     validatePalette(sprite, path, err);
   } else if (sprite.kind === "textBlock") {
     knownSet = KNOWN_TEXT_BLOCK;
@@ -2597,7 +2698,7 @@ function validateSprite(sprite, path, err, warn, spec) {
     validateTextRole(sprite, path, err);
     if (sprite.number !== void 0) {
       const n = sprite.number;
-      if (!isObj(n)) err(`${path}.number`, "must be { value, decimals?, prefix?, suffix?, grouping? }");
+      if (!isObj(n)) err(`${path}.number`, "must be { value, decimals?, prefix?, suffix?, grouping?, minDigits? }");
       else {
         if (!isNum(n.value)) err(`${path}.number.value`, "must be a finite number");
         if (n.decimals !== void 0 && (!isNum(n.decimals) || !Number.isInteger(n.decimals) || n.decimals < 0 || n.decimals > LIMITS.maxTextNumberDecimals)) {
@@ -2608,6 +2709,9 @@ function validateSprite(sprite, path, err, warn, spec) {
           if (v !== void 0 && (!isStr(v) || v.length > LIMITS.maxTextAffix)) err(`${path}.number.${k}`, `must be a string of at most ${LIMITS.maxTextAffix} characters`);
         }
         if (n.grouping !== void 0 && typeof n.grouping !== "boolean") err(`${path}.number.grouping`, "must be a boolean");
+        if (n.minDigits !== void 0 && (!isNum(n.minDigits) || !Number.isInteger(n.minDigits) || n.minDigits < 1 || n.minDigits > LIMITS.maxTextNumberMinDigits)) {
+          err(`${path}.number.minDigits`, `must be a whole number 1..${LIMITS.maxTextNumberMinDigits} (integer digits, zero-padded)`);
+        }
         for (const k of unknownKeys(n, KNOWN_TEXT_NUMBER)) warn(`${path}.number.${k}`, "unknown-property", `unknown number property '${k}' \u2014 will be ignored`);
       }
     }
@@ -2857,13 +2961,16 @@ function validatePathPiece(piece, path, err, warn) {
     const problem = pathGeometryProblem(piece.path, piece.fillRule ?? "auto", piece.fill !== false);
     if (problem && !(keyedPathDepth > 0 && (problem === NO_AREA || problem === NO_LINE))) err(`${path}.path`, problem);
   }
+  validatePiecePaint(piece, path, err, warn);
+  if (piece.fillRule !== void 0 && !["auto", "nonzero", "evenodd"].includes(piece.fillRule)) err(`${path}.fillRule`, "must be 'auto' | 'nonzero' | 'evenodd'");
+}
+function validatePiecePaint(piece, path, err, warn) {
   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.gradient !== void 0) validatePathGradient(piece.gradient, `${path}.gradient`, err, warn);
   if (piece.stroke !== void 0) validatePathStroke(piece.stroke, `${path}.stroke`, err, warn);
-  if (piece.fillRule !== void 0 && !["auto", "nonzero", "evenodd"].includes(piece.fillRule)) err(`${path}.fillRule`, "must be 'auto' | 'nonzero' | 'evenodd'");
 }
-function validatePathGradient(g, path, err) {
+function validatePathGradient(g, path, err, warn) {
   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)");
@@ -2875,6 +2982,7 @@ function validatePathGradient(g, path, err) {
   } else {
     return err(`${path}.type`, "must be 'linear' | 'radial'");
   }
+  for (const k of unknownKeys(g, KNOWN_PATH_GRADIENT[g.type])) warn(`${path}.${k}`, "unknown-property", `unknown ${g.type} gradient property '${k}' \u2014 will be ignored`);
   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;
@@ -2884,16 +2992,18 @@ function validatePathGradient(g, path, err) {
     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");
+    for (const k of unknownKeys(st, KNOWN_PATH_STOP)) warn(`${path}.stops[${i}].${k}`, "unknown-property", `unknown stop property '${k}' \u2014 will be ignored`);
   });
 }
 function validatePathStroke(st, path, err, warn) {
   if (!isObj(st)) return err(path, "must be { color, width, opacity?, join?, cap?, draw? }");
-  color(st.color, `${path}.color`, err);
+  color(st.color, `${path}.color`, err, "`color` is required on a stroke (a hex colour like #0a3a52); a stroke does not inherit the entity colour");
   if (!isNum(st.width) || st.width <= 0 || st.width > 0.5) err(`${path}.width`, "must be > 0 and <= 0.5 (unit-box units: 0.01 is 1% of the drawing's half-size)");
   if (st.opacity !== void 0 && (!isNum(st.opacity) || st.opacity < 0 || st.opacity > 1)) err(`${path}.opacity`, "must be 0..1");
   if (st.join !== void 0 && !["round", "miter", "bevel"].includes(st.join)) err(`${path}.join`, "must be 'round' | 'miter' | 'bevel'");
   if (st.cap !== void 0 && !["round", "butt", "square"].includes(st.cap)) err(`${path}.cap`, "must be 'round' | 'butt' | 'square'");
   if (st.draw !== void 0) validateDraw(st.draw, `${path}.draw`, err, warn);
+  for (const k of unknownKeys(st, KNOWN_PATH_STROKE)) warn(`${path}.${k}`, "unknown-property", `unknown stroke property '${k}' \u2014 will be ignored`);
 }
 function validateWipe(tr, path, err, warn) {
   if (tr.shape !== void 0 && tr.shape !== "circle" && tr.shape !== "line") err(`${path}.shape`, "must be 'circle' | 'line'");
@@ -2912,12 +3022,13 @@ function validateWipe(tr, path, err, warn) {
   }
 }
 function validateDraw(d, path, err, warn) {
-  if (!isObj(d)) return err(path, "must be { start?, end? } \u2014 fractions of the line, 0..1");
+  if (!isObj(d)) return err(path, "must be { start?, end?, mode? } \u2014 fractions of the line, 0..1; mode 'run' | 'each'");
   for (const k of ["start", "end"]) {
     const v = d[k];
     if (v !== void 0 && (!isNum(v) || v < 0 || v > 1)) err(`${path}.${k}`, "must be 0..1 (a fraction of the line's length)");
   }
-  for (const k of Object.keys(d)) if (k !== "start" && k !== "end") warn(`${path}.${k}`, "unknown-property", `unknown draw property '${k}' \u2014 draw takes start and end; will be ignored`);
+  if (d.mode !== void 0 && d.mode !== "run" && d.mode !== "each") err(`${path}.mode`, "must be 'run' (one pen run through every subpath, default) | 'each' (every subpath draws at once)");
+  for (const k of Object.keys(d)) if (k !== "start" && k !== "end" && k !== "mode") warn(`${path}.${k}`, "unknown-property", `unknown draw property '${k}' \u2014 draw takes start, end and mode; will be ignored`);
 }
 function validateShapePoints(points, path, min, err) {
   if (!Array.isArray(points) || points.length < min || points.length > LIMITS.maxShapePoints) {
@@ -3436,7 +3547,9 @@ function textBlockText(s) {
   const d = Math.max(0, Math.min(LIMITS.maxTextNumberDecimals, Math.round(n.decimals ?? 0)));
   const v = Number.isFinite(n.value) ? n.value : 0;
   const fixed = Math.abs(v).toFixed(d);
-  const [whole, frac] = fixed.split(".");
+  const [digits, frac] = fixed.split(".");
+  const pad = Math.max(1, Math.min(LIMITS.maxTextNumberMinDigits, Math.round(n.minDigits ?? 1)));
+  const whole = digits.padStart(pad, "0");
   const grouped = n.grouping === false ? whole : whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   const neg = v < 0 && Number(fixed) !== 0;
   return `${n.prefix ?? ""}${neg ? "-" : ""}${grouped}${frac !== void 0 ? `.${frac}` : ""}${n.suffix ?? ""}`;
@@ -3520,6 +3633,7 @@ function lifeStaggerAt(life, t, i) {
 }
 function wrap(v, min, max) {
   const range2 = max - min;
+  if (range2 <= 0) return min;
   return ((v - min) % range2 + range2) % range2 + min;
 }
 function reflect(v, min, max) {
@@ -3947,8 +4061,9 @@ function transformOrigin(tf, layer, w, h, unit) {
 function transformPoint(tf, p, w, h, unit, origin = { x: w / 2, y: h / 2 }) {
   const s = tf.scale ?? 1;
   const sx = s * (tf.scaleX ?? 1);
+  const sy = s * (tf.scaleY ?? 1);
   let x = (p.x - origin.x) * sx;
-  let y = (p.y - origin.y) * s;
+  let y = (p.y - origin.y) * sy;
   if (tf.rotate) {
     const r = tf.rotate * Math.PI / 180;
     const c = Math.cos(r);
@@ -3960,7 +4075,61 @@ function transformPoint(tf, p, w, h, unit, origin = { x: w / 2, y: h / 2 }) {
 function transformSize(tf) {
   if (!tf) return 1;
   const s = tf.scale ?? 1;
-  return s * Math.sqrt(Math.abs(tf.scaleX ?? 1));
+  return s * Math.sqrt(Math.abs((tf.scaleX ?? 1) * (tf.scaleY ?? 1)));
+}
+var TRANSFORM_FIELDS = { x: 0, y: 0, scale: 1, scaleX: 1, scaleY: 1, rotate: 0 };
+function transformRangeOf(tf) {
+  const r = {};
+  for (const f of Object.keys(TRANSFORM_FIELDS)) {
+    const v = tf?.[f] ?? TRANSFORM_FIELDS[f];
+    r[f] = [v, v];
+  }
+  return r;
+}
+function maxAxisScale(r) {
+  const s = Math.max(Math.abs(r.scale[0]), Math.abs(r.scale[1]));
+  return s * Math.max(1, Math.abs(r.scaleX[0]), Math.abs(r.scaleX[1]), Math.abs(r.scaleY[0]), Math.abs(r.scaleY[1]));
+}
+function sweptBox(r, p, origin, unit) {
+  const ux = p.x - origin.x;
+  const uy = p.y - origin.y;
+  const b = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+  const take = (x, y) => {
+    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);
+  };
+  const r0 = r.rotate[0] * Math.PI / 180;
+  const r1 = r.rotate[1] * Math.PI / 180;
+  const full = r.rotate[1] - r.rotate[0] >= 360;
+  const QUARTER = Math.PI / 2;
+  for (const s of r.scale) {
+    for (const sx of r.scaleX) for (const sy of r.scaleY) {
+      const vx = ux * s * sx;
+      const vy = uy * s * sy;
+      const len = Math.hypot(vx, vy);
+      if (len === 0) {
+        take(0, 0);
+        continue;
+      }
+      if (full) {
+        take(-len, -len);
+        take(len, len);
+        continue;
+      }
+      const a = Math.atan2(vy, vx);
+      take(len * Math.cos(a + r0), len * Math.sin(a + r0));
+      take(len * Math.cos(a + r1), len * Math.sin(a + r1));
+      for (let phi = Math.ceil((a + r0) / QUARTER) * QUARTER; phi <= a + r1; phi += QUARTER) take(len * Math.cos(phi), len * Math.sin(phi));
+    }
+  }
+  return {
+    x0: b.x0 + origin.x + r.x[0] * unit,
+    x1: b.x1 + origin.x + r.x[1] * unit,
+    y0: b.y0 + origin.y + r.y[0] * unit,
+    y1: b.y1 + origin.y + r.y[1] * unit
+  };
 }
 function groupOf(spec, layer) {
   return layer.group === void 0 ? void 0 : spec.groups?.[layer.group];
@@ -5329,14 +5498,14 @@ var SpecInstance = class {
    * 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) {
+  drawEntity(built, e, t, lifeA, parentE, paint, echo2) {
     const { ctx } = this;
-    const p = echo ? { x: echo.x, y: echo.y, flip: false } : this.entityPos(e, t, parentE);
+    const p = echo2 ? { x: echo2.x, y: echo2.y, flip: false } : this.entityPos(e, t, parentE);
     const sprite = paint?.sprite ?? built.layer.sprite;
-    const sz = echo ? echo.size : sizeAt(e, t);
+    const sz = echo2 ? echo2.size : sizeAt(e, t);
     const rot = rotationAt(e, t);
     const unitScale = this.effSpec.units === "px" ? 1 : Math.min(this.w, this.h);
-    ctx.globalAlpha = echo ? echo.alpha : alphaAt(e, t) * lifeA * (paint?.alpha ?? 1);
+    ctx.globalAlpha = echo2 ? echo2.alpha : alphaAt(e, t) * lifeA * (paint?.alpha ?? 1);
     if (sprite.kind === "ring") {
       const r = sz / 2;
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
@@ -5936,7 +6105,7 @@ var SpecInstance = class {
     ctx.translate(cx + (tf.x ?? 0) * unit, cy + (tf.y ?? 0) * unit);
     if (tf.rotate) ctx.rotate(tf.rotate * Math.PI / 180);
     const s = tf.scale ?? 1;
-    ctx.scale(s * (tf.scaleX ?? 1), s);
+    ctx.scale(s * (tf.scaleX ?? 1), s * (tf.scaleY ?? 1));
     ctx.translate(-cx, -cy);
   }
   /** Scene time for a timeline decision: the last painted frame's, else the loop clock's. */
@@ -7906,7 +8075,7 @@ function finishGrid(cols, rows, cells, bgRow, bgCells) {
     colProfile
   };
 }
-function layerCellFootprints(spec, opts = {}) {
+function layerCellFootprints(spec, opts = {}, sweep) {
   const scene = buildScene(spec, opts);
   const cols = Math.max(8, Math.min(200, opts.cols ?? 80));
   const rows = Math.max(8, Math.min(200, opts.rows ?? 48));
@@ -7914,14 +8083,33 @@ function layerCellFootprints(spec, opts = {}) {
   const cellW = w / cols;
   const cellH = h / rows;
   const fontScale = fontScaleFor(spec, w, h);
-  return scene.layers.map(({ layer, entities }) => {
+  return scene.layers.map(({ layer, entities }, li) => {
     if (layer.motion.type !== "static" || layer.emit || layer.links || layer.trail) return null;
     const s = layer.sprite;
-    const k = layer.transform !== void 0 || layer.group !== void 0 ? paintSize(spec, layer) : 1;
+    const sw = sweep?.get(li);
+    const own = sw ? sw.layer ?? transformRangeOf(layer.transform) : null;
+    const grp = sw ? sw.group ?? transformRangeOf(groupOf(spec, layer)?.transform) : null;
+    const k = own && grp ? maxAxisScale(own) * maxAxisScale(grp) : layer.transform !== void 0 || layer.group !== void 0 ? maxAxisScale(transformRangeOf(layer.transform)) * maxAxisScale(transformRangeOf(groupOf(spec, layer)?.transform)) : 1;
+    const pivot = own ? transformOrigin(layer.transform ?? {}, layer, w, h, scale) : null;
+    const centre = { x: w / 2, y: h / 2 };
     const cells = /* @__PURE__ */ new Set();
     for (const e of entities) {
       if (e.orbitParent || e.cyclePeriod > 0) return null;
-      const p = posOf(scene, e, 0);
+      let box;
+      if (own && grp && pivot) {
+        const lb = sweptBox(own, positionAt(e, 0, w, h), pivot, scale);
+        box = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+        for (const x of [lb.x0, lb.x1]) {
+          for (const y of [lb.y0, lb.y1]) {
+            const gb = sweptBox(grp, { x, y }, centre, scale);
+            box = { x0: Math.min(box.x0, gb.x0), y0: Math.min(box.y0, gb.y0), x1: Math.max(box.x1, gb.x1), y1: Math.max(box.y1, gb.y1) };
+          }
+        }
+      } else {
+        const q = posOf(scene, e, 0);
+        box = { x0: q.x, y0: q.y, x1: q.x, y1: q.y };
+      }
+      const p = { x: (box.x0 + box.x1) / 2, y: (box.y0 + box.y1) / 2 };
       const grow = 1 + Math.abs(e.growAmp);
       const sz = e.size * grow * k;
       const per = e.size > 0 ? sz / e.size : 1;
@@ -7947,11 +8135,11 @@ function layerCellFootprints(spec, opts = {}) {
         const b = s.kind === "text" ? textBox(s, e, p, fontScale, scale) : textBlockBox(s, e, p, w, h);
         reach = Math.hypot(Math.abs(b.cx - p.x) + b.halfX, Math.abs(b.cy - p.y) + b.halfY) * grow * Math.max(1, k);
       } else reach = sz;
-      if (!Number.isFinite(reach) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return null;
-      const c0 = Math.max(0, Math.floor((p.x - reach - 1) / cellW));
-      const c1 = Math.min(cols - 1, Math.floor((p.x + reach + 1) / cellW));
-      const r0 = Math.max(0, Math.floor((p.y - reach - 1) / cellH));
-      const r1 = Math.min(rows - 1, Math.floor((p.y + reach + 1) / cellH));
+      if (!Number.isFinite(reach) || ![box.x0, box.x1, box.y0, box.y1].every(Number.isFinite)) return null;
+      const c0 = Math.max(0, Math.floor((box.x0 - reach - 1) / cellW));
+      const c1 = Math.min(cols - 1, Math.floor((box.x1 + reach + 1) / cellW));
+      const r0 = Math.max(0, Math.floor((box.y0 - reach - 1) / cellH));
+      const r1 = Math.min(rows - 1, Math.floor((box.y1 + reach + 1) / cellH));
       for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) cells.add(r * cols + c);
     }
     return [...cells].sort((a, b) => a - b);
@@ -8360,7 +8548,7 @@ function diffScenes(a, b, opts = {}) {
   const colB = sceneColour(b, opts);
   const motA = motionStats(a, opts);
   const motB = motionStats(b, opts);
-  const weighted = (stats, dom) => {
+  const weighted2 = (stats, dom) => {
     let acc = 0;
     let n = 0;
     for (const m of stats) {
@@ -8378,8 +8566,8 @@ function diffScenes(a, b, opts = {}) {
     const vb = mb?.meanSpeedVp ?? 0;
     return { key, a: va, b: vb, delta: vb - va, headingA: ma?.heading ?? null, headingB: mb?.heading ?? null };
   }).filter((m) => Math.abs(m.delta) > 1e-9 || m.headingA !== m.headingB).sort((x, y) => Math.abs(y.delta) - Math.abs(x.delta));
-  const overallA = weighted(motA, domA);
-  const overallB = weighted(motB, domB);
+  const overallA = weighted2(motA, domA);
+  const overallB = weighted2(motB, domB);
   return {
     t,
     coverage: { a: gridA.coverage, b: gridB.coverage, delta: gridB.coverage - gridA.coverage },
@@ -8502,29 +8690,78 @@ function lumaTracks(spec) {
   if (!tl) return { tracks: [], lap: 0 };
   const lap = tl.loop && tl.duration ? tl.duration : 0;
   const tracks = [];
+  const laps = (ts) => lap ? [...ts, ...ts.map((b) => b + lap)] : ts;
   for (const [path, keys] of timelineTracks(spec)) {
     if (!LUMA_PATH.test(path)) continue;
     const bounds = [];
-    for (const k of keys) {
+    const owners = /* @__PURE__ */ new Map();
+    const jumpAt = [];
+    keys.forEach((k, i) => {
       const dur = k.dur ?? DEFAULT_KEY_DUR;
-      bounds.push(k.t);
-      if (dur > 0) bounds.push(k.t + dur);
-    }
-    tracks.push({ path, times: lap ? [...bounds, ...bounds.map((b) => b + lap)] : bounds });
+      const own = (t) => {
+        bounds.push(t);
+        owners.set(t, (owners.get(t) ?? /* @__PURE__ */ new Set()).add(i));
+      };
+      own(k.t);
+      if (dur > 0) own(k.t + dur);
+      if (dur <= 0) jumpAt.push([k.t, i]);
+      else if (k.ease === "step") jumpAt.push([k.t + dur, i]);
+    });
+    const shared = (t, i) => [...owners.get(t) ?? [], ...lap && t === 0 ? owners.get(lap) ?? [] : []].some((j) => j !== i);
+    const jumps = [...new Set(jumpAt.filter(([t, i]) => shared(t, i)).map(([t]) => t))];
+    tracks.push({ path, times: laps(bounds), jumps: laps(jumps) });
   }
   return { tracks, lap };
 }
+function weighted(tracks) {
+  const extra = new Set(tracks.flatMap((tr) => tr.jumps));
+  return { times: [...new Set(tracks.flatMap((tr) => tr.times))].sort((a, b) => a - b), weight: (t) => extra.has(t) ? 2 : 1 };
+}
 function lumaKeyTimes(spec) {
   const { tracks, lap } = lumaTracks(spec);
-  return { times: [...new Set(tracks.flatMap((tr) => tr.times))].sort((a, b) => a - b), lap };
+  return { times: weighted(tracks).times, lap };
 }
 var PAINT_LEAF = /(^|\.)(opacity|alpha|color|fill)(\.\d+)?$|(^|\.)gradient(\.|$)|(^|\.)draw\.(start|end)$/;
+var MONOTONE_EASES = /* @__PURE__ */ new Set([void 0, "step", "linear", "smooth", "in", "out", "spring"]);
+function widenTransform(r, base, field, keys) {
+  const take = (f, v) => {
+    if (typeof v !== "number" || !Number.isFinite(v)) return false;
+    r[f] = [Math.min(r[f][0], v), Math.max(r[f][1], v)];
+    return true;
+  };
+  for (const k of keys) {
+    if (!MONOTONE_EASES.has(k.ease)) return false;
+    if (field !== null) {
+      if (!(field in TRANSFORM_FIELDS) || !take(field, k.value)) return false;
+      continue;
+    }
+    const v = k.value;
+    if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+    const o = v;
+    for (const name of Object.keys(o)) if (name !== "origin" && !(name in TRANSFORM_FIELDS)) return false;
+    if (o.origin !== base?.origin) return false;
+    for (const f of Object.keys(TRANSFORM_FIELDS)) if (!take(f, o[f] ?? TRANSFORM_FIELDS[f])) return false;
+  }
+  return true;
+}
 function pathCells(spec) {
   const layers = spec.layers ?? [];
   const volatile = /* @__PURE__ */ new Set();
   const members = (g) => layers.flatMap((l, i) => l.group === g ? [i] : []);
   const reach = /* @__PURE__ */ new Map();
-  for (const path of timelineTracks(spec).keys()) {
+  const layerRanges = /* @__PURE__ */ new Map();
+  const groupRanges = /* @__PURE__ */ new Map();
+  const bound = (ranges, id, base, rest, keys) => {
+    if (rest.length > 2) return false;
+    if (!ranges.has(id)) ranges.set(id, transformRangeOf(base));
+    const r = ranges.get(id);
+    if (!r || !widenTransform(r, base, rest[1] ?? null, keys)) {
+      ranges.set(id, null);
+      return false;
+    }
+    return true;
+  };
+  for (const [path, keys] of timelineTracks(spec)) {
     const [root, id, ...rest] = path.split(".");
     const leaf = rest.join(".");
     let to;
@@ -8532,18 +8769,27 @@ function pathCells(spec) {
       const n = Number(id);
       to = [n];
       if (!PAINT_LEAF.test(leaf)) {
-        if (rest[0] === "transform") volatile.add(n);
-        else for (let i = n; i < layers.length; i++) volatile.add(i);
+        if (rest[0] === "transform") {
+          if (!bound(layerRanges, n, layers[n]?.transform, rest, keys)) volatile.add(n);
+        } else for (let i = n; i < layers.length; i++) volatile.add(i);
       }
     } else if (root === "groups" && id !== void 0) {
       to = members(id);
-      if (leaf !== "opacity") for (const i of to) volatile.add(i);
+      if (leaf !== "opacity" && !(rest[0] === "transform" && bound(groupRanges, id, spec.groups?.[id]?.transform, rest, keys))) for (const i of to) volatile.add(i);
     } else if (root === "background") to = "all";
     else return null;
     if (LUMA_PATH.test(path)) reach.set(path, to);
   }
   if (reach.size === 0) return /* @__PURE__ */ new Map();
-  const footprints = layerCellFootprints(withoutTimeline(spec), { cols: COLS, rows: ROWS });
+  for (const [n, r] of layerRanges) if (!r) volatile.add(n);
+  for (const [g, r] of groupRanges) if (!r) for (const i of members(g)) volatile.add(i);
+  const sweep = /* @__PURE__ */ new Map();
+  layers.forEach((l, i) => {
+    const own = layerRanges.get(i) ?? void 0;
+    const grp = l.group !== void 0 && spec.groups?.[l.group] ? groupRanges.get(l.group) ?? void 0 : void 0;
+    if (own || grp) sweep.set(i, { layer: own, group: grp });
+  });
+  const footprints = layerCellFootprints(withoutTimeline(spec), { cols: COLS, rows: ROWS }, sweep);
   const out = /* @__PURE__ */ new Map();
   for (const [path, to] of reach) {
     if (to === "all" || to.some((i) => volatile.has(i) || !footprints[i])) out.set(path, null);
@@ -8556,23 +8802,28 @@ function cellsThatCanFlash(tracks, cellsOf, from, to) {
   for (const tr of tracks) {
     const ts = tr.times.filter((t) => t >= from && t <= to);
     if (ts.length === 0) continue;
+    const part = { times: ts, jumps: tr.jumps };
     const cells = cellsOf.get(tr.path);
-    if (cells === null || cells === void 0) for (const list of perCell) list.push(...ts);
-    else for (const c of cells) perCell[c].push(...ts);
+    if (cells === null || cells === void 0) for (const list of perCell) list.push(part);
+    else for (const c of cells) perCell[c].push(part);
   }
   let n = 0;
-  for (const list of perCell) {
-    if (list.length < MIN_BOUNDARIES) continue;
-    const ts = [...new Set(list)].sort((a, b) => a - b);
-    for (let i = 0; i + MIN_BOUNDARIES - 1 < ts.length; i++) {
-      if (ts[i + MIN_BOUNDARIES - 1] - ts[i] <= WINDOW + 2) {
-        n++;
-        break;
-      }
-    }
+  for (const parts of perCell) {
+    if (parts.length === 0) continue;
+    const { times: ts, weight } = weighted(parts);
+    if (denseRun(ts, weight, WINDOW + 2) !== null) n++;
   }
   return n;
 }
+function denseRun(ts, weight, span) {
+  let sum = 0;
+  for (let i = 0, e = 0; i < ts.length; i++) {
+    while (e < ts.length && ts[e] - ts[i] <= span) sum += weight(ts[e++]);
+    if (sum >= MIN_BOUNDARIES) return [i, e];
+    sum -= weight(ts[i]);
+  }
+  return null;
+}
 function flashSampleTimes(boundaries) {
   const ts = /* @__PURE__ */ new Set();
   boundaries.forEach((t, i) => {
@@ -8583,45 +8834,37 @@ function flashSampleTimes(boundaries) {
   });
   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;
+function* flashSampleChunks(spec) {
+  if (!spec.timeline) return;
   const { tracks, lap } = lumaTracks(spec);
-  const times = [...new Set(tracks.flatMap((tr) => tr.times))].sort((a, b) => a - b);
+  const { times, weight } = weighted(tracks);
   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;
+  for (let i = 0, e = 0, sum = 0; i < times.length; i++) {
+    while (e < times.length && times[e] < times[i] + WINDOW) sum += weight(times[e++]);
+    if (sum >= MIN_BOUNDARIES) {
+      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, sum);
+      } else dense.push({ from: times[i], to: times[e - 1], n: sum });
+    }
+    sum -= weight(times[i]);
+  }
+  if (dense.length === 0) return;
   dense.sort((a, b) => b.n - a.n);
   let budget = MAX_TOTAL_SAMPLES;
-  let worst = pass;
+  let over = false;
   const cellsOf = pathCells(spec);
   for (const w of dense) {
     if (cellsOf && cellsThatCanFlash(tracks, cellsOf, w.from, w.to) < Math.ceil(AREA_THRESHOLD * COLS * ROWS)) continue;
+    const at = lap ? w.from % lap : w.from;
     const sampleTimes = flashSampleTimes(times.filter((t) => t >= w.from && t <= w.to));
     for (let from = 0; from < sampleTimes.length - 1; ) {
       const chunk = sampleTimes.slice(from, from + MAX_SAMPLES);
       if (chunk.length < 2) break;
-      if (chunk.length > budget) return { ...worst, fails: true, at: lap ? w.from % lap : w.from, incomplete: true, boundariesPerSecond: w.n };
-      budget -= chunk.length;
-      const samples = chunk.map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: 16, rows: 9 }).cells.flat().map((v) => srgbToLinear2(v * 255)) }));
-      const r = analyzeFlashes(samples);
-      if (r.general.worstTileFlashesPerSecond > worst.flashesPerSecond || !worst.fails && r.general.fails) {
-        worst = {
-          fails: r.general.fails,
-          flashesPerSecond: r.general.worstTileFlashesPerSecond,
-          flashingArea: r.general.flashingAreaFraction,
-          at: lap ? w.from % lap : w.from
-        };
-      }
-      if (worst.fails) return worst;
+      if (chunk.length > budget) over = true;
+      if (!over) budget -= chunk.length;
+      yield { times: chunk, at, n: w.n, over };
       if (from + MAX_SAMPLES >= sampleTimes.length) break;
       const resume = chunk[chunk.length - 1] - WINDOW;
       let next = from + 1;
@@ -8629,11 +8872,44 @@ function timelineFlashReport(spec) {
       from = next;
     }
   }
+}
+var PASS = { fails: false, flashesPerSecond: 0, flashingArea: 0, at: null };
+var failClosed = (worst, c) => ({ ...worst, fails: true, at: c.at, incomplete: true, boundariesPerSecond: c.n });
+function timelineFlashReport(spec) {
+  let worst = { ...PASS };
+  for (const c of flashSampleChunks(spec)) {
+    if (c.over) return failClosed(worst, c);
+    const samples = c.times.map((t) => ({ t, lum: luminanceGrid(spec, { t, cols: COLS, rows: ROWS }).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: c.at
+      };
+    }
+    if (worst.fails) return worst;
+  }
   return worst;
 }
+function flashSamplingForecast(spec) {
+  let samples = 0;
+  let needed = 0;
+  let first;
+  for (const c of flashSampleChunks(spec)) {
+    needed += c.times.length;
+    if (!c.over) samples += c.times.length;
+    else first ??= c;
+  }
+  const base = { samples, needed, budget: MAX_TOTAL_SAMPLES };
+  if (!first) return { exhausted: false, at: null, ...base, report: { ...PASS } };
+  return { exhausted: true, at: first.at, boundariesPerSecond: first.n, ...base, report: failClosed({ ...PASS }, first) };
+}
 
 // src/period.ts
 var MAX_SCENE_PERIOD = 36e5;
+var SEAMLESS_PERIOD_KINDS = /* @__PURE__ */ new Set(["spin", "rock", "pulse", "grow"]);
 var PERIOD_LEAF = /(^|\.)(period|rate|every|duration|spin|speed|blink|drift)$/;
 var gcd = (a, b) => {
   while (b) [a, b] = [b, a % b];
@@ -8651,81 +8927,180 @@ function toRatio(ms) {
   return null;
 }
 var range = (r) => r === void 0 ? null : typeof r === "number" ? r : r[0] === r[1] ? r[0] : NaN;
-function scenePeriod(spec) {
+function scenePeriod(spec, skip) {
   const parts = [];
   const reasons = [];
-  const add = (label, ms) => {
-    if (!(ms > 0) || !Number.isFinite(ms)) return;
+  const add = (label, ms, kind) => {
+    if (!(ms > 0) || !Number.isFinite(ms) || skip?.has(kind)) return;
     const ratio = toRatio(ms);
     if (!ratio) reasons.push(`${label} repeats every ${Number(ms.toFixed(3))} ms, which has no exact ratio to combine`);
-    else parts.push([label, ratio[0], ratio[1]]);
+    else parts.push([label, ratio[0], ratio[1], kind]);
   };
   const tl = spec.timeline;
   if (tl && tl.keys.length > 0) {
     const keyed = tl.keys.filter((k) => PERIOD_LEAF.test(String(k.path)));
     if (keyed.length > 0) reasons.push(`timeline keys animate ${[...new Set(keyed.map((k) => String(k.path)))].join(", ")}, which sets the scene's own period`);
-    if (tl.loop && (tl.duration ?? 0) > 0) add("timeline", tl.duration);
+    if (tl.loop && (tl.duration ?? 0) > 0) add("timeline", tl.duration, "timeline");
     else reasons.push("timeline does not loop (it plays once, then holds)");
   }
   const bg = spec.background;
-  if (bg && bg.type !== "solid" && bg.drift) {
+  if (bg && bg.type !== "solid" && bg.drift && !(bg.type === "field" && bg.drift.amount === 0)) {
     const { period } = bg.drift;
-    const field = bg.type === "field" && bg.drift.amount !== 0;
-    const r = field ? toRatio(period) : null;
-    add("background drift", r ? r[0] / gcd(r[0], FIELD_BUCKET_MS) * FIELD_BUCKET_MS : period);
+    const r = bg.type === "field" ? toRatio(period) : null;
+    add("background drift", r ? r[0] / gcd(r[0], FIELD_BUCKET_MS) * FIELD_BUCKET_MS : period, "background");
   }
   if (spec.finish?.animate && ((spec.finish.grain ?? 0) > 0 || (spec.finish.dither ?? 0) > 0)) reasons.push("finish.animate steps the grain without repeating");
   spec.layers.forEach((layer, i) => {
     const at = `layers[${i}]${layer.key ? ` (${layer.key})` : ""}`;
     const rate = layer.clock?.rate ?? 1;
     const life = layer.life;
-    if (life && (life.exit !== void 0 || life.enter !== void 0 && ((life.enter ?? 0) > 0 || (life.fade ?? 1e3) > 0))) reasons.push(`${at} life builds in or out once`);
-    if (layer.pulse) add(`${at} pulse`, layer.pulse.period / rate);
-    if (layer.grow) add(`${at} grow`, layer.grow.period / rate);
-    if (layer.rock) add(`${at} rock`, layer.rock.period / rate);
-    if (layer.emit) add(`${at} emit`, layer.emit.every);
+    const staggered = (life?.stagger ?? 0) > 0;
+    if (life && (life.exit !== void 0 || life.enter !== void 0 && ((life.enter ?? 0) > 0 || (life.fade ?? 1e3) > 0 || staggered))) reasons.push(`${at} life builds in or out once`);
+    if (layer.pulse && layer.pulse.amp !== 0) add(`${at} pulse`, layer.pulse.period / rate, "pulse");
+    if (layer.grow) add(`${at} grow`, layer.grow.period / rate, "grow");
+    if (layer.rock) add(`${at} rock`, layer.rock.period / rate, "rock");
+    if (layer.emit) add(`${at} emit`, layer.emit.every, "emit");
     const spin = range(layer.spin);
-    if (spin !== null) {
+    const fold = spin !== null && spin !== 0 ? spinSymmetry(layer.sprite) : 1;
+    if (spin !== null && fold !== Infinity) {
       if (Number.isNaN(spin)) reasons.push(`${at} spin range gives each entity its own speed`);
-      else if (spin !== 0) add(`${at} spin`, 36e4 / Math.abs(spin));
+      else if (spin !== 0) add(`${at} spin${fold > 1 ? ` (${fold}-fold)` : ""}`, 36e4 / Math.abs(spin) / fold, "spin");
     }
     const sp = layer.sprite;
-    if ((sp.kind === "emoji" || sp.kind === "text") && sp.cycle && spriteVariants(sp) > 1) add(`${at} cycle`, sp.cycle.period * spriteVariants(sp) / rate);
+    if ((sp.kind === "emoji" || sp.kind === "text") && sp.cycle && spriteVariants(sp) > 1) add(`${at} cycle`, sp.cycle.period * spriteVariants(sp) / rate, "cycle");
     if (sp.kind === "textBlock" && sp.reveal) {
       if ((sp.reveal.speed ?? 0) > 0) reasons.push(`${at} reveal types itself once`);
       if (sp.reveal.caret) {
         const hz = Math.min(3, sp.reveal.caret === true ? 1.2 : sp.reveal.caret.blink ?? 1.2);
-        if (hz > 0) add(`${at} caret`, 1e3 / hz);
+        if (hz > 0) add(`${at} caret`, 1e3 / hz, "caret");
       }
     }
     const m = layer.motion;
-    if (m.type === "path") add(`${at} path`, m.duration);
+    if (m.type === "path") add(`${at} path`, m.duration, "path");
     else if (m.type === "orbit") {
       const s = range(m.speed);
       if (s === null || Number.isNaN(s)) reasons.push(`${at} orbit speed range gives each entity its own lap`);
-      else if (s !== 0) add(`${at} orbit`, 36e4 / Math.abs(s));
+      else if (s !== 0) add(`${at} orbit`, 36e4 / Math.abs(s), "orbit");
     } else if (m.type !== "static") {
       if (m.type === "drift" && m.ease?.type === "settle" && !layer.emit) reasons.push(`${at} drift settles once`);
       else reasons.push(`${at} ${m.type} motion travels at seeded per-entity speeds`);
     }
   });
   const labelled = parts.map(([l, n, d]) => `${l}: ${Number((n / d).toFixed(3))} ms`);
-  if (reasons.length > 0) return { period: null, parts: labelled, reasons };
-  if (parts.length === 0) return { period: 0, parts: labelled, reasons };
+  const kinds = parts.map(([, , , k]) => k);
+  if (reasons.length > 0) return { period: null, parts: labelled, kinds, reasons };
+  const combined = combinePeriods(parts);
+  return { ...combined, parts: labelled, kinds };
+}
+function combinePeriods(parts) {
+  if (parts.length === 0) return { period: 0, reasons: [] };
   let num = 1;
   let den = 0;
   for (const [, n, d] of parts) {
     num = num / gcd(num, n) * n;
     den = gcd(den, d);
     if (num / den > MAX_SCENE_PERIOD) {
-      return { period: null, parts: labelled, reasons: [`its parts share no cycle shorter than ${MAX_SCENE_PERIOD / 6e4} min`] };
+      return { period: null, reasons: [`its parts share no cycle shorter than ${MAX_SCENE_PERIOD / 6e4} min`] };
+    }
+  }
+  if (num % den !== 0) return { period: null, reasons: [`its parts repeat together every ${Number((num / den).toFixed(3))} ms, not a whole number of milliseconds`] };
+  return { period: num / den, reasons: [] };
+}
+function periodWithoutTimeline(spec, skip) {
+  return scenePeriod(withoutTimeline(spec), skip);
+}
+var MAX_SYMMETRY = 64;
+var MAX_SYMMETRY_POINTS = 8192;
+function spinSymmetry(sp) {
+  if (sp.kind === "circle" || sp.kind === "ring") return Infinity;
+  if (sp.kind !== "polygon" || sp.gradient) return 1;
+  if (!isPathPolygon(sp)) {
+    if (sp.points && sp.points.length >= 3) return largestSymmetry(/* @__PURE__ */ new Map([["fill", closedSegs(sp.points)]]));
+    return Math.max(3, Math.round(sp.sides ?? DEFAULT_POLYGON_SIDES));
+  }
+  if ((sp.span ?? "box") !== "box") return 1;
+  const [ox, oy] = sp.origin ?? [0, 0];
+  if (sp.soft && !sp.parts && (ox !== 0 || oy !== 0)) return 1;
+  const groups = /* @__PURE__ */ new Map();
+  const add = (key, segs) => {
+    const list = groups.get(key);
+    if (list) list.push(...segs);
+    else groups.set(key, segs);
+  };
+  const shift = (pts) => pts.map(([x, y]) => [x - ox, y - oy]);
+  for (const part of pathParts(sp)) {
+    if (part.gradient || part.stroke && drawSpan(part.stroke.draw) !== null) return 1;
+    const colour = part.color ?? "*";
+    if (part.fill && part.flat.points.length >= 3) {
+      for (const l of part.flat.lines) if (l.points.length >= 3) add(`F|${colour}|${part.rule}|${part.opacity}`, closedSegs(shift(l.points)));
+    }
+    const st = part.stroke;
+    if (st) {
+      const key = `S|${st.color}|${st.width}|${st.opacity ?? 1}|${st.join ?? ""}|${st.cap ?? ""}|${part.opacity}`;
+      for (const l of part.flat.lines) {
+        const pts = shift(l.points);
+        add(key, l.closed ? closedSegs(pts) : openSegs(pts));
+      }
     }
   }
-  if (num % den !== 0) return { period: null, parts: labelled, reasons: [`its parts repeat together every ${Number((num / den).toFixed(3))} ms, not a whole number of milliseconds`] };
-  return { period: num / den, parts: labelled, reasons };
+  return largestSymmetry(groups);
+}
+function closedSegs(pts) {
+  return pts.map(([x, y], i) => {
+    const [x2, y2] = pts[(i + 1) % pts.length];
+    return [x, y, x2, y2];
+  });
 }
-function periodWithoutTimeline(spec) {
-  return scenePeriod(withoutTimeline(spec));
+function openSegs(pts) {
+  const out = [];
+  for (let i = 0; i + 1 < pts.length; i++) out.push([pts[i][0], pts[i][1], pts[i + 1][0], pts[i + 1][1]]);
+  return out;
+}
+function largestSymmetry(groups) {
+  let radius = 0;
+  let total = 0;
+  for (const segs of groups.values()) {
+    total += segs.length;
+    for (const [ax, ay, bx, by] of segs) radius = Math.max(radius, Math.hypot(ax, ay), Math.hypot(bx, by));
+  }
+  if (radius === 0 || total === 0 || total > MAX_SYMMETRY_POINTS) return 1;
+  const eps = Math.max(2e-3 * radius, 2e-3);
+  const indexed = [...groups.values()].map((segs) => ({ grid: segGrid(segs, radius, eps), probes: segs.flatMap(([ax, ay, bx, by]) => [[ax, ay], [(ax + bx) / 2, (ay + by) / 2]]) }));
+  for (let n = MAX_SYMMETRY; n >= 2; n--) {
+    const a = 2 * Math.PI / n;
+    if (indexed.every(({ grid, probes }) => [a, -a].every((t) => {
+      const c = Math.cos(t);
+      const s = Math.sin(t);
+      return probes.every(([x, y]) => grid.near(x * c - y * s, x * s + y * c));
+    }))) return n;
+  }
+  return 1;
+}
+function segGrid(segs, radius, eps) {
+  const n = Math.max(1, Math.min(128, Math.ceil(Math.sqrt(segs.length) * 2)));
+  const lo = -radius - eps;
+  const size = 2 * (radius + eps) / n;
+  const cellOf = (v) => Math.max(0, Math.min(n - 1, Math.floor((v - lo) / size)));
+  const cells = Array.from({ length: n * n }, () => []);
+  for (const sg of segs) {
+    const [ax, ay, bx, by] = sg;
+    for (let cy = cellOf(Math.min(ay, by) - eps); cy <= cellOf(Math.max(ay, by) + eps); cy++) {
+      for (let cx = cellOf(Math.min(ax, bx) - eps); cx <= cellOf(Math.max(ax, bx) + eps); cx++) cells[cy * n + cx].push(sg);
+    }
+  }
+  return {
+    near: (x, y) => {
+      if (x < lo || y < lo || x > -lo || y > -lo) return false;
+      for (const [ax, ay, bx, by] of cells[cellOf(y) * n + cellOf(x)]) {
+        const dx = bx - ax;
+        const dy = by - ay;
+        const len2 = dx * dx + dy * dy;
+        const u = len2 > 0 ? Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / len2)) : 0;
+        if (Math.hypot(x - ax - u * dx, y - ay - u * dy) <= eps) return true;
+      }
+      return false;
+    }
+  };
 }
 
 // src/advise.ts
@@ -8969,14 +9344,15 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
   if (authored.timeline?.loop && (authored.timeline.duration ?? 0) > 0) {
     const lap = Math.round(authored.timeline.duration);
     const rest = periodWithoutTimeline(authored);
-    if (rest.period !== null && rest.period > 0 && lap % rest.period !== 0) {
+    const seam = rest.period !== null && rest.period > 0 && lap % rest.period !== 0 ? periodWithoutTimeline(authored, SEAMLESS_PERIOD_KINDS) : null;
+    if (seam && seam.period !== null && seam.period > 0 && lap % seam.period !== 0) {
       let a = lap;
-      let b = rest.period;
+      let b = seam.period;
       while (b) [a, b] = [b, a % b];
       warnings.push({
         path: "timeline.duration",
         code: "loop-seam",
-        message: `the timeline loops every ${lap} ms but the rest of the scene repeats every ${rest.period} ms (${rest.parts.join(", ")}), so the whole scene only repeats every ${lap / a * rest.period} ms \u2014 make the lap a multiple of ${rest.period} ms for one lap to loop`
+        message: `the timeline loops every ${lap} ms but ${seam.parts.join(", ")} repeat${seam.parts.length === 1 ? "s" : ""} every ${seam.period} ms, so the scene only comes round to its first frame every ${lap / a * seam.period} ms \u2014 make the lap a multiple of ${seam.period} ms for one lap to loop`
       });
     }
   }
@@ -12084,6 +12460,7 @@ export {
   SAKURA_SPEC,
   SCHEMA_EXAMPLES,
   SCHEMA_VERSION,
+  SEAMLESS_PERIOD_KINDS,
   SHARD_FALL_SPEC,
   SIGNAL_BOARD_SPEC,
   SNOWFALL_SPEC,
@@ -12132,6 +12509,7 @@ export {
   fieldRgbAt,
   fieldSampleTime,
   finishStrength,
+  flashSamplingForecast,
   flattenPath,
   grainOffset,
   grainTilePixels,
@@ -12188,6 +12566,7 @@ export {
   sequenceSwapCompatible,
   sequenceWantsFinish,
   sizeAt,
+  spinSymmetry,
   spriteIndexAt,
   spriteVariants,
   steerablePaths,