@litfamily/litopencode 1.0.29 → 1.0.30

package/skills/lit-typographic-motion/probe.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 // The five MO-A-44 probes, reported on every doctor/status run: Chrome, ffmpeg (with the preview
 // encoder rung), the WebGL2 renderer string from a real headless probe, the software-GL warning, and
-// pre-warm state naming what is missing and the command that fixes it.
+// pre-warm state naming what is missing and the command that fixes it. A sixth line names the cover
+// encoder (cover mode: img2webp decoded with dwebp, else gifski decoded with ffmpeg).
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import os from "node:os";
@@ -9,7 +10,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { isSoftwareRenderer, unknownRenderer } from "./engine/constants.mjs";
 import { chromeVersion, findChrome, launchLadder, loadPlaywright, which } from "./engine/browser.mjs";
+import { splitLines } from "./engine/command.mjs";
 import { inspectWarmState } from "./runtime.mjs";
+import { coverEncoder } from "./engine/cover/render.mjs";
 
 export function previewEncoderRung(ffmpeg, env = process.env) {
   if (ffmpeg) {
@@ -26,11 +29,12 @@ export async function probe(env = process.env) {
   const ffmpeg = which("ffmpeg", env);
   const report = {
     chrome: chrome.path ? { ok: true, path: chrome.path, version: chromeVersion(chrome.path) } : { ok: false, detail: `${chrome.missing} (not found on PATH / not installed)` },
-    ffmpeg: ffmpeg ? { ok: true, path: ffmpeg, version: (spawnSync(ffmpeg, ["-version"], { encoding: "utf8", timeout: 15000 }).stdout ?? "").split("\n")[0], previewEncoder: previewEncoderRung(ffmpeg, env) }
+    ffmpeg: ffmpeg ? { ok: true, path: ffmpeg, version: splitLines(spawnSync(ffmpeg, ["-version"], { encoding: "utf8", timeout: 15000 }).stdout ?? "")[0], previewEncoder: previewEncoderRung(ffmpeg, env) }
       : { ok: false, detail: "ffmpeg not found on PATH", previewEncoder: previewEncoderRung(undefined, env) },
     webgl2: { ok: false, renderer: null, flags: [], detail: "" },
     softwareWarning: null,
-    prewarm
+    prewarm,
+    coverEncoder: coverEncoder(env)
   };
   if (!chrome.path) report.webgl2.detail = "not probed: Chrome is missing";
   else if (prewarm.deps.length) report.webgl2.detail = `not probed: the pinned driver is not pre-warmed; run ${prewarm.fix}`;
@@ -63,6 +67,7 @@ export function formatProbe(report) {
     `motion ffmpeg: ${report.ffmpeg.ok ? `${report.ffmpeg.path} — ${report.ffmpeg.version}` : report.ffmpeg.detail}; preview encoder rung: ${report.ffmpeg.previewEncoder}`,
     `motion webgl2: ${report.webgl2.ok ? `${report.webgl2.renderer} (rung ${report.webgl2.rung}: ${report.webgl2.flags.join(" ")})` : report.webgl2.detail}`,
     `motion software-gl: ${report.softwareWarning}`,
+    `motion cover encoder: ${report.coverEncoder.name === "none" ? `none; cover renders stop with exit 21; fix: ${report.coverEncoder.fix}` : `${report.coverEncoder.name} (the gate decodes with ${report.coverEncoder.decoder})`}`,
     `motion prewarm: ${p.ready ? `ready in ${p.cache} (Hangul body: ${p.hangul})` : `missing ${missing.join(", ")}; run ${p.fix}`}; audio: ${p.audio.ready ? "ready" : p.audio.reason}; word timing: ${p.wordTiming.reason}`
   ].join("\n");
 }

package/skills/lit-typographic-motion/recipes/negatives/card-scenes/expected.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "note": "A slide-like page that must keep failing these gates at FLOOR on the decoded file, and no other FLOOR gate among G1-G4; tools/qa-cover-recipes.mjs --negatives passes it only when the render completed and was gated. Never tune a threshold so it passes.",
+  "mustFail": [
+    "G2.floor"
+  ],
+  "treatment": {
+    "loopSec": 9,
+    "fps": 20,
+    "encode": {
+      "q": 78,
+      "edgeQ": 78,
+      "edgeFrames": 0
+    }
+  }
+}

package/skills/lit-typographic-motion/recipes/negatives/card-scenes/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- NEGATIVE, never a recipe: three text cards, each fading in, holding and fading out. Each hold
+     stays under 2 s, so G3 passes its floor, but only the fades move: the decoded file fails G2
+     (moving share under 0.45). It must keep failing it. -->
+<link rel="stylesheet" href="/lit/fonts.css">
+<style>
+  html, body { margin: 0; width: 1200px; height: 600px; overflow: hidden; background: #0f1318; font-family: "Archivo", sans-serif; }
+  .card { position: absolute; left: 150px; top: 150px; width: 900px; height: 300px; background: #e9edf2; color: #10141a; font-size: 72px; font-weight: 900; line-height: 300px; text-align: center; opacity: 0; }
+  body.mask { background: #000; }
+  body.mask .card { background: #000; color: #fff; }
+</style>
+</head>
+<body>
+<div class="card">LITCARD</div>
+<div class="card">ONE TOOL</div>
+<div class="card">EVERY DAY</div>
+<script>
+const cards = [...document.querySelectorAll(".card")];
+// Each card owns a third of the loop; on a 9 s loop that is 0.6 s in, a 1.8 s hold, 0.6 s out.
+window.renderFrame = (t, { mask = false } = {}) => {
+  document.body.className = mask ? "mask" : "";
+  cards.forEach((card, i) => {
+    const p = t * 3 - i;
+    const fade = 0.2;
+    const level = p < 0 || p >= 1 ? 0 : p < fade ? p / fade : p > 1 - fade ? (1 - p) / fade : 1;
+    card.style.opacity = mask ? (level > 0.5 ? "1" : "0") : level.toFixed(4);
+  });
+};
+document.fonts.ready.then(() => { window.renderFrame(0); window.ready = true; });
+</script>
+</body>
+</html>

package/skills/lit-typographic-motion/recipes/negatives/reset-sweep/expected.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "note": "A slide-like page that must keep failing these gates at FLOOR on the decoded file, and no other FLOOR gate among G1-G4; tools/qa-cover-recipes.mjs --negatives passes it only when the render completed and was gated. Never tune a threshold so it passes.",
+  "mustFail": [
+    "G4.floor"
+  ],
+  "treatment": {
+    "loopSec": 8,
+    "fps": 20,
+    "encode": {
+      "q": 78,
+      "edgeQ": 78,
+      "edgeFrames": 0
+    }
+  }
+}

package/skills/lit-typographic-motion/recipes/negatives/reset-sweep/index.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- NEGATIVE, never a recipe: a progress sweep that fills the frame over the loop and resets at the
+     seam. Everything moves steadily, so G2 and G3 pass their floors, but the jump back to empty is a
+     step far larger than its neighbours: the decoded file fails G4 (the seam). It must keep failing. -->
+<link rel="stylesheet" href="/lit/fonts.css">
+<style>
+  html, body { margin: 0; width: 1200px; height: 600px; overflow: hidden; background: #0e1217; font-family: "Archivo", sans-serif; }
+  #fill { position: absolute; left: 0; top: 0; height: 600px; width: 0; background: #2f4a63; }
+  #word { position: absolute; left: 0; right: 0; top: 240px; text-align: center; font-size: 96px; font-weight: 900; color: #f3f5f8; }
+  body.mask { background: #000; }
+  body.mask #fill { visibility: hidden; }
+</style>
+</head>
+<body>
+<div id="fill"></div>
+<div id="word">LITSWEEP</div>
+<script>
+const fill = document.getElementById("fill");
+window.renderFrame = (t, { mask = false } = {}) => {
+  document.body.className = mask ? "mask" : "";
+  fill.style.width = `${(1200 * t).toFixed(3)}px`;
+};
+document.fonts.ready.then(() => { window.renderFrame(0); window.ready = true; });
+</script>
+</body>
+</html>

package/skills/lit-typographic-motion/recipes/negatives/still-glow/expected.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "note": "A slide-like page that must keep failing these gates at FLOOR on the decoded file, and no other FLOOR gate among G1-G4; tools/qa-cover-recipes.mjs --negatives passes it only when the render completed and was gated. Never tune a threshold so it passes.",
+  "mustFail": [
+    "G2.floor",
+    "G3.floor"
+  ],
+  "treatment": {
+    "loopSec": 8,
+    "fps": 16,
+    "encode": {
+      "q": 72,
+      "edgeQ": 72,
+      "edgeFrames": 0
+    }
+  }
+}

package/skills/lit-typographic-motion/recipes/negatives/still-glow/index.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- NEGATIVE, never a recipe: a still picture with a faint breathing glow. The glow changes each
+     pixel by less than the encoder's threshold, so the decoded file barely moves: it fails G2 and
+     G3 (the whole loop reads as one hold). It must keep failing them. -->
+<link rel="stylesheet" href="/lit/fonts.css">
+<style>
+  html, body { margin: 0; width: 1200px; height: 600px; overflow: hidden; background: #0d1116; font-family: "Archivo", sans-serif; }
+  #word { position: absolute; left: 0; right: 0; top: 240px; text-align: center; font-size: 96px; font-weight: 900; color: #f3f5f8; }
+  #glow { position: absolute; left: 350px; top: 150px; width: 500px; height: 300px; border-radius: 50%; background: radial-gradient(closest-side, rgba(255, 140, 80, 0.35), rgba(255, 140, 80, 0)); }
+  body.mask { background: #000; }
+  body.mask #glow { visibility: hidden; }
+</style>
+</head>
+<body>
+<div id="glow"></div>
+<div id="word">LITGLOW</div>
+<script>
+const glow = document.getElementById("glow");
+window.renderFrame = (t, { mask = false } = {}) => {
+  document.body.className = mask ? "mask" : "";
+  glow.style.opacity = (0.92 + 0.08 * Math.sin(2 * Math.PI * t)).toFixed(4);
+};
+document.fonts.ready.then(() => { window.renderFrame(0); window.ready = true; });
+</script>
+</body>
+</html>

package/skills/lit-typographic-motion/recipes/negatives/title-slam/expected.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "note": "A slide-like page that must keep failing these gates at FLOOR on the decoded file, and no other FLOOR gate among G1-G4; tools/qa-cover-recipes.mjs --negatives passes it only when the render completed and was gated. Never tune a threshold so it passes.",
+  "mustFail": [
+    "G2.floor",
+    "G3.floor"
+  ],
+  "treatment": {
+    "loopSec": 10,
+    "fps": 20,
+    "encode": {
+      "q": 78,
+      "edgeQ": 78,
+      "edgeFrames": 0
+    }
+  }
+}

package/skills/lit-typographic-motion/recipes/negatives/title-slam/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- NEGATIVE, never a recipe: the slide habit cover mode exists to stop. A title slams in, three
+     lines arrive one by one, and an end card holds. Most of the loop is a hold, so the decoded file
+     fails G2 (motion energy) and G3 (longest still run). It must keep failing them. -->
+<link rel="stylesheet" href="/lit/fonts.css">
+<style>
+  html, body { margin: 0; width: 1200px; height: 600px; overflow: hidden; background: #10141a; font-family: "Archivo", sans-serif; color: #f2f4f7; }
+  #title { position: absolute; left: 0; right: 0; top: 150px; text-align: center; font-size: 84px; font-weight: 900; }
+  .line { position: absolute; left: 0; right: 0; text-align: center; font-size: 30px; font-weight: 400; }
+  body.mask { background: #000; }
+  body.mask .line { visibility: hidden; }
+  body.mask #title { color: #fff; }
+</style>
+</head>
+<body>
+<div id="title">LITCARD</div>
+<div class="line" style="top: 300px">first line</div>
+<div class="line" style="top: 350px">second line</div>
+<div class="line" style="top: 400px">third line</div>
+<script>
+const lines = [...document.querySelectorAll(".line")];
+const title = document.getElementById("title");
+window.renderFrame = (t, { mask = false } = {}) => {
+  document.body.className = mask ? "mask" : "";
+  const slam = Math.min(1, t / 0.04);
+  title.style.transform = `scale(${(1.6 - 0.6 * slam).toFixed(4)})`;
+  lines.forEach((line, i) => { line.style.opacity = t > 0.12 + 0.1 * i ? "1" : "0"; });
+};
+document.fonts.ready.then(() => { window.renderFrame(0); window.ready = true; });
+</script>
+</body>
+</html>

package/skills/lit-typographic-motion/recipes/orbit-loop/expected.json

@@ -0,0 +1,62 @@
+{
+  "schemaVersion": 1,
+  "note": "The decoded gate row this recipe reached when it shipped; tools/qa-cover-recipes.mjs renders it again and fails when median d or the moving share move more than 15 %, seamLocal leaves the cover TARGET, the file passes 2 MiB or the render exits non-zero. Measured 2026-10-20 on headless Chrome's software rung with CPU raster and libwebp 1.6.0.",
+  "row": {
+    "medianD": 0.002325,
+    "movingFrac": 1.0,
+    "longestStillSec": 0.0,
+    "spike": 2.394,
+    "seamLocal": 1.492,
+    "bytes": 1576692
+  },
+  "settings": {
+    "size": [
+      1000,
+      500
+    ],
+    "fps": 25,
+    "frames": 200,
+    "encode": {
+      "q": 78,
+      "edgeQ": 90,
+      "edgeFrames": 20,
+      "method": 4
+    }
+  },
+  "treatment": {
+    "mode": "cover",
+    "request": "Make a looping README cover for LitOpenCode that shows a running system.",
+    "idea": "Three orbits cross one gate and every crossing lights a cell of the ledger under the name.",
+    "recipe": "orbit-loop",
+    "recipeReason": "A system with whole-number laps closes by itself and gives the beat events a cause.",
+    "brandWord": "LITOPENCODE",
+    "aspect": "2:1",
+    "loopSec": 8,
+    "fps": 25,
+    "layers": {
+      "slow": "Dashed guide rings turn one dash period per loop.",
+      "mid": "Three dots lap their rings three, two and one times.",
+      "beat": "The gate flashes and a ledger cell lights at each crossing; the core rings on four bars."
+    },
+    "system": {
+      "rule": "One orbit law, angle from laps and direction.",
+      "copies": "Three rings.",
+      "offset": "Each ring's start angle and direction."
+    },
+    "title": {
+      "box": [
+        0.05,
+        0.39,
+        0.375,
+        0.14
+      ],
+      "kind": "live"
+    },
+    "encode": {
+      "q": 78,
+      "edgeQ": 90,
+      "edgeFrames": 20
+    },
+    "ambition": "Every beat event has a visible cause, and the crossings are solved rather than detected."
+  }
+}

package/skills/lit-typographic-motion/recipes/orbit-loop/index.html

@@ -0,0 +1,100 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- Cover recipe "orbit-loop": a system beside a still word. Three rings turn a whole number of laps
+     per loop (3, 2, 1), in alternating directions, each carrying a dot with a trail. A gate at twelve
+     o'clock flashes whenever a dot crosses it, and the crossing times, computed rather than detected,
+     light the cells of a ledger under the word: six crossings, six cells, so the ledger loops too.
+     The core breathes once per loop and rings on each of four bars. Change WORD and the colours. -->
+<link rel="stylesheet" href="/lit/fonts.css">
+<script src="/lit/loop-kit.js"></script>
+<style>
+  html, body { margin: 0; width: 1200px; height: 600px; overflow: hidden; background: #0c1015; }
+  canvas { position: absolute; inset: 0; width: 1200px; height: 600px; }
+  #word { position: absolute; left: 70px; top: 238px; font: 800 64px/80px "JetBrains Mono", monospace; letter-spacing: 0; color: #f1f4f7; white-space: pre; }
+  body.mask { background: #000; }
+  body.mask canvas { visibility: hidden; }
+  body.mask #word { color: #fff; }
+</style>
+</head>
+<body>
+<canvas id="orbit" width="2400" height="1200"></canvas>
+<div id="word">LITOPENCODE</div>
+<script>
+const { TAU, fract, mix, ease, cubicPulse, cdist } = LitLoop;
+const ctx = document.getElementById("orbit").getContext("2d");
+ctx.scale(2, 2);
+const CORE = [880, 300];
+const GATE = -Math.PI / 2;
+// One orbit rule, three copies: radius, laps per loop, direction, and where the dot starts.
+const RINGS = [
+  { r: 110, laps: 3, dir: 1, start: 0.3, colour: [255, 138, 76] },
+  { r: 185, laps: 2, dir: -1, start: 1.9, colour: [120, 200, 255] },
+  { r: 260, laps: 1, dir: 1, start: 4.1, colour: [196, 232, 92] }
+];
+const angle = (ring, t) => ring.start + ring.dir * TAU * ring.laps * t;
+// Every crossing of the gate in [0, 1), solved from the angle law: start + dir 2pi laps t = GATE + 2pi k.
+const crossings = RINGS.flatMap((ring, i) => Array.from({ length: ring.laps }, (_, k) => ({ ring: i, t: fract(((GATE - ring.start) / (ring.dir * TAU) + k) / ring.laps) }))).sort((a, b) => a.t - b.t);
+const LEDGER = { x: 72, y: 340, cell: 54, gap: 10 };
+const since = (t, at) => fract(t - at);
+// A lit cell falls back in four flat steps over 0.4 of the loop: big steps the encoder keeps.
+const cellLevel = (s) => (s < 0.4 ? Math.ceil(4 * (1 - s / 0.4)) / 4 : 0);
+
+window.renderFrame = (t, { mask = false } = {}) => {
+  document.body.className = mask ? "mask" : "";
+  ctx.clearRect(0, 0, 1200, 600);
+  if (mask) return;
+  // SLOW: dashed guide rings turn perpetually, one dash period per loop in alternate directions.
+  ctx.lineWidth = 3;
+  RINGS.forEach((ring, i) => {
+    ctx.setLineDash([10, 14]);
+    ctx.lineDashOffset = (i % 2 ? -1 : 1) * 24 * fract(t) * 4;
+    ctx.strokeStyle = "rgba(120, 140, 160, 0.55)";
+    ctx.beginPath(); ctx.arc(CORE[0], CORE[1], ring.r, 0, TAU); ctx.stroke();
+  });
+  ctx.setLineDash([]);
+  // MID: the dots and their fading arc trails.
+  RINGS.forEach((ring) => {
+    const a = angle(ring, t), [r, g, b] = ring.colour;
+    for (let s = 0; s < 20; s++) {
+      const a0 = a - ring.dir * 0.05 * s, a1 = a - ring.dir * 0.05 * (s + 1);
+      ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, ${0.8 * (1 - s / 20)})`;
+      ctx.lineWidth = 9 - s * 0.35;
+      ctx.beginPath(); ctx.arc(CORE[0], CORE[1], ring.r, Math.min(a0, a1), Math.max(a0, a1)); ctx.stroke();
+    }
+  });
+  // BEAT: the gate flashes on each crossing and the crossing dot swells.
+  const hit = Math.max(...crossings.map((c) => cubicPulse(0, 0.025, cdist(t, c.t))));
+  ctx.fillStyle = `rgba(255, 236, 200, ${0.35 + 0.65 * hit})`;
+  ctx.fillRect(CORE[0] - 4, CORE[1] - RINGS[2].r - 24, 8, RINGS[2].r - RINGS[0].r + 48);
+  RINGS.forEach((ring, i) => {
+    const a = angle(ring, t), [r, g, b] = ring.colour;
+    const pulse = Math.max(0, ...crossings.filter((c) => c.ring === i).map((c) => cubicPulse(0, 0.03, cdist(t, c.t))));
+    ctx.fillStyle = `rgb(${r}, ${g}, ${b})`;
+    ctx.beginPath(); ctx.arc(CORE[0] + ring.r * Math.cos(a), CORE[1] + ring.r * Math.sin(a), 11 + 7 * pulse, 0, TAU); ctx.fill();
+  });
+  // The core breathes once per loop and rings on each of four bars.
+  const breath = 0.5 - 0.5 * Math.cos(TAU * t);
+  ctx.fillStyle = `rgba(255, 170, 110, ${0.55 + 0.35 * breath})`;
+  ctx.beginPath(); ctx.arc(CORE[0], CORE[1], 34 + 8 * breath, 0, TAU); ctx.fill();
+  const bar = fract(4 * t), ring = ease.outExpo(bar);
+  ctx.strokeStyle = `rgba(255, 190, 140, ${0.7 * (1 - bar)})`;
+  ctx.lineWidth = 4;
+  ctx.beginPath(); ctx.arc(CORE[0], CORE[1], 40 + 60 * ring, 0, TAU); ctx.stroke();
+  // The ledger under the word: one cell per crossing, lit at its crossing time.
+  crossings.forEach((c, k) => {
+    const [r, g, b] = RINGS[c.ring].colour, level = cellLevel(since(t, c.t));
+    ctx.fillStyle = "#1a222c";
+    ctx.fillRect(LEDGER.x + k * (LEDGER.cell + LEDGER.gap), LEDGER.y, LEDGER.cell, 14);
+    if (level > 0) {
+      ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${level})`;
+      ctx.fillRect(LEDGER.x + k * (LEDGER.cell + LEDGER.gap), LEDGER.y, LEDGER.cell, 14);
+    }
+  });
+};
+
+document.fonts.load('800 64px "JetBrains Mono"').then(() => { window.renderFrame(0); window.ready = true; });
+</script>
+</body>
+</html>

package/skills/lit-typographic-motion/recipes/painted-light/expected.json

@@ -0,0 +1,95 @@
+{
+  "schemaVersion": 1,
+  "note": "The decoded gate row this recipe reached when it shipped; tools/qa-cover-recipes.mjs renders it again and fails when median d or the moving share move more than 15 %, seamLocal leaves the cover TARGET, the file passes 2 MiB or the render exits non-zero. Measured 2026-10-20 on headless Chrome's software rung with CPU raster and libwebp 1.6.0.",
+  "row": {
+    "medianD": 0.002112,
+    "movingFrac": 1.0,
+    "longestStillSec": 0.0,
+    "spike": 1.662,
+    "seamLocal": 1.903,
+    "bytes": 2059158
+  },
+  "settings": {
+    "size": [
+      1000,
+      500
+    ],
+    "fps": 16,
+    "frames": 128,
+    "encode": {
+      "q": 83,
+      "edgeQ": 97,
+      "edgeFrames": 18,
+      "method": 4
+    }
+  },
+  "base": "test/fixtures/cover/painted-light-five-panel.png in this repository (1536x1024, the five-panel family painting), the painting the PAINTING block was measured on; another painting needs its own block",
+  "assets": [
+    {
+      "path": "cover/assets/base.png",
+      "role": "base-art",
+      "source": "user",
+      "box": [
+        0.125,
+        0,
+        0.75,
+        1
+      ],
+      "checkBox": [
+        0.131,
+        0.1445,
+        0.1416,
+        0.778
+      ],
+      "title": true
+    }
+  ],
+  "treatment": {
+    "mode": "cover",
+    "request": "Make the LitFamily README motion cover from the painted robot line-up.",
+    "idea": "A window of work light walks the sleeping bays while the lead robot breathes and a comet laps its frame.",
+    "recipe": "painted-light",
+    "recipeReason": "The painting already carries the brand, so the loop relights it instead of drawing over it.",
+    "brandWord": "LITFAMILY",
+    "aspect": "2:1",
+    "loopSec": 8,
+    "fps": 16,
+    "layers": {
+      "slow": "A comet laps the lead frame and motes rise one screen per loop.",
+      "mid": "A sharp-edged light window walks the bays once per loop, with scan bands at two passes.",
+      "beat": "Eyes breathe twice, one blink, and the LIT. flare pulses at t = 0 and 0.5."
+    },
+    "system": {
+      "rule": "One light window and one scan band rule.",
+      "copies": "Seven bays and fifty motes.",
+      "offset": "Each bay's phase comes from its x position."
+    },
+    "title": {
+      "box": [
+        0.347,
+        0.031,
+        0.31,
+        0.086
+      ],
+      "kind": "painted"
+    },
+    "encode": {
+      "q": 83,
+      "edgeQ": 97,
+      "edgeFrames": 18
+    },
+    "ambition": "Light reads as moving edges that survive the encoder, and the seam disappears under the flare."
+  },
+  "regressions": {
+    "feather-150": {
+      "patch": {
+        "find": "half: 230, edge: 24,",
+        "replace": "half: 230, edge: 150,"
+      },
+      "mustFail": [
+        "G1.target"
+      ],
+      "defect": "A 150 px soft light edge: the window reads as a soft wash instead of a moving edge. At this recipe's encode (q83, edge q97 for 18 frames) the encoder keeps the soft edge, so no motion gate sees it; it measured 2.59 MB against 2.06 MB with median d and the seam inside TARGET. What it reliably trips is the 2 MiB size TARGET. The wash itself is caught by look review on the sheet, not by a gate."
+    }
+  }
+}