@idle-screens/schema 3.6.1 → 3.8.0

package/dist/index.js

@@ -12,6 +12,8 @@ var LIMITS = {
   // ms — caps pulse at 2 Hz (WCAG flash threshold is 3 Hz)
   maxSpin: 360,
   // degrees/sec — one full revolution per second
+  maxRotate: 360,
+  // degrees — static per-entity rotation, one turn either way
   maxGrowAmp: 0.8,
   // size breathing amplitude cap (fraction of base size)
   maxOrbitSpeed: 180,
@@ -27,9 +29,19 @@ var LIMITS = {
   maxTrailSamples: 24,
   // dots per trail
   minDriftPeriod: 1e4,
-  // ms — background drift floor (10 s)
+  // ms — background drift floor (10 s), gradient and field alike
   maxDriftAmount: 0.3,
   // fraction of gradient stop shift
+  minFieldScale: 0.5,
+  // features per short side — below this the field is one flat blob
+  maxFieldScale: 8,
+  // above this a 96 px raster cell spans more than one feature
+  maxFieldOctaves: 4,
+  minFieldBands: 2,
+  maxFieldBands: 8,
+  maxFieldQuantize: 8,
+  maxFieldDriftAmount: 1,
+  // feature units of domain travel
   maxGhosting: 0.95,
   // frame persistence cap — bounds the seek warm-up replay
   maxGhostReplayFrames: 120,
@@ -46,7 +58,8 @@ var LIMITS = {
   maxTextBlockLength: 2e3,
   minTextBlockFontSize: 0.01,
   maxTextBlockFontSize: 0.2,
-  maxTextBlockMaxWidth: 1,
+  maxTextBlockMaxWidth: 2,
+  // of min(w,h) — wider than the frame is legal; text-off-screen reports the overflow
   maxRevealSpeed: 120,
   // graphemes/sec — faster than any readable typing
   maxCaretBlinkHz: 3,
@@ -83,16 +96,19 @@ var LIMITS = {
 
 // src/steer.ts
 var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-var STEERABLE_ROOT_KEYS = /* @__PURE__ */ new Set(["ghosting", "referenceViewport"]);
+var STEERABLE_ROOT_KEYS = /* @__PURE__ */ new Set(["ghosting", "referenceViewport", "finish"]);
 function resolveSpecPath(spec, path) {
   if (!spec || typeof spec !== "object" || !path) return null;
   const parts = path.split(".");
   if (parts.some((p) => UNSAFE_KEYS.has(p))) return null;
   const s = spec;
-  if (parts[0] !== "layers" && parts[0] !== "background" && !STEERABLE_ROOT_KEYS.has(parts[0]) && Array.isArray(s.layers)) {
+  if (parts[0] !== "layers" && parts[0] !== "background" && Array.isArray(s.layers)) {
     const idx = s.layers.findIndex((l) => l && l.key === parts[0]);
-    if (idx === -1) return null;
-    parts.splice(0, 1, "layers", String(idx));
+    if (idx !== -1) {
+      parts.splice(0, 1, "layers", String(idx));
+    } else if (!STEERABLE_ROOT_KEYS.has(parts[0])) {
+      return null;
+    }
   }
   let node = spec;
   for (let i = 0; i < parts.length - 1; i++) {
@@ -149,10 +165,66 @@ function lerpSpec(from, to, k) {
   };
   return walk(from, to);
 }
+function textStringsOf(sprite) {
+  if (sprite.kind === "text") return sprite.strings;
+  if (sprite.kind === "textBlock") return [sprite.text];
+  return null;
+}
+function textStringsDiffer(a, b, i) {
+  const sa = a.layers[i]?.sprite;
+  const sb = b.layers[i]?.sprite;
+  if (!sa || !sb) return false;
+  const ta = textStringsOf(sa);
+  const tb = textStringsOf(sb);
+  if (!ta || !tb) return false;
+  return ta.length !== tb.length || ta.some((s, j) => s !== tb[j]);
+}
+var NON_RENDERED_KEYS = /* @__PURE__ */ new Set(["id", "label", "schemaVersion", "key"]);
+function morphNothingMorphable(a, b, opts = {}) {
+  if (opts.textCrossfade && a.layers.some((_, i) => textStringsDiffer(a, b, i))) return false;
+  let hasDiff = false;
+  let hasGlide = false;
+  const walk = (x, y, key) => {
+    if (key !== void 0 && NON_RENDERED_KEYS.has(key)) return;
+    if (x === y) return;
+    if (typeof x === "number" && typeof y === "number") {
+      hasDiff = true;
+      hasGlide = true;
+      return;
+    }
+    if (typeof x === "string" && typeof y === "string" && HEX.test(x) && HEX.test(y)) {
+      const ca = hexToRgb(x);
+      const cb = hexToRgb(y);
+      if (ca.some((v, i) => v !== cb[i])) {
+        hasDiff = true;
+        hasGlide = true;
+      }
+      return;
+    }
+    if (Array.isArray(x) && Array.isArray(y) && x.length === y.length) {
+      for (let i = 0; i < y.length; i++) walk(x[i], y[i]);
+      return;
+    }
+    if (x && y && typeof x === "object" && typeof y === "object" && !Array.isArray(x) && !Array.isArray(y)) {
+      const keys = /* @__PURE__ */ new Set([...Object.keys(x), ...Object.keys(y)]);
+      for (const k of keys) {
+        walk(x[k], y[k], k);
+      }
+      return;
+    }
+    hasDiff = true;
+  };
+  walk(a, b);
+  return hasDiff && !hasGlide;
+}
 function steerablePaths(spec) {
   if (!spec || typeof spec !== "object") return [];
   const SKIP = /* @__PURE__ */ new Set(["kind", "type", "key", "schemaVersion", "id", "label", "seed", "units", "motionIntensity", "mode", "curve", "layer"]);
-  const INDEXED = /* @__PURE__ */ new Set(["layers", "stops"]);
+  const INDEXED = /* @__PURE__ */ new Set(["layers", "stops", "bands"]);
+  const layers = spec.layers;
+  const shadowedRootKeys = new Set(
+    Array.isArray(layers) ? layers.map((l) => l && typeof l === "object" ? l.key : void 0).filter((k) => typeof k === "string" && STEERABLE_ROOT_KEYS.has(k)) : []
+  );
   const out = [];
   const walk = (node, prefix, key) => {
     if (Array.isArray(node) && INDEXED.has(key)) {
@@ -166,6 +238,7 @@ function steerablePaths(spec) {
     if (node && typeof node === "object") {
       for (const [k, v] of Object.entries(node)) {
         if (SKIP.has(k)) continue;
+        if (!prefix && shadowedRootKeys.has(k)) continue;
         walk(v, prefix ? `${prefix}.${k}` : k, k);
       }
       return;
@@ -175,6 +248,12 @@ function steerablePaths(spec) {
   walk(spec, "", "");
   return out;
 }
+function sequenceSteerablePaths(seq) {
+  const out = /* @__PURE__ */ new Set(["sequence.segment"]);
+  if (seq.bed) for (const p of steerablePaths(seq.bed)) out.add(`bed.${p}`);
+  for (const seg of seq.segments) for (const p of steerablePaths(seg.scene)) out.add(p);
+  return [...out];
+}
 function easeSmooth(k) {
   const c = Math.max(0, Math.min(1, k));
   return c * c * (3 - 2 * c);
@@ -182,7 +261,10 @@ function easeSmooth(k) {
 function structuralSignature(spec) {
   return JSON.stringify([
     spec.units,
-    spec.referenceViewport,
+    // Normalized against the same default every renderer uses — an omitted
+    // referenceViewport and an explicit 1080 render identically, so they must
+    // hash identically or a same-sizing morph gets rejected as structural.
+    spec.referenceViewport ?? LIMITS.referenceViewport,
     spec.layers.map((l) => {
       const s = l.sprite;
       return [
@@ -208,7 +290,10 @@ function structuralSignature(spec) {
         l.sprite.kind === "rect" ? [s.width, s.aspect] : l.sprite.kind === "bar" ? [s.length, s.thickness] : void 0,
         Array.isArray(s.colors) ? s.colors.length : void 0,
         s.colorWeights,
-        l.sprite.kind === "emoji" ? [l.sprite.glyphs.length, l.sprite.cycle?.period] : l.sprite.kind === "text" ? [l.sprite.strings.length, l.sprite.cycle?.period] : l.sprite.kind === "textBlock" ? [l.sprite.fontSize] : void 0
+        l.sprite.kind === "emoji" ? [l.sprite.glyphs.length, l.sprite.cycle?.period] : l.sprite.kind === "text" ? [l.sprite.strings.length, l.sprite.cycle?.period] : l.sprite.kind === "textBlock" ? l.sprite.anchor ? [l.sprite.fontSize, l.sprite.anchor] : [l.sprite.fontSize] : void 0,
+        // Static rotation is baked into entities (a range draws a seeded
+        // angle). Appended only when set — same rule as `anchor` above.
+        ...l.rotate !== void 0 ? [l.rotate] : []
       ];
     })
   ]);
@@ -220,7 +305,8 @@ 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 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"]);
+var KNOWN_TOP = /* @__PURE__ */ new Set(["schemaVersion", "id", "label", "seed", "motionIntensity", "density", "units", "referenceViewport", "background", "layers", "ghosting", "finish"]);
+var KNOWN_FINISH = /* @__PURE__ */ new Set(["grain", "dither", "animate"]);
 var KNOWN_LAYER = /* @__PURE__ */ new Set([
   "count",
   "sprite",
@@ -241,7 +327,8 @@ var KNOWN_LAYER = /* @__PURE__ */ new Set([
   "layout",
   "life",
   "emit",
-  "clock"
+  "clock",
+  "rotate"
 ]);
 var KNOWN_CIRCLE = /* @__PURE__ */ new Set(["kind", "radius", "color", "soft", "colors", "colorWeights"]);
 var KNOWN_RING = /* @__PURE__ */ new Set(["kind", "radius", "color", "width", "colors", "colorWeights"]);
@@ -251,8 +338,11 @@ var KNOWN_BAR = /* @__PURE__ */ new Set(["kind", "values", "length", "thickness"
 var KNOWN_POLYGON = /* @__PURE__ */ new Set(["kind", "radius", "color", "sides", "points", "soft", "colors", "colorWeights"]);
 var KNOWN_STROKE = /* @__PURE__ */ new Set(["kind", "length", "points", "color", "width", "curve", "taper", "orient", "colors", "colorWeights"]);
 var KNOWN_EMOJI = /* @__PURE__ */ new Set(["kind", "glyphs", "cycle"]);
-var KNOWN_TEXT = /* @__PURE__ */ new Set(["kind", "strings", "color", "font", "align", "baseline", "maxWidth", "cycle"]);
-var KNOWN_TEXT_BLOCK = /* @__PURE__ */ new Set(["kind", "text", "maxWidth", "fontSize", "lineHeight", "align", "color", "reveal"]);
+var KNOWN_TEXT = /* @__PURE__ */ new Set(["kind", "strings", "color", "font", "align", "baseline", "maxWidth", "cycle", "role"]);
+var KNOWN_TEXT_BLOCK = /* @__PURE__ */ new Set(["kind", "text", "maxWidth", "fontSize", "lineHeight", "align", "color", "reveal", "anchor", "font", "opacity", "role"]);
+var TEXT_ROLES = /* @__PURE__ */ new Set(["read", "atmosphere"]);
+var TEXT_BLOCK_ANCHORS = /* @__PURE__ */ new Set(["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"]);
+var FONT_SIZE_RE = /\d(?:px|pt|pc|em|rem|ex|ch|vw|vh|vmin|vmax|%)/i;
 var KNOWN_REVEAL = /* @__PURE__ */ new Set(["progress", "mode", "speed", "caret", "fade"]);
 var KNOWN_REVEAL_CARET = /* @__PURE__ */ new Set(["blink", "color"]);
 var KNOWN_DRIFT = /* @__PURE__ */ new Set(["type", "speed", "angle", "bidirectional", "bob", "ease"]);
@@ -265,7 +355,9 @@ var KNOWN_WARP = /* @__PURE__ */ new Set(["type", "speed", "center"]);
 var KNOWN_PATH = /* @__PURE__ */ new Set(["type", "points", "duration", "curve", "closed", "scatter"]);
 var KNOWN_BG_SOLID = /* @__PURE__ */ new Set(["type", "color"]);
 var KNOWN_BG_GRADIENT = /* @__PURE__ */ new Set(["type", "stops", "band", "drift"]);
-var LAYER_PROPS_ON_SPRITE = /* @__PURE__ */ new Set(["blend", "trail", "alpha", "pulse", "spin", "grow", "region", "links", "flip", "wrap", "key", "emit", "clock", "life", "layout"]);
+var KNOWN_BG_FIELD = /* @__PURE__ */ new Set(["type", "scale", "octaves", "warp", "quantize", "bands", "drift", "seed"]);
+var KNOWN_FIELD_DRIFT = /* @__PURE__ */ new Set(["period", "amount"]);
+var LAYER_PROPS_ON_SPRITE = /* @__PURE__ */ new Set(["blend", "trail", "alpha", "pulse", "spin", "grow", "region", "links", "flip", "wrap", "key", "emit", "clock", "life", "layout", "rotate"]);
 function unknownKeys(obj, known) {
   return Object.keys(obj).filter((k) => !known.has(k));
 }
@@ -321,6 +413,7 @@ function validateSpec(spec) {
     warn(k, "unknown-property", `unknown top-level property '${k}' \u2014 will be ignored`);
   }
   if (spec.background !== void 0) validateBackground(spec.background, err, warn);
+  if (spec.finish !== void 0) validateFinish(spec.finish, "finish", err, warn);
   if (!Array.isArray(spec.layers) || spec.layers.length === 0) {
     err("layers", "must be a non-empty array");
   } else {
@@ -337,6 +430,16 @@ function validateSpec(spec) {
 function color(v, path, err) {
   if (!isStr(v) || !HEX2.test(v)) err(path, "must be a hex colour like #0a3a52");
 }
+function validateFinish(f, path, err, warn) {
+  if (!isObj(f)) return err(path, "must be an object");
+  for (const k of ["grain", "dither"]) {
+    if (f[k] !== void 0 && (!isNum(f[k]) || f[k] < 0 || f[k] > 1)) err(`${path}.${k}`, "must be a number 0..1");
+  }
+  if (f.animate !== void 0 && typeof f.animate !== "boolean") err(`${path}.animate`, "must be a boolean");
+  for (const k of unknownKeys(f, KNOWN_FINISH)) {
+    warn(`${path}.${k}`, "unknown-property", `unknown finish property '${k}' \u2014 will be ignored`);
+  }
+}
 function validateBackground(bg, err, warn) {
   if (!isObj(bg)) return err("background", "must be an object");
   if (bg.type === "solid") {
@@ -374,8 +477,47 @@ function validateBackground(bg, err, warn) {
     for (const k of unknownKeys(bg, KNOWN_BG_GRADIENT)) {
       warn(`background.${k}`, "unknown-property", `unknown background property '${k}' \u2014 will be ignored`);
     }
+  } else if (bg.type === "field") {
+    validateFieldBackground(bg, err, warn);
+  } else {
+    err("background.type", "must be solid | gradient | field");
+  }
+}
+function validateFieldBackground(bg, err, warn) {
+  if (!isNum(bg.scale) || bg.scale < LIMITS.minFieldScale || bg.scale > LIMITS.maxFieldScale) {
+    err("background.scale", `must be a number ${LIMITS.minFieldScale}..${LIMITS.maxFieldScale} (features across the short side)`);
+  }
+  if (bg.octaves !== void 0 && (!isNum(bg.octaves) || !Number.isInteger(bg.octaves) || bg.octaves < 1 || bg.octaves > LIMITS.maxFieldOctaves)) {
+    err("background.octaves", `must be an integer 1..${LIMITS.maxFieldOctaves}`);
+  }
+  if (bg.warp !== void 0 && (!isNum(bg.warp) || bg.warp < 0 || bg.warp > 1)) {
+    err("background.warp", "must be a number 0..1");
+  }
+  if (bg.quantize !== void 0 && (!isNum(bg.quantize) || !Number.isInteger(bg.quantize) || bg.quantize < 0 || bg.quantize === 1 || bg.quantize > LIMITS.maxFieldQuantize)) {
+    err("background.quantize", `must be 0 (smooth) or an integer 2..${LIMITS.maxFieldQuantize}`);
+  }
+  if (!Array.isArray(bg.bands) || bg.bands.length < LIMITS.minFieldBands || bg.bands.length > LIMITS.maxFieldBands) {
+    err("background.bands", `must be ${LIMITS.minFieldBands}..${LIMITS.maxFieldBands} hex colours`);
   } else {
-    err("background.type", "must be solid | gradient");
+    for (let i = 0; i < bg.bands.length; i++) color(bg.bands[i], `background.bands[${i}]`, err);
+  }
+  if (bg.drift !== void 0) {
+    if (!isObj(bg.drift)) err("background.drift", "must be an object");
+    else {
+      if (!isNum(bg.drift.period) || bg.drift.period < LIMITS.minDriftPeriod) {
+        err("background.drift.period", `must be >= ${LIMITS.minDriftPeriod} ms`);
+      }
+      if (bg.drift.amount !== void 0 && (!isNum(bg.drift.amount) || bg.drift.amount < 0 || bg.drift.amount > LIMITS.maxFieldDriftAmount)) {
+        err("background.drift.amount", `must be a number 0..${LIMITS.maxFieldDriftAmount}`);
+      }
+      for (const k of unknownKeys(bg.drift, KNOWN_FIELD_DRIFT)) {
+        warn(`background.drift.${k}`, "unknown-property", `unknown drift property '${k}' \u2014 will be ignored`);
+      }
+    }
+  }
+  if (bg.seed !== void 0 && !isNum(bg.seed)) err("background.seed", "must be a number");
+  for (const k of unknownKeys(bg, KNOWN_BG_FIELD)) {
+    warn(`background.${k}`, "unknown-property", `unknown background property '${k}' \u2014 will be ignored`);
   }
 }
 function validateLayer(layer, path, err, warn, spec) {
@@ -464,6 +606,17 @@ function validateLayer(layer, path, err, warn, spec) {
       err(`${path}.spin`, `must be within \xB1${LIMITS.maxSpin} deg/sec`);
     }
   }
+  if (layer.rotate !== void 0) {
+    if (isRange(layer.rotate)) {
+      if (Math.abs(layer.rotate[0]) > LIMITS.maxRotate || Math.abs(layer.rotate[1]) > LIMITS.maxRotate) {
+        err(`${path}.rotate`, `each end of the range must be within \xB1${LIMITS.maxRotate} degrees`);
+      }
+    } else if (!isNum(layer.rotate)) {
+      err(`${path}.rotate`, "must be a number or a [min,max] range (degrees)");
+    } else if (Math.abs(layer.rotate) > LIMITS.maxRotate) {
+      err(`${path}.rotate`, `must be within \xB1${LIMITS.maxRotate} degrees`);
+    }
+  }
   if (layer.grow !== void 0) {
     if (!isObj(layer.grow)) err(`${path}.grow`, "must be an object");
     else {
@@ -674,6 +827,7 @@ function validateSprite(sprite, path, err, warn) {
     if (sprite.maxWidth !== void 0 && (!isNum(sprite.maxWidth) || sprite.maxWidth <= 0)) {
       err(`${path}.maxWidth`, "must be a positive number");
     }
+    validateTextRole(sprite, path, err);
     validateCycle(sprite, path, err);
   } else if (sprite.kind === "circle") {
     knownSet = KNOWN_CIRCLE;
@@ -760,6 +914,20 @@ function validateSprite(sprite, path, err, warn) {
       err(`${path}.align`, "must be 'left' | 'center' | 'right'");
     }
     if (sprite.color !== void 0) color(sprite.color, `${path}.color`, err);
+    if (sprite.anchor !== void 0 && !TEXT_BLOCK_ANCHORS.has(sprite.anchor)) {
+      err(`${path}.anchor`, "must be 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right'");
+    }
+    if (sprite.font !== void 0) {
+      if (!isStr(sprite.font) || sprite.font.trim() === "") {
+        err(`${path}.font`, "must be a non-empty string (family and/or weight)");
+      } else if (FONT_SIZE_RE.test(sprite.font)) {
+        err(`${path}.font`, "must name a family and/or weight only \u2014 fontSize owns the size");
+      }
+    }
+    if (sprite.opacity !== void 0 && (!isNum(sprite.opacity) || sprite.opacity < 0 || sprite.opacity > 1)) {
+      err(`${path}.opacity`, "must be a number between 0 and 1");
+    }
+    validateTextRole(sprite, path, err);
     if (sprite.reveal !== void 0) {
       const rv = sprite.reveal;
       if (typeof rv !== "object" || rv === null || Array.isArray(rv)) {
@@ -826,6 +994,11 @@ function validatePalette(sprite, path, err) {
     }
   }
 }
+function validateTextRole(sprite, path, err) {
+  if (sprite.role !== void 0 && !TEXT_ROLES.has(sprite.role)) {
+    err(`${path}.role`, "must be 'read' | 'atmosphere'");
+  }
+}
 function validateCycle(sprite, path, err) {
   if (sprite.cycle === void 0) return;
   if (!isObj(sprite.cycle)) return err(`${path}.cycle`, "must be an object");
@@ -998,6 +1171,7 @@ function validateSequence(seq) {
       }
     }
   }
+  if (isObj(seq) && isObj(seq.bed)) normalizeColors(seq.bed);
   const errors = [];
   const warnings = [];
   const err = (path, message) => void errors.push({ path, message });
@@ -1008,6 +1182,8 @@ function validateSequence(seq) {
   if (!isStr(seq.label) || seq.label.trim() === "") err("label", "must be a non-empty string");
   if (seq.seed !== void 0 && !isNum(seq.seed)) err("seed", "must be a number");
   if (typeof seq.loop !== "boolean") err("loop", "must be a boolean");
+  if (seq.sync !== void 0 && seq.sync !== "mount" && seq.sync !== "epoch") err("sync", "must be 'mount' | 'epoch'");
+  if (seq.finish !== void 0) validateFinish(seq.finish, "finish", err, (p, code, message) => void warnings.push({ path: p, code, message }));
   if (!Array.isArray(seq.segments) || seq.segments.length === 0) {
     err("segments", "must be a non-empty array");
     return { valid: false, errors, warnings };
@@ -1050,12 +1226,19 @@ function validateSequence(seq) {
     if (s.transition !== void 0) {
       if (!isObj(s.transition)) {
         err(`${p}.transition`, "must be an object");
-      } else if (s.transition.type === "morph") {
+      } else if (s.transition.type === "morph" || s.transition.type === "fade") {
         if (!isNum(s.transition.dur) || s.transition.dur < LIMITS.minTransitionDur || s.transition.dur > LIMITS.maxTransitionDur) {
           err(`${p}.transition.dur`, `must be a number between ${LIMITS.minTransitionDur} and ${LIMITS.maxTransitionDur}`);
         }
       } else if (s.transition.type !== "cut") {
-        err(`${p}.transition.type`, "must be 'cut' or 'morph'");
+        err(`${p}.transition.type`, "must be 'cut', 'morph' or 'fade'");
+      }
+      if (isObj(s.transition) && s.transition.text !== void 0) {
+        if (s.transition.type !== "morph") {
+          err(`${p}.transition.text`, "is a morph option (fade already cross-fades whole frames; cut has no window)");
+        } else if (s.transition.text !== "step" && s.transition.text !== "crossfade") {
+          err(`${p}.transition.text`, "must be 'step' | 'crossfade'");
+        }
       }
     }
     if (isObj(s.scene)) {
@@ -1071,6 +1254,32 @@ function validateSequence(seq) {
   if (seq.loop === true && hasDurationless) {
     err("loop", "loop: true requires all segments to have a duration");
   }
+  if (seq.bed !== void 0) {
+    if (!isObj(seq.bed)) {
+      err("bed", "must be a SaverSpec object");
+    } else {
+      const bedResult = validateSpec(seq.bed);
+      for (const e of bedResult.errors) errors.push({ path: `bed.${e.path}`, message: e.message });
+      for (const w of bedResult.warnings ?? []) warnings.push({ path: `bed.${w.path}`, code: w.code, message: w.message });
+      if (bedResult.valid) {
+        const entityTotal = (spec) => isObj(spec) && Array.isArray(spec.layers) ? spec.layers.reduce((n, l) => n + (isObj(l) && isNum(l.count) ? l.count : 0), 0) : 0;
+        const bedTotal = entityTotal(seq.bed);
+        const largest = seq.segments.reduce((m, s) => Math.max(m, isObj(s) ? entityTotal(s.scene) : 0), 0);
+        if (bedTotal + largest > LIMITS.maxTotal) {
+          err("bed", `bed entities ${bedTotal} + largest segment ${largest} = ${bedTotal + largest} exceeds cap ${LIMITS.maxTotal} (the two are live at once)`);
+        }
+        seq.segments.forEach((s, i) => {
+          if (isObj(s) && isObj(s.scene) && s.scene.background !== void 0) {
+            warnings.push({
+              path: `segments[${i}].scene.background`,
+              code: "bed-hides-segment-background",
+              message: `segment ${i} declares a background but the sequence has a bed \u2014 segments render transparently over the bed, so this background is never painted`
+            });
+          }
+        });
+      }
+    }
+  }
   if (errors.length === 0 && Array.isArray(seq.segments)) {
     for (let i = 0; i < seq.segments.length; i++) {
       const s = seq.segments[i];
@@ -1085,6 +1294,12 @@ function validateSequence(seq) {
           code: "morph-structural-mismatch",
           message: `segments ${i}\u2192${i + 1} differ structurally: morph will fall back to cut`
         });
+      } else if (morphNothingMorphable(s.scene, next.scene, { textCrossfade: s.transition.text === "crossfade" })) {
+        warnings.push({
+          path: `segments[${i}].transition`,
+          code: "morph-nothing-morphable",
+          message: `segments ${i}\u2192${i + 1} differ only in values morph cannot interpolate (strings such as textBlock.text step on the first frame): the morph will look like a cut \u2014 fade text via colour or reveal.progress`
+        });
       }
     }
   }
@@ -1473,7 +1688,10 @@ function buildEntities(layer, rng, w, h, scale = 1, countScale = 1) {
       } : {},
       // Time-structure fields (2026-09): ease draws nothing; emit's one draw
       // per entity happens in a pass AFTER this loop (see below).
-      ...ease ? { ease: { type: ease.type, tau: ease.tau } } : {}
+      ...ease ? { ease: { type: ease.type, tau: ease.tau } } : {},
+      // Static rotation (2026-09-10): a scalar draws nothing; the range form
+      // draws one value here, last, only when declared.
+      ...typeof layer.rotate === "number" ? { rotate: layer.rotate * Math.PI / 180 } : Array.isArray(layer.rotate) ? { rotate: rng.range(layer.rotate[0], layer.rotate[1]) * Math.PI / 180 } : {}
     });
     if (layer.clock) {
       const ent = out[out.length - 1];
@@ -1547,8 +1765,9 @@ function sizeAt(e, t) {
   return s > 0 ? s : 0.1;
 }
 function rotationAt(e, t) {
-  if (!e.spinSpeed) return 0;
-  return e.spinPhase + e.spinSpeed * (t / 1e3);
+  const base = e.rotate ?? 0;
+  if (!e.spinSpeed) return base;
+  return base + e.spinPhase + e.spinSpeed * (t / 1e3);
 }
 function lifeAlphaAt(life, t) {
   if (!life) return 1;
@@ -1777,18 +1996,25 @@ function linkPairs(positions, k, maxDist, doWrap, w, h) {
 }
 var CHAR_NARROW = new Set(`iIljtf1!|.,;:'"()[]{}`);
 var CHAR_WIDE = new Set("mwMWGOQD@%");
-function charWidthEm(ch) {
+var MONO_FAMILY_RE = /\b(?:ui-)?mono(?:space)?\b|courier|menlo|monaco|sfmono|consolas|inconsolata|fira\s*code|source\s*code|jetbrains|ibm\s*plex\s*mono|roboto\s*mono/i;
+function textMetricsClassFor(font) {
+  return font && MONO_FAMILY_RE.test(font) ? "mono" : "proportional";
+}
+var MONO_ADVANCE_EM = 0.6;
+function charWidthEm(ch, metrics = "proportional") {
+  if (metrics === "mono") return MONO_ADVANCE_EM;
   if (ch === " " || ch === "	") return 0.3;
   if (CHAR_NARROW.has(ch)) return 0.35;
   if (CHAR_WIDE.has(ch)) return 0.72;
   return 0.55;
 }
-function textWidthEm(str) {
+function textWidthEm(str, metrics = "proportional") {
+  if (metrics === "mono") return graphemeClusters(str).length * MONO_ADVANCE_EM;
   let w = 0;
-  for (let i = 0; i < str.length; i++) w += charWidthEm(str[i]);
+  for (let i = 0; i < str.length; i++) w += charWidthEm(str[i], metrics);
   return w;
 }
-function breakTextBlock(text, maxWidthEm) {
+function breakTextBlock(text, maxWidthEm, metrics = "proportional") {
   const paragraphs = text.split("\n");
   const lines = [];
   for (const para of paragraphs) {
@@ -1802,11 +2028,11 @@ function breakTextBlock(text, maxWidthEm) {
       continue;
     }
     let lineText = words[0];
-    let lineW = textWidthEm(lineText);
-    const spaceW = charWidthEm(" ");
+    let lineW = textWidthEm(lineText, metrics);
+    const spaceW = charWidthEm(" ", metrics);
     for (let i = 1; i < words.length; i++) {
       const word = words[i];
-      const wordW = textWidthEm(word);
+      const wordW = textWidthEm(word, metrics);
       if (lineW + spaceW + wordW <= maxWidthEm) {
         lineText += " " + word;
         lineW += spaceW + wordW;
@@ -1820,6 +2046,13 @@ function breakTextBlock(text, maxWidthEm) {
   }
   return lines;
 }
+function textBlockAnchorOffset(s, maxWPx, maxLineW, totalH) {
+  if (!s.anchor) return { dx: 0, dy: 0 };
+  const ax = s.anchor.endsWith("left") ? 0 : s.anchor.endsWith("right") ? 1 : 0.5;
+  const ay = s.anchor.startsWith("top") ? 0 : s.anchor.startsWith("bottom") ? 1 : 0.5;
+  const inkX0 = s.align === "center" ? (maxWPx - maxLineW) / 2 : s.align === "right" ? maxWPx - maxLineW : 0;
+  return { dx: -(inkX0 + ax * maxLineW), dy: -(ay * totalH) };
+}
 function isClusterExtend(cp) {
   return cp >= 768 && cp <= 879 || // combining diacritics
   cp >= 6832 && cp <= 6911 || cp >= 8400 && cp <= 8447 || cp >= 65024 && cp <= 65039 || // variation selectors
@@ -1924,6 +2157,254 @@ import {
   createRng
 } from "@idle-screens/core";
 
+// src/field.ts
+var TWO_PI = Math.PI * 2;
+var FIELD_BUCKET_MS = 100;
+var FIELD_RASTER_SHORT_SIDE = 96;
+var FIELD_RASTER_SHORT_SIDE_LOW = 48;
+var WARP_GAIN = 2;
+var DRIFT_GAIN = 1;
+var FIELD_DRIFT_DEFAULT_AMOUNT = 0.3;
+var CONTRAST = [1, 1.45, 1.8, 1.95, 2];
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function latticeHash(ix, iy, seed) {
+  let h = Math.imul(ix | 0, 668265261) ^ Math.imul(iy | 0, 374761393) ^ Math.imul(seed | 0, 2654435761);
+  h = Math.imul(h ^ h >>> 15, 2246822507);
+  h = Math.imul(h ^ h >>> 13, 3266489909);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+var smoothstep2 = (k) => k * k * (3 - 2 * k);
+function valueNoise(x, y, seed) {
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const fx = smoothstep2(x - x0);
+  const fy = smoothstep2(y - y0);
+  const a = latticeHash(x0, y0, seed);
+  const b = latticeHash(x0 + 1, y0, seed);
+  const c = latticeHash(x0, y0 + 1, seed);
+  const d = latticeHash(x0 + 1, y0 + 1, seed);
+  const top = a + (b - a) * fx;
+  const bottom = c + (d - c) * fx;
+  return top + (bottom - top) * fy;
+}
+function fbm(x, y, seed, octaves) {
+  let sum = 0;
+  let amp = 1;
+  let norm = 0;
+  let f = 1;
+  for (let i = 0; i < octaves; i++) {
+    sum += amp * valueNoise(x * f + i * 17.3, y * f + i * 31.7, seed + i * 101);
+    norm += amp;
+    amp *= 0.5;
+    f *= 2;
+  }
+  return sum / norm;
+}
+function fieldOctaves(cfg) {
+  const o = Math.round(cfg.octaves ?? 2);
+  return o < 1 ? 1 : o > 4 ? 4 : o;
+}
+function fieldSampleTime(cfg, t) {
+  return cfg.drift && cfg.drift.amount !== 0 ? Math.floor(t / FIELD_BUCKET_MS) * FIELD_BUCKET_MS : 0;
+}
+function fieldAt(u, v, t, cfg, seed) {
+  const scale = cfg.scale;
+  const octaves = fieldOctaves(cfg);
+  const s = (cfg.seed ?? seed) >>> 0;
+  let x = u * scale;
+  let y = v * scale;
+  const drift = cfg.drift;
+  if (drift) {
+    const phase = TWO_PI * t / drift.period;
+    const r = (drift.amount ?? FIELD_DRIFT_DEFAULT_AMOUNT) * DRIFT_GAIN;
+    x += r * Math.sin(phase);
+    y += r * Math.cos(phase);
+  }
+  const warp = cfg.warp ?? 0;
+  if (warp > 0) {
+    const qx = fbm(x + 5.2, y + 1.3, s + 7919, octaves) - 0.5;
+    const qy = fbm(x + 1.7, y + 9.2, s + 104729, octaves) - 0.5;
+    x += warp * WARP_GAIN * qx;
+    y += warp * WARP_GAIN * qy;
+  }
+  const raw = fbm(x, y, s, octaves);
+  return clamp01(0.5 + (raw - 0.5) * CONTRAST[octaves]);
+}
+function hexToRgb255(hex) {
+  const h = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
+  const n = parseInt(h.slice(1), 16);
+  if (Number.isNaN(n)) return [128, 128, 128];
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function rgb255Luma(rgb) {
+  return (0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]) / 255;
+}
+function fieldRgb(value, bands, quantize) {
+  const n = bands.length;
+  const q = Math.round(quantize ?? n);
+  let f;
+  if (q >= 2) {
+    const level = Math.min(q - 1, Math.floor(clamp01(value) * q));
+    f = level * (n - 1) / (q - 1);
+  } else {
+    f = clamp01(value) * (n - 1);
+  }
+  const i = Math.min(n - 2, Math.floor(f));
+  const k = f - i;
+  const a = hexToRgb255(bands[i]);
+  if (k === 0) return a;
+  const b = hexToRgb255(bands[i + 1]);
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * k),
+    Math.round(a[1] + (b[1] - a[1]) * k),
+    Math.round(a[2] + (b[2] - a[2]) * k)
+  ];
+}
+function fieldRgbAt(u, v, t, cfg, seed) {
+  return fieldRgb(fieldAt(u, v, t, cfg, seed), cfg.bands, cfg.quantize);
+}
+
+// src/finish.ts
+var GRAIN_TILE = 256;
+var DITHER_TILE = 8;
+var GRAIN_ALPHA = 0.35;
+var DITHER_ALPHA = 0.25;
+var FINISH_ANIMATE_HZ = 12;
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function finishStrength(f) {
+  return { grain: clamp012(f?.grain ?? 0), dither: clamp012(f?.dither ?? 0) };
+}
+function grainTilePixels(seed) {
+  const px = new Uint8ClampedArray(GRAIN_TILE * GRAIN_TILE * 4);
+  const s = seed >>> 0;
+  let i = 0;
+  for (let y = 0; y < GRAIN_TILE; y++) {
+    for (let x = 0; x < GRAIN_TILE; x++) {
+      const v = (latticeHash(x, y, s) + latticeHash(x, y, s + 1540483477)) / 2;
+      const g = Math.round(128 + (v - 0.5) * 255);
+      px[i++] = g;
+      px[i++] = g;
+      px[i++] = g;
+      px[i++] = 255;
+    }
+  }
+  return px;
+}
+function bayerMatrix() {
+  let m = [[0]];
+  for (let n = 1; n < DITHER_TILE; n *= 2) {
+    const next = [];
+    for (let y = 0; y < n * 2; y++) {
+      const row = [];
+      for (let x = 0; x < n * 2; x++) {
+        const base = m[y % n][x % n] * 4;
+        const quadrant = (y >= n ? 2 : 0) + (x >= n ? 1 : 0);
+        row.push(base + [0, 2, 3, 1][quadrant]);
+      }
+      next.push(row);
+    }
+    m = next;
+  }
+  return m;
+}
+function bayerTilePixels() {
+  const m = bayerMatrix();
+  const px = new Uint8ClampedArray(DITHER_TILE * DITHER_TILE * 4);
+  let i = 0;
+  for (let y = 0; y < DITHER_TILE; y++) {
+    for (let x = 0; x < DITHER_TILE; x++) {
+      const g = Math.round((m[y][x] + 0.5) / (DITHER_TILE * DITHER_TILE) * 255);
+      px[i++] = g;
+      px[i++] = g;
+      px[i++] = g;
+      px[i++] = 255;
+    }
+  }
+  return px;
+}
+function grainOffset(t, seed, animate) {
+  if (!animate) return { x: 0, y: 0 };
+  const bucket = Math.floor(t * FINISH_ANIMATE_HZ / 1e3);
+  const s = seed >>> 0;
+  return {
+    x: Math.floor(latticeHash(bucket, 1, s) * GRAIN_TILE),
+    y: Math.floor(latticeHash(bucket, 2, s) * GRAIN_TILE)
+  };
+}
+function pickScreenOp(ctx) {
+  const prev = ctx.globalCompositeOperation;
+  let op = "multiply";
+  for (const candidate of ["overlay", "soft-light"]) {
+    ctx.globalCompositeOperation = candidate;
+    if (ctx.globalCompositeOperation === candidate) {
+      op = candidate;
+      break;
+    }
+  }
+  ctx.globalCompositeOperation = prev;
+  return op;
+}
+function tileCanvas(size, pixels) {
+  const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(size, size);
+  canvas.width = size;
+  canvas.height = size;
+  const ctx = canvas.getContext("2d");
+  if (!ctx || typeof ctx.createImageData !== "function") return null;
+  const img = ctx.createImageData(size, size);
+  img.data.set(pixels);
+  ctx.putImageData(img, 0, 0);
+  return canvas;
+}
+function createFinishPass(visible, seed) {
+  const ctx = visible.getContext("2d", { alpha: false });
+  if (!ctx) return null;
+  return { canvas: visible, ctx, op: pickScreenOp(ctx), grain: null, dither: null, seed };
+}
+function createSceneCanvas(width, height) {
+  if (typeof document === "undefined") return new OffscreenCanvas(Math.max(1, width), Math.max(1, height));
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.max(1, width);
+  canvas.height = Math.max(1, height);
+  return canvas;
+}
+function pattern(fp, size, pixels) {
+  const tile = tileCanvas(size, pixels);
+  if (!tile || typeof fp.ctx.createPattern !== "function") return null;
+  return fp.ctx.createPattern(tile, "repeat");
+}
+function presentWithFinish(fp, scene, w, h, t, finish, animateAllowed, seed = fp.seed) {
+  const p = fp.ctx;
+  p.globalAlpha = 1;
+  p.globalCompositeOperation = "source-over";
+  p.drawImage(scene, 0, 0, w, h);
+  const normalizedSeed = seed >>> 0 || 1;
+  if (normalizedSeed !== fp.seed) {
+    fp.seed = normalizedSeed;
+    fp.grain = null;
+  }
+  const { grain, dither } = finishStrength(finish);
+  if (grain > 0) {
+    fp.grain ??= pattern(fp, GRAIN_TILE, grainTilePixels(fp.seed));
+    if (fp.grain) screen(fp, fp.grain, grain * GRAIN_ALPHA, grainOffset(t, fp.seed, animateAllowed && finish?.animate === true), w, h);
+  }
+  if (dither > 0) {
+    fp.dither ??= pattern(fp, DITHER_TILE, bayerTilePixels());
+    if (fp.dither) screen(fp, fp.dither, dither * DITHER_ALPHA, { x: 0, y: 0 }, w, h);
+  }
+}
+function screen(fp, pat, alpha, off, w, h) {
+  const p = fp.ctx;
+  p.save();
+  p.globalCompositeOperation = fp.op;
+  p.globalAlpha = alpha;
+  p.imageSmoothingEnabled = false;
+  p.fillStyle = pat;
+  p.translate(-off.x, -off.y);
+  p.fillRect(off.x, off.y, w, h);
+  p.restore();
+}
+
 // src/sequence.ts
 function segmentStart(seq, index) {
   let t = 0;
@@ -1967,9 +2448,70 @@ function resolveSegment(seq, T, opts = {}) {
   const lastStart = totalTimed - (segments[last].duration ?? 0);
   return { index: last, localT: t0 - lastStart, startT: lastStart };
 }
+function canMorph(seq, from) {
+  const seg = seq.segments[from];
+  if (!seg || seg.transition?.type !== "morph") return false;
+  const next = seq.segments[from + 1];
+  if (!next) return false;
+  return structuralSignature(seg.scene) === structuralSignature(next.scene);
+}
+function morphChainRoot(seq, index) {
+  let i = index;
+  while (i > 0 && canMorph(seq, i - 1)) i--;
+  return i;
+}
+function normalizeSeed(seed) {
+  return seed >>> 0 || 1;
+}
+function segmentRenderSeed(seq, index) {
+  const root = morphChainRoot(seq, index);
+  const scene = seq.segments[root]?.scene;
+  if (!scene) return void 0;
+  const raw = scene.seed ?? (seq.seed !== void 0 ? seq.seed + root : void 0);
+  return raw === void 0 ? void 0 : normalizeSeed(raw);
+}
+function bedRenderSeed(seq) {
+  if (!seq.bed) return void 0;
+  const raw = seq.bed.seed ?? (seq.seed !== void 0 ? seq.seed + LIMITS.maxSegments : void 0);
+  return raw === void 0 ? void 0 : normalizeSeed(raw);
+}
+function sequenceSwapCompatible(prev, next) {
+  if (prev.segments.length !== next.segments.length) return false;
+  if (prev.loop !== next.loop) return false;
+  if ((prev.sync ?? "mount") !== (next.sync ?? "mount")) return false;
+  if (!!prev.bed !== !!next.bed) return false;
+  if (prev.bed && next.bed) {
+    if (structuralSignature(prev.bed) !== structuralSignature(next.bed)) return false;
+    if (bedRenderSeed(prev) !== bedRenderSeed(next)) return false;
+  }
+  for (let i = 0; i < prev.segments.length; i++) {
+    const a = prev.segments[i];
+    const b = next.segments[i];
+    if (a.duration !== b.duration) return false;
+    if ((a.advance ?? "auto") !== (b.advance ?? "auto")) return false;
+    if (transitionKey(a.transition) !== transitionKey(b.transition)) return false;
+    if (structuralSignature(a.scene) !== structuralSignature(b.scene)) return false;
+    if (segmentRenderSeed(prev, i) !== segmentRenderSeed(next, i)) return false;
+  }
+  return true;
+}
+function transitionKey(tr) {
+  if (!tr || tr.type === "cut") return "cut";
+  if (tr.type === "morph") return `morph:${tr.dur}:${tr.text ?? "step"}`;
+  return `fade:${tr.dur}`;
+}
 
 // src/compile.ts
 var DEFAULT_STEER_DUR = 1e3;
+function applyRetainedDeltas(spec, deltas) {
+  let out = spec;
+  for (const d of deltas) {
+    if (!resolveSpecPath(out, d.path)) continue;
+    const next = applyDeltasToSpec(out, [d]);
+    if (validateSpec(next).valid) out = next;
+  }
+  return out;
+}
 function hexToRgba(hex, alpha) {
   const h = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
   const n = parseInt(h.slice(1), 16);
@@ -2007,11 +2549,15 @@ function manifestFor(spec) {
   };
 }
 var SpecInstance = class {
-  constructor(spec, ctx) {
+  constructor(spec, ctx, opts = {}) {
     this.spec = spec;
     this.effSpec = spec;
     this.saverCtx = ctx;
-    this.seed = (spec.seed ?? ctx.seed) >>> 0 || 1;
+    this.transparent = opts.transparent === true;
+    const tier = opts.capabilityTier;
+    this.fieldShortSide = tier === "basic" || tier === "minimal" ? FIELD_RASTER_SHORT_SIDE_LOW : FIELD_RASTER_SHORT_SIDE;
+    this.animateFinish = tier !== "basic" && tier !== "minimal";
+    this.seed = normalizeSeed(spec.seed ?? ctx.seed);
     let canvas;
     if (ctx.surface) {
       canvas = ctx.surface;
@@ -2024,8 +2570,15 @@ var SpecInstance = class {
       canvas = el;
       this.ownsCanvas = true;
     }
+    if (spec.finish !== void 0 && !this.transparent && !opts.hostPresents) {
+      const pass = createFinishPass(canvas, this.seed);
+      if (pass) {
+        this.finishPass = pass;
+        canvas = createSceneCanvas(ctx.width, ctx.height);
+      }
+    }
     this.canvas = canvas;
-    const c2d = canvas.getContext("2d", { alpha: false });
+    const c2d = canvas.getContext("2d", { alpha: this.transparent });
     if (!c2d) throw new Error("schema saver: no 2d context");
     this.ctx = c2d;
     this.w = ctx.width;
@@ -2033,12 +2586,16 @@ var SpecInstance = class {
     this.sizeCanvas();
     this.rebuild();
     this.paused = ctx.reducedMotion;
-    if (this.paused) this.renderFrame(0, this.seed);
-    else this.start();
+    if (this.paused) {
+      if (!opts.skipInitialPaint) this.renderFrame(0, this.seed);
+    } else {
+      this.start();
+    }
   }
   spec;
   canvas;
   ownsCanvas;
+  transparent;
   ctx;
   saverCtx;
   seed;
@@ -2058,6 +2615,25 @@ var SpecInstance = class {
   /** Active glide between two resolved specs (live setParam/applyTrack). */
   transition = null;
   lastStructural = "";
+  /** See `LayerPaintOverride`; null (the default, and every plain mount) draws every layer once. */
+  paintOverrides = null;
+  /** Raster short side for a `field` background — halved on the low tiers. */
+  fieldShortSide;
+  /** The `field` background's cached raster; null until a field is first painted. */
+  field = null;
+  /**
+   * The presentation pass when this instance applies a `finish`: the
+   * visible canvas plus the cached screen tiles. When set, `this.canvas` is
+   * an offscreen SCENE canvas — the surface every layer (and `ghosting`'s
+   * persistence) draws into — and each frame ends by copying it to the
+   * visible canvas and screening the finish over the copy. The finish thus
+   * never enters the persistence loop. Null (every plain mount without a
+   * finish, every sequence child) draws straight onto the visible canvas,
+   * exactly as before the field existed.
+   */
+  finishPass = null;
+  /** False on the `basic`/`minimal` tiers — `finish.animate` renders as a static tile. */
+  animateFinish;
   /** Viewport factor for absolute px sizes — 1 for `units: 'px'` specs. */
   fontScale() {
     if (this.effSpec.units === "px") return 1;
@@ -2068,6 +2644,11 @@ var SpecInstance = class {
     this.canvas.width = Math.max(1, Math.round(this.w * dpr));
     this.canvas.height = Math.max(1, Math.round(this.h * dpr));
     this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    if (this.finishPass) {
+      this.finishPass.canvas.width = this.canvas.width;
+      this.finishPass.canvas.height = this.canvas.height;
+      this.finishPass.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    }
     this.lastRenderT = Number.NEGATIVE_INFINITY;
   }
   /** (Re)seed and place all entities — deterministic for the seed + viewport. */
@@ -2109,6 +2690,10 @@ var SpecInstance = class {
       ctx.fillRect(0, 0, w, h);
       return;
     }
+    if (bg.type === "field") {
+      this.drawField(bg, t);
+      return;
+    }
     const g = ctx.createLinearGradient(0, 0, 0, h);
     const drift = bg.drift;
     for (let i = 0; i < bg.stops.length; i++) {
@@ -2129,6 +2714,58 @@ var SpecInstance = class {
       ctx.fillRect(0, h - bh, w, bh);
     }
   }
+  /**
+   * Paint a `field` background: sample the field into a low-res raster (short
+   * side `fieldShortSide`, the long side by aspect) and draw it scaled to the
+   * canvas — nearest-neighbour for quantised bands so contours stay crisp,
+   * smoothed for `quantize: 0`. The raster is recomputed only when its key
+   * changes: the config (steering glides it), the canvas size, or — while
+   * drifting — the 100 ms bucket `t` falls in (`fieldSampleTime`); a static
+   * field is sampled exactly once per mount. `luminanceGrid` samples the same
+   * function at the same bucketed time, so perception and paint agree.
+   */
+  drawField(bg, t) {
+    const { ctx, w, h } = this;
+    const short = Math.max(1, Math.min(w, h));
+    const cols = Math.max(1, Math.round(this.fieldShortSide * w / short));
+    const rows = Math.max(1, Math.round(this.fieldShortSide * h / short));
+    const ft = fieldSampleTime(bg, t);
+    const key = `${JSON.stringify(bg)}|${w}x${h}|${cols}x${rows}|${ft}`;
+    let raster = this.field;
+    if (!raster || raster.key !== key) {
+      if (!raster || raster.cols !== cols || raster.rows !== rows) {
+        const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(cols, rows);
+        canvas.width = cols;
+        canvas.height = rows;
+        const rctx = canvas.getContext("2d");
+        if (!rctx) return;
+        raster = { canvas, ctx: rctx, cols, rows, key: "" };
+      }
+      const img = raster.ctx.createImageData(cols, rows);
+      const data = img.data;
+      const seed = this.seed;
+      let i = 0;
+      for (let r = 0; r < rows; r++) {
+        const v = (r + 0.5) * h / rows / short;
+        for (let c = 0; c < cols; c++) {
+          const u = (c + 0.5) * w / cols / short;
+          const rgb = fieldRgbAt(u, v, ft, bg, seed);
+          data[i++] = rgb[0];
+          data[i++] = rgb[1];
+          data[i++] = rgb[2];
+          data[i++] = 255;
+        }
+      }
+      raster.ctx.putImageData(img, 0, 0);
+      raster.key = key;
+      this.field = raster;
+    }
+    const smooth = Math.round(bg.quantize ?? bg.bands.length) < 2;
+    const prev = ctx.imageSmoothingEnabled;
+    ctx.imageSmoothingEnabled = smooth;
+    ctx.drawImage(raster.canvas, 0, 0, w, h);
+    ctx.imageSmoothingEnabled = prev;
+  }
   /** Position with parent-orbit resolution: a layer-parented orbit entity's
    *  positionAt is an offset around (0,0); add the parent's own analytic position. */
   entityPos(e, t, parentE) {
@@ -2194,14 +2831,14 @@ var SpecInstance = class {
       ctx.fill();
     }
   }
-  drawEntity(built, e, t, lifeA, parentE) {
+  drawEntity(built, e, t, lifeA, parentE, paint) {
     const { ctx } = this;
     const p = this.entityPos(e, t, parentE);
-    const sprite = built.layer.sprite;
+    const sprite = paint?.sprite ?? built.layer.sprite;
     const sz = sizeAt(e, t);
     const rot = rotationAt(e, t);
     const unitScale = this.effSpec.units === "px" ? 1 : Math.min(this.w, this.h);
-    ctx.globalAlpha = alphaAt(e, t) * lifeA;
+    ctx.globalAlpha = alphaAt(e, t) * lifeA * (paint?.alpha ?? 1);
     if (sprite.kind === "ring") {
       const r = sz / 2;
       const resolvedColor = sprite.colors?.[e.colorIndex] ?? sprite.color;
@@ -2353,7 +2990,7 @@ var SpecInstance = class {
       const lh = (sprite.lineHeight ?? 1.4) * fsPx;
       const maxWPx = sprite.maxWidth * unitScale2;
       const maxWEm = maxWPx / fsPx;
-      const lines = breakTextBlock(sprite.text, maxWEm);
+      const lines = breakTextBlock(sprite.text, maxWEm, textMetricsClassFor(sprite.font));
       const align = sprite.align ?? "left";
       const reveal = sprite.reveal;
       const rs = reveal ? revealState(lines, reveal, t) : null;
@@ -2361,7 +2998,13 @@ var SpecInstance = class {
       ctx.save();
       ctx.translate(p.x, p.y);
       if (rot) ctx.rotate(rot);
-      ctx.font = `${fsPx}px system-ui, sans-serif`;
+      if (sprite.anchor) {
+        const maxLineW = lines.reduce((m, l) => Math.max(m, l.widthEm), 0) * fsPx;
+        const { dx, dy } = textBlockAnchorOffset(sprite, maxWPx, maxLineW, lines.length * lh);
+        if (dx !== 0 || dy !== 0) ctx.translate(dx, dy);
+      }
+      if (sprite.opacity !== void 0) ctx.globalAlpha *= sprite.opacity;
+      ctx.font = sprite.font ? composeFontShorthand(fsPx, sprite.font) : `${fsPx}px system-ui, sans-serif`;
       ctx.fillStyle = sprite.color ?? "#e6e8ef";
       ctx.textBaseline = "top";
       ctx.textAlign = align;
@@ -2475,6 +3118,33 @@ var SpecInstance = class {
       this.renderFrame(this.lastT, this.seed);
     }
   }
+  /**
+   * Apply steering deltas immediately: no glide, no frame painted. Each delta
+   * is routed by `applyRetainedDeltas` (unresolvable or invalid ones are
+   * skipped on this spec alone). `SequenceInstance` uses this to hand a
+   * freshly created child the track the sequence has retained, so a steer
+   * made while another segment was active lands on the segment that owns the
+   * path. Not painting matters: a child is created inside the parent's
+   * renderFrame, and a stray t=0 paint here would make the real frame that
+   * follows look "contiguous" to the ghosting warm-up — but the constructor
+   * already painted ONE stray t=0 frame of the pre-steer spec (SpecInstance's
+   * own mount does an immediate render when paused, which every sequence
+   * child is), so `lastRenderT` must be reset too: otherwise, with `ghosting`
+   * on, the real frame that follows still finds itself "contiguous" with
+   * that stray paint and composites over it at partial alpha, briefly
+   * showing a ghost of the un-steered scene.
+   */
+  applyDeltasNow(deltas) {
+    const next = applyRetainedDeltas(this.effSpec, deltas);
+    if (next === this.effSpec) return;
+    this.transition = null;
+    this.lastRenderT = Number.NEGATIVE_INFINITY;
+    this.effSpec = next;
+    if (structuralSignature(this.effSpec) !== this.lastStructural) this.rebuild();
+    else this.layers.forEach((b, i) => {
+      b.layer = this.effSpec.layers[i] ?? b.layer;
+    });
+  }
   drawLinks(built, t, lifeA, parentE) {
     const { links } = built.layer;
     if (!links) return;
@@ -2520,19 +3190,28 @@ var SpecInstance = class {
    *  showing through — the ghosting smear. */
   paintFrame(t, bgAlpha) {
     const { ctx } = this;
-    ctx.globalAlpha = bgAlpha;
-    ctx.globalCompositeOperation = "source-over";
-    this.drawBackground(t);
+    if (!this.transparent) {
+      ctx.globalAlpha = bgAlpha;
+      ctx.globalCompositeOperation = "source-over";
+      this.drawBackground(t);
+    }
     ctx.globalAlpha = 1;
-    for (const built of this.layers) {
+    for (let li = 0; li < this.layers.length; li++) {
+      const built = this.layers[li];
       const lifeA = lifeAlphaAt(built.layer.life, t);
       if (lifeA <= 0) continue;
       const parentE = this.parentEntityFor(built);
       ctx.globalCompositeOperation = built.layer.blend ?? "source-over";
       this.drawLinks(built, t, lifeA, parentE);
+      const override = this.paintOverrides?.get(li) ?? null;
       for (const e of built.entities) {
         this.drawTrail(built, e, t, lifeA, parentE);
-        this.drawEntity(built, e, t, lifeA, parentE);
+        if (override === null) {
+          this.drawEntity(built, e, t, lifeA, parentE);
+          continue;
+        }
+        if (override.k < 1) this.drawEntity(built, e, t, lifeA, parentE, { sprite: override.outgoing, alpha: 1 - override.k });
+        if (override.k > 0) this.drawEntity(built, e, t, lifeA, parentE, { alpha: override.k });
       }
     }
     ctx.globalAlpha = 1;
@@ -2549,7 +3228,7 @@ var SpecInstance = class {
    */
   renderFrame(t, _seed) {
     this.stepTransition(t);
-    const g = this.effSpec.ghosting ?? 0;
+    const g = this.transparent ? 0 : this.effSpec.ghosting ?? 0;
     if (g > 0) {
       const dt = 1e3 / 60;
       const contiguous = this.lastRenderT !== Number.NEGATIVE_INFINITY && t > this.lastRenderT && t - this.lastRenderT <= 250;
@@ -2566,6 +3245,7 @@ var SpecInstance = class {
       this.paintFrame(t, 1);
     }
     this.lastRenderT = t;
+    if (this.finishPass) presentWithFinish(this.finishPass, this.canvas, this.w, this.h, t, this.effSpec.finish, this.animateFinish);
   }
   setPaused(paused) {
     this.paused = paused;
@@ -2585,8 +3265,8 @@ var SpecInstance = class {
   }
   /**
    * Replace the rendered spec without triggering a transition glide.
-   * Checks structural signature — use `hotSwapPaint` when the caller
-   * already knows the signature is unchanged (e.g. mid-morph lerp).
+   * Checks structural signature — use `hotSwapPaint` only when the caller
+   * already knows the signature is unchanged.
    */
   hotSwapSpec(spec) {
     this.effSpec = spec;
@@ -2603,20 +3283,37 @@ var SpecInstance = class {
       b.layer = this.effSpec.layers[i] ?? b.layer;
     });
   }
+  /**
+   * Internal (see `LayerPaintOverride`): draw the listed layers twice —
+   * outgoing sprite at `1 − k`, own sprite at `k` — until cleared with
+   * `null`. Keyed by layer index. A `SequenceInstance` sets it per morph
+   * frame under `text: 'crossfade'`; nothing else does.
+   */
+  setLayerPaintOverrides(overrides) {
+    this.paintOverrides = overrides && overrides.size > 0 ? overrides : null;
+  }
   dispose() {
     this.stop();
-    if (this.ownsCanvas && typeof HTMLCanvasElement !== "undefined" && this.canvas instanceof HTMLCanvasElement) this.canvas.remove();
+    this.field = null;
+    const visible = this.finishPass?.canvas ?? this.canvas;
+    this.finishPass = null;
+    if (this.ownsCanvas && typeof HTMLCanvasElement !== "undefined" && visible instanceof HTMLCanvasElement) visible.remove();
   }
 };
 function compileSaver(spec) {
   const valid = assertValidSpec(spec);
   return {
     manifest: manifestFor(valid),
-    mount: (ctx) => new SpecInstance(valid, ctx),
+    mount: (ctx) => new SpecInstance(valid, ctx, { capabilityTier: ctx.capabilityTier }),
     spec: valid
   };
 }
+var BED_PREFIX = "bed.";
+function hasHotSwapSequence(inst) {
+  return typeof inst.hotSwapSequence === "function";
+}
 var SequenceInstance = class {
+  /** Replaced wholesale by `hotSwapSequence`; every per-segment lookup (`segmentStart`, `canMorph`, `childScene`) reads it live, so there are no derived tables to refresh. */
   seq;
   childCtx;
   canvas;
@@ -2646,8 +3343,76 @@ var SequenceInstance = class {
    */
   clockOffset = 0;
   releasedBelow = 0;
+  /**
+   * Set by a `sequence.segment` steer that targets segment 0 under `loop:
+   * true`: the steer resets the clock to segment 0's own start (localT 0),
+   * so `renderFrame`'s wrap check (which compares the raw, ever-increasing
+   * clock against `timedTotal()`) can no longer recognize the jump as a
+   * wrap. This flag lets the clicker's jump to 0 still count as one, so the
+   * last segment's fade plays instead of a hard cut. Cleared once the wrap
+   * window (if any) has passed.
+   */
+  pendingWrapFade = false;
+  /**
+   * Every non-`sequence.segment` delta this instance has been handed, last
+   * wins per path, merged across `applyTrack` calls. Children are created
+   * lazily and disposed on every segment switch, so a steer forwarded only
+   * to the active child would evaporate at the next boundary — and a steer
+   * to a path only a *later* segment owns (`bars.sprite.values` while the title
+   * slide is up) would land nowhere. Re-applied to every child on creation
+   * and folded into the morph endpoints; each child keeps the deltas that
+   * resolve on it (see `applyRetainedDeltas`).
+   */
+  retainedDeltas = /* @__PURE__ */ new Map();
+  /**
+   * Every `bed.<path>` delta (prefix stripped, last wins per path). The bed
+   * is never re-created, so these are applied to it once on arrival — the
+   * map exists only so `hotSwapSequence` can put a steered bed colour back
+   * after the bed takes its republished scene. Absent a swap it is never read.
+   */
+  retainedBedDeltas = /* @__PURE__ */ new Map();
+  /** The outgoing segment while a `fade` runs; null otherwise. */
+  fading = null;
+  /**
+   * The incoming segment while a `fade` runs over a `bed`. Children over a
+   * bed are transparent, so a cross-fade needs both of them on canvases of
+   * their own — the incoming composited at k, the outgoing at 1 − k. Without
+   * a bed the incoming paints its own opaque ground on the shared surface and
+   * this stays null.
+   */
+  fadingIn = null;
+  /** False on the `basic`/`minimal` capability tiers — fade renders as cut. */
+  fadeEnabled;
+  /** The mount's tier, handed to every child and the bed. */
+  capabilityTier;
+  /**
+   * The sequence's presentation pass when it — or any segment — declares a
+   * `finish`: children and the bed draw into an offscreen scene canvas
+   * (`childCtx.surface`), and every frame ends by copying it to the visible
+   * surface with the finish screened over the copy — once per composed
+   * frame, bed + segment + fade together. Null when no finish is declared
+   * anywhere: children draw straight onto the visible surface, as before.
+   */
+  finishPass = null;
+  /** False on the `basic`/`minimal` tiers — `finish.animate` renders as a static tile. */
+  animateFinish;
+  /**
+   * The sequence's `bed`: one scene on the shared surface, drawn first every
+   * frame at the sequence clock — WITHOUT `clockOffset`, so a
+   * `sequence.segment` steer rewinds the segment and never the bed — and never
+   * re-created. Segments render over it transparently. Null when absent.
+   */
+  bed;
   constructor(seq, ctx) {
     this.seq = seq;
+    const { sequenceBaseT, capabilityTier, ...plainCtx } = ctx;
+    this.capabilityTier = capabilityTier;
+    this.fadeEnabled = capabilityTier !== "basic" && capabilityTier !== "minimal";
+    if (seq.sync === "epoch" && typeof sequenceBaseT === "number" && Number.isFinite(sequenceBaseT)) {
+      this.baseT = Math.max(0, sequenceBaseT);
+      this.lastT = this.baseT;
+      this.renderedT = this.baseT;
+    }
     let surface = ctx.surface ?? null;
     let canvas = null;
     if (!surface && typeof document !== "undefined") {
@@ -2659,15 +3424,42 @@ var SequenceInstance = class {
     }
     this.canvas = canvas;
     this.seed = (seq.seed ?? ctx.seed ?? 0) >>> 0 || 1;
-    this.childCtx = { ...ctx, surface, reducedMotion: true };
+    this.animateFinish = capabilityTier !== "basic" && capabilityTier !== "minimal";
+    const wantsFinish = seq.finish !== void 0 || seq.segments.some((s) => s.scene.finish !== void 0);
+    if (wantsFinish && surface) {
+      const pass = createFinishPass(surface, this.seed);
+      if (pass) {
+        this.finishPass = pass;
+        surface = createSceneCanvas(ctx.width, ctx.height);
+      }
+    }
+    this.childCtx = { ...plainCtx, surface, reducedMotion: true };
+    this.sizeVisible();
     this.children = new Array(seq.segments.length).fill(null);
+    if (seq.bed) {
+      this.bed = new SpecInstance(this.bedScene(seq.bed), this.childCtx, { capabilityTier, hostPresents: true });
+      this.bed.setPaused(true);
+    } else {
+      this.bed = null;
+    }
     this.paused = ctx.reducedMotion;
-    if (this.paused) this.renderFrame(0, this.seed);
+    if (this.paused) this.renderFrame(this.baseT, this.seed);
     else this.start();
   }
   childSeed(index, fallback) {
     return this.seq.segments[index].scene.seed ?? this.seq.seed ?? fallback;
   }
+  /**
+   * The bed's seed follows the segment rule (own seed, else the sequence seed)
+   * but offset by `maxSegments`, past every segment's `seed + index`, so a bed
+   * and segment 0 never share an entity stream and adding a segment does not
+   * re-seat the bed.
+   */
+  bedScene(bed) {
+    if (bed.seed != null) return bed;
+    if (this.seq.seed != null) return { ...bed, seed: this.seq.seed + LIMITS.maxSegments };
+    return bed;
+  }
   childScene(index) {
     const seg = this.seq.segments[index];
     if (seg.scene.seed != null) return seg.scene;
@@ -2676,29 +3468,132 @@ var SequenceInstance = class {
   }
   /** Whether the boundary from `from` to `from+1` should morph. */
   canMorph(from) {
-    const seg = this.seq.segments[from];
-    if (!seg || seg.transition?.type !== "morph") return false;
-    const next = this.seq.segments[from + 1];
-    if (!next) return false;
-    return structuralSignature(seg.scene) === structuralSignature(next.scene);
+    return canMorph(this.seq, from);
   }
   /** Walk back through consecutive morph boundaries to find the chain origin. */
   morphChainRoot(index) {
-    let i = index;
-    while (i > 0 && this.canMorph(i - 1)) i--;
-    return i;
+    return morphChainRoot(this.seq, index);
   }
   morphDur(from) {
     const tr = this.seq.segments[from]?.transition;
     return tr?.type === "morph" ? tr.dur : 0;
   }
-  ensureChild(index) {
+  /** Whether the morph out of `from` cross-fades its text (default `step`: strings switch at k > 0). */
+  morphTextCrossfades(from) {
+    const tr = this.seq.segments[from]?.transition;
+    return tr?.type === "morph" && tr.text === "crossfade";
+  }
+  /**
+   * The paint overrides for one crossfade frame: every text layer whose
+   * words differ between the outgoing and incoming specs, painting the
+   * outgoing words (in the lerped frame's paint — colour and alpha glide as
+   * usual) at `1 − k` under the incoming at `k`. Null when nothing differs,
+   * so a crossfade between same-worded twins is a plain morph frame.
+   */
+  crossfadeOverrides(specA, specB, lerped, k) {
+    let map = null;
+    for (let i = 0; i < lerped.layers.length; i++) {
+      if (!textStringsDiffer(specA, specB, i)) continue;
+      const from = specA.layers[i].sprite;
+      const now = lerped.layers[i].sprite;
+      const outgoing = from.kind === "text" && now.kind === "text" ? { ...now, strings: from.strings } : from.kind === "textBlock" && now.kind === "textBlock" ? { ...now, text: from.text } : now;
+      if (outgoing === now) continue;
+      (map ??= /* @__PURE__ */ new Map()).set(i, { outgoing, k });
+    }
+    return map;
+  }
+  /** Length of the fade out of segment `from`, or 0 (no fade, or a tier that plays it as cut). */
+  fadeDur(from) {
+    const tr = this.seq.segments[from]?.transition;
+    return this.fadeEnabled && tr?.type === "fade" ? tr.dur : 0;
+  }
+  /** Sum of every timed segment — the lap length under `loop: true`. */
+  timedTotal() {
+    const last = this.seq.segments.length - 1;
+    return segmentStart(this.seq, last) + (this.seq.segments[last].duration ?? 0);
+  }
+  releaseFading() {
+    if (this.fading) {
+      this.fading.child.dispose();
+      this.fading = null;
+    }
+    if (this.fadingIn) {
+      this.fadingIn.child.dispose();
+      this.fadingIn = null;
+    }
+  }
+  /**
+   * A segment child on a canvas of its own. Like a morph it mounts on its
+   * chain root's scene and seed (so its entities are the ones the viewer was
+   * watching) and hot-swaps to the segment's spec; the retained track is
+   * applied last. Transparent over a bed, opaque otherwise.
+   */
+  offscreenChild(index, root) {
+    const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(Math.max(1, this.childCtx.width), Math.max(1, this.childCtx.height));
+    const child = new SpecInstance(this.childScene(root), { ...this.childCtx, surface: canvas }, { transparent: this.bed !== null, capabilityTier: this.capabilityTier, hostPresents: true });
+    child.setPaused(true);
+    if (root !== index) child.hotSwapSpec(this.childScene(index));
+    if (this.retainedDeltas.size > 0) child.applyDeltasNow(this.retainedDeltas.values());
+    return { index, child, canvas };
+  }
+  /** Render an offscreen child; a transparent one never clears, so its owner does here. */
+  renderOffscreen(oc, t, seed) {
+    if (this.bed) {
+      const c = oc.canvas.getContext("2d");
+      c?.clearRect(0, 0, this.childCtx.width, this.childCtx.height);
+    }
+    oc.child.renderFrame(t, seed);
+  }
+  /** Draw an offscreen canvas onto the shared surface at `alpha`. */
+  composite(canvas, alpha) {
+    const main = this.childCtx.surface?.getContext("2d");
+    if (!main) return;
+    main.save();
+    main.globalAlpha = alpha;
+    main.globalCompositeOperation = "source-over";
+    main.drawImage(canvas, 0, 0, this.childCtx.width, this.childCtx.height);
+    main.restore();
+  }
+  /**
+   * Render the outgoing segment `from` of a live fade onto its own canvas. It
+   * keeps animating at `duration(from) + localT` (it does not freeze — and if
+   * it was an `advance: 'input'` hold it resumes from its duration, not from
+   * wherever the hold had reached). Two live segments for `dur` only; the
+   * outgoing one is disposed when the fade ends.
+   */
+  renderOutgoing(from, localT, seed) {
+    if (this.fading && this.fading.index !== from) {
+      this.fading.child.dispose();
+      this.fading = null;
+    }
+    if (!this.fading) this.fading = this.offscreenChild(from, this.morphChainRoot(from));
+    const outDur = this.seq.segments[from].duration ?? 0;
+    this.renderOffscreen(this.fading, outDur + localT, this.childSeed(this.morphChainRoot(from), seed));
+    return this.fading;
+  }
+  /** A segment's scene with the retained track applied — `scene` itself when nothing resolves on it. */
+  steeredScene(scene) {
+    return this.retainedDeltas.size === 0 ? scene : applyRetainedDeltas(scene, this.retainedDeltas.values());
+  }
+  /**
+   * The child for segment `index`, created paused on the shared surface if
+   * the slot is empty. `rootScene` (a morph chain's root) mounts the child
+   * with the root's scene so its seed and entity placement are continuous
+   * with the chain, then hot-swaps to the segment's own spec. Either way the
+   * retained track is applied last, so a steer made while another segment
+   * was up is already in effect on this child's first frame. `skipInitialPaint`
+   * is for a caller (the morph branch) that is about to render a real frame,
+   * paint overrides included, in this same call — see `SpecInstanceOptions`.
+   */
+  ensureChild(index, rootScene, skipInitialPaint) {
     if (index < 0 || index >= this.seq.segments.length) index = 0;
     let child = this.children[index];
     if (!child) {
-      child = new SpecInstance(this.childScene(index), this.childCtx);
+      child = new SpecInstance(rootScene ?? this.childScene(index), this.childCtx, { transparent: this.bed !== null, skipInitialPaint, capabilityTier: this.capabilityTier, hostPresents: true });
       this.children[index] = child;
       child.setPaused(true);
+      if (rootScene) child.hotSwapSpec(this.childScene(index));
+      if (this.retainedDeltas.size > 0) child.applyDeltasNow(this.retainedDeltas.values());
     }
     return child;
   }
@@ -2727,12 +3622,61 @@ var SequenceInstance = class {
     this.lastT = now - this.startT + this.baseT;
     this.renderFrame(this.lastT, this.seed);
   }
+  /**
+   * With a presentation pass, size the visible surface like a child sizes
+   * the scene canvas (children never touch the visible surface then).
+   */
+  sizeVisible() {
+    const fp = this.finishPass;
+    if (!fp) return;
+    const dpr = Math.min(this.childCtx.dpr, 2);
+    fp.canvas.width = Math.max(1, Math.round(this.childCtx.width * dpr));
+    fp.canvas.height = Math.max(1, Math.round(this.childCtx.height * dpr));
+    fp.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  }
+  /**
+   * The finish this frame applies: the sequence's own overrides; else the
+   * active segment's (the incoming one during a fade) — read through
+   * `steeredScene` so a retained steer to `finish.grain`/`finish.dither`
+   * takes effect immediately instead of the authored value; a bed's is
+   * ignored.
+   */
+  frameFinish() {
+    if (this.seq.finish !== void 0) return this.seq.finish;
+    if (this.activeIndex < 0) return void 0;
+    return this.steeredScene(this.childScene(this.activeIndex)).finish;
+  }
+  /**
+   * The seed `frameFinish()`'s grain resolves against — the sequence's own
+   * for a sequence-level finish, else the active segment's actual render
+   * seed (`segmentRenderSeed`: chain-root-aware and normalized exactly like
+   * `SpecInstance`, so it agrees with what that segment's entities render
+   * with, morph or not).
+   */
+  frameFinishSeed() {
+    if (this.seq.finish !== void 0) return this.seed;
+    if (this.activeIndex < 0) return this.seed;
+    return segmentRenderSeed(this.seq, this.activeIndex) ?? this.seed;
+  }
   renderFrame(T, seed) {
+    this.renderScene(T, seed);
+    if (this.finishPass) {
+      presentWithFinish(this.finishPass, this.childCtx.surface, this.childCtx.width, this.childCtx.height, T, this.frameFinish(), this.animateFinish, this.frameFinishSeed());
+    }
+  }
+  renderScene(T, seed) {
     this.renderedT = T;
     const resolved = resolveSegment(this.seq, T + this.clockOffset, { releasedBelow: this.releasedBelow });
     const { index, localT } = resolved;
+    this.bed?.renderFrame(T, this.seq.bed?.seed ?? this.seq.seed ?? seed);
     const prevIdx = index > 0 ? index - 1 : -1;
     const morphActive = prevIdx >= 0 && this.canMorph(prevIdx) && localT < this.morphDur(prevIdx);
+    const lastIdx = this.seq.segments.length - 1;
+    const wrapped = this.seq.loop && index === 0 && lastIdx > 0 && (T + this.clockOffset >= this.timedTotal() || this.pendingWrapFade);
+    const fadeFrom = prevIdx >= 0 ? prevIdx : wrapped ? lastIdx : -1;
+    const fadeActive = fadeFrom >= 0 && localT < this.fadeDur(fadeFrom);
+    if (!fadeActive && this.fading) this.releaseFading();
+    if (this.pendingWrapFade && (index !== 0 || !fadeActive)) this.pendingWrapFade = false;
     if (morphActive) {
       const chainRoot = this.morphChainRoot(index);
       this.morphFromIndex = prevIdx;
@@ -2740,12 +3684,14 @@ var SequenceInstance = class {
       for (let i = 0; i < this.children.length; i++) {
         if (i !== chainRoot) this.releaseChild(i);
       }
-      const child = this.ensureChild(chainRoot);
+      const child = this.ensureChild(chainRoot, void 0, this.morphTextCrossfades(prevIdx));
       const dur = this.morphDur(prevIdx);
       const k = easeSmooth(localT / dur);
-      const specA = this.childScene(prevIdx);
-      const specB = this.childScene(index);
-      child.hotSwapPaint(lerpSpec(specA, specB, k));
+      const specA = this.steeredScene(this.childScene(prevIdx));
+      const specB = this.steeredScene(this.childScene(index));
+      const lerped = lerpSpec(specA, specB, k);
+      child.hotSwapSpec(lerped);
+      child.setLayerPaintOverrides(this.morphTextCrossfades(prevIdx) ? this.crossfadeOverrides(specA, specB, lerped, k) : null);
       child.renderFrame(localT, this.childSeed(chainRoot, seed));
     } else {
       if (this.morphFromIndex >= 0) {
@@ -2763,17 +3709,25 @@ var SequenceInstance = class {
       const chainRoot = this.morphChainRoot(index);
       const useMorphSeed = chainRoot < index;
       const effSeed = useMorphSeed ? this.childSeed(chainRoot, seed) : this.childSeed(index, seed);
-      let child;
-      if (useMorphSeed && !this.children[index]) {
-        const rootScene = this.childScene(chainRoot);
-        child = new SpecInstance(rootScene, this.childCtx);
-        this.children[index] = child;
-        child.setPaused(true);
-        child.hotSwapSpec(this.childScene(index));
-      } else {
-        child = this.ensureChild(index);
+      if (fadeActive && this.bed) {
+        const k = easeSmooth(localT / this.fadeDur(fadeFrom));
+        if (this.fadingIn && this.fadingIn.index !== index) {
+          this.fadingIn.child.dispose();
+          this.fadingIn = null;
+        }
+        if (!this.fadingIn) this.fadingIn = this.offscreenChild(index, useMorphSeed ? chainRoot : index);
+        this.renderOffscreen(this.fadingIn, localT, effSeed);
+        const out = this.renderOutgoing(fadeFrom, localT, seed);
+        this.composite(this.fadingIn.canvas, k);
+        this.composite(out.canvas, 1 - k);
+        return;
       }
+      const child = useMorphSeed ? this.ensureChild(index, this.childScene(chainRoot)) : this.ensureChild(index);
       child.renderFrame(localT, effSeed);
+      if (fadeActive) {
+        const out = this.renderOutgoing(fadeFrom, localT, seed);
+        this.composite(out.canvas, 1 - easeSmooth(localT / this.fadeDur(fadeFrom)));
+      }
     }
   }
   setPaused(paused) {
@@ -2783,43 +3737,105 @@ var SequenceInstance = class {
     for (const child of this.children) {
       child?.setPaused(true);
     }
+    this.fading?.child.setPaused(true);
+    this.fadingIn?.child.setPaused(true);
+    this.bed?.setPaused(true);
   }
   resize(width, height, dpr) {
     this.childCtx.width = width;
     this.childCtx.height = height;
     if (dpr !== void 0) this.childCtx.dpr = dpr;
+    this.sizeVisible();
     for (const child of this.children) {
       child?.resize(width, height, dpr);
     }
+    this.fading?.child.resize(width, height, dpr);
+    this.fadingIn?.child.resize(width, height, dpr);
+    this.bed?.resize(width, height, dpr);
   }
   applyTrack(track) {
-    const deltas = track?.deltas ?? [];
+    const all = track?.deltas ?? [];
+    const isBedPath = (d) => this.bed !== null && typeof d.path === "string" && d.path.startsWith(BED_PREFIX);
+    const bedDeltas = all.filter(isBedPath).map((d) => ({ ...d, path: d.path.slice(BED_PREFIX.length) }));
+    if (bedDeltas.length > 0) {
+      for (const d of bedDeltas) this.retainedBedDeltas.set(d.path, d);
+      this.bed.applyTrack({ ...track, deltas: bedDeltas });
+    }
+    const deltas = all.filter((d) => !isBedPath(d));
+    for (const d of deltas) {
+      if (d.path !== "sequence.segment" && typeof d.path === "string") this.retainedDeltas.set(d.path, d);
+    }
     const segDelta = deltas.find((d) => d.path === "sequence.segment");
+    let switchedSegment = false;
     if (segDelta !== void 0 && typeof segDelta.value === "number") {
       const idx = Math.max(0, Math.min(this.seq.segments.length - 1, Math.round(segDelta.value)));
+      this.pendingWrapFade = this.seq.loop && idx === 0 && this.seq.segments.length > 1;
       this.clockOffset = segmentStart(this.seq, idx) - this.renderedT;
       this.releasedBelow = idx;
       this.renderFrame(this.renderedT, this.seed);
+      switchedSegment = true;
     }
     const childDeltas = deltas.filter((d) => d.path !== "sequence.segment");
-    if (childDeltas.length > 0 && this.activeIndex >= 0) {
-      const child = this.children[this.activeIndex];
-      child?.applyTrack({ ...track, deltas: childDeltas });
+    if (childDeltas.length > 0) {
+      if (this.morphFromIndex >= 0) {
+        if (!switchedSegment) this.renderFrame(this.renderedT, this.seed);
+      } else if (this.activeIndex >= 0) {
+        const child = this.children[this.activeIndex];
+        child?.applyTrack({ ...track, deltas: childDeltas });
+      }
+      this.fading?.child.applyTrack({ ...track, deltas: childDeltas });
+      this.fadingIn?.child.applyTrack({ ...track, deltas: childDeltas });
     }
   }
+  /**
+   * See `SequenceSaverInstance.hotSwapSequence`. Nothing that positions the
+   * show is touched: `clockOffset`, `releasedBelow`, `activeIndex`,
+   * `morphFromIndex`, `pendingWrapFade`, `renderedT` and the retained deltas
+   * all keep their values, and the timing terms `sequenceSwapCompatible`
+   * pins (durations, advance, transitions, loop) are the same on both sides,
+   * so `resolveSegment` at the next frame lands where it would have anyway.
+   * Each live child takes its new scene with the retained track re-applied
+   * (`steeredScene` — the same routing a fresh child gets), so steered paint
+   * survives the swap; `hotSwapSpec` keeps the entities (the signatures
+   * match) and does not reset ghosting contiguity, so a drifting entity is
+   * where it was 1 ms ago. Children are always paused, so none of them has a
+   * glide in flight for the swap to interrupt (`SpecInstance.applyTrack`
+   * snaps when paused). A morph in progress is untouched here: its chain-root
+   * child is re-lerped from the new endpoints on the very next frame.
+   */
+  hotSwapSequence(next) {
+    if (!sequenceSwapCompatible(this.seq, next)) return false;
+    this.seq = next;
+    if (this.bed && next.bed) this.bed.hotSwapSpec(applyRetainedDeltas(this.bedScene(next.bed), this.retainedBedDeltas.values()));
+    for (let i = 0; i < this.children.length; i++) {
+      this.children[i]?.hotSwapSpec(this.steeredScene(this.childScene(i)));
+    }
+    if (this.fading) this.fading.child.hotSwapSpec(this.steeredScene(this.childScene(this.fading.index)));
+    if (this.fadingIn) this.fadingIn.child.hotSwapSpec(this.steeredScene(this.childScene(this.fadingIn.index)));
+    if (this.paused) this.renderFrame(this.renderedT, this.seed);
+    return true;
+  }
   dispose() {
     this.stop();
+    this.releaseFading();
     for (let i = 0; i < this.children.length; i++) {
       this.releaseChild(i);
     }
+    this.bed?.dispose();
+    if (this.finishPass) {
+      this.finishPass.grain = null;
+      this.finishPass.dither = null;
+    }
     if (this.canvas) this.canvas.remove();
   }
 };
 function sequenceManifest(seq) {
-  const maxTotal = seq.segments.reduce((max, s) => {
+  const maxSegment = seq.segments.reduce((max, s) => {
     const t = s.scene.layers.reduce((n, l) => n + l.count, 0);
     return Math.max(max, t);
   }, 0);
+  const bedTotal = seq.bed ? seq.bed.layers.reduce((n, l) => n + l.count, 0) : 0;
+  const maxTotal = bedTotal + maxSegment;
   const costTier = maxTotal < 30 ? "idle" : maxTotal < 150 ? "low" : maxTotal < 400 ? "medium" : "high";
   return {
     id: seq.id,
@@ -2847,6 +3863,14 @@ function compileSequence(spec) {
 import { createRng as createRng2 } from "@idle-screens/core";
 
 // src/luma.ts
+function fieldRenderedRgbs(bg) {
+  const n = bg.bands.length;
+  const q = Math.round(bg.quantize ?? n);
+  if (q < 2) return bg.bands.map((hex) => hexToRgb255(hex));
+  const out = [];
+  for (let level = 0; level < q; level++) out.push(fieldRgb((level + 0.5) / q, bg.bands, q));
+  return out;
+}
 function hexLuma(hex) {
   const h = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
   const n = parseInt(h.slice(1), 16);
@@ -2875,6 +3899,10 @@ function spriteHex(layer, e) {
 function backgroundLuma(spec) {
   const bg = spec.background;
   if (!bg || bg.type === "solid") return hexLuma(bg?.color ?? "#05050a");
+  if (bg.type === "field") {
+    const rgbs = fieldRenderedRgbs(bg);
+    return rgbs.reduce((s, c) => s + rgb255Luma(c), 0) / rgbs.length;
+  }
   return bg.stops.reduce((s, st) => s + hexLuma(st.color), 0) / bg.stops.length;
 }
 function hexRgb(hex) {
@@ -2886,14 +3914,20 @@ function hexRgb(hex) {
 function backgroundRgb(spec) {
   const bg = spec.background;
   if (!bg || bg.type === "solid") return hexRgb(bg?.color ?? "#05050a");
-  const acc = bg.stops.reduce(
-    (s, st) => {
-      const c = hexRgb(st.color);
+  if (bg.type === "field") {
+    const rgbs = fieldRenderedRgbs(bg);
+    const acc2 = rgbs.reduce((s, c) => ({ r: s.r + c[0], g: s.g + c[1], b: s.b + c[2] }), { r: 0, g: 0, b: 0 });
+    return { r: acc2.r / rgbs.length / 255, g: acc2.g / rgbs.length / 255, b: acc2.b / rgbs.length / 255 };
+  }
+  const colours = bg.stops.map((st) => st.color);
+  const acc = colours.reduce(
+    (s, hex) => {
+      const c = hexRgb(hex);
       return { r: s.r + c.r, g: s.g + c.g, b: s.b + c.b };
     },
     { r: 0, g: 0, b: 0 }
   );
-  const n = bg.stops.length || 1;
+  const n = colours.length || 1;
   return { r: acc.r / n, g: acc.g / n, b: acc.b / n };
 }
 function colourSeparation(layer, sprite, bg) {
@@ -2903,6 +3937,64 @@ function colourSeparation(layer, sprite, bg) {
   const db = sprite.rgb.b - bg.rgb.b;
   return Math.sqrt((dr * dr + dg * dg + db * db) / 3);
 }
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function relativeLuminance(rgb) {
+  return 0.2126 * srgbToLinear(rgb.r) + 0.7152 * srgbToLinear(rgb.g) + 0.0722 * srgbToLinear(rgb.b);
+}
+function legibilityRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  const hi = Math.max(la, lb);
+  const lo = Math.min(la, lb);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function backgroundRgbAt(spec, yPx, h, unit, xPx, w, seed) {
+  const bg = spec.background;
+  if (!bg || bg.type === "solid") return hexRgb(bg?.color ?? "#05050a");
+  if (bg.type === "field") {
+    if (xPx === void 0 || w === void 0) return backgroundRgb(spec);
+    const short = Math.max(1, Math.min(w, h));
+    const c = fieldRgbAt(xPx / short, yPx / short, 0, bg, seed ?? spec.seed ?? 42);
+    return { r: c[0] / 255, g: c[1] / 255, b: c[2] / 255 };
+  }
+  if (bg.band) {
+    const bh = bg.band.height * unit;
+    if (yPx >= h - bh) return hexRgb(bg.band.color);
+  }
+  const stops = [...bg.stops].sort((a, b) => a.at - b.at);
+  const y = h > 0 ? Math.max(0, Math.min(1, yPx / h)) : 0;
+  const first = stops[0];
+  const last = stops[stops.length - 1];
+  if (y <= first.at) return hexRgb(first.color);
+  if (y >= last.at) return hexRgb(last.color);
+  for (let i = 1; i < stops.length; i++) {
+    const a = stops[i - 1];
+    const b = stops[i];
+    if (y > b.at) continue;
+    const span = b.at - a.at;
+    const k = span > 0 ? (y - a.at) / span : 1;
+    const ca = hexRgb(a.color);
+    const cb = hexRgb(b.color);
+    return { r: ca.r + (cb.r - ca.r) * k, g: ca.g + (cb.g - ca.g) * k, b: ca.b + (cb.b - ca.b) * k };
+  }
+  return hexRgb(last.color);
+}
+function sourceOverPlate(ground, colour, alpha) {
+  return {
+    r: ground.r + (colour.r - ground.r) * alpha,
+    g: ground.g + (colour.g - ground.g) * alpha,
+    b: ground.b + (colour.b - ground.b) * alpha
+  };
+}
+function additivePlate(ground, colour, alpha, blend) {
+  const mix = (g, c) => {
+    const v = c * alpha;
+    return blend === "lighter" ? Math.min(1, g + v) : 1 - (1 - g) * (1 - v);
+  };
+  return { r: mix(ground.r, colour.r), g: mix(ground.g, colour.g), b: mix(ground.b, colour.b) };
+}
 
 // src/cohesion.ts
 var MERGE_FLOOR = 0.35;
@@ -3114,6 +4206,8 @@ function seamsWorthWarning(layer, c, entityCount) {
 // 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;
 function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
   const warnings = [];
   const w = viewport.width;
@@ -3218,8 +4312,8 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
         const fsPx = layer.sprite.fontSize * scale;
         const lh = (layer.sprite.lineHeight ?? 1.4) * fsPx;
         const maxWPx = layer.sprite.maxWidth * scale;
-        const lines = breakTextBlock(layer.sprite.text, maxWPx / fsPx);
-        pixArea = maxWPx * lines.length * lh * 0.55;
+        const lines = breakTextBlock(layer.sprite.text, maxWPx / fsPx, textMetricsClassFor(layer.sprite.font));
+        pixArea = maxWPx * lines.length * lh * 0.55 * (layer.sprite.opacity ?? 1);
       } else {
         pixArea = e.size * e.size;
       }
@@ -3339,9 +4433,16 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
     for (const e of allEntities[li]) {
       const p = positionAt(e, 0, w, h);
       const box = s.kind === "textBlock" ? textBlockBoxAt(s, p, w, h) : textBoxAt(s, e, p, spec, w, h);
-      textBoxes.push({ li, label, ...box });
+      const alpha = Math.max(0, Math.min(1, e.alpha - e.pulseAmp)) * (s.kind === "textBlock" ? s.opacity ?? 1 : 1);
+      textBoxes.push({ li, label, alpha, ...box });
     }
   }
+  const asFraction = (b) => ({
+    x: +(b.x0 / w).toFixed(4),
+    y: +(b.y0 / h).toFixed(4),
+    w: +((b.x1 - b.x0) / w).toFixed(4),
+    h: +((b.y1 - b.y0) / h).toFixed(4)
+  });
   const tolX = w * 0.01;
   const tolY = h * 0.01;
   const offFlagged = /* @__PURE__ */ new Set();
@@ -3380,12 +4481,110 @@ function adviseSpec(spec, viewport = { width: 1920, height: 1080 }, opts = {}) {
       warnings.push({
         path: `layers[${first.li}]`,
         code: "text-overlap",
-        message: `${first.label} and ${second.label} text boxes overlap (~${Math.round(share * 100)}% of the smaller one) \u2014 they will paint over each other; move one or shrink it`
+        message: `${first.label} and ${second.label} text boxes overlap (~${Math.round(share * 100)}% of the smaller one) \u2014 they will paint over each other; move one or shrink it`,
+        // The two boxes, so an agent can move one without re-deriving the
+        // layout. Additive: the message is unchanged.
+        boxes: [asFraction(first), asFraction(second)]
+      });
+    }
+  }
+  const readFlagged = /* @__PURE__ */ new Set();
+  for (const b of textBoxes) {
+    if (readFlagged.has(b.li)) continue;
+    const layer = spec.layers[b.li];
+    const s = layer.sprite;
+    if (s.kind !== "text" && s.kind !== "textBlock" || s.role !== "read") continue;
+    const boxes = textBoxes.filter((x) => x.li === b.li);
+    readFlagged.add(b.li);
+    const ink = hexRgb(s.color ?? "#e6e8ef");
+    const textPlate = (base, alpha) => {
+      if (layer.blend === "lighter" || layer.blend === "screen") return additivePlate(base, ink, alpha, layer.blend);
+      if (layer.blend === "multiply") {
+        return {
+          r: base.r * (1 - alpha + ink.r * alpha),
+          g: base.g * (1 - alpha + ink.g * alpha),
+          b: base.b * (1 - alpha + ink.b * alpha)
+        };
+      }
+      return sourceOverPlate(base, ink, alpha);
+    };
+    let worst = null;
+    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);
+      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 };
+      }
+    }
+    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` : "";
+      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`
+      });
+    }
+    const edges = [];
+    const x0 = Math.min(...boxes.map((x) => x.x0));
+    const x1 = Math.max(...boxes.map((x) => x.x1));
+    const y0 = Math.min(...boxes.map((x) => x.y0));
+    const y1 = Math.max(...boxes.map((x) => x.y1));
+    if (x0 < w * READ_SAFE_AREA) edges.push("left");
+    if (x1 > w * (1 - READ_SAFE_AREA)) edges.push("right");
+    if (y0 < h * READ_SAFE_AREA) edges.push("top");
+    if (y1 > h * (1 - READ_SAFE_AREA)) edges.push("bottom");
+    if (edges.length > 0) {
+      warnings.push({
+        path: `layers[${b.li}]`,
+        code: "text-safe-area",
+        message: `${b.label} is declared role: 'read' but its box is within ${READ_SAFE_AREA * 100}% of the ${edges.join(" and ")} edge${edges.length === 1 ? "" : "s"} at ${w}\xD7${h} \u2014 displays crop and bezels hide that zone; move it inward`,
+        boxes: [asFraction({ x0, y0, x1, y1 })]
       });
     }
   }
   return warnings;
 }
+function brightestAdditivePlate(spec, allEntities, ground, box, w, h) {
+  let best = null;
+  for (let lj = 0; lj < spec.layers.length; lj++) {
+    const layer = spec.layers[lj];
+    const blend = layer.blend;
+    if (blend !== "lighter" && blend !== "screen") continue;
+    if (lj === box.li) continue;
+    const entities = allEntities[lj];
+    for (const e of entities) {
+      const hex = spriteHex(layer, e);
+      if (hex === null) continue;
+      const growScale = (e.motion === "warp" ? WARP_MAX_SCALE : 1) * (e.emit ? Math.max(e.emit.growFrom, e.emit.growTo) : 1);
+      const maxDim = Math.max(e.size, e.size2 ?? 0) * (1 + e.growAmp) * growScale;
+      if (maxDim < box.fs) continue;
+      if (!entityReachesBox(e, maxDim / 2, box, w, h)) continue;
+      const a = Math.min(1, e.alpha + e.pulseAmp);
+      if (a <= 0) continue;
+      const plate = additivePlate(ground, hexRgb(hex), a, blend);
+      const lum = relativeLuminance(plate);
+      if (!best || lum > best.lum) {
+        best = { rgb: plate, label: layer.key ? `\`${layer.key}\`` : `layers[${lj}]`, lum };
+      }
+    }
+  }
+  return best ? { rgb: best.rgb, label: best.label } : null;
+}
+function entityReachesBox(e, r, box, w, h) {
+  if (e.motion === "static") {
+    const p = positionAt(e, 0, w, h);
+    return p.x + r > box.x0 && p.x - r < box.x1 && p.y + r > box.y0 && p.y - r < box.y1;
+  }
+  if (e.motion === "orbit" && !e.orbitParent) {
+    const span = e.orbitR + r;
+    return e.orbitCx + span > box.x0 && e.orbitCx - span < box.x1 && e.orbitCy + span > box.y0 && e.orbitCy - span < box.y1;
+  }
+  return true;
+}
 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;
   const fontScale = spec.units === "px" ? 1 : Math.min(w, h) / (spec.referenceViewport ?? LIMITS.referenceViewport);
@@ -3397,28 +4596,39 @@ function textBoxAt(s, e, p, spec, w, h) {
   const baseline = s.baseline ?? "middle";
   const x0 = align === "left" ? p.x : align === "right" ? p.x - fw : p.x - fw / 2;
   const y0 = baseline === "top" ? p.y : baseline === "bottom" ? p.y - fh : p.y - fh / 2;
-  return { x0, y0, x1: x0 + fw, y1: y0 + fh };
+  return { x0, y0, x1: x0 + fw, y1: y0 + fh, fs: fh };
 }
 function textBlockBoxAt(s, p, w, h) {
   const unit = Math.min(w, h);
   const fsPx = s.fontSize * unit;
   const lh = (s.lineHeight ?? 1.4) * fsPx;
   const maxWPx = s.maxWidth * unit;
-  const lines = breakTextBlock(s.text, maxWPx / fsPx);
+  const lines = breakTextBlock(s.text, maxWPx / fsPx, textMetricsClassFor(s.font));
   const maxLineW = lines.reduce((mx, l) => Math.max(mx, l.widthEm), 0) * fsPx;
   const totalH = lines.length * lh;
   const align = s.align ?? "left";
   const x0 = align === "center" ? p.x + (maxWPx - maxLineW) / 2 : align === "right" ? p.x + maxWPx - maxLineW : p.x;
-  return { x0, y0: p.y, x1: x0 + maxLineW, y1: p.y + totalH };
+  const { dx, dy } = textBlockAnchorOffset(s, maxWPx, maxLineW, totalH);
+  return { x0: x0 + dx, y0: p.y + dy, x1: x0 + dx + maxLineW, y1: p.y + dy + totalH, fs: fsPx };
 }
 function adviseSequence(seq, viewport = { width: 1920, height: 1080 }) {
   const warnings = [];
   for (let i = 0; i < seq.segments.length; i++) {
     const segWarnings = adviseSpec(seq.segments[i].scene, viewport);
     for (const w of segWarnings) {
-      warnings.push({ path: `segments[${i}].scene.${w.path}`, code: w.code, message: w.message });
+      warnings.push({ path: `segments[${i}].scene.${w.path}`, code: w.code, message: w.message, boxes: w.boxes });
     }
   }
+  const fadeBound = seq.loop ? seq.segments.length : seq.segments.length - 1;
+  const fades = seq.segments.slice(0, fadeBound).filter((s) => s.transition?.type === "fade").length;
+  if (fades > 0) {
+    const first = seq.segments.slice(0, fadeBound).findIndex((s) => s.transition?.type === "fade");
+    warnings.push({
+      path: `segments[${first}].transition`,
+      code: "fade-degrades-on-low-tier",
+      message: `informational: ${fades} fade transition${fades === 1 ? "" : "s"} declared \u2014 viewers on the 'basic' or 'minimal' capability tier render fade as cut (two live segments for dur is over that budget); the show still plays`
+    });
+  }
   for (let i = 0; i < seq.segments.length - 1; i++) {
     const lumaA = backgroundLuma(seq.segments[i].scene);
     const lumaB = backgroundLuma(seq.segments[i + 1].scene);
@@ -3440,6 +4650,12 @@ function adviseSequence(seq, viewport = { width: 1920, height: 1080 }) {
           code: "morph-structural-mismatch",
           message: `segments ${i}\u2192${i + 1} differ structurally: morph will fall back to cut`
         });
+      } else if (morphNothingMorphable(seq.segments[i].scene, seq.segments[i + 1].scene, { textCrossfade: tr.text === "crossfade" })) {
+        warnings.push({
+          path: `segments[${i}].transition`,
+          code: "morph-nothing-morphable",
+          message: `segments ${i}\u2192${i + 1} differ only in values morph cannot interpolate (strings such as textBlock.text step on the first frame): the morph will look like a cut \u2014 fade text via colour or reveal.progress`
+        });
       }
     }
   }
@@ -3534,7 +4750,7 @@ function describeScene(spec, options = {}) {
     return { t, viewport: { w, h }, layers: layerSnapshots, warnings };
   });
   return {
-    spec: { id: spec.id, label: spec.label, units: spec.units ?? "px" },
+    spec: { id: spec.id, label: spec.label, units: spec.units ?? "px", ...spec.finish ? { finish: spec.finish } : {} },
     snapshots
   };
 }
@@ -3592,14 +4808,15 @@ function textBlockBox(s, _e, p, w, h) {
   const lh = (s.lineHeight ?? 1.4) * fsPx;
   const maxWPx = s.maxWidth * unitScale;
   const maxWEm = maxWPx / fsPx;
-  const lines = breakTextBlock(s.text, maxWEm);
+  const lines = breakTextBlock(s.text, maxWEm, textMetricsClassFor(s.font));
   const totalH = lines.length * lh;
   const maxLineW = lines.reduce((m, l) => Math.max(m, l.widthEm), 0) * fsPx;
   const align = s.align ?? "left";
   const cx = align === "center" ? p.x + maxWPx / 2 : align === "right" ? p.x + maxWPx - maxLineW / 2 : p.x + maxLineW / 2;
+  const { dx, dy } = textBlockAnchorOffset(s, maxWPx, maxLineW, totalH);
   return {
-    cx,
-    cy: p.y + totalH / 2,
+    cx: cx + dx,
+    cy: p.y + totalH / 2 + dy,
     halfX: maxLineW / 2,
     halfY: totalH / 2
   };
@@ -3608,7 +4825,7 @@ function textBlockRevealFraction(s, w, h, t) {
   if (!s.reveal) return 1;
   const unitScale = Math.min(w, h);
   const maxWEm = s.maxWidth * unitScale / (s.fontSize * unitScale);
-  const lines = breakTextBlock(s.text, maxWEm);
+  const lines = breakTextBlock(s.text, maxWEm, textMetricsClassFor(s.font));
   const rs = revealState(lines, s.reveal, t);
   if (rs.glyphAlphas) {
     let sum = 0;
@@ -3631,8 +4848,23 @@ function luminanceGrid(spec, opts = {}) {
   const cellH = h / rows;
   const bg = spec.background;
   const bgRow = new Array(rows).fill(0);
+  let bgCells;
   if (!bg || bg.type === "solid") {
     bgRow.fill(hexLuma(bg?.color ?? "#05050a"));
+  } else if (bg.type === "field") {
+    bgCells = new Array(cols * rows);
+    const short = Math.max(1, Math.min(w, h));
+    const seed = opts.seed ?? spec.seed ?? 42;
+    const ft = fieldSampleTime(bg, t);
+    for (let r = 0; r < rows; r++) {
+      let rowSum = 0;
+      for (let c = 0; c < cols; c++) {
+        const lum = rgb255Luma(fieldRgbAt((c + 0.5) * cellW / short, (r + 0.5) * cellH / short, ft, bg, seed));
+        bgCells[r * cols + c] = lum;
+        rowSum += lum;
+      }
+      bgRow[r] = rowSum / cols;
+    }
   } else {
     const stops = [...bg.stops].sort((a, b) => a.at - b.at);
     for (let r = 0; r < rows; r++) {
@@ -3657,7 +4889,7 @@ function luminanceGrid(spec, opts = {}) {
     }
   }
   const cells = new Array(cols * rows);
-  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) cells[r * cols + c] = bgRow[r];
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) cells[r * cols + c] = bgCells ? bgCells[r * cols + c] : bgRow[r];
   const compose = (idx, lum, a, blend) => {
     const cur = cells[idx];
     if (blend === "lighter" || blend === "screen") cells[idx] = Math.min(1, cur + lum * a);
@@ -3802,7 +5034,7 @@ function luminanceGrid(spec, opts = {}) {
         const c1 = Math.min(cols - 1, Math.floor((centerX + reachX) / cellW));
         const r0 = Math.max(0, Math.floor((centerY - reachY) / cellH));
         const r1 = Math.min(rows - 1, Math.floor((centerY + reachY) / cellH));
-        const inkWeight = (s.kind === "text" || s.kind === "emoji" || s.kind === "textBlock" ? 0.55 : 1) * (s.kind === "textBlock" ? textBlockRevealFraction(s, w, h, t) : 1);
+        const inkWeight = (s.kind === "text" || s.kind === "emoji" || s.kind === "textBlock" ? 0.55 : 1) * (s.kind === "textBlock" ? textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1) : 1);
         for (let r = r0; r <= r1; r++) {
           for (let c = c0; c <= c1; c++) {
             const dx = (c + 0.5) * cellW - centerX;
@@ -3871,6 +5103,9 @@ function luminanceGrid(spec, opts = {}) {
     }
   }
   splatPass(t, 1);
+  return finishGrid(cols, rows, cells, bgRow, bgCells);
+}
+function finishGrid(cols, rows, cells, bgRow, bgCells) {
   let sum = 0;
   let covered = 0;
   let devSum = 0;
@@ -3882,7 +5117,7 @@ function luminanceGrid(spec, opts = {}) {
     for (let c = 0; c < cols; c++) {
       const v = cells[r * cols + c];
       sum += v;
-      const dev = Math.abs(v - bgRow[r]);
+      const dev = Math.abs(v - (bgCells ? bgCells[r * cols + c] : bgRow[r]));
       if (dev > 0.03) covered++;
       devSum += dev;
       cxAcc += dev * (c + 0.5);
@@ -3898,6 +5133,7 @@ function luminanceGrid(spec, opts = {}) {
     rows,
     cells,
     background: bgRow,
+    ...bgCells ? { backgroundCells: bgCells } : {},
     meanLuminance: sum / (cols * rows),
     coverage: covered / (cols * rows),
     centroid: devSum > 1e-6 ? { x: cxAcc / devSum / cols, y: cyAcc / devSum / rows } : null,
@@ -3980,6 +5216,21 @@ function textSprites(spec, opts = {}) {
   return out;
 }
 function dominanceRanking(spec, opts = {}) {
+  return rankDominance(rawDominance(spec, opts));
+}
+function rankDominance(raw) {
+  const total = raw.reduce((s, r) => s + r.weight, 0) || 1;
+  return raw.slice().sort((a, b) => b.weight - a.weight).map((r, i) => ({
+    rank: i + 1,
+    layerIndex: r.layerIndex,
+    key: r.key,
+    share: r.weight / total,
+    entityCount: r.entityCount,
+    meanLuma: r.meanLuma,
+    factors: r.factors
+  }));
+}
+function rawDominance(spec, opts = {}) {
   const scene = buildScene(spec, opts);
   const t = opts.t ?? 5e3;
   const { w, h, scale } = scene;
@@ -4031,7 +5282,7 @@ function dominanceRanking(spec, opts = {}) {
         entArea = box.halfX * 2 * box.halfY * 2 * 0.55;
       } else if (s.kind === "textBlock") {
         const box = textBlockBox(s, e, { x: 0, y: 0 }, w, h);
-        entArea = box.halfX * 2 * box.halfY * 2 * 0.55 * textBlockRevealFraction(s, w, h, t);
+        entArea = box.halfX * 2 * box.halfY * 2 * 0.55 * textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1);
       } else entArea = sz * sz * 0.55;
       area += entArea * a;
       if (layer.trail) {
@@ -4060,16 +5311,7 @@ function dominanceRanking(spec, opts = {}) {
     const weight = area / (w * h) * contrast * blendBoost * motionBoost;
     return { layerIndex, key: layer.key, weight, entityCount: entities.length, meanLuma, factors: { area: area / (w * h), contrast, blendBoost, motionBoost } };
   });
-  const total = raw.reduce((s, r) => s + r.weight, 0) || 1;
-  return raw.slice().sort((a, b) => b.weight - a.weight).map((r, i) => ({
-    rank: i + 1,
-    layerIndex: r.layerIndex,
-    key: r.key,
-    share: r.weight / total,
-    entityCount: r.entityCount,
-    meanLuma: r.meanLuma,
-    factors: r.factors
-  }));
+  return raw;
 }
 function layerCohesion(spec, opts = {}) {
   const scene = buildScene(spec, opts);
@@ -4115,8 +5357,9 @@ function regionMeans(grid) {
   const cnt = new Array(9).fill(0);
   for (let r = 0; r < grid.rows; r++) {
     for (let c = 0; c < grid.cols; c++) {
+      const idx = r * grid.cols + c;
       const region = Math.min(2, Math.floor(r / grid.rows * 3)) * 3 + Math.min(2, Math.floor(c / grid.cols * 3));
-      out[region] += Math.abs(grid.cells[r * grid.cols + c] - grid.background[r]);
+      out[region] += Math.abs(grid.cells[idx] - (grid.backgroundCells ? grid.backgroundCells[idx] : grid.background[r]));
       cnt[region]++;
     }
   }
@@ -4176,6 +5419,60 @@ function perceiveScene(spec, opts = {}) {
     advisories: adviseSpec(spec, opts.viewport ?? { width: 1920, height: 1080 }, { t: opts.t, seed: opts.seed })
   };
 }
+var bedKey = (key, layerIndex) => `bed:${key ?? layerIndex}`;
+function perceiveSequenceFrame(seq, T, opts = {}) {
+  const { releasedBelow, ...gridOpts } = opts;
+  const r = resolveSegment(seq, T, { releasedBelow });
+  const seg = seq.segments[r.index];
+  const segment = { index: r.index, key: seg.key, localT: r.localT, ...r.held ? { held: true } : {} };
+  const segOpts = { ...gridOpts, t: r.localT, seed: gridOpts.seed ?? segmentRenderSeed(seq, r.index) };
+  if (!seq.bed) return { ...perceiveScene(seg.scene, segOpts), segment, bed: false };
+  const bedOpts = { ...gridOpts, t: T, seed: gridOpts.seed ?? bedRenderSeed(seq) };
+  const viewport = gridOpts.viewport ?? { width: 1920, height: 1080 };
+  const ink = { ...seg.scene, background: { type: "solid", color: "#000000" } };
+  delete ink.ghosting;
+  const inkOverBed = { ...ink, background: seq.bed.background ?? { type: "solid", color: "#05050a" } };
+  const bedGrid = luminanceGrid(seq.bed, bedOpts);
+  const inkGrid = luminanceGrid(ink, segOpts);
+  const cells = bedGrid.cells.map((v, i) => Math.min(1, v + inkGrid.cells[i]));
+  const grid = finishGrid(bedGrid.cols, bedGrid.rows, cells, bedGrid.background, bedGrid.backgroundCells);
+  const bedLayers = seq.bed.layers.length;
+  const dominance = rankDominance([
+    ...rawDominance(seq.bed, bedOpts).map((d) => ({ ...d, key: bedKey(d.key, d.layerIndex) })),
+    ...rawDominance(inkOverBed, segOpts).map((d) => ({ ...d, layerIndex: d.layerIndex + bedLayers }))
+  ]);
+  const shift = (x) => ({ ...x, layerIndex: x.layerIndex + bedLayers });
+  const prefix = (x) => ({ ...x, key: bedKey(x.key, x.layerIndex) });
+  return {
+    t: r.localT,
+    braille: renderBrailleMap(grid),
+    density: renderDensityMap(grid),
+    coverage: grid.coverage,
+    meanLuminance: grid.meanLuminance,
+    centroid: grid.centroid,
+    rowProfile: grid.rowProfile,
+    colProfile: grid.colProfile,
+    dominance,
+    motion: [...motionStats(seq.bed, bedOpts).map(prefix), ...motionStats(ink, segOpts).map(shift)],
+    form: [...layerCohesion(seq.bed, bedOpts).map(prefix), ...layerCohesion(ink, segOpts).map(shift)],
+    text: [...textSprites(seq.bed, bedOpts).map(prefix), ...textSprites(ink, segOpts).map(shift)],
+    advisories: [
+      ...adviseSpec(seq.bed, viewport, { t: T, seed: bedOpts.seed }).map((w) => ({ ...w, path: `bed.${w.path}` })),
+      // inkOverBed's layers are the segment's (seed: segOpts.seed) but its
+      // background is the bed's (seq.bed.background) — a field there must be
+      // sampled with the bed's own seed, or a `role: 'read'` legibility
+      // advisory checks terrain that isn't what's actually behind the ink.
+      // `?? 42`: inkOverBed.seed is the SEGMENT's raw seed field (it's `ink`
+      // spread first), so adviseSpec's own `backgroundSeed ?? seed` fallback
+      // would substitute the segment's seed, not the bed's, if bedOpts.seed
+      // were left undefined — 42 is the same default `luminanceGrid` (and
+      // every other field seed fallback) converges on.
+      ...adviseSpec(inkOverBed, viewport, { t: r.localT, seed: segOpts.seed, backgroundSeed: bedOpts.seed ?? 42 })
+    ],
+    segment,
+    bed: true
+  };
+}
 
 // src/examples/aquarium.ts
 var AQUARIUM_SPEC = {
@@ -5065,6 +6362,85 @@ var LANTERNS_SPEC = {
   ]
 };
 
+// src/examples/lobby-talk.ts
+var LOBBY_TALK_SPEC = {
+  schemaVersion: 1,
+  id: "lobby-talk",
+  label: "Lobby Talk",
+  seed: 1207,
+  motionIntensity: "calm",
+  background: {
+    type: "gradient",
+    stops: [
+      { at: 0, color: "#060912" },
+      { at: 1, color: "#0b1224" }
+    ],
+    drift: { period: 4e4, amount: 0.1 }
+  },
+  layers: [
+    {
+      key: "haze",
+      count: 3,
+      sprite: { kind: "circle", radius: [0.22, 0.3], soft: true, color: "#123a4a", colors: ["#123a4a", "#2a1e4a", "#0e2a3a"] },
+      alpha: [0.35, 0.5],
+      blend: "lighter",
+      region: { x: [0.2, 0.8], y: [0.3, 0.7] },
+      motion: { type: "wander", speed: [2e-3, 4e-3], meander: 0.05 },
+      pulse: { amp: 0.15, period: 9e3 }
+    },
+    {
+      key: "dust",
+      count: 50,
+      sprite: { kind: "circle", radius: [8e-4, 18e-4], soft: true, color: "#7fb8c9" },
+      alpha: [0.2, 0.5],
+      blend: "lighter",
+      motion: { type: "wander", speed: [1e-3, 3e-3] }
+    },
+    {
+      key: "title",
+      count: 1,
+      sprite: { kind: "textBlock", text: "Adoption by feature, % of accounts", maxWidth: 1, fontSize: 0.034, color: "#f2f4f8", role: "read" },
+      motion: { type: "static" },
+      position: { x: 0.12, y: 0.16 }
+    },
+    {
+      key: "labels",
+      count: 5,
+      sprite: { kind: "text", strings: ["Onboarding", "Search", "Billing", "Exports", "Mobile"], font: "system-ui", align: "left", baseline: "middle", color: "#a9b7cc", role: "read" },
+      size: [0.03, 0.03],
+      motion: { type: "static" },
+      position: { x: 0.12, y: 0.32 },
+      layout: { type: "list", gap: 0.085 }
+    },
+    {
+      key: "bars",
+      count: 5,
+      sprite: {
+        kind: "bar",
+        values: [82, 64, 91, 37, 58],
+        max: 100,
+        length: 0.42,
+        thickness: 0.026,
+        color: "#7fe0d2",
+        colors: ["#7fe0d2", "#7fe0d2", "#ffcf7a", "#7fe0d2", "#7fe0d2"]
+      },
+      alpha: [0.9, 0.9],
+      motion: { type: "static" },
+      position: { x: 0.33, y: 0.32 },
+      layout: { type: "list", gap: 0.085 }
+    },
+    {
+      key: "readouts",
+      count: 5,
+      sprite: { kind: "text", strings: ["82%", "64%", "91%", "37%", "58%"], font: "bold system-ui", align: "left", baseline: "middle", color: "#f2f4f8", role: "read" },
+      size: [0.03, 0.03],
+      motion: { type: "static" },
+      position: { x: 0.78, y: 0.32 },
+      layout: { type: "list", gap: 0.085 }
+    }
+  ]
+};
+
 // src/examples/matrix-rain.ts
 var MATRIX_RAIN_SPEC = {
   schemaVersion: 1,
@@ -5716,6 +7092,38 @@ var SNOWFALL_SPEC = {
   ]
 };
 
+// src/examples/thermal-field.ts
+var THERMAL_FIELD_SPEC = {
+  schemaVersion: 1,
+  id: "thermal-field",
+  label: "Thermal Field",
+  seed: 71,
+  motionIntensity: "calm",
+  // The riso print: grain at half strength, a light dither screen — the
+  // finish that makes the flat inks read as paper rather than pixels.
+  finish: { grain: 0.5, dither: 0.3 },
+  background: {
+    type: "field",
+    scale: 2.2,
+    octaves: 3,
+    warp: 0.4,
+    quantize: 6,
+    bands: ["#1b1a3a", "#0078bf", "#00a99d", "#ffe800", "#ff6c2f", "#ff48b0"],
+    drift: { period: 4e4, amount: 0.3 }
+  },
+  layers: [
+    {
+      key: "motes",
+      count: 14,
+      sprite: { kind: "circle", radius: [0.012, 0.028], color: "#fff6e0", soft: true },
+      motion: { type: "wander", speed: [3e-3, 8e-3], meander: 0.04, coherence: 0.3 },
+      alpha: [0.18, 0.4],
+      blend: "screen",
+      pulse: { amp: 0.15, period: 9e3 }
+    }
+  ]
+};
+
 // src/examples/warp-tunnel.ts
 var WARP_TUNNEL_SPEC = {
   schemaVersion: 1,
@@ -5789,7 +7197,9 @@ var SCHEMA_EXAMPLES = [
   { id: "haiku", label: "Haiku", spec: HAIKU_SPEC },
   { id: "pings", label: "Pings", spec: PINGS_SPEC },
   { id: "facets", label: "Facets", spec: FACETS_SPEC },
-  { id: "relay-board", label: "Relay Board", spec: RELAY_BOARD_SPEC }
+  { id: "relay-board", label: "Relay Board", spec: RELAY_BOARD_SPEC },
+  { id: "lobby-talk", label: "Lobby Talk", spec: LOBBY_TALK_SPEC },
+  { id: "thermal-field", label: "Thermal Field", spec: THERMAL_FIELD_SPEC }
 ];
 var EXAMPLE_SPECS = SCHEMA_EXAMPLES.map((e) => e.spec);
 var EXAMPLE_BY_ID = Object.fromEntries(
@@ -5802,12 +7212,22 @@ export {
   COMETS_SPEC,
   CONSTELLATION_SPEC,
   DASHBOARD_SPEC,
+  DITHER_ALPHA,
+  DITHER_TILE,
   EXAMPLE_BY_ID,
   EXAMPLE_SPECS,
   FACETS_SPEC,
+  FIELD_BUCKET_MS,
+  FIELD_DRIFT_DEFAULT_AMOUNT,
+  FIELD_RASTER_SHORT_SIDE,
+  FIELD_RASTER_SHORT_SIDE_LOW,
+  FINISH_ANIMATE_HZ,
+  GRAIN_ALPHA,
+  GRAIN_TILE,
   HAIKU_SPEC,
   LANTERNS_SPEC,
   LIMITS,
+  LOBBY_TALK_SPEC,
   MATRIX_RAIN_SPEC,
   NOSTALGHIA_CANDLE_SPEC,
   ORRERY_SPEC,
@@ -5820,6 +7240,8 @@ export {
   SCHEMA_EXAMPLES,
   SCHEMA_VERSION,
   SNOWFALL_SPEC,
+  THERMAL_FIELD_SPEC,
+  WARP_MAX_SCALE,
   WARP_NEAR,
   WARP_TUNNEL_SPEC,
   adviseSequence,
@@ -5828,19 +7250,36 @@ export {
   applyDeltasToSpec,
   assertValidSequence,
   assertValidSpec,
+  bayerMatrix,
+  bayerTilePixels,
+  bedRenderSeed,
   breakTextBlock,
   buildEntities,
+  canMorph,
   cohesionOf,
   compileSaver,
   compileSequence,
+  createFinishPass,
+  createSceneCanvas,
   describeScene,
   diffScenes,
   dominanceRanking,
   easeSmooth,
   emitEnvelope,
   emitWindow,
+  fieldAt,
+  fieldOctaves,
+  fieldRgb,
+  fieldRgbAt,
+  fieldSampleTime,
+  finishStrength,
+  grainOffset,
+  grainTilePixels,
   graphemeClusters,
+  hasHotSwapSequence,
   headingAt,
+  hexToRgb255,
+  latticeHash,
   layerCohesion,
   lerpSpec,
   lifeAlphaAt,
@@ -5848,24 +7287,38 @@ export {
   linkPairs,
   luminanceGrid,
   manifestFor,
+  morphChainRoot,
+  morphNothingMorphable,
   motionStats,
+  normalizeSeed,
   perceiveScene,
+  perceiveSequenceFrame,
+  pickScreenOp,
   positionAt,
+  presentWithFinish,
   renderBrailleMap,
   renderDensityMap,
   resolveSegment,
   resolveSpecPath,
   revealState,
+  rgb255Luma,
   rotationAt,
   seamCauseOf,
   seamsWorthWarning,
+  segmentRenderSeed,
   segmentStart,
+  sequenceSteerablePaths,
+  sequenceSwapCompatible,
   sizeAt,
   spriteIndexAt,
   spriteVariants,
   steerablePaths,
   structuralSignature,
+  textBlockAnchorOffset,
+  textMetricsClassFor,
   textSprites,
+  textStringsDiffer,
+  textStringsOf,
   textWidthEm,
   validateSequence,
   validateSpec