diff --git a/flow-state/EPIC-4.md b/flow-state/EPIC-4.md
index 5c9481f..a2e2d82 100644
--- a/flow-state/EPIC-4.md
+++ b/flow-state/EPIC-4.md
@@ -394,3 +394,191 @@ do it once the numbers were understood, and they now are.
 written — direction clears the arcless reference by 0.26, which is hard to explain without
 a story — but it remains the only thing that would attribute the floor rise (0.1697 →
 0.2130) to this work rather than to everything else that changed alongside it.
+
+---
+
+## 14. Composition — the frame has a floor and a ceiling
+
+Not part of the original plan. It comes out of the same place §12 did: the layer stack was
+being asked to carry the video, and half of what it was stacking was nothing.
+
+**The floor.** Two thirds of the library is `composable` — sparse by design, elements ON
+something. `canBackground` let almost all of it anchor a section anyway, so a section's
+bottom layer was regularly a scene painting 2% of the frame with black behind it. Measured
+across six videos, sampling the middle of every section: **9 of 40 frames were under 20%
+painted, the darkest at 0.3%**. That is a minute and a half of a few bright things on black,
+and no gate could see it, because every gate on the stack was a limit rather than a floor.
+
+Every section now stands on a GROUND: a canvas painting at least half the frame, cast per
+section kind so a section's shot cuts change the shot and not the world. When the shot is
+itself a full canvas it *is* the ground — two canvases stacked is two pictures fighting. The
+same measurement now reads **mean 92% painted, darkest 63%, nothing under 30%**, and phase 12
+gates it in the image, not in the spec.
+
+**The ceiling.** Layering had a rate but no budget, so how full a frame got was a die roll
+that knew nothing about the song. A stack now has a coverage budget — director appetite
+(`crowd`, 1.05 brutalist to 1.7 corrupt), times the section's energy and density, times where
+the story is — capped at **200%**, two frames' worth of material. The ground and the shot are
+paid for first; the budget governs what may be stacked on top, and the odds of an overlay
+fall off as the headroom does rather than only at the wall.
+
+**What it cost, and what it bought.** Same instrument, same six seeds:
+
+```
+                baseline    with grounds
+separation      0.10        0.44
+direction       0.06        0.21   (arcless reference 0.02 → 0.08)
+library         80%         97%    of what the library can express
+scale           42%         56%
+motion          68%         96%
+texture         74%         90%
+```
+
+The ceiling *fell* (0.2334 → 0.2031) while observed rose, so part of that separation gain is
+the reference arm coming down: videos that share a ground vocabulary are less unalike even
+when they share no shots. The honest reading is that the floor rose 0.009, direction tripled,
+and the ceiling moved toward the floor — the numbers are up, and not all of the rise is
+signal.
+
+**A scene that reads the previous frame cannot be a ground.** `prev()` returns the whole
+composited frame, *including whatever is layered on top of this scene*, so a datamosh under a
+shot is not grounding it, it is eating it. Measured the moment one became a bed: the render
+stopped reproducing from a seek, and two WebGL contexts diverged by 91/255 against a ceiling
+of 4 — phase 4 caught both. `readsHistory` is derived from the shader source rather than
+declared, and costs the ground pool six of twenty scenes, five of them glitch.
+
+`scenes/coverage.js` is the measured coverage of every scene, pasted back out of the phase 12
+gate, which re-measures and fails on drift over a tenth of a frame. A new scene has no entry
+and therefore cannot ground anything until someone renders it.
+
+### 14.1 The measurements moved into the repo
+
+Everything in §14 depends on a number — how much of the frame a scene paints — and the
+first version of it was a table pasted into a source file by hand. That is the same mistake
+`surface` already was: a measured fact written down by a person, correct on the day and
+wrong after the next shader edit.
+
+**`src/scenes/metadata.json`** is now generated, tracked in git, and holds every measured
+fact about every visualizer: coverage as a shot, coverage as a bed, the variety score, the
+per-block scores, and the mean structural profile. Nothing in it is typed by a human.
+`surface` is derived from it (canvas at 50%, composable below) and declaring `surface:` in a
+scene file is now a lint error.
+
+It is refreshed from **gallery.html → refresh metadata**, which re-renders the library and
+writes the file through a dev-only endpoint in `vite.config.js`. The file carries a
+fingerprint of everything that can move a number in it — the scenes, the shader contract,
+the identities and palettes they are handed, the descriptor definitions — and phase 12 fails
+when that stops matching. A stale metadata file does not produce a stale report, it produces
+wrong videos, so it has to be detectable.
+
+**Measuring at the wrong bias measures nothing.** Coverage is mostly a function of a scene's
+parameters, and the first measurement took one number per scene at the busiest section of
+six songs. Metaballs measures 69% there and painted **6%** as an intro's ground. Three
+things came out of chasing that, in order of how much each was worth:
+
+* A bed is drawn with a **moderate hand**. `extremity` pushes parameters toward the ends of
+  their ranges, and half of what decides coverage is a parameter with no `bias` key at all —
+  Metaballs' `threshold` — so extremity is the only thing moving it and one end is an empty
+  frame. Grounds sample at `extremity * 0.2`. The extremes belong to the shot.
+* Energy and density are **floors** for a ground, not reductions. Calming the bed by
+  lowering energy is how to empty it: scenes bias their fill against `energy` as often as
+  against `density`.
+* Coverage is measured **twice**, once as a shot and once as a bed, at the same bias and
+  temperament the generator will use. `GROUND_BIAS` and `groundTemperamentFrom` live in
+  `scenes/surface.js` and are imported by both the generator and the measuring pass, so the
+  two cannot drift apart.
+
+Rendered result across six videos, sampling the middle of every section: **mean 87% painted,
+darkest 30%**, against 51%/0.3% before any of this.
+
+**Eleven scenes can ground a section** — five organic, five geometric, one structural. There
+is no `minimal`, `flow` or `glitch` canvas in the library that paints half the frame without
+reading `prev()`, so every quiet section in every video stands on one of five organic beds.
+That is the largest remaining hole and it is library work, not generator work: the fix is
+writing dense, self-contained canvases in the three thin families.
+
+### 14.2 The red line is gone
+
+`MIN_VARIETY` — 0.1, drawn across the gallery, "below this a scene is the same picture
+wherever it appears" — was right when a section was one scene and is wrong now. A section is
+a ground, a shot on it and sometimes a pass over that, so what a viewer sees is a
+combination, and a scene that is reliably itself is a good ingredient in one. Nineteen
+scenes were failing a bar for being consistent.
+
+What replaced it is a level up, and it is the reason the profiles are in the metadata: the
+generator weights every layering choice by **structural distance** — how unalike two scenes
+measured, on the same descriptor the variety harness compares videos with. Family labels and
+the render disagree often enough to matter; two `geometric` scenes can be 0.31 apart and a
+`flow` and an `organic` scene 0.04, and stacking the second pair is one picture at double
+density. Measured over 436 stacked pairs: **mean distance 0.268, zero near-twins**.
+
+### 14.3 The other end of the frame
+
+The floor had a ceiling missing. Measured across twelve videos, sampling the middle of every
+section: **a median 24% of every frame was clipped to pure white, and whole sections
+rendered at 100%.** The videos were washed out, and no gate could see it because every guard
+on the frame asked whether there was enough in it.
+
+Three causes, all introduced or exposed by §14, in the order they were found:
+
+**The shot was screened over its ground.** Screen is a lightening operator — correct for a
+few bright elements over a bed, and over a filled canvas it drives everything toward white.
+Replaced with a **lumakey** blend (`passes.js`): the shot's own brightness is its alpha, so
+it replaces the ground where it paints and leaves it where it does not, keeping its own
+colour instead of adding it to the bed's. Median clipping 24% → 11%.
+
+**The feedback loop was an accumulator.** `cur + hist * decay * amount` settles a still
+image at `1/(1 - decay*amount)` times its drawn brightness — **2.3x** at the settings the
+generator hands out. Survivable when a frame was a few bright things on black; fatal the
+moment every section stood on a filled ground. Turning feedback off took a blown frame from
+100% to 34% mean luminance, which is the whole diagnosis in one number. It now divides by
+the same gain, at 0.6 rather than 1.0: full normalisation took the lift out along with the
+blowout — the median frame fell from 95% painted to 71% and fourteen sections dropped
+through the black-frame floor.
+
+**Nothing rolled off.** The grade clipped. A **highlight shoulder** now compresses everything
+above 0.75 toward but never to 1. Clipped white is not brightness, it is missing information:
+every difference inside it has been deleted.
+
+Rendered, after all three — 74 sections, twelve videos:
+
+```
+                 before        after
+painted          51% mean      88% mean, darkest 43%   (was darkest 0.3%)
+clipped white    24% median    0% median, worst 21%    (was worst 100%)
+luminance        77% median    42% median, worst 80%
+```
+
+The gate is now two-ended: `composition · a rendered section is neither black nor blown out`.
+
+**A ground has to survive the song's identity.** Chasing the dark end turned up the same
+class of error as §14.1: a ground measured at 61% painted **2%** in one particular video,
+because that song's ink treatment is `hollow` — outlines, no fill. Two changes came out of
+it. The world is now drawn solid and the song's hand is kept for the subject
+(`groundPersonalityFrom`), and eligibility takes the **worst** identity into account as well
+as the mean: a ground fills the frame on average and never vanishes. Holding the worst case
+to the full 50% would leave *four* castable beds in the library, which is a worse video than
+an occasionally dim intro.
+
+**Seven scenes can ground a section** — five geometric, two organic. Every quiet section of
+every video stands on one of two beds. Restated from §14.1 because it got worse, not better:
+this is the library's largest hole.
+
+### 14.4 Blazing on purpose
+
+Screening the shot over its ground and letting the two brightnesses sum is a real effect — a
+drop that goes to paper for eight bars reads as the song peaking. The mistake in §14.3 was
+not the effect, it was that the effect was the **default**: every section did it, so a median
+quarter of every frame in every video was clipped, and nothing about that said "peak".
+
+It is a decision now. Each director declares a `blaze` appetite — brutalist 0.05 (mass does
+not glow), corrupt 0.5 (overload is the subject) — and a section still has to earn one: loud,
+and late in the story. Quiet kinds never blaze, because a breakdown that goes white is not a
+choice, it is a bug with a rationale. The default composite is the lumakey, which keeps the
+shot's own colour.
+
+The ceiling gate matches the intent rather than banning brightness. Per section, only a hard
+cap — past about half the frame at full white there is no picture left to read. Across the
+population, **no more than a fifth of sections may be hot at all**, which is the number that
+actually distinguishes a director choosing to peak from a pipeline with no headroom.
+Measured now: **1 of 74 sections blazing**, worst 30% clipped.
diff --git a/flow-state/HOWTO-variety.md b/flow-state/HOWTO-variety.md
index 26605e8..f12586b 100644
--- a/flow-state/HOWTO-variety.md
+++ b/flow-state/HOWTO-variety.md
@@ -28,16 +28,23 @@ checks.html?scene=X   the per-scene gate, including `consumes:` lines
 ```
 
 The gallery score is the mean structural distance between a scene's own six
-frames, on the same descriptor the variety harness uses. **Minimum bar: 0.1**
-(`MIN_VARIETY` in `checks/gallery.js`), drawn as a red line. Below it a scene is
-the same picture wherever it appears, and because it is cast into many songs
-that sameness leaks between them — the viewer recognises the shot rather than
-the song.
+frames, on the same descriptor the variety harness uses. High means the song
+changes this scene a lot; low means it looks like itself wherever it is cast.
 
-Most of the library does not clear it. That is deliberate: a bar set where the
-work already is measures nothing.
+**There is no bar.** There used to be one — 0.1, drawn across the gallery as a
+red line — and it was removed when composition arrived. A section is no longer
+one scene: it is a ground, a shot standing on it, and sometimes a pass over
+that, so what a viewer sees is a COMBINATION. A scene that is reliably itself is
+a perfectly good ingredient in one, and the old line failed it for being
+consistent.
 
-Some reference points, measured:
+What replaced it is a level up. The interesting quantity is how unalike the
+scenes in one stack are, and the generator now weights its choices by exactly
+that — see `structuralDistance` in `scenes/surface.js`. Your scene does not have
+to be varied on its own. It has to be unlike the things it will be stacked with,
+and that is measured for you.
+
+Some reference points, measured across six songs:
 
 ```
 0.324  Droste Feedback      varies a lot
@@ -47,6 +54,29 @@ Some reference points, measured:
 0.047  Moiré Grid           after a subject; 0.031 before
 ```
 
+### The measured metadata
+
+`src/scenes/metadata.json` is generated, tracked in git, and holds every
+measured fact about every scene: coverage, variety, per-block scores and the
+structural profile the distance above is computed from. Nothing in it is
+hand-written, and two decisions read it:
+
+* **`surface`** — canvas at 50% coverage or more, composable below. It used to
+  be declared per scene and it drifted; nine scenes claimed `canvas` while
+  painting under a third of the frame. Declaring `surface:` in a scene file is
+  now an error.
+* **which scenes may be a GROUND** — a canvas that does not call `prev()`, fills the frame
+  when sampled as a bed, and does not vanish under any of the six identities. Coverage is
+  measured twice, once as a shot and once as a bed, because a scene paints wildly different
+  amounts at different parameters: Metaballs is 69% as a drop's shot and 6% as an intro's
+  ground.
+
+Refresh it from **gallery.html → refresh metadata** after changing a shader or a
+metric. The file carries a fingerprint of the scenes, the shader contract, the
+identities and palettes, and the descriptor definitions; when that stops
+matching, phase 12 fails and tells you to re-measure. The write goes through a
+dev-only endpoint in `vite.config.js`, so it only works under `npm run dev`.
+
 ---
 
 ## What the descriptor can and cannot see
diff --git a/flow-state/gallery.html b/flow-state/gallery.html
index aefb33d..0912bc8 100644
--- a/flow-state/gallery.html
+++ b/flow-state/gallery.html
@@ -126,6 +126,7 @@
         <span class="spinner"></span>
         <span id="libctl">
             <button id="rebuild">rebuild</button>
+            <button id="refresh" title="re-measure the library and write src/scenes/metadata.json — the git-tracked numbers the generator composes with">refresh metadata</button>
             <select id="sort">
                 <option value="variety">sort: least varied first</option>
                 <option value="name">sort: by name</option>
@@ -152,7 +153,10 @@
     <div id="out"></div>
 
 <script type="module">
-import { buildGallery, galleryContexts, THUMB, MIN_VARIETY, blit } from '/src/checks/gallery.js';
+import { buildGallery, galleryContexts, THUMB, blit } from '/src/checks/gallery.js';
+import { measureLibrary, metadataDrift, writeMetadata, metadataIsFresh } from '/src/checks/metadata.js';
+// A gallery showing numbers the generator is not using is a trap, so say so.
+const STALE_NOTE = metadataIsFresh() ? '' : ' · metadata is STALE — press refresh';
 import {
     sourceFingerprint, loadGallery, saveGallery, clearGallery,
     pixelsToBlob, blobToCanvas,
@@ -167,13 +171,16 @@ const status = document.getElementById('status');
 const sortSel = document.getElementById('sort');
 const progress = document.querySelector('#progress i');
 const rebuildBtn = document.getElementById('rebuild');
+const refreshBtn = document.getElementById('refresh');
 
 let rows = [];        // { name, family, role, variety, byBlock, blobs, error }
 let contexts = [];
 
-// Graded against the bar rather than against taste: below it is a failure, and
-// the band just above it is where a scene is passing by too little to trust.
-const grade = (v, err) => (err ? 'broken' : v < MIN_VARIETY ? 'flat' : v < MIN_VARIETY * 2 ? 'thin' : 'good');
+// There is no bar any more — see checks/gallery.js for why the 0.1 red line
+// went. What is left is a broken/working distinction and a relative shading, so
+// the eye can still find the flattest scenes in a sorted list without anyone
+// pretending a threshold decides whether a scene is allowed to exist.
+const grade = (v, err) => (err ? 'broken' : v < 0.08 ? 'thin' : 'good');
 
 function draw() {
     const mode = sortSel.value;
@@ -184,17 +191,7 @@ function draw() {
         : a.variety - b.variety));
 
     out.innerHTML = '';
-    let drewCut = false;
     for (const row of sorted) {
-        // One line across the whole gallery, where the sort crosses the bar.
-        // Everything above it repeats itself between songs.
-        if (mode === 'variety' && !drewCut && row.variety >= MIN_VARIETY) {
-            drewCut = true;
-            const cut = document.createElement('div');
-            cut.className = 'cutline';
-            cut.innerHTML = `<span>minimum variety ${MIN_VARIETY.toFixed(3)} — everything above repeats itself between songs</span>`;
-            out.appendChild(cut);
-        }
         const el = document.createElement('div');
         el.className = `row ${grade(row.variety, row.error)}`;
         const blocks = Object.entries(row.byBlock || {})
@@ -203,9 +200,9 @@ function draw() {
             <div class="head">
                 <span class="name"><a href="?scene=${encodeURIComponent(row.name)}" title="open this one on a wide grid of songs and seeds">${row.name}</a></span>
                 <span class="fam">${row.family}${row.role === 'accent' ? ' · accent' : ''}</span>
-                <span class="surf ${row.surface}" title="paints ${((row.coverage || 0) * 100).toFixed(0)}% of the frame">${row.surface || '?'} ${((row.coverage || 0) * 100).toFixed(0)}%</span>
+                <span class="surf ${surfaceFor(row)}" title="paints ${((row.coverage || 0) * 100).toFixed(0)}% of the frame across the six songs — this is what decides the label">${surfaceFor(row)} ${((row.coverage || 0) * 100).toFixed(0)}%</span>
                 <span class="score">
-                    <span class="meter"><i style="width:${Math.min(100, row.variety * 500)}%"></i><b style="left:${MIN_VARIETY * 500}%" title="minimum ${MIN_VARIETY}"></b></span>
+                    <span class="meter"><i style="width:${Math.min(100, row.variety * 500)}%"></i></span>
                     ${row.variety.toFixed(3)}
                 </span>
                 <span class="blocks">${row.error ? `<span class="err">${row.error}</span>` : blocks}</span>
@@ -231,13 +228,18 @@ function draw() {
 
 sortSel.addEventListener('change', draw);
 
+// The label a scene WOULD carry from this build's numbers, which is not
+// necessarily the one the checked-in metadata gives it — that is the whole
+// point of showing it here.
+const surfaceFor = (row) => ((row.coverage || 0) >= 0.5 ? 'canvas' : 'composable');
+
 function summarise(built) {
-    const flat = rows.filter((r) => r.variety < MIN_VARIETY && !r.error).length;
     const broken = rows.filter((r) => r.error).length;
-    return `${rows.length} scenes · ${flat} below the ${MIN_VARIETY} bar` +
+    const canvases = rows.filter((r) => surfaceFor(r) === 'canvas').length;
+    return `${rows.length} scenes · ${canvases} canvas / ${rows.length - canvases} composable` +
         (broken ? ` · ${broken} BROKEN` : '') +
         ` · ${rows.filter((r) => (r.coverage || 0) < 0.3).length} paint under 30% of the frame` +
-        (built ? ` · built ${new Date(built).toLocaleString()}` : '');
+        (built ? ` · built ${new Date(built).toLocaleString()}` : '') + STALE_NOTE;
 }
 
 async function build(fingerprint) {
@@ -432,14 +434,14 @@ async function renderSweep() {
 
     // Three numbers rather than one: which AXIS is flat is the thing the
     // library gallery cannot tell you, and it decides what to go and fix.
-    const weak = (v) => (v < MIN_VARIETY ? ' weak' : '');
+    const weak = (v) => (v < 0.08 ? ' weak' : '');
     const twin = result.closest
         ? `${cells[result.closest.a].name} ≈ ${cells[result.closest.b].name} at ${result.closest.distance.toFixed(3)}`
         : '—';
     sweepInfo.innerHTML = `
         <div class="axes">
             <div class="${weak(result.variety)}">overall <b>${result.variety.toFixed(3)}</b>
-                <small>every cell against every other · bar ${MIN_VARIETY}</small></div>
+                <small>every cell against every other</small></div>
             <div class="${weak(result.bySeed)}">across seeds <b>${result.bySeed.toFixed(3)}</b>
                 <small>same song, different draw — low means the scene ignores the identity</small></div>
             <div class="${weak(result.bySong)}">across songs <b>${result.bySong.toFixed(3)}</b>
@@ -512,6 +514,43 @@ async function main() {
     await build(fingerprint);
 }
 
+// ---- metadata refresh ---------------------------------------------------
+// The gallery is where the library gets measured, so it is where the measured
+// facts are written back. The numbers go to src/scenes/metadata.json — tracked
+// in git, read by the look generator, and stamped with a fingerprint of the
+// scenes and the metric definitions so a stale file is detectable rather than
+// merely old. See src/checks/metadata.js.
+refreshBtn.addEventListener('click', async () => {
+    refreshBtn.disabled = true;
+    rebuildBtn.disabled = true;
+    bar.classList.add('building');
+    const started = Date.now();
+    try {
+        const fresh = measureLibrary({
+            onScene: (done, total, name) => {
+                status.textContent = `measuring ${done}/${total} · ${name}`;
+                progress.style.width = `${(done / total) * 100}%`;
+            },
+        });
+        const { moved, gone } = metadataDrift(fresh);
+        await writeMetadata(fresh);
+        const changes = moved.slice(0, 6).map((m) => `${m.name} ${m.note}`).join(' · ');
+        status.textContent =
+            `metadata written in ${((Date.now() - started) / 1000).toFixed(0)}s · ` +
+            `${Object.keys(fresh.scenes).length} scenes · ` +
+            (moved.length ? `${moved.length} moved — ${changes}` : 'nothing moved') +
+            (gone.length ? ` · dropped ${gone.join(', ')}` : '');
+    } catch (err) {
+        status.textContent = `metadata refresh failed: ${err.message} ` +
+            '(the write endpoint only exists under npm run dev)';
+    } finally {
+        bar.classList.remove('building');
+        refreshBtn.disabled = false;
+        rebuildBtn.disabled = false;
+        progress.style.width = '0%';
+    }
+});
+
 rebuildBtn.addEventListener('click', async () => {
     await clearGallery();
     await build(sourceFingerprint());
diff --git a/flow-state/src/Show.js b/flow-state/src/Show.js
index 87d07aa..8bdbb0c 100644
--- a/flow-state/src/Show.js
+++ b/flow-state/src/Show.js
@@ -6,6 +6,7 @@ import { generateLook, rerollLook, rerollSection } from './look/LookGenerator.js
 import { ArcDriver } from './look/ArcDriver.js';
 import { grainEnvelope } from './look/grain.js';
 import { hashSamples } from './engine/rng.js';
+import { subjectOf } from './look/stack.js';
 
 /**
  * The opening and closing fade to black. Exported because anything SAMPLING a
@@ -45,8 +46,12 @@ export class Show {
      * Decode, analyse, and generate a look. `onProgress(stage, fraction)` is
      * called throughout; analysis is CPU-bound and will block the main thread
      * for a second or two on a long track.
+     *
+     * `seed` replaces the audio-derived one. Only the debug pages pass it, and
+     * only so that watching a song reproduces the look they measured — the
+     * filmstrip seeds off the song's name, not off its samples.
      */
-    async load(file, onProgress = null) {
+    async load(file, onProgress = null, { seed = null } = {}) {
         const report = (stage, p) => onProgress && onProgress(stage, p);
 
         report('decoding', 0);
@@ -64,7 +69,9 @@ export class Show {
 
         report('look', 0.97);
         const samples = monoSamples(audioBuffer);
-        this.setLook(generateLook(this.track, { samples }));
+        this.setLook(seed === null
+            ? generateLook(this.track, { samples })
+            : generateLook(this.track, { seed }));
 
         this.engine.timeline.setDuration(this.track.duration);
         this.engine.setFeatureProvider(featureProviderFor(this.track));
@@ -76,12 +83,22 @@ export class Show {
         return this;
     }
 
-    /** Attach an already-analysed track. Used by the check harness and by tests. */
+    /**
+     * Attach an already-analysed track. Used by the check harness and by tests.
+     *
+     * Prewarms, like every other path that installs a look. It was the one that
+     * did not, and that was invisible while most sections were a single layer:
+     * with a ground under every shot there are always at least two programs to
+     * link, and the first frame a fresh Show rendered came out different from
+     * every later render of it — the exact hazard Compositor.prime documents,
+     * caught by the phase 4 first-render check.
+     */
     useTrack(track, look) {
         this.track = track;
         this.engine.timeline.setDuration(track.duration);
         this.engine.setFeatureProvider(featureProviderFor(track));
         this.setLook(look || generateLook(track, { seed: 1 }));
+        this.prewarm();
         return this;
     }
 
@@ -116,7 +133,7 @@ export class Show {
     setSectionParam(sectionIndex, name, value) {
         const section = this.look.sections[sectionIndex];
         if (!section) return;
-        section.layers[0].params[name] = value;
+        subjectOf(section.layers).params[name] = value;
         this._lastLayers = null;
     }
 
diff --git a/flow-state/src/checks/blit.js b/flow-state/src/checks/blit.js
new file mode 100644
index 0000000..4784165
--- /dev/null
+++ b/flow-state/src/checks/blit.js
@@ -0,0 +1,21 @@
+/**
+ * WebGL readback into a canvas, the right way up.
+ *
+ * Its own module because two debug pages need it and neither should pull in the
+ * other's dependencies to get it. It lived in checks/gallery.js, and importing
+ * it from the filmstrip dragged the entire gallery — the engine, the song bank,
+ * the look generator, the whole scene library — into a page that wanted ten
+ * lines of pixel copying.
+ */
+export function blit(canvas, pixels, width, height) {
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    const image = ctx.createImageData(width, height);
+    const row = width * 4;
+    for (let y = 0; y < height; y++) {
+        const src = (height - 1 - y) * row;
+        image.data.set(pixels.subarray(src, src + row), y * row);
+    }
+    ctx.putImageData(image, 0, 0);
+}
diff --git a/flow-state/src/checks/gallery.js b/flow-state/src/checks/gallery.js
index 781040f..9714256 100644
--- a/flow-state/src/checks/gallery.js
+++ b/flow-state/src/checks/gallery.js
@@ -16,8 +16,9 @@
 // looking for the repetitive ones is exactly the job a sort order should do.
 
 import { Engine } from '../engine/Engine.js';
+import { blit } from './blit.js';
 import { scenes } from '../scenes/registry.js';
-import { sampleValues, surfaceOf } from '../params/schema.js';
+import { sampleValues } from '../params/schema.js';
 import { Rng, hashString } from '../engine/rng.js';
 import { featureProviderFor } from '../audio/FeatureTrack.js';
 import { songBank } from '../audio/songbank.js';
@@ -29,28 +30,23 @@ import { descriptorDistance, STRUCTURAL } from './variety/signature.js';
 
 const THUMB = { width: 256, height: 144 };
 
-/**
- * The floor a visualizer has to clear: how different its own six frames must be
- * from each other, across six songs' identities.
+/*
+ * There used to be a MIN_VARIETY floor here — 0.1, drawn as a red line across
+ * the gallery — on the theory that a scene which looks the same in every song
+ * leaks that sameness between videos.
  *
- * Below this a scene is the same picture wherever it appears, and because it is
- * cast into many songs that repetition leaks between them — the viewer who
- * watches two videos recognises the shot rather than the song. It is a property
- * of the scene, not of the generator, so it is the scene that has to be lifted.
+ * That was true when a section was ONE scene. It is not any more: a section is
+ * a ground, a shot over it and sometimes a pass over that, so what a viewer
+ * sees is a combination, and a scene that is reliably itself is a perfectly
+ * good ingredient in one. Held against a floor, such scenes were failing for
+ * being consistent.
  *
- * 0.1, and deliberately a target rather than a description of where the library
- * currently sits. Most of it does not clear this — of the scenes measured after
- * the region block went in, only Droste Feedback at 0.324 is comfortably over,
- * with Plasma Bloom at 0.082 and Voronoi Shatter at 0.062 still short. A bar set
- * where the work already is measures nothing.
- *
- * It has moved twice for instrument reasons rather than taste — the motion block
- * was reading zero for the whole library, and adding the region block made the
- * total a mean over six rather than five — and both raised every score. Expect
- * to re-read it off a fresh gallery whenever the descriptor changes, rather than
- * carrying the old number forward.
+ * The score is still measured, still reported, and still what the gallery sorts
+ * by — it is genuinely the right question to ask about a scene you are working
+ * on. It is no longer a bar anything has to clear, and the interesting quantity
+ * moved up a level: how unalike the scenes in one stack are. That lives in
+ * scenes/metadata.json and is read by the look generator.
  */
-export const MIN_VARIETY = 0.1;
 
 /**
  * Six contexts, one per song: everything a scene is handed when it is cast.
@@ -78,20 +74,6 @@ export function galleryContexts(count = 6) {
     });
 }
 
-/** Bottom-up WebGL pixels into a canvas the right way up. */
-function blit(canvas, pixels, width, height) {
-    canvas.width = width;
-    canvas.height = height;
-    const ctx = canvas.getContext('2d');
-    const image = ctx.createImageData(width, height);
-    const row = width * 4;
-    for (let y = 0; y < height; y++) {
-        const src = (height - 1 - y) * row;
-        image.data.set(pixels.subarray(src, src + row), y * row);
-    }
-    ctx.putImageData(image, 0, 0);
-}
-
 /**
  * Render one scene across every context.
  *
@@ -175,9 +157,14 @@ export function renderScene(engine, module, contexts) {
 
     return {
         thumbs,
+        // The six per-context descriptors, so a caller can average them into a
+        // profile rather than re-render the library to get one. See
+        // checks/metadata.js — this function is the only place the scenes are
+        // rendered under real identities, and everything measured about a scene
+        // comes out of here.
+        descriptors,
         variety: pairs ? total / pairs : 0,
         coverage: covered,
-        surface: surfaceOf(module),
         byBlock,
         error: dead
             ? `renders nothing — luminance ${lum.toFixed(4)}, variance ${variance.toFixed(4)}. ` +
diff --git a/flow-state/src/checks/metadata.js b/flow-state/src/checks/metadata.js
new file mode 100644
index 0000000..2539dd6
--- /dev/null
+++ b/flow-state/src/checks/metadata.js
@@ -0,0 +1,217 @@
+// Measuring every visualizer, and writing the answers back into the repo.
+//
+// The library has always had two kinds of fact about a scene. Declared ones —
+// family, traits, `consumes` — which say what the scene is FOR, and measured
+// ones, which say what it actually does when rendered. Declared facts belong in
+// the scene file. Measured facts do not: hand-written, they drift the moment a
+// shader changes, and nine scenes declaring `surface: 'canvas'` while painting
+// under a third of the frame is what that drift looks like.
+//
+// So the measured half lives in scenes/metadata.json, generated from here,
+// tracked in git, and stamped with a fingerprint of everything that could
+// change it. When the fingerprint stops matching, the numbers are stale and the
+// phase 12 gate says so — the file is a cache of a render, and a cache nobody
+// can tell is stale is worse than no cache.
+//
+// The measurement is the GALLERY's: six songs, sampled parameters, real
+// identities and palettes — a scene as it is actually cast, not as it renders
+// at default parameters. The difference is not academic. Salt Flat paints 65%
+// of the frame at defaults and 32% across six real songs, and the generator
+// chooses grounds with this number.
+
+import { Engine } from '../engine/Engine.js';
+import { scenes } from '../scenes/registry.js';
+import { galleryContexts, renderScene, THUMB } from './gallery.js';
+import { readsHistory } from '../params/schema.js';
+import { GROUND_BIAS, groundTemperamentFrom, groundPersonalityFrom } from '../scenes/surface.js';
+import metadata from '../scenes/metadata.json';
+
+/**
+ * What invalidates the measurements.
+ *
+ * Deliberately NOT every file under src/, which is what the gallery cache
+ * fingerprints: that changes when the UI changes, and it would mark the
+ * metadata stale for edits that cannot move a single number. What can move one
+ * is the scenes themselves, the contract they are compiled against, the
+ * identities and palettes they are handed, and the metric definitions — so
+ * those, and nothing else.
+ *
+ * Globbed rather than listed wherever a whole directory qualifies, because the
+ * file that invalidates a measurement is exactly the one nobody remembers to
+ * add to a list.
+ */
+const SOURCES = {
+    ...import.meta.glob('/src/scenes/**/*.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/checks/variety/descriptors.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/checks/variety/signature.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/checks/gallery.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/checks/metadata.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/engine/shader-contract.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/look/Identity.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/look/Personality.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/look/palette.js', { query: '?raw', import: 'default', eager: true }),
+    ...import.meta.glob('/src/audio/songbank.js', { query: '?raw', import: 'default', eager: true }),
+};
+
+/** The version of the measurement itself. Bump to force a refresh of everything. */
+export const SCHEMA = 4;
+
+export function metricsFingerprint() {
+    let h = 0x811c9dc5 >>> 0;
+    const mix = (str) => {
+        for (let i = 0; i < str.length; i++) {
+            h ^= str.charCodeAt(i);
+            h = Math.imul(h, 0x01000193) >>> 0;
+        }
+    };
+    mix(`schema:${SCHEMA}`);
+    for (const path of Object.keys(SOURCES).sort()) {
+        mix(path);
+        mix(SOURCES[path]);
+    }
+    return h.toString(16).padStart(8, '0');
+}
+
+/** Whether the checked-in metadata was measured from the code that is here now. */
+export function metadataIsFresh() {
+    return metadata.fingerprint === metricsFingerprint();
+}
+
+/** Anything a viewer would read as painted rather than as backdrop. */
+function litFraction(pixels) {
+    let lit = 0;
+    for (let i = 0; i < pixels.length; i += 4) {
+        if (pixels[i] + pixels[i + 1] + pixels[i + 2] > 90) lit++;
+    }
+    return lit / (pixels.length / 4);
+}
+
+const round = (x, places = 4) => Number(x.toFixed(places));
+
+/** Mean of the six per-context descriptors, block by block. */
+function meanProfile(descriptors) {
+    const out = {};
+    for (const block of Object.keys(descriptors[0])) {
+        const length = descriptors[0][block].length;
+        const acc = new Array(length).fill(0);
+        for (const d of descriptors) {
+            for (let i = 0; i < length; i++) acc[i] += d[block][i] / descriptors.length;
+        }
+        out[block] = acc.map((v) => round(v));
+    }
+    return out;
+}
+
+/**
+ * Measure the whole library.
+ *
+ * Per scene: how much frame it paints, how much it changes between songs, and
+ * its mean structural profile — the descriptor the variety harness compares
+ * videos with, averaged over the six renders. The profile is what makes this
+ * more than a list of numbers: two profiles can be compared, so the generator
+ * can ask whether a shot and the thing under it are the same picture twice.
+ *
+ * @returns {object} the metadata file's contents
+ */
+export function measureLibrary({ onScene = null, contexts = null } = {}) {
+    const ctx = contexts || galleryContexts(6);
+    // The same six songs, sampled the way a BED is. Coverage is mostly a
+    // function of a scene's parameters, so "how much does this paint" has two
+    // answers and the generator needs both: one for the budget, and one for
+    // whether it may be a ground at all. See GROUND_BIAS.
+    const bedCtx = ctx.map((c) => ({
+        ...c,
+        bias: { ...c.bias, ...GROUND_BIAS },
+        personality: {
+            ...groundPersonalityFrom(c.personality),
+            temperament: groundTemperamentFrom(c.personality.temperament),
+        },
+    }));
+    const engine = new Engine({ ...THUMB });
+    const out = {};
+    try {
+        const list = scenes.filter((m) => m.kind === 'fragment');
+        for (const module of list) {
+            const { thumbs, variety, byBlock, descriptors, error } = renderScene(engine, module, ctx);
+            const bed = renderScene(engine, module, bedCtx);
+            out[module.name] = {
+                coverage: round(thumbs.reduce((s, px) => s + litFraction(px), 0) / thumbs.length, 3),
+                // The WORST of the six, not the mean. What a ground has to
+                // promise is a filled frame in the video it lands in, and the
+                // spread across identities is enormous: a track whose ink
+                // treatment is `hollow` draws outlines instead of fills, so a
+                // scene that paints 61% averaged over six songs paints 2% in
+                // the one that asked for outlines — measured, and it is how a
+                // section with a ground under it still rendered near-black.
+                // A mean cannot make a promise; a minimum can.
+                bedCoverage: round(Math.min(...bed.thumbs.map(litFraction)), 3),
+                bedCoverageMean: round(
+                    bed.thumbs.reduce((s, px) => s + litFraction(px), 0) / bed.thumbs.length, 3),
+                variety: round(variety, 3),
+                blocks: Object.fromEntries(
+                    Object.entries(byBlock).map(([b, v]) => [b, round(v, 3)])),
+                // Declared, not measured, and carried here anyway: it is a fact
+                // about the scene that the composition rules read, and having
+                // every compositional input in one file is the point.
+                readsHistory: readsHistory(module),
+                profile: meanProfile(descriptors),
+                ...(error ? { error } : {}),
+            };
+            if (onScene) onScene(Object.keys(out).length, list.length, module.name);
+        }
+    } finally {
+        engine.dispose();
+    }
+
+    return {
+        fingerprint: metricsFingerprint(),
+        schema: SCHEMA,
+        measured: new Date().toISOString().slice(0, 10),
+        contexts: ctx.map((c) => c.name),
+        scenes: out,
+    };
+}
+
+/** What moved against the checked-in file. */
+export function metadataDrift(fresh) {
+    // Tolerates a missing or half-written file on purpose: this runs on the way
+    // to REPLACING it, and refusing to report because the thing being replaced
+    // is malformed is the least useful moment to be strict.
+    const previous = (metadata && metadata.scenes) || {};
+    const moved = [];
+    for (const [name, row] of Object.entries(fresh.scenes)) {
+        const was = previous[name];
+        if (!was) {
+            moved.push({ name, note: 'new' });
+            continue;
+        }
+        const delta = row.coverage - was.coverage;
+        if (Math.abs(delta) > 0.02) {
+            moved.push({
+                name, note: `coverage ${(was.coverage * 100).toFixed(0)}% → ${(row.coverage * 100).toFixed(0)}%`,
+                delta,
+            });
+        }
+    }
+    const gone = Object.keys(previous).filter((n) => !fresh.scenes[n]);
+    return {
+        moved: moved.sort((a, b) => Math.abs(b.delta || 0) - Math.abs(a.delta || 0)),
+        gone,
+    };
+}
+
+/**
+ * Ask the dev server to write the file back into the source tree.
+ *
+ * Dev-only by construction — the endpoint is a middleware in vite.config.js. A
+ * built page has no source tree to write to, and failing there is correct.
+ */
+export async function writeMetadata(fresh) {
+    const response = await fetch('/__metadata', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(fresh, null, 2) + '\n',
+    });
+    if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
+    return response.text();
+}
diff --git a/flow-state/src/checks/phase10.js b/flow-state/src/checks/phase10.js
index b144287..f71ad16 100644
--- a/flow-state/src/checks/phase10.js
+++ b/flow-state/src/checks/phase10.js
@@ -37,6 +37,7 @@ import { frameDistance, frameLuminance } from '../engine/hash.js';
 import { battery as timbreBattery } from './phase3.js';
 import { grainEnvelope } from '../look/grain.js';
 import { signatureUniforms } from '../look/Personality.js';
+import { subjectOf, overlaysOf } from '../look/stack.js';
 
 /**
  * Several tracks that genuinely differ in what they sound like — the population
@@ -124,8 +125,8 @@ check(10, 'one scene looks different in two different videos', () => {
                 // track's temperament — the question is what this scene WOULD
                 // look like in that video, and falling back to defaults would
                 // compare two identical parameter sets and prove nothing.
-                const stack = stacksOf(look).find((s) => s[0].module === module);
-                const params = stack ? stack[0].params : sampleValues(
+                const stack = stacksOf(look).find((s) => subjectOf(s).module === module);
+                const params = stack ? subjectOf(stack).params : sampleValues(
                     module,
                     new Rng(look.seed ^ 0x51ed270b),
                     look.sections[0].bias,
@@ -187,7 +188,7 @@ check(10, 'overlays happen sometimes and not always', () => {
             const look = generateLook(track, { seed: 900 + s * 5231 });
             for (const stack of stacksOf(look)) {
                 stacks++;
-                const overlay = stack[1];
+                const overlay = overlaysOf(stack)[0];
                 if (overlay) {
                     withOverlay++;
                     blends.add(overlay.blend);
@@ -214,7 +215,7 @@ check(10, 'an overlay never hides the shot underneath it', () => {
     for (const { track } of battery()) {
         for (let s = 0; s < 4; s++) {
             for (const stack of stacksOf(generateLook(track, { seed: 1300 + s * 8641 }))) {
-                for (const layer of stack.slice(1)) {
+                for (const layer of overlaysOf(stack)) {
                     if (layer.opacity > 0.6) {
                         problems.push(`${layer.module.name} at ${layer.opacity.toFixed(2)}`);
                     }
diff --git a/flow-state/src/checks/phase11.js b/flow-state/src/checks/phase11.js
index b663ae5..0c79a20 100644
--- a/flow-state/src/checks/phase11.js
+++ b/flow-state/src/checks/phase11.js
@@ -26,6 +26,7 @@ import { Rng } from '../engine/rng.js';
 import { frameDistance, frameLuminance } from '../engine/hash.js';
 import { SHOT_SIZES, SHOT_SIZE_NAMES, describeFraming } from '../look/framing.js';
 import { reachFor, CURVE_NAMES } from '../look/Camera.js';
+import { subjectOf } from '../look/stack.js';
 
 /** Tracks at several tempos: shot length is measured in bars, so tempo is the axis. */
 let cached = null;
@@ -273,7 +274,7 @@ check(11, 'two tracks do not agree on what a section kind looks like', () => {
             directors.add(look.director);
             look.sections.forEach((section) => {
                 const set = seen.get(section.kind) || new Set();
-                (section.variants || [section.layers]).forEach((v) => set.add(v[0].module.family));
+                (section.variants || [section.layers]).forEach((v) => set.add(subjectOf(v).module.family));
                 seen.set(section.kind, set);
             });
         }
@@ -299,7 +300,7 @@ check(11, 'a track shows more of the library than it used to', () => {
         for (let s = 0; s < 4; s++) {
             const look = generateLook(t, { seed: (i * 2654435761 + s * 40503) >>> 0 });
             look.sections.forEach((section) =>
-                (section.variants || [section.layers]).forEach((v) => cast.add(v[0].module.name)));
+                (section.variants || [section.layers]).forEach((v) => cast.add(subjectOf(v).module.name)));
         }
     });
     const pool = scenes.filter(canBackground).length;
@@ -492,8 +493,11 @@ check(11, 'the slow axis is a journey rather than a cycle', () => {
 
     try {
         const cue = arc.cues[0];
-        const at = (time) => arc._paramsAt(cue, 0, time, t.at(Math.round(time * 60)));
-        const spec = arc._specFor(cue.sectionIndex, cue.variant, 0);
+        // The shot, not the bed under it — the slow axis is a claim about the
+        // scene the section is about.
+        const slot = arc._subjectSlot(cue);
+        const at = (time) => arc._paramsAt(cue, slot, time, t.at(Math.round(time * 60)));
+        const spec = arc._specFor(cue.sectionIndex, cue.variant, slot);
         const axis = arc._slowAxisFor(spec.module);
 
         const start = at(t.duration * 0.05);
diff --git a/flow-state/src/checks/phase12.js b/flow-state/src/checks/phase12.js
index 69f48f5..5ec2cd3 100644
--- a/flow-state/src/checks/phase12.js
+++ b/flow-state/src/checks/phase12.js
@@ -20,10 +20,14 @@ import { song } from '../audio/songbank.js';
 import { Show } from '../Show.js';
 import { generateLook } from '../look/LookGenerator.js';
 import { scenes } from '../scenes/registry.js';
-import { surfaceOf, canBackground } from '../params/schema.js';
-import { Engine } from '../engine/Engine.js';
-import { defaultValues } from '../params/schema.js';
-import { featureProviderFor } from '../audio/FeatureTrack.js';
+import { canBackground } from '../params/schema.js';
+import {
+    GROUND_MIN, canGround, isMeasured, surfaceOf, METADATA,
+    coverageOf as declaredCoverage, structuralDistance,
+} from '../scenes/surface.js';
+import { metadataIsFresh, metricsFingerprint } from './metadata.js';
+import { RESTFUL_FAMILIES } from '../look/directors.js';
+import { stackCoverage } from '../look/stack.js';
 import { frameDescriptor, rotate90, recolour } from './variety/descriptors.js';
 import { descriptorDistance, signatureDistance } from './variety/signature.js';
 import {
@@ -185,62 +189,249 @@ check(12, 'seed variety · different seeds render structurally different videos'
 
 
 /**
- * How much of the frame a scene actually paints.
+ * The metadata is measured from the code that is actually here.
  *
- * A composable scene has to leave room for what it sits on. One that claims to
- * and covers the frame anyway will hide its background completely, which is the
- * failure the declaration exists to prevent — and it is not something you can
- * see from the source, only from the render.
+ * scenes/metadata.json is a cache of a render — how much frame each scene
+ * paints, how much it changes between songs, what it looks like structurally —
+ * and the generator composes with it: which scenes may ground a section, and
+ * which pairs are unalike enough to be worth stacking. A stale file therefore
+ * does not produce a stale REPORT, it produces wrong videos, silently.
+ *
+ * So the file carries a fingerprint of everything that can move a number in it
+ * — the scenes, the shader contract, the identities and palettes they are
+ * handed, and the metric definitions — and this fails when it stops matching.
+ * The fix is not code: open gallery.html and press "refresh metadata".
  */
-function coverageOf(engine, module) {
-    engine.setLayerSpecs([{
-        module, params: defaultValues(module), seed: 4242,
-        opacity: 1, blend: 'normal',
-        palette: [[0.05, 0.05, 0.1], [0.9, 0.3, 0.5], [0.3, 0.8, 0.9], [0.95, 0.9, 0.4]],
-    }]);
-    engine.compositor.reset();
-    for (let f = 594; f < 600; f++) engine.renderFrame(f);
-    const px = Uint8Array.from(engine.readPixels(engine.renderFrame(600)));
-    let lit = 0;
-    for (let i = 0; i < px.length; i += 4) {
-        // Anything a viewer would read as painted rather than as backdrop.
-        if (px[i] + px[i + 1] + px[i + 2] > 90) lit++;
-    }
-    return lit / (px.length / 4);
-}
+check(12, 'metadata · the measurements match the code that produced them', () => {
+    const fresh = metadataIsFresh();
+    const rows = Object.keys(METADATA.scenes || {}).length;
+    const unmeasured = scenes
+        .filter((m) => m.kind === 'fragment' && !isMeasured(m))
+        .map((m) => m.name);
 
-check(12, 'surface · a composable scene leaves room for what it sits on', () => {
-    const engine = new Engine({ width: 128, height: 72 });
-    const track = varietyTrack();
-    engine.timeline.setDuration(track.duration);
-    engine.setFeatureProvider(featureProviderFor(track));
+    return expect(fresh && unmeasured.length === 0,
+        (fresh ? '' : `stale: measured against ${METADATA.fingerprint}, code is ${metricsFingerprint()} — ` +
+            'rebuild it from gallery.html → refresh metadata · ') +
+        (unmeasured.length ? `never measured: ${unmeasured.slice(0, 5).join(', ')} · ` : '') +
+        `${rows} scenes measured ${METADATA.measured} · ` +
+        `${scenes.filter(canGround).length} can ground a section`);
+});
 
-    const wrong = [];
-    const measured = [];
-    try {
-        for (const module of scenes) {
-            if (module.kind !== 'fragment') continue;
-            const cover = coverageOf(engine, module);
-            const surface = surfaceOf(module);
-            measured.push({ name: module.name, surface, cover });
-            // A composable scene painting most of the frame hides its
-            // background; a canvas leaving it nearly empty is a canvas in name
-            // only and will read as a black frame when nothing is under it.
-            if (surface === 'composable' && cover > 0.55) wrong.push(`${module.name} claims composable but covers ${(cover * 100).toFixed(0)}%`);
-            if (surface === 'canvas' && cover < 0.08) wrong.push(`${module.name} claims canvas but covers only ${(cover * 100).toFixed(0)}%`);
+/**
+ * The labels the measurements produce are usable ones.
+ *
+ * Not a re-measurement — the check above covers staleness. This asks whether
+ * the library, as labelled, can still cast a video: every section needs a
+ * ground, quiet sections are held to the restful families, so a threshold that
+ * left one ground in the whole library would pass every other gate here and
+ * make every video identical underneath.
+ */
+check(12, 'metadata · the measured labels leave enough grounds to cast with', () => {
+    const grounds = scenes.filter(canGround);
+    const byFamily = {};
+    for (const m of grounds) byFamily[m.family] = (byFamily[m.family] || 0) + 1;
+    const restful = RESTFUL_FAMILIES.reduce((n, f) => n + (byFamily[f] || 0), 0);
+
+    const problems = [];
+    // Low bars, and they are where the library actually is rather than where it
+    // ought to be. Seven scenes can ground a section — five geometric, two
+    // organic — and the two organic ones carry every quiet section of every
+    // video, because no minimal or flow canvas in the library fills half the
+    // frame without reading prev(). That is the library's largest hole and it
+    // is scene work, not generator work. The numbers are printed on every run
+    // so it stays visible instead of becoming the way things are.
+    if (grounds.length < 6) problems.push(`only ${grounds.length} grounds in the library`);
+    if (restful < 2) problems.push(`only ${restful} restful grounds for quiet sections`);
+
+    return expect(problems.length === 0,
+        (problems.length ? problems.join(' · ') + ' — ' : '') +
+        `${grounds.length} grounds · ` +
+        Object.entries(byFamily).map(([f, n]) => `${f} ${n}`).join(' · '));
+});
+
+/**
+ * COMPOSITION — what every section's frame is made of.
+ *
+ * Two rules, and they are the two ends of the same idea: a section always has a
+ * filled picture underneath it, and it never stacks up more than two frames'
+ * worth of material on top of that. Between them they rule out both failures
+ * the layer stack can produce — a shot floating on black, and four passes of
+ * texture over each other.
+ *
+ * Measured across the song bank rather than one track, because both rules are
+ * decided per director, per kind and per point in the story, and a single song
+ * exercises one director's opinion about six sections.
+ */
+check(12, 'composition · every section stands on a canvas, under a budget', () => {
+    const problems = [];
+    const budgets = [];
+    let stacks = 0;
+    let grounded = 0;
+
+    for (const name of ['centre', 'drone', 'lattice']) {
+        const track = song(name).track;
+        for (let s = 0; s < 4; s++) {
+            const look = generateLook(track, { seed: 4000 + s * 7717 });
+            for (const section of look.sections) {
+                for (const stack of section.variants || [section.layers]) {
+                    stacks++;
+                    const base = stack[0];
+                    const cover = declaredCoverage(base.module);
+                    if (surfaceOf(base.module) !== 'canvas' || cover < GROUND_MIN) {
+                        problems.push(`${section.kind} stands on ${base.module.name} at ${(cover * 100).toFixed(0)}%`);
+                    } else {
+                        grounded++;
+                    }
+                    if (base.opacity < 1 || base.blend !== 'normal') {
+                        problems.push(`${section.kind} ground ${base.module.name} is ${base.blend} at ${base.opacity.toFixed(2)}`);
+                    }
+                    const total = stackCoverage(stack);
+                    budgets.push(total);
+                    if (total > 2.0001) {
+                        problems.push(`${section.kind} paints ${(total * 100).toFixed(0)}% — over budget`);
+                    }
+                }
+            }
         }
-    } finally {
-        engine.dispose();
     }
 
-    // Reported whatever the verdict, because the useful output of this check is
-    // the list itself — it is how the library gets labelled in the first place.
-    const sorted = measured.sort((a, b) => a.cover - b.cover);
-    window.__COVERAGE__ = sorted;
-    const sparse = sorted.filter((m) => m.cover < 0.3).length;
+    const mean = budgets.reduce((a, b) => a + b, 0) / Math.max(1, budgets.length);
+    const max = Math.max(...budgets);
+    return expect(problems.length === 0,
+        (problems.length ? problems.slice(0, 4).join(' · ') + ' — ' : '') +
+        `${grounded}/${stacks} grounded · coverage mean ${(mean * 100).toFixed(0)}% ` +
+        `· peak ${(max * 100).toFixed(0)}% of the 200% ceiling`);
+});
 
-    return expect(wrong.length === 0,
-        (wrong.length ? wrong.slice(0, 4).join(' · ') + ' — ' : '') +
-        `${measured.length} scenes · ${sparse} paint under 30% of the frame ` +
-        `· sparsest ${sorted[0].name} at ${(sorted[0].cover * 100).toFixed(0)}%`);
+/**
+ * The rendered frame, at BOTH ends.
+ *
+ * The spec-level check above says the generator intended a filled frame. This
+ * renders the middle of every section of twelve videos and looks at what came
+ * out, which is the only statement that matters to someone watching.
+ *
+ * Two failures, and they are opposites that arrive by the same route:
+ *
+ *   too black   a section that is a few bright things on nothing. Measured at
+ *               9 of 40 sampled frames under 20% painted before grounds, the
+ *               darkest at 0.3%.
+ *   too white   a section clipped to paper. Measured at a median 24% of pixels
+ *               at full white and entire sections at 100% when the shot was
+ *               screened over its ground and the feedback loop was still an
+ *               accumulator. Clipped white is not brightness, it is missing
+ *               information: every difference inside it has been deleted.
+ *
+ * `ink` is counted at a low threshold on purpose — the question is whether the
+ * frame has anything IN it, not whether it is bright, and a legitimately dark
+ * scene is not a failure. `blown` is counted at near-full white on all three
+ * channels, which no grade should produce over a quarter of a frame.
+ */
+check(12, 'composition · a rendered section is neither black nor blown out', () => {
+    const dark = [];
+    const white = [];
+    const ink = [];
+    const blown = [];
+    const lum = [];
+
+    for (const name of ['centre', 'drone', 'lattice', 'glare', 'murk', 'runner']) {
+        const track = song(name).track;
+        for (const seed of [4001, 9931]) {
+            const show = new Show({ width: 160, height: 90 });
+            try {
+                show.useTrack(track, generateLook(track, { seed }));
+                for (const section of show.look.sections) {
+                    const f = Math.round(section.startFrame
+                        + (section.endFrame - section.startFrame) * 0.5);
+                    show.engine.compositor.reset();
+                    for (let k = Math.max(0, f - 12); k < f; k++) show.renderFrame(k);
+                    const px = Uint8Array.from(show.readPixels(show.renderFrame(f)));
+
+                    let inked = 0, clipped = 0, light = 0;
+                    const n = px.length / 4;
+                    for (let i = 0; i < px.length; i += 4) {
+                        const r = px[i], g = px[i + 1], b = px[i + 2];
+                        const l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                        if (l > 13) inked++;
+                        if (r > 238 && g > 238 && b > 238) clipped++;
+                        light += l;
+                    }
+                    const where = `${name}/${seed.toString(16)} ${section.kind}`;
+                    ink.push(inked / n);
+                    blown.push(clipped / n);
+                    lum.push(light / n / 255);
+                    if (inked / n < 0.3) dark.push(`${where} only ${((inked / n) * 100).toFixed(0)}% painted`);
+                    // Per section: the hard cap only. A deliberate blaze is
+                    // allowed to be bright; nothing is allowed to be gone.
+                    if (clipped / n > 0.5) white.push(`${where} ${((clipped / n) * 100).toFixed(0)}% clipped white`);
+                    if (light / n / 255 > 0.9) white.push(`${where} mean luminance ${((light / n / 255) * 100).toFixed(0)}%`);
+                }
+            } finally {
+                show.dispose();
+            }
+        }
+    }
+
+    // A BLAZE is allowed; blazing by default is not.
+    //
+    // The ceiling is therefore two numbers rather than one. No single section
+    // may be wholly gone — past about half the frame at full white there is no
+    // picture left to read — and only a minority of them may be hot at all. The
+    // second is the one that matters: screening every shot over its ground blew
+    // a median quarter of EVERY frame, which is not a director choosing to peak,
+    // it is a pipeline with no headroom. See blazeOf in look/directors.js.
+    const hot = blown.filter((b) => b > 0.25).length;
+    const hotShare = hot / Math.max(1, blown.length);
+    if (hotShare > 0.2) {
+        white.push(`${(hotShare * 100).toFixed(0)}% of sections clipped past 25% — blazing is the default, not a choice`);
+    }
+
+    const problems = [...dark, ...white];
+    const mean = (a) => a.reduce((x, y) => x + y, 0) / Math.max(1, a.length);
+    return expect(problems.length === 0,
+        (problems.length ? problems.slice(0, 4).join(' · ') + ' — ' : '') +
+        `${ink.length} sections · painted mean ${(mean(ink) * 100).toFixed(0)}% ` +
+        `darkest ${(Math.min(...ink) * 100).toFixed(0)}% · ` +
+        `clipped mean ${(mean(blown) * 100).toFixed(0)}% worst ${(Math.max(...blown) * 100).toFixed(0)}% · ` +
+        `${hot} of ${blown.length} sections blazing`);
 }, { slow: true });
+
+/**
+ * A stack is two things happening, not one thing twice.
+ *
+ * The point of the measured profiles: family labels say a `flow` scene and an
+ * `organic` scene are different, and the render can disagree — two of them can
+ * sit 0.04 apart, which stacked is one texture at double density. This asks
+ * whether the generator's stacks are actually made of unalike material.
+ *
+ * A mean rather than a per-stack floor, because a lean is what the generator
+ * applies. Demanding every pair clear a bar would be demanding a particular
+ * draw, and the seed is supposed to be able to make an ordinary choice.
+ */
+check(12, 'composition · stacked layers are structurally unalike', () => {
+    const pairs = [];
+    for (const name of ['centre', 'drone', 'lattice']) {
+        const track = song(name).track;
+        for (let s = 0; s < 4; s++) {
+            const look = generateLook(track, { seed: 5200 + s * 3931 });
+            for (const section of look.sections) {
+                for (const stack of section.variants || [section.layers]) {
+                    for (let i = 0; i < stack.length; i++) {
+                        for (let j = i + 1; j < stack.length; j++) {
+                            const d = structuralDistance(stack[i].module, stack[j].module);
+                            if (d !== null) pairs.push(d);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    const mean = pairs.reduce((a, b) => a + b, 0) / Math.max(1, pairs.length);
+    const twins = pairs.filter((d) => d < 0.03).length;
+    // Against the library's own median distance, so this measures the CHOOSING
+    // rather than the library — a bar in absolute units would drift every time
+    // a scene was added.
+    return expect(pairs.length > 0 && mean > 0.08 && twins / pairs.length < 0.05,
+        `${pairs.length} stacked pairs · mean distance ${mean.toFixed(3)} · ` +
+        `${twins} near-twins (${((twins / Math.max(1, pairs.length)) * 100).toFixed(0)}%)`);
+});
diff --git a/flow-state/src/checks/phase13.js b/flow-state/src/checks/phase13.js
index da83ab2..10f1dca 100644
--- a/flow-state/src/checks/phase13.js
+++ b/flow-state/src/checks/phase13.js
@@ -27,6 +27,7 @@ import { FeatureTrack } from '../audio/FeatureTrack.js';
 import { synthesizeSectioned } from '../audio/synth.js';
 import { song } from '../audio/songbank.js';
 import { storyStateAt, STORY_VARS, PLOT_NAMES } from '../look/Story.js';
+import { subjectOf } from '../look/stack.js';
 
 /**
  * Bank songs rather than the two-section synthetics the other phases use.
@@ -107,7 +108,7 @@ check(13, 'the second time a kind happens is not the first time again', () => {
             if (list.length < 2) continue;
             const first = list[0];
             const last = list[list.length - 1];
-            const sceneChanged = first.layers[0].module.name !== last.layers[0].module.name;
+            const sceneChanged = subjectOf(first.layers).module.name !== subjectOf(last.layers).module.name;
             const pushed = Math.abs(last.story.tension - first.story.tension);
             seen.push({ name, kind, sceneChanged, pushed });
         }
@@ -210,7 +211,7 @@ check(13, 'a recapitulation actually recapitulates', () => {
             // residue on everything else that makes the ending a return rather
             // than a rewind.
             rows.push({
-                same: intro.layers[0].module.name === outro.layers[0].module.name,
+                same: subjectOf(intro.layers).module.name === subjectOf(outro.layers).module.name,
                 moved: Math.max(...['journey', 'reveal', 'tension'].map((k) =>
                     Math.abs(outro.story[k] - intro.story[k]))),
             });
diff --git a/flow-state/src/checks/phase3.js b/flow-state/src/checks/phase3.js
index fa8015f..6cf2a0f 100644
--- a/flow-state/src/checks/phase3.js
+++ b/flow-state/src/checks/phase3.js
@@ -14,6 +14,7 @@ import { generateLook, rerollSection, rerollLook, describeLook } from '../look/L
 import { paletteContrast, relativeLuminance } from '../look/palette.js';
 import { frameDistance, frameLuminance, frameVariance } from '../engine/hash.js';
 import { testTrack } from './phase1.js';
+import { subjectOf } from '../look/stack.js';
 
 /** Four deliberately different tracks: the differentiation gate needs real spread. */
 let cachedBattery = null;
@@ -34,15 +35,22 @@ export function battery() {
 
 export function renderLookFrame(engine, track, look, frame) {
     const section = look.sections[track.sectionIndexAt(frame)] || look.sections[0];
-    const layer = section.layers[0];
-    engine.setLayerSpecs([{
+    // The WHOLE stack, not the subject alone.
+    //
+    // This rendered `layers[0]` back when that was the section's only layer,
+    // and rendering one layer of a composed section answers a question nobody
+    // asked: a composable shot on its own is a few bright things on black,
+    // which is exactly what it is not supposed to be shown as. Measured, it
+    // reported a dead frame — luminance 0.0006 — for a section that renders
+    // perfectly well with the ground it was built with underneath it.
+    engine.setLayerSpecs(section.layers.map((layer) => ({
         module: layer.module,
         params: layer.params,
         seed: layer.seed,
         opacity: layer.opacity,
         blend: layer.blend,
         palette: look.palette,
-    }]);
+    })));
     engine.compositor.setPost(look.post).setFeedback(look.feedback);
     engine.compositor.reset();
     return Uint8Array.from(engine.readPixels(engine.renderFrame(frame)));
@@ -55,9 +63,10 @@ check(3, 'the same audio always produces the same look', () => {
     const b = generateLook(track, { samples });
 
     if (a.seed !== b.seed) return expect(false, `seeds differ: ${a.seed} vs ${b.seed}`);
-    const sameScenes = a.sections.every((s, i) => s.layers[0].module.name === b.sections[i].layers[0].module.name);
-    const sameParams = JSON.stringify(a.sections.map((s) => s.layers[0].params))
-                     === JSON.stringify(b.sections.map((s) => s.layers[0].params));
+    const sameScenes = a.sections.every((s, i) =>
+        subjectOf(s.layers).module.name === subjectOf(b.sections[i].layers).module.name);
+    const sameParams = JSON.stringify(a.sections.map((s) => subjectOf(s.layers).params))
+                     === JSON.stringify(b.sections.map((s) => subjectOf(s.layers).params));
     const samePalette = JSON.stringify(a.palette) === JSON.stringify(b.palette);
 
     return expect(sameScenes && sameParams && samePalette,
@@ -144,7 +153,7 @@ check(3, 'different tracks get different looks at the same seed', () => {
     const palettes = looks.map(({ look }) => look.palette.map(relativeLuminance).join(','));
     const uniquePalettes = new Set(palettes).size;
     const sceneSets = looks.map(({ look }) =>
-        [...new Set(look.sections.map((s) => s.layers[0].module.name))].sort().join('+'));
+        [...new Set(look.sections.map((s) => subjectOf(s.layers).module.name))].sort().join('+'));
 
     return expect(uniquePalettes === looks.length,
         `${uniquePalettes}/${looks.length} distinct palettes at a fixed seed · ` +
@@ -173,7 +182,7 @@ check(3, 'every generated look renders a live frame on every track', () => {
                     const lum = frameLuminance(pixels);
                     const variance = frameVariance(pixels);
                     if (lum < 0.0008 || lum > 0.99 || variance < 0.0015) {
-                        problems.push(`${name} s${s} ${section.kind}/${section.layers[0].module.name}: ` +
+                        problems.push(`${name} s${s} ${section.kind}/${subjectOf(section.layers).module.name}: ` +
                             `lum ${lum.toFixed(4)} var ${variance.toFixed(4)}`);
                     }
                 }
@@ -194,7 +203,7 @@ check(3, 'sections of the same kind share a scene', () => {
     const byKind = new Map();
     let violations = 0;
     for (const s of look.sections) {
-        const name = s.layers[0].module.name;
+        const name = subjectOf(s.layers).module.name;
         if (byKind.has(s.kind) && byKind.get(s.kind) !== name) violations++;
         byKind.set(s.kind, name);
     }
@@ -205,14 +214,14 @@ check(3, 'sections of the same kind share a scene', () => {
 check(3, 'reroll changes a section and respects locks', () => {
     const track = testTrack();
     const look = generateLook(track, { seed: 555 });
-    const before = JSON.stringify(look.sections[0].layers[0].params);
+    const before = JSON.stringify(subjectOf(look.sections[0].layers).params);
 
     rerollSection(look, track, 0, 1);
-    const afterUnlocked = JSON.stringify(look.sections[0].layers[0].params);
+    const afterUnlocked = JSON.stringify(subjectOf(look.sections[0].layers).params);
 
     look.sections[0].locked = true;
     rerollSection(look, track, 0, 2);
-    const afterLocked = JSON.stringify(look.sections[0].layers[0].params);
+    const afterLocked = JSON.stringify(subjectOf(look.sections[0].layers).params);
 
     return expect(before !== afterUnlocked && afterUnlocked === afterLocked,
         `changed when unlocked: ${before !== afterUnlocked}, held when locked: ${afterUnlocked === afterLocked}`);
@@ -222,12 +231,12 @@ check(3, 'a whole-track reroll preserves locked sections', () => {
     const track = testTrack();
     const look = generateLook(track, { seed: 777 });
     look.sections[0].locked = true;
-    const lockedScene = look.sections[0].layers[0].module.name;
-    const lockedParams = JSON.stringify(look.sections[0].layers[0].params);
+    const lockedScene = subjectOf(look.sections[0].layers).module.name;
+    const lockedParams = JSON.stringify(subjectOf(look.sections[0].layers).params);
 
     const next = rerollLook(look, track, 888);
     return expect(
-        next.sections[0].layers[0].module.name === lockedScene &&
-        JSON.stringify(next.sections[0].layers[0].params) === lockedParams,
+        subjectOf(next.sections[0].layers).module.name === lockedScene &&
+        JSON.stringify(subjectOf(next.sections[0].layers).params) === lockedParams,
         `locked section survived a full reroll (${lockedScene})`);
 });
diff --git a/flow-state/src/checks/phase5.js b/flow-state/src/checks/phase5.js
index 3931165..a4d6b5a 100644
--- a/flow-state/src/checks/phase5.js
+++ b/flow-state/src/checks/phase5.js
@@ -18,6 +18,7 @@ import { peakFlashRate } from '../engine/flash.js';
 import { particleField } from '../scenes/layers3d/particles.js';
 import { nebula } from '../scenes/shader/nebula.js';
 import { BLEND_MODES } from '../engine/Layer.js';
+import { subjectOf } from '../look/stack.js';
 
 const PALETTE = [
     [0.06, 0.03, 0.16], [0.85, 0.15, 0.55], [0.15, 0.75, 0.95],
@@ -192,7 +193,7 @@ check(5, 'generated looks stay within the flash-rate ceiling', () => {
                 }
                 const rate = peakFlashRate(luminance, 60);
                 const section = show.look.sections[cue.sectionIndex];
-                const scene = (section.variants[cue.variant] || section.layers)[0].module.name;
+                const scene = subjectOf(section.variants[cue.variant] || section.layers).module.name;
                 const label = `seed ${s} ${section.kind}/${scene}`;
                 if (rate > worst) { worst = rate; worstLabel = label; }
                 if (rate > 3) problems.push(`${label}: ${rate}/s`);
diff --git a/flow-state/src/checks/phase7.js b/flow-state/src/checks/phase7.js
index f925643..9118315 100644
--- a/flow-state/src/checks/phase7.js
+++ b/flow-state/src/checks/phase7.js
@@ -16,6 +16,7 @@ import { FeatureTrack, featureProviderFor } from '../audio/FeatureTrack.js';
 import { synthesizeSectioned } from '../audio/synth.js';
 import { generateLook } from '../look/LookGenerator.js';
 import { frameDistance, frameMaxDelta, frameLuminance, frameVariance } from '../engine/hash.js';
+import { subjectOf } from '../look/stack.js';
 
 const PALETTE = [
     [0.06, 0.03, 0.16], [0.85, 0.15, 0.55], [0.15, 0.75, 0.95],
@@ -247,7 +248,7 @@ check(7, 'quiet sections now get minimal scenes', () => {
         for (const section of look.sections) {
             if (!(section.kind in kinds)) continue;
             total++;
-            const family = section.layers[0].module.family;
+            const family = subjectOf(section.layers).module.family;
             if (restful.has(family)) restfulCount++;
             if (family === 'minimal') minimalCount++;
         }
diff --git a/flow-state/src/checks/phase8.js b/flow-state/src/checks/phase8.js
index 0803a5a..617166d 100644
--- a/flow-state/src/checks/phase8.js
+++ b/flow-state/src/checks/phase8.js
@@ -12,6 +12,7 @@ import { synthesizeSectioned } from '../audio/synth.js';
 import { generateLook } from '../look/LookGenerator.js';
 import { MIN_SHOT_SECONDS, MAX_SHOT_SECONDS, HARD_CUT_ENERGY } from '../look/shots.js';
 import { frameDistance } from '../engine/hash.js';
+import { subjectOf } from '../look/stack.js';
 
 let cached = null;
 function track8() {
@@ -131,7 +132,7 @@ check(8, 'the same section kind reuses the same roster', () => {
     for (const look of looks()) {
         const byKind = new Map();
         for (const section of look.sections) {
-            const roster = (section.variants || [section.layers]).map((v) => v[0].module.name).join('+');
+            const roster = (section.variants || [section.layers]).map((v) => subjectOf(v).module.name).join('+');
             const seen = byKind.get(section.kind);
             if (seen && seen !== roster) problems.push(`${section.kind}: ${seen} vs ${roster}`);
             byKind.set(section.kind, roster);
diff --git a/flow-state/src/checks/phase9.js b/flow-state/src/checks/phase9.js
index 77c7048..d49df38 100644
--- a/flow-state/src/checks/phase9.js
+++ b/flow-state/src/checks/phase9.js
@@ -20,6 +20,7 @@ import { Rng } from '../engine/rng.js';
 import { FeatureTrack, featureProviderFor } from '../audio/FeatureTrack.js';
 import { synthesizeSectioned } from '../audio/synth.js';
 import { frameMaxDelta } from '../engine/hash.js';
+import { subjectOf } from '../look/stack.js';
 
 const PALETTE = [
     [0.06, 0.03, 0.16], [0.85, 0.15, 0.55], [0.15, 0.75, 0.95],
@@ -40,7 +41,7 @@ function looks(count = 8) {
     return Array.from({ length: count }, (_, i) => generateLook(track, { seed: 3000 + i * 6841 }));
 }
 
-const castOf = (look) => look.sections.flatMap((s) => (s.variants || [s.layers]).map((v) => v[0].module));
+const castOf = (look) => look.sections.flatMap((s) => (s.variants || [s.layers]).map((v) => subjectOf(v).module));
 
 /** Two personalities differing in exactly one trait, for the "does it show" checks. */
 function pairDifferingIn(trait) {
@@ -140,7 +141,7 @@ check(9, 'casting leans hard on the track\'s signature', () => {
         }
         for (const section of look.sections) {
             anchors++;
-            if (sceneHonours(section.layers[0].module, signature)) anchorsHonoured++;
+            if (sceneHonours(subjectOf(section.layers).module, signature)) anchorsHonoured++;
         }
     }
     const share = total ? honoured / total : 0;
diff --git a/flow-state/src/checks/variety/report.js b/flow-state/src/checks/variety/report.js
index 13d6d80..3fb8a7f 100644
--- a/flow-state/src/checks/variety/report.js
+++ b/flow-state/src/checks/variety/report.js
@@ -35,6 +35,8 @@ import { Rng } from '../../engine/rng.js';
 import { videoSignature, signatureDistance, STRUCTURAL } from './signature.js';
 import { songBank } from '../../audio/songbank.js';
 import { hashString } from '../../engine/rng.js';
+import { subjectOf, isGround } from '../../look/stack.js';
+import { canGround } from '../../scenes/surface.js';
 
 const RENDER = { width: 160, height: 90 };
 
@@ -70,11 +72,17 @@ export function signatureForChaos(track, seed, options = {}) {
         const look = generateLook(track, { seed: seed >>> 0 });
         const rng = new Rng((seed * 2246822519) >>> 0);
         const pool = scenes.filter(canBackground);
+        // The ground keeps its JOB when its identity is thrown away. Recasting
+        // it from the whole library would give the reference videos thin,
+        // half-black frames no real video can have any more, and a ceiling
+        // measured on those is a ceiling for a pipeline that does not exist —
+        // it fell below the floor the first time this ran.
+        const groundPool = scenes.filter(canGround);
         const temperament = look.personality && look.personality.temperament;
         for (const section of look.sections) {
             for (const variant of section.variants) {
                 for (const layer of variant) {
-                    layer.module = rng.pick(pool);
+                    layer.module = rng.pick(isGround(layer) ? groundPool : pool);
                     layer.params = sampleValues(layer.module, rng, section.bias, temperament);
                     layer.seed = rng.int(0, 0x7fffffff);
                 }
@@ -435,7 +443,7 @@ export function measureSpecDiversity(track, { seeds = 32, seed0 = 0x5eed } = {})
         grain: entropy(looks.map((l) => l.grain.mode)),
         framing: entropy(looks.map((l) => l.framing.mode)),
         paletteArc: entropy(looks.map((l) => l.paletteArc.mode)),
-        anchorScenes: entropy(looks.map((l) => l.sections.map((s) => s.layers[0].module.name).join('>'))),
+        anchorScenes: entropy(looks.map((l) => l.sections.map((s) => subjectOf(s.layers).module.name).join('>'))),
     };
 }
 
diff --git a/flow-state/src/engine/passes.js b/flow-state/src/engine/passes.js
index cba178f..fc6e245 100644
--- a/flow-state/src/engine/passes.js
+++ b/flow-state/src/engine/passes.js
@@ -30,6 +30,23 @@ void main() {
     else if (u_mode == 3) result = mix(base.rgb, base.rgb * src.rgb, a);          // multiply
     else if (u_mode == 4) result = mix(base.rgb, blendOverlay(base.rgb, src.rgb), a);
     else if (u_mode == 5) result = mix(base.rgb, blendSoftLight(base.rgb, src.rgb), a);
+    // LUMAKEY — the source's own brightness is its alpha.
+    //
+    // For a layer that is a PICTURE with black around it, which is what a
+    // composable scene is: it replaces the base where it paints and leaves it
+    // where it does not. Screen was doing this job and screen is a lightening
+    // operator — over a filled ground it drives everything toward white, which
+    // measured as a median 24% of the frame clipped and whole sections at
+    // 100%. This keeps the shot's own colour instead of adding it to the bed's.
+    //
+    // The key is smoothstepped rather than raw luma so a dark-but-present shot
+    // does not dissolve into the ground, and gamma-ish weighted to keep thin
+    // bright lines opaque.
+    else if (u_mode == 6) {
+        float key = dot(src.rgb, vec3(0.2126, 0.7152, 0.0722));
+        key = smoothstep(0.02, 0.32, key);
+        result = mix(base.rgb, src.rgb, key * a);
+    }
     else                  result = mix(base.rgb, src.rgb, a);                     // normal
 
     gl_FragColor = vec4(result, max(base.a, a));
@@ -65,7 +82,26 @@ void main() {
     vec3 hist = texture2D(u_history, clamp(warped, 0.0, 1.0)).rgb;
     // Decay strictly below 1 keeps the loop convergent; the 10k-frame stability
     // check in tools/ verifies it neither saturates to white nor dies to black.
-    vec3 outC = cur + hist * u_decay * u_amount;
+    //
+    // NORMALISED, which it was not. cur + hist * decay * amount is an
+    // accumulator: a static image settles at 1/(1 - decay*amount) times its own
+    // brightness, which is 2.3x at the settings the generator hands out. That
+    // was survivable while a frame was a few bright things on black and stopped
+    // being survivable the moment every section stood on a filled ground —
+    // measured, entire sections rendered as pure white, and turning feedback off
+    // took the same frame from 100% blown to 34% mean luminance.
+    //
+    // Dividing by the gain keeps the trail — moving content still smears, which
+    // is the whole point — instead of stacking exposures.
+    //
+    // PARTIALLY, at 0.6, rather than all the way. Full normalisation is the
+    // mathematically tidy answer and it takes the lift out with the blowout:
+    // measured over 74 sections, the median frame went from 95% painted to 71%
+    // and fourteen fell under the black-frame floor. Feedback contributing SOME
+    // brightness is part of what the looks were built around. At 0.6 a still
+    // frame settles about 1.2x its drawn brightness instead of 2.3x.
+    float gain = u_decay * u_amount;
+    vec3 outC = (cur + hist * gain) / (1.0 + gain * 0.6);
     gl_FragColor = vec4(min(outC, vec3(4.0)), 1.0);
 }
 `;
@@ -155,6 +191,19 @@ void main() {
     float v = 1.0 - u_vignette * dot(dir, dir) * 2.0;
     col *= clamp(v, 0.0, 1.0);
 
+    // HIGHLIGHT SHOULDER — the top end rolls off instead of clipping.
+    //
+    // Everything under the knee is untouched, so the image keeps its contrast;
+    // above it, values compress toward but never reach 1. Without this, bloom
+    // plus a filled ground plus a bright palette clips large areas to pure
+    // white — measured at 38% of a drop's frame — and clipped white is not
+    // bright, it is missing: every difference inside it is gone.
+    //
+    // Cheap, per channel, and deliberately not a full filmic curve. The job is
+    // to stop the frame flattening out at the top, not to grade it.
+    vec3 over = max(col - 0.75, vec3(0.0));
+    col = min(col, vec3(0.75)) + over / (1.0 + over * 4.0);
+
     // Deterministic grain: keyed on frame index, never on a random source.
     //
     // Cell size and refresh rate are separate on purpose. Fine-and-boiling is
@@ -204,4 +253,5 @@ void main() { gl_FragColor = texture2D(u_tex, vUv); }
 
 export const BLEND_MODE_IDS = {
     normal: 0, add: 1, screen: 2, multiply: 3, overlay: 4, softlight: 5,
+    lumakey: 6,
 };
diff --git a/flow-state/src/look/ArcDriver.js b/flow-state/src/look/ArcDriver.js
index aeacd26..edec234 100644
--- a/flow-state/src/look/ArcDriver.js
+++ b/flow-state/src/look/ArcDriver.js
@@ -6,6 +6,8 @@ import { shiftPalette } from './palette.js';
 import { frameShot, neutralFraming } from './framing.js';
 import { planGaze, gazeAt } from './Camera.js';
 import { storyStateAt, NEUTRAL_STATE } from './Story.js';
+import { subjectIndexOf, isGround } from './stack.js';
+import { groundPersonalityFrom } from '../scenes/surface.js';
 
 /**
  * Drives the look across the song.
@@ -597,7 +599,7 @@ export class ArcDriver {
                 layer.opacity = slot === 0 ? 1 : spec.opacity;
                 layer.blend = slot === 0 ? 'normal' : spec.blend;
                 layer.setPalette(palette);
-                layer.setPersonality(personality);
+                layer.setPersonality(isGround(spec) ? groundPersonalityFrom(personality) : personality);
                 layer.setFraming(outgoingFraming);
                 layers.push(layer);
             }
@@ -610,7 +612,7 @@ export class ArcDriver {
             layer.opacity = (slot === 0 ? 1 : spec.opacity) * (fading ? eased : 1);
             layer.blend = slot === 0 ? 'normal' : spec.blend;
             layer.setPalette(palette);
-            layer.setPersonality(personality);
+            layer.setPersonality(isGround(spec) ? groundPersonalityFrom(personality) : personality);
             layer.setFraming(framing);
             layers.push(layer);
         }
@@ -622,7 +624,11 @@ export class ArcDriver {
             variant: cue.variant,
             kind: section.kind,
             crossfade: fading ? eased : 0,
-            sceneName: this._specFor(cue.sectionIndex, cue.variant, 0).module.name,
+            // The SHOT's name, not the ground's. Every stack starts with a bed
+            // now, and the HUD naming it would report the same handful of
+            // canvases for every section of every video.
+            sceneName: this._specFor(
+                cue.sectionIndex, cue.variant, this._subjectSlot(cue)).module.name,
             buildSlope: features ? features.buildSlope || 0 : 0,
             // Where the story is, for the HUD and the checks. A video that is
             // supposed to be going somewhere should be able to say where.
@@ -636,10 +642,18 @@ export class ArcDriver {
         return layers;
     }
 
-    _stackSize(cue) {
+    /** Which slot of a cue's stack is the shot. See look/stack.js. */
+    _subjectSlot(cue) {
+        return subjectIndexOf(this._stackFor(cue));
+    }
+
+    _stackFor(cue) {
         const section = this.look.sections[cue.sectionIndex];
-        const stack = (section.variants && section.variants[cue.variant]) || section.layers;
-        return stack.length;
+        return (section.variants && section.variants[cue.variant]) || section.layers;
+    }
+
+    _stackSize(cue) {
+        return this._stackFor(cue).length;
     }
 
     /** Layers changed identity — the compositor needs the new list. */
diff --git a/flow-state/src/look/LookGenerator.js b/flow-state/src/look/LookGenerator.js
index e2cdcd7..082a516 100644
--- a/flow-state/src/look/LookGenerator.js
+++ b/flow-state/src/look/LookGenerator.js
@@ -7,13 +7,20 @@
 import { Rng, hashSamples } from '../engine/rng.js';
 import { AudioPalette, generateUsablePalette } from './palette.js';
 import { scenes, scenesInFamily, FAMILIES } from '../scenes/registry.js';
-import { sampleValues, defaultValues, surfaceOf, canBackground } from '../params/schema.js';
+import { sampleValues, defaultValues, canBackground } from '../params/schema.js';
+import {
+    canGround, surfaceOf, structuralDistance, groundBiasFrom, groundTemperamentFrom,
+    coverageOf as sceneCoverage, GROUND_MIN,
+} from '../scenes/surface.js';
+import { GROUND, subjectOf } from './stack.js';
 import { planShots } from './shots.js';
 import {
     generatePersonality, sceneHonours, signatureWeight, describePersonality,
 } from './Personality.js';
 import { deriveGrain, describeGrain, applyGrainToPost } from './grain.js';
-import { pickDirector, directorByName } from './directors.js';
+import {
+    pickDirector, directorByName, crowdOf, blazeOf, RESTFUL_FAMILIES, QUIET_KINDS,
+} from './directors.js';
 import { derivePaletteArc, describePaletteArc } from './paletteArc.js';
 import { deriveFramingStyle, describeFraming } from './framing.js';
 import { deriveCamera, describeCamera } from './Camera.js';
@@ -208,6 +215,120 @@ function rosterSizeFor(kind) {
     return (KIND_ENERGY[kind] ?? 0.5) > 0.5 ? 4 : 3;
 }
 
+/**
+ * The most painted frame a stack is allowed to add up to.
+ *
+ * 1.0 is one filled picture. 2.0 is two of them stacked, which is where the
+ * compositor's blends stop producing depth and start producing mud — past it
+ * the layers are no longer readable as separate things, so nothing is gained
+ * by the third pass except cost.
+ */
+const MAX_COVERAGE = 2.0;
+
+
+/**
+ * How full THIS section's frame is allowed to get, in painted coverage.
+ *
+ * Three inputs, in the order they matter:
+ *
+ *   the director  — how much this point of view lets happen at once. A
+ *                   brutalist video is one large thing everywhere in it; a
+ *                   corrupt one is everything over everything. See crowdOf.
+ *   the song       — a loud, dense section carries more than a quiet one.
+ *   the stage      — where the story is. `population` is literally how crowded
+ *                    this point in the video wants to be, and layering is the
+ *                    one lever on it that needs no cooperation from the scenes.
+ *
+ * The floor is GROUND_MIN because the ground is not optional: a section always
+ * pays for its bed first, and the budget governs what may be stacked on it.
+ */
+function coverageBudgetFor(bias, story, director) {
+    const stage = story ? story.population * 0.6 + story.tension * 0.4 : 0.5;
+    const want = 0.6 + bias.energy * 0.5 + bias.density * 0.2 + (stage - 0.5) * 0.5;
+    return Math.max(GROUND_MIN, Math.min(MAX_COVERAGE, want * crowdOf(director)));
+}
+
+/** The budget a KIND is planned against, before a section's own bias exists. */
+function kindBudget(kind, director) {
+    return coverageBudgetFor(
+        { energy: KIND_ENERGY[kind] ?? 0.5, density: 0.5 }, null, director);
+}
+
+/**
+ * The GROUND a kind's sections stand on: a canvas that paints at least half the
+ * frame, cast once per kind so a section's cuts change the shot without moving
+ * the video to another world.
+ *
+ * Most of the library cannot do this job and is not supposed to — two thirds of
+ * it is composable, which means it reads as elements ON something and has
+ * nothing of its own behind them. Those scenes were being cast as backgrounds
+ * anyway, which is why a section could be a few bright things on black for
+ * ninety seconds. The ground is what they are on.
+ *
+ * Chosen against the kind's budget rather than at random: a scene that paints
+ * 98% of the frame is a legitimate ground for a drop and the wrong bed for an
+ * intro, because everything the intro puts on it has to remain visible.
+ */
+function castGround(kind, roster, rng, signature, director, used) {
+    const pool = scenes.filter(canGround);
+    if (!pool.length) return null;
+
+    const families = director.families[kind] || Object.keys(FAMILIES);
+    const quiet = QUIET_KINDS.includes(kind);
+    // What the shots standing on it will paint, so the ground leaves room for
+    // the section it is under.
+    const reserve = roster.length
+        ? roster.reduce((sum, m) => sum + sceneCoverage(m), 0) / roster.length
+        : 0.2;
+    const headroom = kindBudget(kind, director) - reserve;
+
+    const weights = pool.map((m) => {
+        const at = families.indexOf(m.family);
+        // Off-family grounds stay reachable — the ground is a bed, not the
+        // director's statement — but the director still leads.
+        let w = at >= 0 ? families.length - at : 0.35;
+        // The quiet-kind rule applies to the floor as well. An intro standing on
+        // a strobing glitch canvas is the mistake that rule exists to prevent,
+        // and it is worse underneath than on top because nothing hides it.
+        if (quiet && !RESTFUL_FAMILIES.includes(m.family)) w *= 0.15;
+        w *= signatureWeight(m, signature);
+        // Overshooting the budget is allowed and discouraged: the ground is
+        // mandatory, so an oversized one is spent frame the shot cannot use.
+        w /= 1 + 4 * Math.max(0, sceneCoverage(m) - headroom);
+        // The bed has to be unlike the things standing on it, or the section is
+        // one texture at double density. Measured against the whole roster,
+        // because every member of it will be shot against this ground.
+        w *= contrastWeight(m, roster.map((r) => ({ module: r })));
+        // A video returns to its world rather than visiting six of them.
+        if (used.has(m.name)) w *= 3;
+        // Nothing stands on itself. If the kind's own anchor is groundable it
+        // will be its own ground in buildStack, and this pick is for the rest.
+        if (roster.some((r) => r.name === m.name)) w *= 0.1;
+        return Math.max(1e-4, w);
+    });
+
+    const ground = rng.pickWeighted(pool, weights);
+    used.add(ground.name);
+    return ground;
+}
+
+/** One ground per section kind. See castGround. */
+function assignGroundsByKind(rosterByKind, rng, signature, director) {
+    const grounds = new Map();
+    const used = new Set();
+    // Loud kinds first, for the same reason rosters are assigned that way: they
+    // are what the video is remembered for, so they choose their world first.
+    const priority = ['drop', 'sustain', 'build', 'breakdown', 'intro', 'outro'];
+    const kinds = [...rosterByKind.keys()]
+        .sort((a, b) => priority.indexOf(a) - priority.indexOf(b));
+    for (const kind of kinds) {
+        grounds.set(kind, castGround(
+            kind, rosterByKind.get(kind) || [], rng.fork(`ground:${kind}`),
+            signature, director, used));
+    }
+    return grounds;
+}
+
 /**
  * Scenes are chosen per section KIND, not per section — and a kind gets a
  * ROSTER of two or three, not one.
@@ -341,10 +462,49 @@ function derivePost(summary, rng, grain) {
 }
 
 /**
- * One layer stack: a background scene, and sometimes one or two composable
- * scenes composited over it.
+ * How much a candidate would add to a stack, structurally.
  *
- *   background — the shot. Always present, always opaque.
+ * The question a stack has to answer is not "are these two scenes different
+ * things" but "will a viewer see two things". Those come apart: the measured
+ * distance between two scenes' structural profiles is what a viewer reads, and
+ * it does not follow the family labels. So a candidate is weighted by how far
+ * it sits from everything already in the stack, taking the CLOSEST such
+ * distance — one near-twin in the stack is enough to make the addition read as
+ * more of the same, however unlike the other layers it is.
+ *
+ * A lean, not a filter, and for the same reason the signature weighting is:
+ * measured distances are a description of the library as it is today, and a
+ * generator that obeyed them exactly would cast the same handful of contrasts
+ * in every video. Unmeasured scenes score neutral rather than zero — never
+ * having been rendered is not evidence of sameness.
+ */
+const CONTRAST_NEUTRAL = 0.12;
+
+function contrastWeight(candidate, stack) {
+    let closest = Infinity;
+    for (const layer of stack) {
+        const d = structuralDistance(candidate, layer.module);
+        if (d !== null) closest = Math.min(closest, d);
+    }
+    if (closest === Infinity) closest = CONTRAST_NEUTRAL;
+    // 0.02 apart (twins) → 0.25; 0.12 (typical) → 1.0; 0.30 (unalike) → 2.1.
+    return Math.max(0.15, Math.min(2.5, 0.15 + (closest / CONTRAST_NEUTRAL) * 0.85));
+}
+
+/**
+ * One layer stack: the ground, the shot standing on it, and sometimes a pass
+ * or two composited over both.
+ *
+ *   ground     — a canvas painting at least half the frame. Always present,
+ *                always opaque, and usually NOT the scene the section is about:
+ *                two thirds of the library is composable, and a composable
+ *                scene on its own is a few bright things on black. It is the
+ *                one layer the section does not choose freely — see castGround.
+ *                When the shot is itself a full canvas it IS the ground, because
+ *                two canvases stacked is two pictures fighting.
+ *   shot       — what the section is about. Screened over the ground rather
+ *                than replacing it, so what it does not paint is the ground
+ *                rather than black. `subjectOf` finds it; see look/stack.js.
  *   overlay    — a composable scene at partial opacity. Not always: this is the
  *                variation valve, and a stack that always doubled up would read
  *                as permanently cluttered rather than as occasionally layered.
@@ -360,14 +520,80 @@ function derivePost(summary, rng, grain) {
  *
  * Quiet material mostly goes without any — an intro is supposed to be sparse.
  */
-function buildStack(module, overlayRoster, bias, rng, temperament, story = null) {
-    const layers = [{
+function buildStack(module, overlayRoster, bias, rng, temperament, story = null,
+                    { ground = null, director = null, kind = null } = {}) {
+    const sectionKind = kind;
+    // A shot that fills the frame by itself is its own ground; anything else
+    // gets one under it.
+    const standsAlone = canGround(module) || !ground;
+
+    // --- the blaze ------------------------------------------------------
+    // Whether THIS section is one the director lets bloom out: the shot added
+    // to its ground rather than keyed onto it, so the two brightnesses sum and
+    // the highlights go to paper.
+    //
+    // A decision, and a rationed one. Screening every shot over its ground is
+    // how a median quarter of every frame in every video ended up clipped —
+    // the effect was not wrong, being the default was. It has to be earned:
+    // the director's appetite, times a loud section, times a late point in the
+    // story. Quiet kinds never blaze; a breakdown that goes white is not a
+    // decision, it is a bug with a rationale.
+    const blaze = !standsAlone
+        && !QUIET_KINDS.includes(sectionKind)
+        && rng.bool(blazeOf(director) * clamp01(bias.energy * 1.2)
+            * (story ? 0.4 + story.tension * 0.9 : 0.7));
+
+    // The shot is sampled first and from the caller's rng, so a stack draws the
+    // same shot it always did and the ground arrives underneath it rather than
+    // in front of it in the seed stream.
+    const shot = {
         module,
         params: sampleValues(module, rng, bias, temperament),
         seed: rng.int(0, 0x7fffffff),
-        blend: 'normal',
+        // Keyed over the ground on its own brightness by default: what the shot
+        // leaves unpainted is then the ground rather than black, which is the
+        // whole point of standing it on one, and what it DOES paint stays its
+        // own colour. 'screen' is the blaze — see above, and passes.js.
+        blend: standsAlone ? 'normal' : (blaze ? 'screen' : 'lumakey'),
+        // Carried so the HUD, the checks and a later pass over the look can all
+        // tell a deliberate bloom-out from a broken one.
+        blaze,
         opacity: 1,
-    }];
+    };
+
+    // --- ground ---------------------------------------------------------
+    // Sampled calmer and sparser than it would be as a shot, because a bed the
+    // shot cannot be read against is not a bed.
+    const layers = [];
+    if (!standsAlone) {
+        const groundRng = rng.fork(`ground:${ground.name}`);
+        layers.push({
+            module: ground,
+            role: GROUND,
+            // Calmed, but NOT thinned — see GROUND_BIAS in scenes/surface.js,
+            // which is also the bias the ground was MEASURED at. The first
+            // version subtracted 0.3 from density here, which is exactly
+            // backwards for a bed: an intro is already biased sparse, so the
+            // ground came out at density zero and the section was thin again
+            // for a new reason. Three of forty rendered sections fell under 30%
+            // painted with a ground under every one of them.
+            params: sampleValues(ground, groundRng, groundBiasFrom(bias),
+                groundTemperamentFrom(temperament)),
+            seed: groundRng.int(0, 0x7fffffff),
+            blend: 'normal',
+            opacity: 1,
+        });
+    }
+    layers.push(shot);
+
+    // --- the budget -----------------------------------------------------
+    // What is on the frame so far, and how much more this section is allowed
+    // to put on it. See coverageBudgetFor: the ground and the shot are not
+    // negotiable, so the budget governs the passes over them — a quiet intro
+    // spends everything on its bed and stacks nothing, a crowded drop under a
+    // director with an appetite for it gets two passes.
+    const budget = coverageBudgetFor(bias, story, director);
+    let spent = layers.reduce((sum, l) => sum + sceneCoverage(l.module), 0);
 
     // --- overlay --------------------------------------------------------
     // Roughly a third of stacks on busy material, rarely on quiet material, and
@@ -410,10 +636,26 @@ function buildStack(module, overlayRoster, bias, rng, temperament, story = null)
         Math.min(0.25, overlayChance * bias.energy * 0.5),
     ];
     for (const [pass, chance] of chances.entries()) {
-        if (!available.length || !rng.bool(chance)) break;
-        // Prefer a different family so the images argue instead of blurring.
+        // The budget is a wall, and it is also a lean: as the frame fills up
+        // the odds of adding to it fall away before the wall is reached, so a
+        // stack that is already nearly full rarely gets a token last pass.
+        const headroom = budget - spent;
+        const fits = available.filter((m) => sceneCoverage(m) <= headroom);
+        if (!fits.length || !rng.bool(chance * clamp01(headroom / 0.35))) break;
+        available = fits;
+        // Prefer a different family so the images argue instead of blurring —
+        // and then, within that, prefer the ones that MEASURE different.
+        //
+        // Family is a label somebody typed; structural distance is what the
+        // gallery saw when it rendered the two scenes under the same six songs.
+        // They disagree often enough to matter: two 'geometric' scenes can be
+        // 0.31 apart and a 'flow' and an 'organic' scene 0.04, and stacking the
+        // second pair is one picture at double density rather than a picture
+        // with something happening in it. See scenes/surface.js.
         const offFamily = available.filter((m) => m.family !== module.family);
-        const overlay = rng.pick(offFamily.length ? offFamily : available);
+        const pool = offFamily.length ? offFamily : available;
+        const overlay = rng.pickWeighted(pool, pool.map((m) => contrastWeight(m, layers)));
+        spent += sceneCoverage(overlay);
         available = available.filter((m) => m.name !== overlay.name
             && m.family !== overlay.family);
         // Screen and add keep the background readable underneath; softlight and
@@ -486,6 +728,10 @@ export function generateLook(track, {
     const rosterByKind = assignRostersByKind(
         track.sections, rng.fork('scenes'), personality.signature, director, pool);
     if (story.recap) applyRecap(rosterByKind);
+    // What each kind's sections stand on. After the recap, so the outro is
+    // grounded against the roster it actually ends up with.
+    const groundByKind = assignGroundsByKind(
+        rosterByKind, rng.fork('grounds'), personality.signature, director);
     // The grain treatment: usually none, and when present described rather than
     // dialled. See look/grain.js.
     const grain = deriveGrain(summary, rng.fork('grain'));
@@ -523,9 +769,12 @@ export function generateLook(track, {
         // so the last occurrence of a kind samples further out than the first.
         const temperament = temperamentFor(personality.temperament, state);
 
+        const ground = groundByKind.get(section.kind) || null;
+
         const variants = roster.map((module, v) => buildStack(
             module, overlayRoster, bias,
             sectionRng.fork(`variant:${section.index}:${v}`), temperament, state,
+            { ground, director, kind: section.kind },
         ));
 
         const shots = planShots(
@@ -579,7 +828,8 @@ export function rerollSection(look, track, sectionIndex, salt = 0) {
 
     const rng = new Rng((look.seed ^ (sectionIndex * 0x9e3779b9) ^ (salt * 0x85ebca6b)) >>> 0);
     const signature = (look.personality && look.personality.signature) || [];
-    const families = directorByName(look.director).families[section.kind] || Object.keys(FAMILIES);
+    const director = directorByName(look.director);
+    const families = director.families[section.kind] || Object.keys(FAMILIES);
     // A reroll re-draws this section's cast from the same kind of pool the track
     // was built with, weighted by the signature rather than filtered by it.
     let candidates = families.flatMap((f) => scenesInFamily(f))
@@ -602,9 +852,14 @@ export function rerollSection(look, track, sectionIndex, salt = 0) {
     // A reroll changes what this section is made of. Where it sits in the story
     // is a property of the song, so it survives untouched.
     const state = section.story || NEUTRAL_STATE;
+    // The section is re-cast, so its ground is re-cast with it — a reroll that
+    // kept the old bed under new shots would be answering half the question.
+    const ground = castGround(
+        section.kind, roster, rng.fork('ground'), signature, director, new Set());
     section.variants = roster.map((module, v) => buildStack(
         module, overlayRoster, section.bias, rng.fork(`variant:${v}`),
         temperamentFor(look.personality && look.personality.temperament, state), state,
+        { ground, director, kind: section.kind },
     ));
     section.shots = planShots(
         section, track, section.bias, section.variants.length, rng.fork('shots'), state,
@@ -633,7 +888,7 @@ function applyOverrides(look, overrides) {
         overrides.sections.forEach((o, i) => {
             if (!look.sections[i]) return;
             if (o.locked !== undefined) look.sections[i].locked = o.locked;
-            if (o.params) Object.assign(look.sections[i].layers[0].params, o.params);
+            if (o.params) Object.assign(subjectOf(look.sections[i].layers).params, o.params);
         });
     }
     return look;
@@ -641,7 +896,7 @@ function applyOverrides(look, overrides) {
 
 /** Compact description, used by the HUD and by check output. */
 export function describeLook(look) {
-    const kinds = look.sections.map((s) => `${s.kind}:${s.layers[0].module.name}`);
+    const kinds = look.sections.map((s) => `${s.kind}:${subjectOf(s.layers).module.name}`);
     return `seed ${look.seed.toString(16)} · ${look.director} · ${look.paletteScheme} · ` +
            `${describePersonality(look.personality)} · ${describeGrain(look.grain)} · ` +
            `${describePaletteArc(look.paletteArc)} · ${describeFraming(look.framing)} · ` +
diff --git a/flow-state/src/look/directors.js b/flow-state/src/look/directors.js
index 1c623cd..a0303cb 100644
--- a/flow-state/src/look/directors.js
+++ b/flow-state/src/look/directors.js
@@ -35,7 +35,34 @@
  * when it is being quiet.
  */
 export const RESTFUL_FAMILIES = ['minimal', 'flow', 'organic'];
-const QUIET_KINDS = ['intro', 'breakdown', 'outro'];
+export const QUIET_KINDS = ['intro', 'breakdown', 'outro'];
+
+/**
+ * How full a director lets the frame get.
+ *
+ * Scales the coverage budget in LookGenerator — the painted-area ceiling a
+ * section's stack is built against, where 1.0 is one filled frame and 2.0 is
+ * the hard cap. A point of view about what a song looks like includes how much
+ * is allowed to be happening at once, and it is the difference between a
+ * brutalist drop (one big thing) and a corrupt one (everything, over
+ * everything). Absent, a director is read as 1.2.
+ */
+const DEFAULT_CROWD = 1.2;
+
+/**
+ * How willing a director is to let the frame BLAZE.
+ *
+ * A blaze is the shot composited additively over its ground instead of keyed
+ * onto it, so the two brightnesses sum and the highlights bloom out. It is a
+ * real effect and worth having — a drop that goes white for eight bars reads as
+ * the song peaking — and it was, until it was made a decision, simply what
+ * every section did: screen over a filled ground blew a median quarter of every
+ * frame to paper, all the time, in every video.
+ *
+ * So it is rationed. This is the appetite; the section still has to be loud and
+ * late in the story to earn one. Absent, a director is read as 0.15.
+ */
+const DEFAULT_BLAZE = 0.15;
 
 /**
  * Each director maps every section kind to three families, most-preferred
@@ -45,6 +72,11 @@ const QUIET_KINDS = ['intro', 'breakdown', 'outro'];
 export const DIRECTORS = [
     {
         name: 'ambient',
+        // Space, not glare. A blaze here is the exception that proves it.
+        blaze: 0.1,
+        // Space is the subject, so the frame stays owed to it: one
+        // picture, and a pass over it only when the song is at its loudest.
+        crowd: 1.1,
         // Patient camera to match: long moves, mostly along one line. See
         // look/Camera.js — a director's point of view now includes how it
         // shoots, not only what it points at.
@@ -63,6 +95,11 @@ export const DIRECTORS = [
     },
     {
         name: 'brutalist',
+        // Mass does not glow. Almost never.
+        blaze: 0.05,
+        // One large thing, seen whole. Layering hides mass, which is the
+        // only thing this director is interested in.
+        crowd: 1.05,
         // Holds, then commits to one large move. Architecture is looked AT.
         camera: 'deliberate',
         // Everything is architecture. Quiet means empty rather than soft, so it
@@ -79,6 +116,11 @@ export const DIRECTORS = [
     },
     {
         name: 'organicist',
+        // Light through leaves — bloom belongs to this world.
+        blaze: 0.2,
+        // Growth accumulates. Things overlap here because that is what
+        // living material does — nothing in this world is a single clean plate.
+        crowd: 1.45,
         // Never settles, because nothing here is ever finished settling.
         camera: 'roaming',
         // Nothing is ever built; things grow and dissolve. Deliberately never
@@ -95,6 +137,11 @@ export const DIRECTORS = [
     },
     {
         name: 'corrupt',
+        // Overload is the subject. Half its drops go white.
+        blaze: 0.5,
+        // Everything over everything. The damage is the subject and it is
+        // never confined to one plate.
+        crowd: 1.7,
         // Cuts with the camera already moving.
         camera: 'kinetic',
         // The signal is damaged and the damage is the subject — everywhere the
@@ -112,6 +159,11 @@ export const DIRECTORS = [
     },
     {
         name: 'geometer',
+        // Exact, and occasionally exact and incandescent.
+        blaze: 0.15,
+        // Pattern on pattern is a moiré, which is a pattern. Layers are
+        // welcome as long as they are exact.
+        crowd: 1.3,
         // Small, exact, always arrives — the pattern is the subject and the
         // camera does not editorialise about it.
         camera: 'precise',
@@ -156,6 +208,16 @@ export function pickDirector(summary, rng) {
     return rng.pickWeighted(DIRECTORS, weights);
 }
 
+/** How full this director lets the frame get. See DEFAULT_CROWD. */
+export function crowdOf(director) {
+    return (director && director.crowd) || DEFAULT_CROWD;
+}
+
+/** How willing this director is to let a section blaze. See DEFAULT_BLAZE. */
+export function blazeOf(director) {
+    return (director && director.blaze !== undefined) ? director.blaze : DEFAULT_BLAZE;
+}
+
 export function directorByName(name) {
     return DIRECTORS.find((d) => d.name === name) || DIRECTORS[0];
 }
diff --git a/flow-state/src/look/stack.js b/flow-state/src/look/stack.js
new file mode 100644
index 0000000..5fc482b
--- /dev/null
+++ b/flow-state/src/look/stack.js
@@ -0,0 +1,55 @@
+// What a layer stack is made of, and how to ask it questions.
+//
+// A stack used to be "the scene, then whatever was composited over it", so
+// `layers[0]` meant the section's scene everywhere in the program. It no longer
+// does: every stack now starts with a GROUND — a filled canvas the shot happens
+// on — and the scene the section is ABOUT sits above it.
+//
+// Everything that used to reach for `layers[0]` wants the subject, not the
+// ground: the param panel edits it, the HUD names it, and the variety report
+// counts it. Those all go through `subjectOf` now. Reading the ground as the
+// section's scene would be actively wrong for the measurements — grounds come
+// from a twenty-scene pool, so a report that counted them would show a library
+// three times smaller than the one actually on screen.
+
+import { coverageOf } from '../scenes/surface.js';
+
+/** Layers carrying this role are the bed, not the shot. */
+export const GROUND = 'ground';
+
+export function isGround(layer) {
+    return !!layer && layer.role === GROUND;
+}
+
+/** Index of the layer the section is about. */
+export function subjectIndexOf(stack) {
+    const at = stack.findIndex((l) => !isGround(l));
+    return at < 0 ? 0 : at;
+}
+
+/** The layer the section is about — the shot, as opposed to what it stands on. */
+export function subjectOf(stack) {
+    return stack[subjectIndexOf(stack)];
+}
+
+/** The ground under a stack, or null if the subject is its own ground. */
+export function groundOf(stack) {
+    return stack.find(isGround) || null;
+}
+
+/** Everything above the subject: the passes composited over the shot. */
+export function overlaysOf(stack) {
+    return stack.slice(subjectIndexOf(stack) + 1);
+}
+
+/**
+ * How much painted frame a stack adds up to, in units of one filled frame.
+ *
+ * Deliberately a SUM and not a union: two layers each painting 60% do not add
+ * up to 120% of a screen, but they do add up to two things happening at once,
+ * and that is the quantity the budget is about. 2.0 is the ceiling — see
+ * MAX_COVERAGE in LookGenerator.
+ */
+export function stackCoverage(stack) {
+    return stack.reduce((sum, l) => sum + coverageOf(l.module), 0);
+}
diff --git a/flow-state/src/main.js b/flow-state/src/main.js
index 0cf2e1f..7f52943 100644
--- a/flow-state/src/main.js
+++ b/flow-state/src/main.js
@@ -7,6 +7,8 @@ import { toHex } from './look/palette.js';
 import { applyGrainToPost, describeGrain, GRAIN_MASKS, GRAIN_MODES } from './look/grain.js';
 import { renderClickTrack, audioBufferToWavBlob } from './audio/metronome.js';
 import { Exporter, exportSegment, downloadBlob, PRESETS, isSupported } from './export/Exporter.js';
+import { subjectOf, groundOf, overlaysOf, stackCoverage } from './look/stack.js';
+import { coverageOf as sceneCoverage } from './scenes/surface.js';
 
 const QUALITY = {
     draft: 0.5,     // half resolution — for scrubbing heavy stacks
@@ -56,7 +58,7 @@ const paramPanel = new ParamPanel(document.createElement('div'), onParamChange);
 
 // ---------------------------------------------------------------- loading
 
-async function loadFile(file) {
+async function loadFile(file, { seed = null } = {}) {
     if (state.busy) return;
     state.busy = true;
     stopPlayback();
@@ -76,7 +78,7 @@ async function loadFile(file) {
         await state.show.load(file, (stage, fraction) => {
             dom.thStep.textContent = stage;
             dom.thFill.style.width = `${Math.round((fraction || 0) * 100)}%`;
-        });
+        }, { seed });
 
         dom.audio.src = URL.createObjectURL(file);
         dom.thLabel.textContent = 'loaded track';
@@ -113,6 +115,35 @@ if (dom.changeTrack) dom.changeTrack.addEventListener('click', () => dom.fileInp
 dom.fileInput.addEventListener('change', (e) => {
     if (e.target.files[0]) loadFile(e.target.files[0]);
 });
+/**
+ * `?song=centre` — open a bank song straight from a debug page.
+ *
+ * The filmstrip reduces a song to nine stills; the only way to argue with that
+ * reading is to watch the thing move, and until now that meant remembering
+ * which of seventeen near-identically-named wavs to drag in. `&seed=` carries
+ * the strip's seed across so the video you watch is the one it measured.
+ *
+ * Dev-only in practice: `test/songs/` is served by vite from the project root
+ * and is not part of a build. The name is matched against a bare word rather
+ * than the bank list so the app does not have to import the synth.
+ */
+async function loadBankSong(name, seed) {
+    if (!/^[a-z0-9_-]+$/i.test(name)) return;
+    const url = `/test/songs/${name}.wav`;
+    try {
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+        const blob = await res.blob();
+        await loadFile(new File([blob], `${name}.wav`, { type: 'audio/wav' }), { seed });
+    } catch (err) {
+        dom.thLabel.textContent = 'no such song';
+        dom.thName.hidden = false;
+        dom.thName.textContent = name;
+        dom.thStep.textContent = `${url}: ${err.message} — run npm run build:songs`;
+        console.error(err);
+    }
+}
+
 document.addEventListener('dragover', (e) => e.preventDefault());
 document.addEventListener('drop', (e) => {
     e.preventDefault();
@@ -265,7 +296,8 @@ function renderPanel() {
 
     if (state.tab === 'scene') {
         paramPanel.container = dom.panelBody;
-        paramPanel.build(section.layers[0].module, section.layers[0].params);
+        const subject = subjectOf(section.layers);
+        paramPanel.build(subject.module, subject.params);
 
         // The section's stage visuals, with the one currently on screen marked.
         // Params above edit the anchor (variant 0) — the image the section opens
@@ -278,20 +310,29 @@ function renderPanel() {
             list.innerHTML = `<div class="pp-sub">stage visuals · ${shots.length} shots</div>` +
                 section.variants.map((stack, v) =>
                     `<div class="pp-react-row${v === active ? ' current' : ''}">` +
-                    `<span>${v === 0 ? '&#9679;' : '&#9675;'} ${stack[0].module.name}</span>` +
+                    `<span>${v === 0 ? '&#9679;' : '&#9675;'} ${subjectOf(stack).module.name}</span>` +
                     `<span class="pp-feature">${shots.filter((s) => s.variant === v).length}&times;</span>` +
                     `</div>`).join('');
             dom.panelBody.appendChild(list);
         }
 
-        if (section.layers.length > 1) {
+        // The rest of the stack, named by the job each layer is doing rather
+        // than by its index: what is under the shot and what is over it are
+        // different questions, and the panel used to call both "layered over".
+        const ground = groundOf(section.layers);
+        const overlays = overlaysOf(section.layers);
+        if (ground || overlays.length) {
+            const row = (l, label) =>
+                `<div class="pp-react-row"><span>${l.module.name}</span>` +
+                `<span class="pp-feature">${label}</span>` +
+                `<span class="pp-amount">${(sceneCoverage(l.module) * 100).toFixed(0)}%</span></div>`;
             const note = document.createElement('div');
             note.className = 'pp-reactive';
-            note.innerHTML = `<div class="pp-sub">layered over (${section.layers.length - 1})</div>` +
-                section.layers.slice(1).map((l) =>
-                    `<div class="pp-react-row"><span>${l.module.name}</span>` +
-                    `<span class="pp-feature">${l.blend}</span>` +
-                    `<span class="pp-amount">${l.opacity.toFixed(2)}</span></div>`).join('');
+            note.innerHTML =
+                `<div class="pp-sub">stack · ${(stackCoverage(section.layers) * 100).toFixed(0)}% painted</div>` +
+                (ground ? row(ground, 'ground') : '') +
+                row(subject, 'shot') +
+                overlays.map((l) => row(l, l.blend)).join('');
             dom.panelBody.appendChild(note);
         }
         return;
@@ -326,7 +367,7 @@ function renderPanel() {
                 <div class="kv ${i === index ? 'current' : ''}">
                     <span>${s.kind}${s.locked ? ' &#128274;' : ''}
                         ${s.shots ? `<i class="dim">${s.shots.length} shots</i>` : ''}</span>
-                    <b>${(s.variants || [s.layers]).map((v) => v[0].module.name).join(' / ')}</b>
+                    <b>${(s.variants || [s.layers]).map((v) => subjectOf(v).module.name).join(' / ')}</b>
                 </div>`).join('')}
             <button id="btn-metronome" class="wide">download click track</button>
             <div class="hint">Mixes clicks onto the detected beat grid. If they don't sit on
@@ -664,3 +705,9 @@ resize();
 // "never going to start", and the failure it exists to catch is exactly the one
 // that produces no error at all in the page.
 window.__FLOW_STATE_READY__ = true;
+
+const query = new URLSearchParams(location.search);
+if (query.get('song')) {
+    const seed = query.get('seed');
+    loadBankSong(query.get('song'), seed === null ? null : (Number(seed) >>> 0));
+}
diff --git a/flow-state/src/params/schema.js b/flow-state/src/params/schema.js
index 22713bf..08fa6e1 100644
--- a/flow-state/src/params/schema.js
+++ b/flow-state/src/params/schema.js
@@ -68,34 +68,26 @@ export const REACTIVE_RESPONSES = ['linear', 'spike', 'smooth', 'inverse'];
 export const ARTIFACT_NAMES = ['cast', 'ink', 'staging', 'form'];
 
 /**
- * What a scene is for, compositionally.
+ * Whether a scene's image depends on the FRAME BEFORE IT.
  *
- *   canvas      fills the frame. Belongs underneath, and two of them stacked is
- *               two pictures fighting rather than one picture with depth.
- *   composable  mostly empty by design. Reads as elements ON something, and
- *               shown alone it is a few bright things on black — which scores
- *               well for variety and is thin to watch.
+ * Read off the shader rather than declared, because the declaration would be a
+ * second copy of something the source already says exactly: a scene reads
+ * history if and only if it calls `prev()`.
  *
- * The distinction was implicit in `role: 'accent'` and that was not enough: it
- * marked the depth passes and said nothing about the sixty scenes that are all
- * treated as interchangeable backgrounds despite half of them being sparse.
+ * What it decides is where a scene may sit in a stack. `prev()` returns the
+ * whole composited previous frame — everything, including whatever was layered
+ * ON TOP of this scene — so a datamosh or a time smear underneath a shot is not
+ * grounding it, it is recycling it. Two things follow, and both were measured
+ * the moment such a scene became a bed: the render stops being reproducible from
+ * a seek (state carries across frames that a seek has not rendered), and small
+ * numeric differences compound frame over frame instead of staying put — 91/255
+ * between two WebGL contexts, against a ceiling of 4.
  *
- * It also has to be DECLARED to mean anything. For a while the field existed,
- * the generator gated layering on it, and no scene carried it — so nothing could
- * ever be layered and the one scene with `role: 'accent'` was the only thing
- * that ever appeared on top of anything. The labels below come from the measured
- * coverage the phase 12 gate prints; anything under 30% is composable.
- *
- * Verified rather than trusted — see the coverage gate in checks/phase12. A
- * scene that claims to be composable and paints the whole frame will cover
- * whatever it is layered over.
+ * These scenes are exactly right as a shot or as a pass over one. They are only
+ * wrong as the thing underneath. See canGround in scenes/surface.js.
  */
-export const SURFACES = ['canvas', 'composable'];
-
-/** What a scene is, defaulting to the behaviour it had before this existed. */
-export function surfaceOf(module) {
-    if (module.surface) return module.surface;
-    return 'canvas';
+export function readsHistory(module) {
+    return typeof module.shader === 'string' && /\bprev\s*\(/.test(module.shader);
 }
 
 /**
@@ -291,8 +283,11 @@ export function validateModule(module) {
             if (!TRAIT_NAMES.includes(t)) errors.push(`${id}: unknown trait '${t}'`);
         }
     }
-    if (module.surface !== undefined && !SURFACES.includes(module.surface)) {
-        errors.push(`${id}: unknown surface '${module.surface}' — one of ${SURFACES.join('/')}`);
+    // `surface` was a declaration and is now measured — see scenes/surface.js.
+    // Rejected rather than ignored, so a scene file carrying a stale one is a
+    // loud error instead of a line that quietly means nothing.
+    if (module.surface !== undefined) {
+        errors.push(`${id}: 'surface' is derived from scenes/metadata.json — remove the declaration`);
     }
     if (module.consumes !== undefined) {
         if (!Array.isArray(module.consumes)) {
diff --git a/flow-state/src/scenes/layers3d/particles.js b/flow-state/src/scenes/layers3d/particles.js
index 45a2892..2f8f9db 100644
--- a/flow-state/src/scenes/layers3d/particles.js
+++ b/flow-state/src/scenes/layers3d/particles.js
@@ -19,7 +19,6 @@ export const particleField = {
     // top — every layered stack in every song was these particles — while the
     // general overlay path sat dead because nothing else was labelled. It is one
     // composable scene among many now.
-    surface: 'composable',
     // Points in empty space with no ground of their own — the one scene in the
     // library that genuinely cannot carry a section alone. See schema.canBackground.
     background: false,
diff --git a/flow-state/src/scenes/metadata.json b/flow-state/src/scenes/metadata.json
new file mode 100644
index 0000000..48be678
--- /dev/null
+++ b/flow-state/src/scenes/metadata.json
@@ -0,0 +1,8190 @@
+{
+  "fingerprint": "8385c9e8",
+  "schema": 4,
+  "measured": "2026-08-20",
+  "contexts": [
+    "drone",
+    "elegy",
+    "dusk",
+    "chrome",
+    "grit",
+    "flare"
+  ],
+  "scenes": {
+    "Deep Nebula": {
+      "coverage": 0.657,
+      "bedCoverage": 0.207,
+      "bedCoverageMean": 0.654,
+      "variety": 0.158,
+      "blocks": {
+        "scale": 0.02,
+        "orient": 0.113,
+        "layout": 0.228,
+        "region": 0.336,
+        "texture": 0.111,
+        "motion": 0.142,
+        "colour": 0.472
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1274,
+          0.1271,
+          0.1588,
+          0.2331,
+          0.3536
+        ],
+        "orient": [
+          0.1652,
+          0.0914,
+          0.0488,
+          0.0558,
+          0.033,
+          0.04
+        ],
+        "layout": [
+          0.0469,
+          0.0542,
+          0.0546,
+          0.0311,
+          0.0888,
+          0.1099,
+          0.0725,
+          0.0485,
+          0.0519,
+          0.105,
+          0.0689,
+          0.0508,
+          0.067,
+          0.0622,
+          0.0525,
+          0.0352
+        ],
+        "region": [
+          -0.1709,
+          -0.0443,
+          -0.0207,
+          0.0812,
+          -0.097,
+          -0.3185,
+          -0.349,
+          0.1104,
+          0.1109,
+          0.441,
+          0.0627,
+          0.375,
+          0.3888,
+          0.0602,
+          0.0072,
+          -0.0582,
+          0.2272,
+          0.3793,
+          0.1289,
+          -0.164,
+          -0.0763,
+          -0.1207,
+          -0.1487,
+          -0.4672,
+          -0.3411,
+          -0.0066,
+          0.0102
+        ],
+        "texture": [
+          0.8975,
+          0.1978,
+          0.1696,
+          0.0451,
+          0.2028,
+          0.136,
+          0.1144
+        ],
+        "colour": [
+          0.0053,
+          0.1147,
+          0.2156,
+          0.2661,
+          0.3652,
+          0.033,
+          0.594,
+          0.2593
+        ],
+        "motion": [
+          0.3077,
+          0.2462,
+          0.2002,
+          0.139,
+          0.1069,
+          0.055,
+          0.0638,
+          0.0509,
+          0.0353,
+          0.0926,
+          0.1115,
+          0.0753,
+          0.0422,
+          0.0584,
+          0.1007,
+          0.0622,
+          0.0483,
+          0.0696,
+          0.0609,
+          0.0451,
+          0.0283
+        ]
+      }
+    },
+    "Classic Wave": {
+      "coverage": 0.423,
+      "bedCoverage": 0.287,
+      "bedCoverageMean": 0.382,
+      "variety": 0.092,
+      "blocks": {
+        "scale": 0.036,
+        "orient": 0.052,
+        "layout": 0.047,
+        "region": 0.258,
+        "texture": 0.118,
+        "motion": 0.042,
+        "colour": 0.388
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2628,
+          0.2774,
+          0.2044,
+          0.1345,
+          0.1208
+        ],
+        "orient": [
+          0.2425,
+          0.1252,
+          0.0479,
+          0.0407,
+          0.0257,
+          0.015
+        ],
+        "layout": [
+          0.0523,
+          0.0615,
+          0.0595,
+          0.0416,
+          0.0627,
+          0.0813,
+          0.0933,
+          0.0484,
+          0.0616,
+          0.0842,
+          0.0967,
+          0.0443,
+          0.0542,
+          0.057,
+          0.0618,
+          0.0397
+        ],
+        "region": [
+          -0.104,
+          0.0346,
+          -0.0627,
+          0.116,
+          -0.0981,
+          -0.104,
+          -0.228,
+          0.0806,
+          -0.0187,
+          0.0391,
+          0.0436,
+          0.1235,
+          0.5162,
+          0.0072,
+          0.0946,
+          -0.0546,
+          0.0408,
+          -0.0101,
+          -0.114,
+          -0.1147,
+          0.0188,
+          0.0915,
+          -0.1304,
+          -0.0605,
+          -0.2624,
+          0.1364,
+          0.0191
+        ],
+        "texture": [
+          0.8024,
+          0.2984,
+          0.2946,
+          0.0166,
+          0.0524,
+          0.1711,
+          -0.0489
+        ],
+        "colour": [
+          0.109,
+          0.1662,
+          0.1754,
+          0.1257,
+          0.1803,
+          0.2434,
+          0.4768,
+          0.224
+        ],
+        "motion": [
+          0.3846,
+          0.2534,
+          0.1572,
+          0.0994,
+          0.1054,
+          0.055,
+          0.0629,
+          0.067,
+          0.0457,
+          0.057,
+          0.0762,
+          0.0892,
+          0.0499,
+          0.0628,
+          0.0758,
+          0.0906,
+          0.0442,
+          0.0591,
+          0.0635,
+          0.0613,
+          0.0397
+        ]
+      }
+    },
+    "Floating Geometry": {
+      "coverage": 0.221,
+      "bedCoverage": 0.036,
+      "bedCoverageMean": 0.221,
+      "variety": 0.256,
+      "blocks": {
+        "scale": 0.023,
+        "orient": 0.066,
+        "layout": 0.543,
+        "region": 0.503,
+        "texture": 0.124,
+        "motion": 0.278,
+        "colour": 0.5
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1426,
+          0.1564,
+          0.1954,
+          0.2464,
+          0.2592
+        ],
+        "orient": [
+          0.204,
+          0.1254,
+          0.1257,
+          0.1428,
+          0.0922,
+          0.1336
+        ],
+        "layout": [
+          0.0188,
+          0.0868,
+          0.0589,
+          0.0125,
+          0.1305,
+          0.1302,
+          0.0769,
+          0.0161,
+          0.031,
+          0.1506,
+          0.1113,
+          0.017,
+          0.0361,
+          0.0838,
+          0.0247,
+          0.0147
+        ],
+        "region": [
+          -0.244,
+          0.061,
+          0.1679,
+          0.1339,
+          -0.0788,
+          0.1828,
+          -0.5537,
+          -0.0718,
+          -0.2613,
+          0.7901,
+          0.0837,
+          0.2509,
+          1.1925,
+          0.0708,
+          0.258,
+          -0.3366,
+          0.1431,
+          0.0161,
+          -0.3212,
+          -0.0814,
+          0.0433,
+          0.0276,
+          -0.0862,
+          -0.4278,
+          -0.6885,
+          -0.0403,
+          -0.2301
+        ],
+        "texture": [
+          0.4317,
+          0.0679,
+          0.1097,
+          0.0368,
+          0.0217,
+          0.1554,
+          -0.0462
+        ],
+        "colour": [
+          0.1168,
+          0.0601,
+          0.3523,
+          0.2171,
+          0.1854,
+          0.0683,
+          0.6099,
+          0.1665
+        ],
+        "motion": [
+          0.2885,
+          0.2018,
+          0.179,
+          0.1652,
+          0.1655,
+          0.0131,
+          0.0758,
+          0.0576,
+          0.0082,
+          0.0841,
+          0.1761,
+          0.076,
+          0.0222,
+          0.0371,
+          0.1302,
+          0.1111,
+          0.0253,
+          0.0472,
+          0.0871,
+          0.0335,
+          0.0153
+        ]
+      }
+    },
+    "Synthwave Run": {
+      "coverage": 0.048,
+      "bedCoverage": 0.009,
+      "bedCoverageMean": 0.04,
+      "variety": 0.247,
+      "blocks": {
+        "scale": 0.013,
+        "orient": 0.074,
+        "layout": 0.54,
+        "region": 0.513,
+        "texture": 0.104,
+        "motion": 0.241,
+        "colour": 0.474
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2624,
+          0.2012,
+          0.1738,
+          0.1863,
+          0.1763
+        ],
+        "orient": [
+          0.1387,
+          0.1621,
+          0.0915,
+          0.0817,
+          0.0658,
+          0.0639
+        ],
+        "layout": [
+          0.0315,
+          0.0845,
+          0.0496,
+          0.0154,
+          0.1093,
+          0.1383,
+          0.1089,
+          0.0146,
+          0.1105,
+          0.0586,
+          0.0947,
+          0.0233,
+          0.0834,
+          0.0217,
+          0.0384,
+          0.0171
+        ],
+        "region": [
+          -0.35,
+          -0.007,
+          0.0369,
+          0.5347,
+          0.0544,
+          0.0403,
+          -0.7517,
+          0.115,
+          -0.3843,
+          0.92,
+          0.031,
+          0.7888,
+          0.9407,
+          -0.0894,
+          -0.049,
+          -0.457,
+          -0.0778,
+          -0.3146,
+          0.2641,
+          -0.0559,
+          0.4743,
+          -0.5136,
+          0.0753,
+          -0.3956,
+          -0.5872,
+          -0.0456,
+          -0.1967
+        ],
+        "texture": [
+          0.4355,
+          0.094,
+          0.1115,
+          0.0353,
+          0.0022,
+          0.1188,
+          -0.0027
+        ],
+        "colour": [
+          0.1936,
+          0.0696,
+          0.35,
+          0.1679,
+          0.1965,
+          0.0225,
+          0.4835,
+          0.0364
+        ],
+        "motion": [
+          0.389,
+          0.2189,
+          0.1527,
+          0.1103,
+          0.1291,
+          0.0506,
+          0.0752,
+          0.0502,
+          0.0304,
+          0.1061,
+          0.1159,
+          0.0588,
+          0.0341,
+          0.1201,
+          0.053,
+          0.0645,
+          0.0368,
+          0.114,
+          0.0311,
+          0.0414,
+          0.0179
+        ]
+      }
+    },
+    "Psychedelic Drift": {
+      "coverage": 0.135,
+      "bedCoverage": 0.042,
+      "bedCoverageMean": 0.145,
+      "variety": 0.255,
+      "blocks": {
+        "scale": 0.039,
+        "orient": 0.085,
+        "layout": 0.486,
+        "region": 0.513,
+        "texture": 0.152,
+        "motion": 0.251,
+        "colour": 0.488
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1471,
+          0.145,
+          0.2034,
+          0.2244,
+          0.2802
+        ],
+        "orient": [
+          0.1998,
+          0.166,
+          0.0774,
+          0.0847,
+          0.0651,
+          0.0941
+        ],
+        "layout": [
+          0.046,
+          0.0823,
+          0.0509,
+          0.0053,
+          0.0627,
+          0.1241,
+          0.0916,
+          0.0136,
+          0.0597,
+          0.1687,
+          0.1318,
+          0.0113,
+          0.044,
+          0.0421,
+          0.0445,
+          0.0213
+        ],
+        "region": [
+          0.1346,
+          -0.0181,
+          -0.1967,
+          0.3924,
+          0.0029,
+          0.4453,
+          -0.7764,
+          -0.1672,
+          -0.4197,
+          0.2503,
+          0.1406,
+          0.5073,
+          1.3328,
+          0.1148,
+          0.3908,
+          -0.5501,
+          0.0305,
+          -0.2694,
+          -0.0472,
+          -0.014,
+          0.1853,
+          -0.1422,
+          -0.1493,
+          -0.493,
+          -0.5942,
+          0.0598,
+          -0.1499
+        ],
+        "texture": [
+          0.5586,
+          0.2118,
+          0.0938,
+          0.0416,
+          0.1116,
+          0.1674,
+          -0.0163
+        ],
+        "colour": [
+          0.1243,
+          0.0836,
+          0.2065,
+          0.149,
+          0.2695,
+          0.1671,
+          0.5101,
+          0.0953
+        ],
+        "motion": [
+          0.2679,
+          0.1931,
+          0.2008,
+          0.173,
+          0.1653,
+          0.0425,
+          0.0735,
+          0.0577,
+          0.0051,
+          0.0651,
+          0.1242,
+          0.0836,
+          0.0176,
+          0.083,
+          0.1678,
+          0.1186,
+          0.012,
+          0.0411,
+          0.0286,
+          0.0524,
+          0.0271
+        ]
+      }
+    },
+    "Horizon Lines": {
+      "coverage": 0.315,
+      "bedCoverage": 0.089,
+      "bedCoverageMean": 0.325,
+      "variety": 0.227,
+      "blocks": {
+        "scale": 0.08,
+        "orient": 0.129,
+        "layout": 0.367,
+        "region": 0.444,
+        "texture": 0.125,
+        "motion": 0.219,
+        "colour": 0.393
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2741,
+          0.1972,
+          0.1623,
+          0.1709,
+          0.1955
+        ],
+        "orient": [
+          0.1504,
+          0.0949,
+          0.0743,
+          0.0496,
+          0.0591,
+          0.0531
+        ],
+        "layout": [
+          0.0633,
+          0.0677,
+          0.0754,
+          0.0278,
+          0.0596,
+          0.0878,
+          0.0842,
+          0.0272,
+          0.0602,
+          0.1106,
+          0.0722,
+          0.0221,
+          0.0635,
+          0.0869,
+          0.0641,
+          0.0273
+        ],
+        "region": [
+          0.0054,
+          -0.1994,
+          -0.1661,
+          0.1762,
+          -0.0745,
+          -0.136,
+          -0.3276,
+          0.0648,
+          -0.0482,
+          0.0674,
+          -0.077,
+          0.0437,
+          0.5782,
+          -0.0207,
+          0.1071,
+          -0.4338,
+          -0.0216,
+          -0.2695,
+          -0.0837,
+          0.1292,
+          0.0507,
+          0.4887,
+          0.1231,
+          0.3392,
+          -0.4709,
+          0.0761,
+          0.079
+        ],
+        "texture": [
+          0.7106,
+          0.2304,
+          0.198,
+          0.0417,
+          -0.0262,
+          0.0569,
+          0.0073
+        ],
+        "colour": [
+          0.0528,
+          0.0984,
+          0.2942,
+          0.1973,
+          0.2344,
+          0.1229,
+          0.5028,
+          0.2105
+        ],
+        "motion": [
+          0.3474,
+          0.2083,
+          0.1467,
+          0.1448,
+          0.1528,
+          0.0693,
+          0.0717,
+          0.0655,
+          0.0179,
+          0.0597,
+          0.0909,
+          0.0748,
+          0.0321,
+          0.0606,
+          0.1105,
+          0.0707,
+          0.0326,
+          0.0418,
+          0.0987,
+          0.0616,
+          0.0416
+        ]
+      }
+    },
+    "Spectrum Sculpture": {
+      "coverage": 0.053,
+      "bedCoverage": 0,
+      "bedCoverageMean": 0.041,
+      "variety": 0.286,
+      "blocks": {
+        "scale": 0.053,
+        "orient": 0.103,
+        "layout": 0.646,
+        "region": 0.471,
+        "texture": 0.089,
+        "motion": 0.352,
+        "colour": 0.337
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3741,
+          0.1968,
+          0.1621,
+          0.1323,
+          0.1348
+        ],
+        "orient": [
+          0.1784,
+          0.2133,
+          0.0921,
+          0.1858,
+          0.0939,
+          0.1429
+        ],
+        "layout": [
+          0.0583,
+          0.0884,
+          0.0548,
+          0.003,
+          0.0547,
+          0.298,
+          0.0827,
+          0.0248,
+          0.0265,
+          0.0946,
+          0.0521,
+          0.0344,
+          0.0249,
+          0.0369,
+          0.0494,
+          0.0165
+        ],
+        "region": [
+          0.1656,
+          0.0433,
+          0.0433,
+          1.8179,
+          -0.0744,
+          1.6693,
+          -0.7905,
+          -0.0627,
+          -0.8224,
+          0.0235,
+          0.0296,
+          -0.1149,
+          0.5252,
+          0.2054,
+          0.5713,
+          -0.3935,
+          0.0085,
+          -0.3403,
+          -0.6612,
+          -0.0696,
+          -0.5743,
+          -0.1989,
+          -0.0006,
+          0.0227,
+          -0.4881,
+          -0.0795,
+          -0.4547
+        ],
+        "texture": [
+          0.1459,
+          0.0153,
+          0.0852,
+          0.0362,
+          0.0403,
+          0.1759,
+          -0.0047
+        ],
+        "colour": [
+          0.0221,
+          0.1075,
+          0.4069,
+          0.1059,
+          0.0888,
+          0.2688,
+          0.0644,
+          0.0352
+        ],
+        "motion": [
+          0.367,
+          0.1986,
+          0.1569,
+          0.1433,
+          0.1343,
+          0.0904,
+          0.1144,
+          0.0641,
+          0.0027,
+          0.0417,
+          0.2933,
+          0.0732,
+          0.0213,
+          0.0166,
+          0.0767,
+          0.0462,
+          0.034,
+          0.0246,
+          0.0414,
+          0.0392,
+          0.0202
+        ]
+      }
+    },
+    "Slow Orb": {
+      "coverage": 0.184,
+      "bedCoverage": 0.046,
+      "bedCoverageMean": 0.155,
+      "variety": 0.233,
+      "blocks": {
+        "scale": 0.019,
+        "orient": 0.099,
+        "layout": 0.485,
+        "region": 0.485,
+        "texture": 0.115,
+        "motion": 0.198,
+        "colour": 0.506
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1067,
+          0.1278,
+          0.1853,
+          0.2626,
+          0.3175
+        ],
+        "orient": [
+          0.1668,
+          0.1568,
+          0.0845,
+          0.1011,
+          0.0605,
+          0.0714
+        ],
+        "layout": [
+          0.0693,
+          0.1351,
+          0.0166,
+          0.0067,
+          0.0399,
+          0.2008,
+          0.1039,
+          0.0146,
+          0.034,
+          0.1122,
+          0.0759,
+          0.0183,
+          0.0476,
+          0.0693,
+          0.0459,
+          0.0098
+        ],
+        "region": [
+          0.3577,
+          -0.1273,
+          -0.2885,
+          0.4814,
+          -0.1222,
+          -0.3498,
+          -0.8777,
+          0.0186,
+          0.0204,
+          0.0104,
+          -0.0053,
+          0.4173,
+          1.0999,
+          0.2356,
+          -0.2037,
+          -0.3653,
+          0.0842,
+          0.285,
+          -0.3524,
+          -0.1094,
+          0.1408,
+          0.1878,
+          -0.0585,
+          -0.1407,
+          -0.5418,
+          0.0843,
+          0.1191
+        ],
+        "texture": [
+          0.73,
+          0.1528,
+          0.1008,
+          0.0417,
+          0.0778,
+          0.1704,
+          0.0034
+        ],
+        "colour": [
+          0.0552,
+          0.0792,
+          0.358,
+          0.1125,
+          0.3663,
+          0.0287,
+          0.5656,
+          0.1376
+        ],
+        "motion": [
+          0.3264,
+          0.2028,
+          0.1715,
+          0.1534,
+          0.1459,
+          0.062,
+          0.1073,
+          0.0313,
+          0.024,
+          0.0555,
+          0.1759,
+          0.0992,
+          0.0313,
+          0.0338,
+          0.1091,
+          0.0468,
+          0.0364,
+          0.0338,
+          0.0795,
+          0.0457,
+          0.0283
+        ]
+      }
+    },
+    "Curl Flow": {
+      "coverage": 0.155,
+      "bedCoverage": 0,
+      "bedCoverageMean": 0.194,
+      "variety": 0.234,
+      "blocks": {
+        "scale": 0.047,
+        "orient": 0.113,
+        "layout": 0.428,
+        "region": 0.427,
+        "texture": 0.141,
+        "motion": 0.246,
+        "colour": 0.469
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.2928,
+          0.183,
+          0.1478,
+          0.1786,
+          0.1977
+        ],
+        "orient": [
+          0.0823,
+          0.0906,
+          0.0448,
+          0.057,
+          0.0567,
+          0.0419
+        ],
+        "layout": [
+          0.0576,
+          0.0289,
+          0.031,
+          0.0159,
+          0.073,
+          0.0659,
+          0.0693,
+          0.0356,
+          0.0681,
+          0.0759,
+          0.0948,
+          0.0781,
+          0.0623,
+          0.0614,
+          0.1244,
+          0.0577
+        ],
+        "region": [
+          -0.0124,
+          -0.0032,
+          -0.1257,
+          -0.4684,
+          -0.0135,
+          -0.3921,
+          -0.6759,
+          -0.0878,
+          -0.3634,
+          0.0452,
+          0.0722,
+          0.1181,
+          0.2991,
+          0.0235,
+          -0.116,
+          0.0832,
+          0.0421,
+          -0.058,
+          -0.0799,
+          0.0571,
+          0.0578,
+          0.5676,
+          -0.0557,
+          0.0491,
+          0.2414,
+          -0.0347,
+          0.8303
+        ],
+        "texture": [
+          0.7583,
+          0.0912,
+          0.1385,
+          0.0404,
+          0.0488,
+          0.0928,
+          -0.0337
+        ],
+        "colour": [
+          0.0228,
+          0.0893,
+          0.4252,
+          0.0771,
+          0.3722,
+          0.0134,
+          0.5021,
+          0.0992
+        ],
+        "motion": [
+          0.3731,
+          0.2067,
+          0.132,
+          0.1286,
+          0.1596,
+          0.0756,
+          0.0237,
+          0.0331,
+          0.0143,
+          0.0776,
+          0.066,
+          0.0699,
+          0.0388,
+          0.0644,
+          0.065,
+          0.1041,
+          0.0745,
+          0.063,
+          0.0601,
+          0.1119,
+          0.0582
+        ]
+      }
+    },
+    "Plasma Bloom": {
+      "coverage": 0.667,
+      "bedCoverage": 0.362,
+      "bedCoverageMean": 0.651,
+      "variety": 0.097,
+      "blocks": {
+        "scale": 0.005,
+        "orient": 0.157,
+        "layout": 0.133,
+        "region": 0.182,
+        "texture": 0.044,
+        "motion": 0.061,
+        "colour": 0.366
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3783,
+          0.2113,
+          0.1442,
+          0.1147,
+          0.1515
+        ],
+        "orient": [
+          0.0413,
+          0.0282,
+          0.0217,
+          0.0298,
+          0.029,
+          0.0247
+        ],
+        "layout": [
+          0.0605,
+          0.0714,
+          0.0642,
+          0.0362,
+          0.0802,
+          0.096,
+          0.0749,
+          0.0397,
+          0.0726,
+          0.0872,
+          0.07,
+          0.0423,
+          0.0526,
+          0.061,
+          0.0561,
+          0.035
+        ],
+        "region": [
+          0.0219,
+          -0.0255,
+          -0.0155,
+          0.1673,
+          0.0049,
+          -0.0034,
+          -0.3136,
+          0.0476,
+          -0.0214,
+          0.2695,
+          -0.0665,
+          0.0024,
+          0.4223,
+          0.0331,
+          0.0132,
+          -0.2361,
+          0.0079,
+          0.0325,
+          -0.023,
+          -0.009,
+          0.0056,
+          0.0418,
+          0.0066,
+          -0.0117,
+          -0.35,
+          0.0009,
+          -0.0018
+        ],
+        "texture": [
+          1.0205,
+          0.063,
+          0.2505,
+          0.0313,
+          0.0036,
+          0.0496,
+          -0.0143
+        ],
+        "colour": [
+          0.0536,
+          0.0903,
+          0.3314,
+          0.1213,
+          0.2152,
+          0.1881,
+          0.6536,
+          0.3233
+        ],
+        "motion": [
+          0.4249,
+          0.2201,
+          0.129,
+          0.0988,
+          0.1272,
+          0.0577,
+          0.0674,
+          0.0612,
+          0.0363,
+          0.0758,
+          0.0962,
+          0.0768,
+          0.0401,
+          0.0751,
+          0.0936,
+          0.0755,
+          0.043,
+          0.0502,
+          0.0623,
+          0.0551,
+          0.0337
+        ]
+      }
+    },
+    "Metaballs": {
+      "coverage": 0.686,
+      "bedCoverage": 0.135,
+      "bedCoverageMean": 0.614,
+      "variety": 0.202,
+      "blocks": {
+        "scale": 0.016,
+        "orient": 0.047,
+        "layout": 0.313,
+        "region": 0.488,
+        "texture": 0.11,
+        "motion": 0.236,
+        "colour": 0.519
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.0975,
+          0.1269,
+          0.1877,
+          0.2526,
+          0.3353
+        ],
+        "orient": [
+          0.3708,
+          0.263,
+          0.1526,
+          0.123,
+          0.0737,
+          0.0552
+        ],
+        "layout": [
+          0.0277,
+          0.0582,
+          0.0794,
+          0.0569,
+          0.0273,
+          0.0799,
+          0.1076,
+          0.0671,
+          0.0329,
+          0.0906,
+          0.0862,
+          0.0555,
+          0.0483,
+          0.0877,
+          0.0643,
+          0.0305
+        ],
+        "region": [
+          -0.5616,
+          -0.2658,
+          -0.5036,
+          0.2221,
+          0.027,
+          0.154,
+          0.1154,
+          0.0947,
+          -0.1164,
+          0.0482,
+          0.0523,
+          0.0848,
+          0.1243,
+          -0.0279,
+          1.0262,
+          0.3015,
+          0.181,
+          0.0553,
+          -0.1749,
+          -0.0866,
+          -0.2519,
+          0.3758,
+          0.0824,
+          0.0654,
+          -0.4507,
+          -0.057,
+          -0.5138
+        ],
+        "texture": [
+          0.662,
+          0.11,
+          0.1447,
+          0.0446,
+          0.0826,
+          0.128,
+          0.0572
+        ],
+        "colour": [
+          0.2063,
+          0.1698,
+          0.2294,
+          0.1912,
+          0.1066,
+          0.0967,
+          0.2524,
+          0.3512
+        ],
+        "motion": [
+          0.2036,
+          0.1727,
+          0.1893,
+          0.2136,
+          0.2208,
+          0.0201,
+          0.0597,
+          0.0935,
+          0.0521,
+          0.0172,
+          0.0517,
+          0.1441,
+          0.0604,
+          0.0193,
+          0.0767,
+          0.0944,
+          0.0548,
+          0.0218,
+          0.1194,
+          0.0755,
+          0.0391
+        ]
+      }
+    },
+    "Kaleido Tunnel": {
+      "coverage": 0.889,
+      "bedCoverage": 0.528,
+      "bedCoverageMean": 0.866,
+      "variety": 0.077,
+      "blocks": {
+        "scale": 0.036,
+        "orient": 0.079,
+        "layout": 0.034,
+        "region": 0.217,
+        "texture": 0.075,
+        "motion": 0.022,
+        "colour": 0.391
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.234,
+          0.201,
+          0.1956,
+          0.189,
+          0.1804
+        ],
+        "orient": [
+          0.205,
+          0.0836,
+          0.0661,
+          0.0432,
+          0.0221,
+          0.0147
+        ],
+        "layout": [
+          0.0683,
+          0.0674,
+          0.0551,
+          0.0614,
+          0.0648,
+          0.072,
+          0.0578,
+          0.0709,
+          0.0568,
+          0.0667,
+          0.0629,
+          0.0586,
+          0.0542,
+          0.0743,
+          0.0598,
+          0.0491
+        ],
+        "region": [
+          0.0878,
+          -0.0159,
+          0.0131,
+          -0.0059,
+          -0.1586,
+          -0.1028,
+          0.0291,
+          0.1099,
+          0.0066,
+          -0.0357,
+          -0.0464,
+          0.0261,
+          0.0014,
+          -0.1172,
+          0.0434,
+          0.0357,
+          0.1015,
+          0.0381,
+          -0.0738,
+          -0.0014,
+          -0.0168,
+          0.1306,
+          -0.0032,
+          -0.0549,
+          -0.1692,
+          0.1313,
+          0.0473
+        ],
+        "texture": [
+          0.8984,
+          0.2199,
+          0.2748,
+          0.025,
+          0.0029,
+          0.1136,
+          0.0127
+        ],
+        "colour": [
+          0.115,
+          0.2246,
+          0.2445,
+          0.1067,
+          0.1238,
+          0.1854,
+          0.565,
+          0.5232
+        ],
+        "motion": [
+          0.2805,
+          0.2187,
+          0.196,
+          0.1611,
+          0.1436,
+          0.0717,
+          0.069,
+          0.0628,
+          0.0601,
+          0.0566,
+          0.0701,
+          0.06,
+          0.0681,
+          0.058,
+          0.0707,
+          0.0629,
+          0.0554,
+          0.0644,
+          0.0688,
+          0.0549,
+          0.0466
+        ]
+      }
+    },
+    "Moiré Grid": {
+      "coverage": 0.377,
+      "bedCoverage": 0.221,
+      "bedCoverageMean": 0.441,
+      "variety": 0.063,
+      "blocks": {
+        "scale": 0.009,
+        "orient": 0.184,
+        "layout": 0.023,
+        "region": 0.114,
+        "texture": 0.043,
+        "motion": 0.004,
+        "colour": 0.591
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.4187,
+          0.2272,
+          0.1483,
+          0.1028,
+          0.1029
+        ],
+        "orient": [
+          0.0545,
+          0.0285,
+          0.0124,
+          0.0181,
+          0.0195,
+          0.0251
+        ],
+        "layout": [
+          0.0524,
+          0.0677,
+          0.0686,
+          0.0419,
+          0.0632,
+          0.0722,
+          0.0831,
+          0.0561,
+          0.0585,
+          0.0723,
+          0.0824,
+          0.0599,
+          0.0488,
+          0.06,
+          0.0654,
+          0.0473
+        ],
+        "region": [
+          -0.0837,
+          -0.0338,
+          0.0111,
+          0.2059,
+          -0.0194,
+          -0.0269,
+          -0.2321,
+          0.0097,
+          0.0434,
+          0.0271,
+          0.0402,
+          0.0368,
+          0.2129,
+          0.0038,
+          0.0517,
+          0.1089,
+          0.0156,
+          -0.0382,
+          -0.1567,
+          -0.0019,
+          -0.0605,
+          0.1005,
+          -0.0355,
+          -0.0396,
+          -0.1829,
+          0.0213,
+          0.022
+        ],
+        "texture": [
+          1.0586,
+          0.0415,
+          0.2609,
+          0.025,
+          -0.0061,
+          0.0329,
+          -0.0166
+        ],
+        "colour": [
+          0.1534,
+          0.018,
+          0.2254,
+          0.1978,
+          0.2223,
+          0.1831,
+          0.7081,
+          0.1992
+        ],
+        "motion": [
+          0.4672,
+          0.2389,
+          0.1363,
+          0.0852,
+          0.0725,
+          0.0546,
+          0.0658,
+          0.069,
+          0.0503,
+          0.0615,
+          0.0751,
+          0.075,
+          0.0585,
+          0.0615,
+          0.0718,
+          0.0701,
+          0.0571,
+          0.0517,
+          0.0681,
+          0.0609,
+          0.049
+        ]
+      }
+    },
+    "Ridge Terrain": {
+      "coverage": 0.408,
+      "bedCoverage": 0.096,
+      "bedCoverageMean": 0.405,
+      "variety": 0.225,
+      "blocks": {
+        "scale": 0.021,
+        "orient": 0.098,
+        "layout": 0.399,
+        "region": 0.415,
+        "texture": 0.11,
+        "motion": 0.308,
+        "colour": 0.498
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1185,
+          0.108,
+          0.1438,
+          0.2492,
+          0.3805
+        ],
+        "orient": [
+          0.1955,
+          0.2035,
+          0.1145,
+          0.1501,
+          0.0554,
+          0.0821
+        ],
+        "layout": [
+          0.0315,
+          0.1026,
+          0.0358,
+          0.0063,
+          0.0566,
+          0.1258,
+          0.0623,
+          0.0238,
+          0.0599,
+          0.1277,
+          0.0766,
+          0.0435,
+          0.0509,
+          0.0903,
+          0.0644,
+          0.0419
+        ],
+        "region": [
+          -0.4438,
+          0.0356,
+          0.0145,
+          0.7861,
+          0.0673,
+          -0.4427,
+          -0.9155,
+          -0.0375,
+          -0.2556,
+          -0.2232,
+          0.0274,
+          0.5419,
+          1.076,
+          0.092,
+          -0.1539,
+          -0.5053,
+          -0.1403,
+          0.2761,
+          -0.1279,
+          -0.0945,
+          0.5807,
+          0.6638,
+          0.1149,
+          -0.4144,
+          -0.3101,
+          -0.0648,
+          -0.1467
+        ],
+        "texture": [
+          0.6379,
+          0.1751,
+          0.0926,
+          0.0447,
+          0.0488,
+          0.1677,
+          -0.0418
+        ],
+        "colour": [
+          0.0057,
+          0.0012,
+          0.2157,
+          0.138,
+          0.1596,
+          0.4798,
+          0.6181,
+          0.3539
+        ],
+        "motion": [
+          0.4018,
+          0.2254,
+          0.1463,
+          0.1145,
+          0.1121,
+          0.0515,
+          0.1332,
+          0.0336,
+          0,
+          0.0684,
+          0.1348,
+          0.0384,
+          0.0007,
+          0.1193,
+          0.1219,
+          0.0458,
+          0.0023,
+          0.0842,
+          0.1195,
+          0.0435,
+          0.0028
+        ]
+      }
+    },
+    "Scan Tear": {
+      "coverage": 0.95,
+      "bedCoverage": 0.861,
+      "bedCoverageMean": 0.962,
+      "variety": 0.073,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.033,
+        "layout": 0.062,
+        "region": 0.206,
+        "texture": 0.093,
+        "motion": 0.028,
+        "colour": 0.372
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.2104,
+          0.1968,
+          0.1991,
+          0.1923,
+          0.2014
+        ],
+        "orient": [
+          0.4716,
+          0.2558,
+          0.1457,
+          0.0824,
+          0.0549,
+          0.0205
+        ],
+        "layout": [
+          0.0663,
+          0.0699,
+          0.0652,
+          0.0624,
+          0.0606,
+          0.0664,
+          0.0595,
+          0.0581,
+          0.0588,
+          0.0675,
+          0.065,
+          0.0625,
+          0.0581,
+          0.0643,
+          0.0598,
+          0.0558
+        ],
+        "region": [
+          0.0566,
+          -0.0096,
+          -0.0406,
+          0.0557,
+          -0.0214,
+          -0.0457,
+          -0.0349,
+          0.0143,
+          -0.0225,
+          0.0524,
+          0.0064,
+          -0.0696,
+          0.017,
+          0.0436,
+          0.0981,
+          -0.0552,
+          0.11,
+          0.0319,
+          -0.0874,
+          -0.0359,
+          0.1203,
+          0.1018,
+          -0.1431,
+          -0.2744,
+          -0.1061,
+          0.0357,
+          0.2026
+        ],
+        "texture": [
+          0.8252,
+          0.407,
+          0.2652,
+          0.0253,
+          0.1986,
+          0.294,
+          0.0574
+        ],
+        "colour": [
+          0.0653,
+          0.041,
+          0.1688,
+          0.1207,
+          0.2899,
+          0.3144,
+          0.615,
+          0.5395
+        ],
+        "motion": [
+          0.269,
+          0.2329,
+          0.2136,
+          0.1528,
+          0.1317,
+          0.0722,
+          0.0689,
+          0.066,
+          0.062,
+          0.0587,
+          0.0629,
+          0.0674,
+          0.0567,
+          0.0672,
+          0.0722,
+          0.0615,
+          0.0583,
+          0.0598,
+          0.0529,
+          0.0561,
+          0.0573
+        ]
+      }
+    },
+    "Block Mosh": {
+      "coverage": 0.917,
+      "bedCoverage": 0.688,
+      "bedCoverageMean": 0.926,
+      "variety": 0.081,
+      "blocks": {
+        "scale": 0.047,
+        "orient": 0.1,
+        "layout": 0.061,
+        "region": 0.168,
+        "texture": 0.078,
+        "motion": 0.033,
+        "colour": 0.517
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.1781,
+          0.1691,
+          0.1986,
+          0.2108,
+          0.2435
+        ],
+        "orient": [
+          0.192,
+          0.0858,
+          0.0761,
+          0.0442,
+          0.0326,
+          0.0272
+        ],
+        "layout": [
+          0.0529,
+          0.0576,
+          0.0658,
+          0.0466,
+          0.0671,
+          0.0668,
+          0.0664,
+          0.054,
+          0.0701,
+          0.0765,
+          0.076,
+          0.0588,
+          0.0518,
+          0.0645,
+          0.0693,
+          0.0558
+        ],
+        "region": [
+          -0.1436,
+          0.0746,
+          -0.0094,
+          -0.0589,
+          0.0241,
+          0.0468,
+          -0.1093,
+          0.0238,
+          0.0215,
+          0.1321,
+          -0.0497,
+          -0.0383,
+          0.1959,
+          -0.0439,
+          0.0322,
+          0.0042,
+          0.0447,
+          0.1088,
+          -0.0511,
+          -0.0944,
+          -0.1245,
+          0.0088,
+          -0.0118,
+          -0.0606,
+          0.022,
+          0.0327,
+          0.0235
+        ],
+        "texture": [
+          0.8887,
+          0.1298,
+          0.2366,
+          0.0339,
+          0.0588,
+          0.0766,
+          -0.0612
+        ],
+        "colour": [
+          0.0493,
+          0.1052,
+          0.3131,
+          0.1739,
+          0.1256,
+          0.233,
+          0.6302,
+          0.451
+        ],
+        "motion": [
+          0.2616,
+          0.2182,
+          0.2076,
+          0.1707,
+          0.1419,
+          0.0601,
+          0.0525,
+          0.0615,
+          0.0492,
+          0.0722,
+          0.0645,
+          0.0576,
+          0.0498,
+          0.0726,
+          0.0758,
+          0.0698,
+          0.0589,
+          0.0603,
+          0.0751,
+          0.0669,
+          0.0533
+        ]
+      }
+    },
+    "Neon City": {
+      "coverage": 0.255,
+      "bedCoverage": 0.071,
+      "bedCoverageMean": 0.241,
+      "variety": 0.174,
+      "blocks": {
+        "scale": 0.017,
+        "orient": 0.093,
+        "layout": 0.329,
+        "region": 0.323,
+        "texture": 0.082,
+        "motion": 0.198,
+        "colour": 0.49
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3617,
+          0.2046,
+          0.1381,
+          0.1138,
+          0.1818
+        ],
+        "orient": [
+          0.0671,
+          0.0457,
+          0.0347,
+          0.0286,
+          0.0352,
+          0.0254
+        ],
+        "layout": [
+          0.0539,
+          0.0711,
+          0.0452,
+          0.0168,
+          0.0753,
+          0.0909,
+          0.0826,
+          0.0304,
+          0.0711,
+          0.0901,
+          0.1078,
+          0.0476,
+          0.044,
+          0.0676,
+          0.0726,
+          0.0331
+        ],
+        "region": [
+          0.0501,
+          -0.0773,
+          -0.0474,
+          0.0526,
+          -0.0697,
+          -0.0386,
+          -0.6325,
+          -0.006,
+          -0.2583,
+          0.2951,
+          0.0966,
+          0.183,
+          0.5783,
+          -0.0543,
+          0.0121,
+          -0.1301,
+          0.0544,
+          0.2164,
+          -0.1784,
+          -0.0578,
+          -0.1748,
+          0.2545,
+          0.0543,
+          -0.0328,
+          -0.2896,
+          0.0597,
+          0.1403
+        ],
+        "texture": [
+          0.9225,
+          0.1094,
+          0.1978,
+          0.0398,
+          0.0161,
+          0.0679,
+          0.002
+        ],
+        "colour": [
+          0.0928,
+          0.1472,
+          0.3212,
+          0.0769,
+          0.2851,
+          0.0767,
+          0.5876,
+          0.1342
+        ],
+        "motion": [
+          0.3903,
+          0.1987,
+          0.1235,
+          0.1189,
+          0.1686,
+          0.0577,
+          0.0684,
+          0.0553,
+          0.016,
+          0.0834,
+          0.0849,
+          0.0898,
+          0.0338,
+          0.0652,
+          0.0794,
+          0.1022,
+          0.0401,
+          0.0412,
+          0.0692,
+          0.0766,
+          0.0369
+        ]
+      }
+    },
+    "Flora": {
+      "coverage": 0.141,
+      "bedCoverage": 0.043,
+      "bedCoverageMean": 0.118,
+      "variety": 0.285,
+      "blocks": {
+        "scale": 0.046,
+        "orient": 0.128,
+        "layout": 0.647,
+        "region": 0.481,
+        "texture": 0.081,
+        "motion": 0.329,
+        "colour": 0.494
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1723,
+          0.1517,
+          0.1757,
+          0.2727,
+          0.2276
+        ],
+        "orient": [
+          0.2224,
+          0.1507,
+          0.1236,
+          0.1232,
+          0.0783,
+          0.0789
+        ],
+        "layout": [
+          0.0344,
+          0.0752,
+          0.048,
+          0,
+          0.1011,
+          0.147,
+          0.1079,
+          0.0001,
+          0.0538,
+          0.1204,
+          0.1001,
+          0.015,
+          0.0573,
+          0.0752,
+          0.0628,
+          0.0016
+        ],
+        "region": [
+          -0.1064,
+          0.0059,
+          -0.3301,
+          0.1583,
+          -0.112,
+          0.4416,
+          -0.9106,
+          -0.0813,
+          -0.5809,
+          -0.0236,
+          -0.0092,
+          0.5202,
+          1.453,
+          0.0684,
+          0.6376,
+          -0.6076,
+          -0.0014,
+          -0.6189,
+          -0.1509,
+          0.1424,
+          0.0757,
+          0.7621,
+          0.0095,
+          0.4362,
+          -0.5744,
+          -0.0222,
+          -0.5814
+        ],
+        "texture": [
+          0.2466,
+          0.0721,
+          0.0812,
+          0.0383,
+          0.0807,
+          0.1254,
+          0.0325
+        ],
+        "colour": [
+          0.1631,
+          0.0882,
+          0.2107,
+          0.2016,
+          0.0569,
+          0.2795,
+          0.2007,
+          0.0977
+        ],
+        "motion": [
+          0.2789,
+          0.2026,
+          0.182,
+          0.1901,
+          0.1464,
+          0.0427,
+          0.071,
+          0.0508,
+          0,
+          0.0528,
+          0.1447,
+          0.118,
+          0,
+          0.0546,
+          0.1394,
+          0.0907,
+          0.0099,
+          0.0883,
+          0.0777,
+          0.0594,
+          0.0001
+        ]
+      }
+    },
+    "Firefly Drift": {
+      "coverage": 0.071,
+      "bedCoverage": 0.003,
+      "bedCoverageMean": 0.048,
+      "variety": 0.234,
+      "blocks": {
+        "scale": 0.033,
+        "orient": 0.07,
+        "layout": 0.483,
+        "region": 0.502,
+        "texture": 0.076,
+        "motion": 0.243,
+        "colour": 0.406
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2198,
+          0.2191,
+          0.2404,
+          0.196,
+          0.1246
+        ],
+        "orient": [
+          0.2035,
+          0.1416,
+          0.0715,
+          0.15,
+          0.0683,
+          0.1401
+        ],
+        "layout": [
+          0.0256,
+          0.0949,
+          0.0511,
+          0.0194,
+          0.0339,
+          0.1201,
+          0.0603,
+          0.0201,
+          0.1312,
+          0.1171,
+          0.0945,
+          0.0224,
+          0.0555,
+          0.0888,
+          0.06,
+          0.0051
+        ],
+        "region": [
+          -0.2442,
+          0.0712,
+          -0.4012,
+          0.1221,
+          -0.0692,
+          0.3881,
+          -0.3632,
+          -0.0213,
+          0.0352,
+          0.7216,
+          0.0939,
+          0.145,
+          0.6454,
+          0.0455,
+          0.7689,
+          -0.6101,
+          0.0155,
+          -0.0638,
+          0.4562,
+          -0.0374,
+          -0.1924,
+          -0.0659,
+          -0.0848,
+          -0.0618,
+          -0.6618,
+          -0.0135,
+          -0.6179
+        ],
+        "texture": [
+          0.1822,
+          0.0373,
+          0.098,
+          0.0405,
+          0.0663,
+          0.0645,
+          0.0459
+        ],
+        "colour": [
+          0.1306,
+          0.0376,
+          0.1846,
+          0.256,
+          0.2733,
+          0.1178,
+          0.2169,
+          0.0388
+        ],
+        "motion": [
+          0.2428,
+          0.2215,
+          0.2105,
+          0.1773,
+          0.1479,
+          0.0371,
+          0.0774,
+          0.0521,
+          0.0189,
+          0.0371,
+          0.1202,
+          0.0424,
+          0.0341,
+          0.1399,
+          0.1165,
+          0.0744,
+          0.0171,
+          0.0587,
+          0.0821,
+          0.0589,
+          0.0334
+        ]
+      },
+      "error": "renders nothing — luminance 0.0011, variance 0.0274. A failed shader compile scores 0.000 on every block; check the console for GLSL errors."
+    },
+    "Silk Ribbon": {
+      "coverage": 0.072,
+      "bedCoverage": 0.052,
+      "bedCoverageMean": 0.069,
+      "variety": 0.239,
+      "blocks": {
+        "scale": 0.024,
+        "orient": 0.09,
+        "layout": 0.533,
+        "region": 0.444,
+        "texture": 0.036,
+        "motion": 0.309,
+        "colour": 0.4
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1754,
+          0.1975,
+          0.2212,
+          0.2211,
+          0.1849
+        ],
+        "orient": [
+          0.1308,
+          0.1166,
+          0.0729,
+          0.1247,
+          0.0924,
+          0.0386
+        ],
+        "layout": [
+          0.048,
+          0.0797,
+          0.0996,
+          0.0058,
+          0.0717,
+          0.1332,
+          0.1087,
+          0,
+          0.0725,
+          0.11,
+          0.0902,
+          0,
+          0.0452,
+          0.0824,
+          0.0427,
+          0.0103
+        ],
+        "region": [
+          -0.1142,
+          0.0906,
+          -0.175,
+          1.0447,
+          0.07,
+          1.288,
+          -0.8481,
+          -0.1236,
+          -0.9155,
+          0.2643,
+          -0.0016,
+          0.3041,
+          1.1127,
+          0.0178,
+          1.3391,
+          -0.7157,
+          0.1174,
+          -0.7897,
+          0.0763,
+          -0.1377,
+          -0.17,
+          -0.1102,
+          -0.0363,
+          -0.2609,
+          -0.7098,
+          0.0034,
+          -0.6201
+        ],
+        "texture": [
+          0.1315,
+          0.0203,
+          0.106,
+          0.0532,
+          0.0665,
+          0.1369,
+          -0.0182
+        ],
+        "colour": [
+          0.0289,
+          0.1229,
+          0.2372,
+          0.2031,
+          0.3051,
+          0.103,
+          0.0914,
+          0.0372
+        ],
+        "motion": [
+          0.2831,
+          0.2024,
+          0.1868,
+          0.1642,
+          0.1635,
+          0.0767,
+          0.0657,
+          0.1259,
+          0.0085,
+          0.0868,
+          0.1306,
+          0.1108,
+          0,
+          0.074,
+          0.0995,
+          0.098,
+          0,
+          0.0347,
+          0.0477,
+          0.0319,
+          0.0092
+        ]
+      }
+    },
+    "Pylon Grid": {
+      "coverage": 0.315,
+      "bedCoverage": 0.128,
+      "bedCoverageMean": 0.296,
+      "variety": 0.12,
+      "blocks": {
+        "scale": 0.022,
+        "orient": 0.102,
+        "layout": 0.104,
+        "region": 0.31,
+        "texture": 0.124,
+        "motion": 0.06,
+        "colour": 0.405
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1426,
+          0.1328,
+          0.1848,
+          0.2589,
+          0.2809
+        ],
+        "orient": [
+          0.1219,
+          0.1275,
+          0.053,
+          0.0653,
+          0.0474,
+          0.0558
+        ],
+        "layout": [
+          0.0321,
+          0.0622,
+          0.0652,
+          0.0366,
+          0.0852,
+          0.1108,
+          0.1207,
+          0.1006,
+          0.0524,
+          0.1138,
+          0.1158,
+          0.0555,
+          0.0041,
+          0.0168,
+          0.0188,
+          0.0094
+        ],
+        "region": [
+          -0.2411,
+          0.0781,
+          0.1413,
+          0.1891,
+          0.0827,
+          1.0352,
+          -0.1077,
+          0.188,
+          0.5626,
+          0.5344,
+          0.0887,
+          -0.0548,
+          0.8938,
+          -0.0183,
+          0.2653,
+          0.6933,
+          0.0358,
+          0.4203,
+          -0.868,
+          -0.0411,
+          -0.8941,
+          -0.3071,
+          -0.3016,
+          -0.7522,
+          -0.7867,
+          -0.1122,
+          -0.7236
+        ],
+        "texture": [
+          0.6285,
+          0.134,
+          0.1685,
+          0.0431,
+          0.2791,
+          0.32,
+          0.0699
+        ],
+        "colour": [
+          0.1007,
+          0.0851,
+          0.2639,
+          0.2569,
+          0.2133,
+          0.0801,
+          0.4421,
+          0.1955
+        ],
+        "motion": [
+          0.2664,
+          0.2046,
+          0.1776,
+          0.1644,
+          0.1869,
+          0.0379,
+          0.0616,
+          0.0649,
+          0.0352,
+          0.0928,
+          0.1232,
+          0.1168,
+          0.1109,
+          0.056,
+          0.0889,
+          0.0985,
+          0.0657,
+          0.0038,
+          0.0208,
+          0.0191,
+          0.0039
+        ]
+      }
+    },
+    "Prism Bloom": {
+      "coverage": 0.087,
+      "bedCoverage": 0.008,
+      "bedCoverageMean": 0.072,
+      "variety": 0.264,
+      "blocks": {
+        "scale": 0.033,
+        "orient": 0.087,
+        "layout": 0.595,
+        "region": 0.471,
+        "texture": 0.1,
+        "motion": 0.299,
+        "colour": 0.435
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2412,
+          0.1877,
+          0.2004,
+          0.2065,
+          0.1641
+        ],
+        "orient": [
+          0.0976,
+          0.1168,
+          0.0627,
+          0.1561,
+          0.0787,
+          0.0714
+        ],
+        "layout": [
+          0.0274,
+          0.0401,
+          0.0468,
+          0.0074,
+          0.2188,
+          0.0729,
+          0.0799,
+          0.0324,
+          0.0415,
+          0.0805,
+          0.105,
+          0.0561,
+          0.0455,
+          0.0436,
+          0.074,
+          0.028
+        ],
+        "region": [
+          -0.1328,
+          -0.0012,
+          -0.5065,
+          -0.1824,
+          -0.0454,
+          -0.0825,
+          -0.6334,
+          -0.0359,
+          -0.6686,
+          1.0991,
+          0.0714,
+          1.6705,
+          0.3898,
+          -0.0072,
+          0.3644,
+          -0.0161,
+          -0.0976,
+          -0.2053,
+          -0.2818,
+          -0.0164,
+          -0.3203,
+          0.0055,
+          0.0921,
+          0.2033,
+          -0.248,
+          0.0402,
+          -0.4549
+        ],
+        "texture": [
+          0.287,
+          0.0529,
+          0.124,
+          0.0375,
+          0.0175,
+          0.0313,
+          -0.0027
+        ],
+        "colour": [
+          0.2294,
+          0.0808,
+          0.2153,
+          0.2661,
+          0.1503,
+          0.0581,
+          0.186,
+          0.0575
+        ],
+        "motion": [
+          0.3194,
+          0.2276,
+          0.1814,
+          0.1479,
+          0.1237,
+          0.0296,
+          0.0375,
+          0.0469,
+          0.0082,
+          0.2198,
+          0.0694,
+          0.0737,
+          0.0299,
+          0.0582,
+          0.0704,
+          0.0937,
+          0.0619,
+          0.0419,
+          0.046,
+          0.0806,
+          0.0324
+        ]
+      }
+    },
+    "Pitch Shatter": {
+      "coverage": 0.882,
+      "bedCoverage": 0.539,
+      "bedCoverageMean": 0.837,
+      "variety": 0.058,
+      "blocks": {
+        "scale": 0.009,
+        "orient": 0.009,
+        "layout": 0.059,
+        "region": 0.164,
+        "texture": 0.075,
+        "motion": 0.031,
+        "colour": 0.377
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.1948,
+          0.1886,
+          0.2121,
+          0.1922,
+          0.2122
+        ],
+        "orient": [
+          0.5432,
+          0.2939,
+          0.1872,
+          0.1043,
+          0.0546,
+          0.0232
+        ],
+        "layout": [
+          0.0482,
+          0.0646,
+          0.0487,
+          0.0685,
+          0.057,
+          0.0725,
+          0.0554,
+          0.0652,
+          0.0622,
+          0.0659,
+          0.0693,
+          0.0618,
+          0.0624,
+          0.0725,
+          0.0708,
+          0.055
+        ],
+        "region": [
+          -0.1907,
+          0.0045,
+          0.02,
+          -0.0119,
+          -0.0036,
+          -0.0605,
+          0.0368,
+          0.0076,
+          -0.0123,
+          -0.0623,
+          -0.048,
+          0.0146,
+          0.0963,
+          0.0318,
+          0.0163,
+          0.0623,
+          0.0302,
+          0.0138,
+          0.0111,
+          0.0777,
+          0.0061,
+          0.1765,
+          0.0208,
+          0.0298,
+          -0.1181,
+          -0.121,
+          -0.0278
+        ],
+        "texture": [
+          0.8235,
+          0.4404,
+          0.2514,
+          0.0322,
+          0.0215,
+          0.2038,
+          0.0183
+        ],
+        "colour": [
+          0.1157,
+          0.0793,
+          0.1613,
+          0.2556,
+          0.1528,
+          0.2353,
+          0.6253,
+          0.4272
+        ],
+        "motion": [
+          0.3008,
+          0.2335,
+          0.205,
+          0.1559,
+          0.1048,
+          0.0439,
+          0.0732,
+          0.0469,
+          0.0632,
+          0.0557,
+          0.0804,
+          0.0559,
+          0.0593,
+          0.0756,
+          0.07,
+          0.0636,
+          0.0611,
+          0.0624,
+          0.0641,
+          0.0707,
+          0.0538
+        ]
+      }
+    },
+    "Aurora Veil": {
+      "coverage": 0.24,
+      "bedCoverage": 0.017,
+      "bedCoverageMean": 0.201,
+      "variety": 0.21,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.121,
+        "layout": 0.329,
+        "region": 0.438,
+        "texture": 0.119,
+        "motion": 0.238,
+        "colour": 0.428
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1148,
+          0.1445,
+          0.2116,
+          0.2592,
+          0.27
+        ],
+        "orient": [
+          0.2384,
+          0.1469,
+          0.0485,
+          0.0769,
+          0.0382,
+          0.0444
+        ],
+        "layout": [
+          0.0616,
+          0.0526,
+          0.0613,
+          0.0143,
+          0.1115,
+          0.1079,
+          0.0815,
+          0.0314,
+          0.061,
+          0.1062,
+          0.1043,
+          0.0314,
+          0.0383,
+          0.032,
+          0.069,
+          0.0359
+        ],
+        "region": [
+          0.0023,
+          -0.1694,
+          0.1265,
+          0.2002,
+          0.0097,
+          0.039,
+          -0.7082,
+          -0.1014,
+          -0.2166,
+          0.3166,
+          0.1001,
+          0.2127,
+          1.0002,
+          -0.0272,
+          0.0972,
+          -0.3815,
+          0.0474,
+          -0.2496,
+          -0.2984,
+          0.0605,
+          0.0117,
+          0.1566,
+          0.0204,
+          -0.2619,
+          -0.2878,
+          0.0599,
+          0.241
+        ],
+        "texture": [
+          0.6866,
+          0.1241,
+          0.1307,
+          0.0428,
+          0.0548,
+          0.0523,
+          -0.0344
+        ],
+        "colour": [
+          0.0463,
+          0.1157,
+          0.3127,
+          0.125,
+          0.2766,
+          0.1237,
+          0.5628,
+          0.1222
+        ],
+        "motion": [
+          0.2469,
+          0.1941,
+          0.1952,
+          0.177,
+          0.1868,
+          0.0541,
+          0.0839,
+          0.0699,
+          0.0146,
+          0.1067,
+          0.0772,
+          0.0775,
+          0.0366,
+          0.0628,
+          0.0852,
+          0.1094,
+          0.032,
+          0.0355,
+          0.0268,
+          0.0888,
+          0.0391
+        ]
+      }
+    },
+    "Tide Rings": {
+      "coverage": 0.788,
+      "bedCoverage": 0.234,
+      "bedCoverageMean": 0.761,
+      "variety": 0.094,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.082,
+        "layout": 0.081,
+        "region": 0.239,
+        "texture": 0.091,
+        "motion": 0.055,
+        "colour": 0.493
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2739,
+          0.2391,
+          0.1912,
+          0.136,
+          0.1599
+        ],
+        "orient": [
+          0.1751,
+          0.0721,
+          0.0405,
+          0.0264,
+          0.0299,
+          0.0252
+        ],
+        "layout": [
+          0.0598,
+          0.0716,
+          0.0603,
+          0.0384,
+          0.0695,
+          0.0862,
+          0.0762,
+          0.0466,
+          0.0599,
+          0.0865,
+          0.0812,
+          0.0515,
+          0.0444,
+          0.0625,
+          0.063,
+          0.0423
+        ],
+        "region": [
+          0.0468,
+          0.0481,
+          -0.1023,
+          0.0986,
+          -0.0325,
+          0.0001,
+          -0.2641,
+          0.1153,
+          -0.0018,
+          0.0936,
+          -0.0566,
+          -0.0165,
+          0.4172,
+          -0.0051,
+          0.0165,
+          -0.1305,
+          -0.1373,
+          -0.0187,
+          -0.1651,
+          0.0071,
+          0.008,
+          0.1303,
+          0.0943,
+          0.0293,
+          -0.2268,
+          -0.0334,
+          0.0853
+        ],
+        "texture": [
+          0.9488,
+          0.2711,
+          0.2716,
+          0.0245,
+          0.025,
+          0.0511,
+          -0.034
+        ],
+        "colour": [
+          0.1636,
+          0.0458,
+          0.1897,
+          0.3461,
+          0.2008,
+          0.054,
+          0.5982,
+          0.3838
+        ],
+        "motion": [
+          0.3713,
+          0.2567,
+          0.1583,
+          0.1086,
+          0.105,
+          0.0517,
+          0.0728,
+          0.0622,
+          0.046,
+          0.0664,
+          0.0773,
+          0.0776,
+          0.0538,
+          0.0616,
+          0.0751,
+          0.0717,
+          0.0568,
+          0.0516,
+          0.0613,
+          0.0651,
+          0.0492
+        ]
+      }
+    },
+    "Dust Chamber": {
+      "coverage": 0.139,
+      "bedCoverage": 0.001,
+      "bedCoverageMean": 0.133,
+      "variety": 0.247,
+      "blocks": {
+        "scale": 0.019,
+        "orient": 0.157,
+        "layout": 0.453,
+        "region": 0.453,
+        "texture": 0.119,
+        "motion": 0.279,
+        "colour": 0.525
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1499,
+          0.1605,
+          0.1925,
+          0.2214,
+          0.2755
+        ],
+        "orient": [
+          0.1559,
+          0.1526,
+          0.0822,
+          0.1297,
+          0.0829,
+          0.1006
+        ],
+        "layout": [
+          0.0368,
+          0.0984,
+          0.0843,
+          0.0233,
+          0.0903,
+          0.1687,
+          0.0854,
+          0.0342,
+          0.039,
+          0.0525,
+          0.0597,
+          0.0522,
+          0.0372,
+          0.0242,
+          0.0822,
+          0.0317
+        ],
+        "region": [
+          -0.2904,
+          -0.2799,
+          -0.454,
+          1.5373,
+          0.1452,
+          0.0106,
+          -0.5951,
+          -0.016,
+          -0.112,
+          0.0259,
+          0.0927,
+          0.1064,
+          0.2962,
+          0.1195,
+          -0.0393,
+          -0.1211,
+          0.0297,
+          0.1344,
+          -0.4408,
+          0.0028,
+          -0.0776,
+          -0.1041,
+          -0.0868,
+          -0.2846,
+          -0.3079,
+          -0.0072,
+          0.7161
+        ],
+        "texture": [
+          0.6616,
+          0.1325,
+          0.0696,
+          0.0281,
+          0.0042,
+          0.0439,
+          -0.0112
+        ],
+        "colour": [
+          0.0275,
+          0.2011,
+          0.3024,
+          0.1012,
+          0.3603,
+          0.0075,
+          0.587,
+          0.0969
+        ],
+        "motion": [
+          0.3738,
+          0.2168,
+          0.1732,
+          0.1289,
+          0.1074,
+          0.0306,
+          0.0975,
+          0.0943,
+          0.0176,
+          0.104,
+          0.162,
+          0.0559,
+          0.0188,
+          0.0409,
+          0.0343,
+          0.0831,
+          0.0642,
+          0.0478,
+          0.0308,
+          0.0741,
+          0.044
+        ]
+      }
+    },
+    "Cargo Belt": {
+      "coverage": 0.079,
+      "bedCoverage": 0.03,
+      "bedCoverageMean": 0.092,
+      "variety": 0.159,
+      "blocks": {
+        "scale": 0.01,
+        "orient": 0.092,
+        "layout": 0.254,
+        "region": 0.387,
+        "texture": 0.069,
+        "motion": 0.144,
+        "colour": 0.429
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3471,
+          0.2709,
+          0.1877,
+          0.1025,
+          0.0918
+        ],
+        "orient": [
+          0.1958,
+          0.176,
+          0.0969,
+          0.1013,
+          0.0451,
+          0.0935
+        ],
+        "layout": [
+          0.0695,
+          0.0816,
+          0.0563,
+          0.0214,
+          0.0658,
+          0.1026,
+          0.0638,
+          0.025,
+          0.059,
+          0.1014,
+          0.0659,
+          0.0314,
+          0.0577,
+          0.0941,
+          0.08,
+          0.0246
+        ],
+        "region": [
+          0.0931,
+          -0.0528,
+          0.1301,
+          0.1015,
+          0.0416,
+          0.1796,
+          -0.4267,
+          0.1011,
+          -0.4107,
+          0.1167,
+          -0.1268,
+          0.0695,
+          0.456,
+          -0.0447,
+          0.2514,
+          -0.458,
+          0.0888,
+          -0.3787,
+          0.0341,
+          -0.1161,
+          0.127,
+          0.5208,
+          -0.0315,
+          0.4288,
+          -0.4375,
+          0.1406,
+          -0.397
+        ],
+        "texture": [
+          0.4395,
+          0.1544,
+          0.1955,
+          0.0335,
+          0.0231,
+          0.083,
+          -0.005
+        ],
+        "colour": [
+          0.1698,
+          0.0025,
+          0.3368,
+          0.0732,
+          0.1822,
+          0.2354,
+          0.2269,
+          0.0637
+        ],
+        "motion": [
+          0.3691,
+          0.2483,
+          0.1904,
+          0.1171,
+          0.075,
+          0.074,
+          0.09,
+          0.062,
+          0.017,
+          0.0778,
+          0.0922,
+          0.0532,
+          0.0162,
+          0.0688,
+          0.1072,
+          0.0479,
+          0.032,
+          0.0648,
+          0.0996,
+          0.0699,
+          0.0275
+        ]
+      }
+    },
+    "Circuit Bloom": {
+      "coverage": 0.029,
+      "bedCoverage": 0.012,
+      "bedCoverageMean": 0.023,
+      "variety": 0.198,
+      "blocks": {
+        "scale": 0.021,
+        "orient": 0.064,
+        "layout": 0.392,
+        "region": 0.432,
+        "texture": 0.071,
+        "motion": 0.209,
+        "colour": 0.322
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.4294,
+          0.2616,
+          0.1586,
+          0.087,
+          0.0635
+        ],
+        "orient": [
+          0.0758,
+          0.1886,
+          0.0554,
+          0.1029,
+          0.0612,
+          0.033
+        ],
+        "layout": [
+          0.0494,
+          0.0664,
+          0.0617,
+          0.0156,
+          0.0869,
+          0.1226,
+          0.0931,
+          0.0284,
+          0.1128,
+          0.1153,
+          0.0923,
+          0.0293,
+          0.0362,
+          0.038,
+          0.0357,
+          0.0162
+        ],
+        "region": [
+          -0.0277,
+          0.0077,
+          -0.2928,
+          0.1232,
+          0.0721,
+          -0.0064,
+          -0.4935,
+          0.0055,
+          -0.2026,
+          0.8526,
+          -0.0459,
+          0.5436,
+          0.7506,
+          0.0038,
+          0.1515,
+          -0.2649,
+          -0.0414,
+          -0.0445,
+          -0.1111,
+          -0.0328,
+          0.1494,
+          -0.1546,
+          -0.0408,
+          -0.041,
+          -0.6747,
+          0.0716,
+          -0.2573
+        ],
+        "texture": [
+          0.4561,
+          0.0373,
+          0.1181,
+          0.037,
+          0.0014,
+          0.0687,
+          -0.0018
+        ],
+        "colour": [
+          0.2837,
+          0.0844,
+          0.3372,
+          0.0921,
+          0.0677,
+          0.1349,
+          0.076,
+          0.0159
+        ],
+        "motion": [
+          0.4543,
+          0.2505,
+          0.1441,
+          0.0821,
+          0.0691,
+          0.0479,
+          0.0752,
+          0.071,
+          0.0205,
+          0.102,
+          0.1193,
+          0.0709,
+          0.027,
+          0.1199,
+          0.0915,
+          0.0836,
+          0.0361,
+          0.0455,
+          0.0337,
+          0.041,
+          0.015
+        ]
+      }
+    },
+    "Truchet Fold": {
+      "coverage": 0.514,
+      "bedCoverage": 0.306,
+      "bedCoverageMean": 0.489,
+      "variety": 0.061,
+      "blocks": {
+        "scale": 0.021,
+        "orient": 0.169,
+        "layout": 0.004,
+        "region": 0.07,
+        "texture": 0.093,
+        "motion": 0.01,
+        "colour": 0.309
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.4522,
+          0.2597,
+          0.1461,
+          0.0747,
+          0.0673
+        ],
+        "orient": [
+          0.1469,
+          0.0403,
+          0.0259,
+          0.0254,
+          0.0166,
+          0.0237
+        ],
+        "layout": [
+          0.0569,
+          0.0663,
+          0.0645,
+          0.0517,
+          0.0634,
+          0.0726,
+          0.0714,
+          0.0604,
+          0.0609,
+          0.0726,
+          0.0678,
+          0.0582,
+          0.0522,
+          0.066,
+          0.0652,
+          0.0497
+        ],
+        "region": [
+          -0.052,
+          0.0075,
+          0.0375,
+          0.0919,
+          -0.0101,
+          0.0098,
+          -0.1076,
+          0.009,
+          0.015,
+          0.047,
+          0.0144,
+          0.0135,
+          0.1538,
+          -0.0433,
+          -0.0266,
+          -0.0009,
+          0.0513,
+          -0.0226,
+          -0.0988,
+          -0.0148,
+          -0.0224,
+          0.094,
+          -0.0325,
+          -0.0073,
+          -0.1274,
+          0.0186,
+          0.003
+        ],
+        "texture": [
+          1.0296,
+          0.1238,
+          0.313,
+          0.0121,
+          0.0088,
+          0.0558,
+          0.0356
+        ],
+        "colour": [
+          0.1238,
+          0.0913,
+          0.2627,
+          0.184,
+          0.1196,
+          0.2186,
+          0.5491,
+          0.2641
+        ],
+        "motion": [
+          0.457,
+          0.2534,
+          0.1469,
+          0.0819,
+          0.0608,
+          0.0572,
+          0.0659,
+          0.0609,
+          0.055,
+          0.0616,
+          0.0706,
+          0.0676,
+          0.0632,
+          0.0645,
+          0.0678,
+          0.061,
+          0.0641,
+          0.0562,
+          0.0662,
+          0.0632,
+          0.0548
+        ]
+      }
+    },
+    "Signal Decay": {
+      "coverage": 0.085,
+      "bedCoverage": 0.009,
+      "bedCoverageMean": 0.08,
+      "variety": 0.184,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.134,
+        "layout": 0.3,
+        "region": 0.425,
+        "texture": 0.061,
+        "motion": 0.168,
+        "colour": 0.304
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.3982,
+          0.2263,
+          0.1544,
+          0.105,
+          0.116
+        ],
+        "orient": [
+          0.0986,
+          0.0735,
+          0.0439,
+          0.0415,
+          0.0336,
+          0.0363
+        ],
+        "layout": [
+          0.0569,
+          0.1039,
+          0.046,
+          0.0224,
+          0.055,
+          0.1214,
+          0.05,
+          0.028,
+          0.0572,
+          0.1192,
+          0.0639,
+          0.0304,
+          0.0454,
+          0.1008,
+          0.0719,
+          0.0276
+        ],
+        "region": [
+          0.0591,
+          -0.0173,
+          0.174,
+          0.1787,
+          0.0538,
+          0.1976,
+          -0.5001,
+          -0.0675,
+          -0.553,
+          0.0771,
+          0.0064,
+          0.1609,
+          0.6311,
+          -0.0113,
+          0.325,
+          -0.4427,
+          -0.0043,
+          -0.3948,
+          -0.0398,
+          0.0375,
+          0.0731,
+          0.508,
+          -0.0059,
+          0.4308,
+          -0.4713,
+          0.0086,
+          -0.4136
+        ],
+        "texture": [
+          0.5355,
+          0.0409,
+          0.1975,
+          0.037,
+          0.0263,
+          0.065,
+          0.0001
+        ],
+        "colour": [
+          0.1589,
+          0.0809,
+          0.3335,
+          0.1258,
+          0.1311,
+          0.1697,
+          0.2079,
+          0.0389
+        ],
+        "motion": [
+          0.4356,
+          0.2239,
+          0.138,
+          0.0959,
+          0.1065,
+          0.0561,
+          0.0985,
+          0.0531,
+          0.0217,
+          0.0559,
+          0.1042,
+          0.0567,
+          0.038,
+          0.0588,
+          0.1132,
+          0.0571,
+          0.0358,
+          0.0528,
+          0.1029,
+          0.0639,
+          0.0314
+        ]
+      }
+    },
+    "Ink Bleed": {
+      "coverage": 0.152,
+      "bedCoverage": 0.001,
+      "bedCoverageMean": 0.15,
+      "variety": 0.27,
+      "blocks": {
+        "scale": 0.029,
+        "orient": 0.106,
+        "layout": 0.558,
+        "region": 0.493,
+        "texture": 0.14,
+        "motion": 0.291,
+        "colour": 0.489
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.1189,
+          0.165,
+          0.2017,
+          0.2801,
+          0.2343
+        ],
+        "orient": [
+          0.2404,
+          0.1395,
+          0.1102,
+          0.1402,
+          0.0723,
+          0.1146
+        ],
+        "layout": [
+          0.0269,
+          0.0437,
+          0.067,
+          0.0072,
+          0.0953,
+          0.1461,
+          0.1219,
+          0.0505,
+          0.0219,
+          0.1086,
+          0.0898,
+          0.0419,
+          0.0418,
+          0.0473,
+          0.0573,
+          0.0327
+        ],
+        "region": [
+          -0.0398,
+          0.0216,
+          -0.3349,
+          0.122,
+          0.0275,
+          -0.2746,
+          -0.5333,
+          -0.2149,
+          -0.3569,
+          0.2902,
+          0.1424,
+          -0.0552,
+          0.74,
+          0.0906,
+          -0.093,
+          0.119,
+          0.1063,
+          0.8797,
+          -0.4994,
+          -0.0514,
+          -0.1679,
+          0.3084,
+          -0.1051,
+          -0.2544,
+          -0.5071,
+          -0.0171,
+          0.6573
+        ],
+        "texture": [
+          0.6849,
+          0.1628,
+          0.049,
+          0.0286,
+          0.0886,
+          0.1876,
+          -0.009
+        ],
+        "colour": [
+          0.0262,
+          0.1595,
+          0.3824,
+          0.0872,
+          0.3395,
+          0.0052,
+          0.5379,
+          0.1095
+        ],
+        "motion": [
+          0.3341,
+          0.2122,
+          0.1615,
+          0.1803,
+          0.1118,
+          0.0418,
+          0.0438,
+          0.0713,
+          0.0077,
+          0.0704,
+          0.1357,
+          0.1021,
+          0.0731,
+          0.0268,
+          0.1091,
+          0.0964,
+          0.0621,
+          0.0364,
+          0.0432,
+          0.0608,
+          0.0192
+        ]
+      }
+    },
+    "Salt Flat": {
+      "coverage": 0.323,
+      "bedCoverage": 0.009,
+      "bedCoverageMean": 0.326,
+      "variety": 0.265,
+      "blocks": {
+        "scale": 0.038,
+        "orient": 0.099,
+        "layout": 0.522,
+        "region": 0.457,
+        "texture": 0.131,
+        "motion": 0.341,
+        "colour": 0.489
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1912,
+          0.1732,
+          0.1844,
+          0.211,
+          0.2402
+        ],
+        "orient": [
+          0.1949,
+          0.1476,
+          0.111,
+          0.1176,
+          0.0862,
+          0.0606
+        ],
+        "layout": [
+          0.0195,
+          0.0594,
+          0.0202,
+          0.0207,
+          0.0626,
+          0.0981,
+          0.1182,
+          0.0375,
+          0.1109,
+          0.085,
+          0.1384,
+          0.0517,
+          0.0411,
+          0.0397,
+          0.0558,
+          0.0413
+        ],
+        "region": [
+          -0.6056,
+          0.0222,
+          -0.1668,
+          0.1659,
+          0.0335,
+          -0.3794,
+          -0.6973,
+          -0.0997,
+          -0.123,
+          0.5989,
+          -0.0531,
+          0.2839,
+          1.1321,
+          -0.006,
+          -0.2092,
+          0.128,
+          0.0725,
+          0.5895,
+          -0.3275,
+          0.0018,
+          0.1392,
+          -0.0535,
+          0.0066,
+          -0.2315,
+          -0.341,
+          0.0221,
+          0.0974
+        ],
+        "texture": [
+          0.7823,
+          0.1053,
+          0.0628,
+          0.0273,
+          0.0885,
+          0.2429,
+          0.0144
+        ],
+        "colour": [
+          0.0112,
+          0.0937,
+          0.3655,
+          0.071,
+          0.3108,
+          0.1479,
+          0.5888,
+          0.1503
+        ],
+        "motion": [
+          0.3963,
+          0.2161,
+          0.1522,
+          0.1358,
+          0.0997,
+          0.0196,
+          0.0552,
+          0.0155,
+          0.0239,
+          0.0789,
+          0.1045,
+          0.1178,
+          0.0474,
+          0.1115,
+          0.0925,
+          0.1072,
+          0.0758,
+          0.0334,
+          0.0317,
+          0.0474,
+          0.0378
+        ]
+      }
+    },
+    "Storm Rift": {
+      "coverage": 0.037,
+      "bedCoverage": 0,
+      "bedCoverageMean": 0.042,
+      "variety": 0.278,
+      "blocks": {
+        "scale": 0.019,
+        "orient": 0.104,
+        "layout": 0.647,
+        "region": 0.472,
+        "texture": 0.09,
+        "motion": 0.334,
+        "colour": 0.482
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.2537,
+          0.1848,
+          0.1855,
+          0.1858,
+          0.1902
+        ],
+        "orient": [
+          0.1293,
+          0.1174,
+          0.0906,
+          0.0766,
+          0.0519,
+          0.0649
+        ],
+        "layout": [
+          0.1325,
+          0.1583,
+          0.0354,
+          0.0018,
+          0.138,
+          0.1244,
+          0.0713,
+          0.0165,
+          0.0508,
+          0.0234,
+          0.0543,
+          0.0742,
+          0.0051,
+          0.0103,
+          0.0477,
+          0.0558
+        ],
+        "region": [
+          1.3353,
+          -0.1062,
+          1.1633,
+          0.6226,
+          -0.0754,
+          0.5662,
+          -0.9615,
+          -0.0757,
+          -0.7181,
+          0.3304,
+          0.1195,
+          0.4901,
+          0.4435,
+          -0.1507,
+          -0.2925,
+          -0.1947,
+          -0.0712,
+          -0.3516,
+          -0.8895,
+          0.2359,
+          -0.3788,
+          -0.6723,
+          0.1846,
+          -0.5348,
+          -0.0138,
+          -0.0608,
+          0.0562
+        ],
+        "texture": [
+          0.2598,
+          0.0796,
+          0.0641,
+          0.0321,
+          0.0219,
+          0.0649,
+          0.0008
+        ],
+        "colour": [
+          0.1563,
+          0.0683,
+          0.101,
+          0.2204,
+          0.3306,
+          0.1234,
+          0.2112,
+          0.0233
+        ],
+        "motion": [
+          0.274,
+          0.1941,
+          0.1846,
+          0.1777,
+          0.1695,
+          0.1576,
+          0.1432,
+          0.0349,
+          0.0005,
+          0.1356,
+          0.1187,
+          0.0743,
+          0.0357,
+          0.0342,
+          0.0343,
+          0.0743,
+          0.0567,
+          0.0036,
+          0.0101,
+          0.047,
+          0.0392
+        ]
+      }
+    },
+    "Vortex Drift": {
+      "coverage": 0.231,
+      "bedCoverage": 0.071,
+      "bedCoverageMean": 0.212,
+      "variety": 0.157,
+      "blocks": {
+        "scale": 0.03,
+        "orient": 0.101,
+        "layout": 0.235,
+        "region": 0.334,
+        "texture": 0.1,
+        "motion": 0.141,
+        "colour": 0.398
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3191,
+          0.1989,
+          0.1779,
+          0.1342,
+          0.1698
+        ],
+        "orient": [
+          0.0724,
+          0.0556,
+          0.0339,
+          0.0327,
+          0.029,
+          0.0313
+        ],
+        "layout": [
+          0.0453,
+          0.0833,
+          0.0615,
+          0.0306,
+          0.0889,
+          0.1076,
+          0.0868,
+          0.0316,
+          0.0685,
+          0.0925,
+          0.0768,
+          0.0386,
+          0.061,
+          0.0612,
+          0.0416,
+          0.0242
+        ],
+        "region": [
+          -0.0568,
+          -0.0156,
+          0.1722,
+          0.4366,
+          -0.0318,
+          -0.1461,
+          -0.4671,
+          0.0571,
+          -0.1397,
+          0.3744,
+          -0.017,
+          0.2638,
+          0.5783,
+          -0.0837,
+          -0.0091,
+          -0.2236,
+          0.1294,
+          -0.1883,
+          0.0039,
+          0.0091,
+          0.2429,
+          -0.0925,
+          -0.13,
+          -0.0069,
+          -0.5533,
+          0.0825,
+          -0.1888
+        ],
+        "texture": [
+          0.9002,
+          0.1362,
+          0.1905,
+          0.0316,
+          -0.011,
+          0.0392,
+          0.0072
+        ],
+        "colour": [
+          0.0856,
+          0.1313,
+          0.2624,
+          0.1652,
+          0.1279,
+          0.2276,
+          0.4806,
+          0.1176
+        ],
+        "motion": [
+          0.3447,
+          0.1933,
+          0.1537,
+          0.1448,
+          0.1634,
+          0.0601,
+          0.0815,
+          0.0575,
+          0.0219,
+          0.1011,
+          0.1226,
+          0.0686,
+          0.0281,
+          0.0705,
+          0.0951,
+          0.0719,
+          0.0343,
+          0.0596,
+          0.0612,
+          0.0417,
+          0.0243
+        ]
+      }
+    },
+    "Gate Corridor": {
+      "coverage": 0.573,
+      "bedCoverage": 0.159,
+      "bedCoverageMean": 0.574,
+      "variety": 0.111,
+      "blocks": {
+        "scale": 0.049,
+        "orient": 0.041,
+        "layout": 0.073,
+        "region": 0.328,
+        "texture": 0.107,
+        "motion": 0.068,
+        "colour": 0.406
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1499,
+          0.19,
+          0.2476,
+          0.2392,
+          0.1733
+        ],
+        "orient": [
+          0.3321,
+          0.1927,
+          0.0895,
+          0.0701,
+          0.058,
+          0.0725
+        ],
+        "layout": [
+          0.0597,
+          0.0693,
+          0.0473,
+          0.0537,
+          0.0587,
+          0.0739,
+          0.0742,
+          0.0617,
+          0.0608,
+          0.0812,
+          0.0623,
+          0.0611,
+          0.0547,
+          0.0808,
+          0.0503,
+          0.0501
+        ],
+        "region": [
+          -0.0134,
+          -0.1824,
+          -0.0717,
+          0.037,
+          0.0206,
+          -0.0613,
+          -0.1395,
+          0.1044,
+          -0.1142,
+          -0.0494,
+          0.0669,
+          0.1471,
+          0.2312,
+          0.1006,
+          0.1331,
+          0.037,
+          -0.0852,
+          -0.016,
+          0.0177,
+          -0.0428,
+          0.05,
+          0.1301,
+          0.061,
+          0.0462,
+          -0.2505,
+          -0.043,
+          -0.1132
+        ],
+        "texture": [
+          0.73,
+          0.2275,
+          0.2554,
+          0.0319,
+          0.0621,
+          0.2853,
+          -0.0717
+        ],
+        "colour": [
+          0.0553,
+          0.057,
+          0.3128,
+          0.1497,
+          0.1326,
+          0.2926,
+          0.5728,
+          0.3379
+        ],
+        "motion": [
+          0.2313,
+          0.2299,
+          0.2086,
+          0.1752,
+          0.155,
+          0.0601,
+          0.0628,
+          0.0521,
+          0.0617,
+          0.058,
+          0.0655,
+          0.0719,
+          0.0717,
+          0.0597,
+          0.0742,
+          0.0586,
+          0.0578,
+          0.0613,
+          0.0799,
+          0.0511,
+          0.0537
+        ]
+      }
+    },
+    "Smoke Column": {
+      "coverage": 0.217,
+      "bedCoverage": 0.007,
+      "bedCoverageMean": 0.223,
+      "variety": 0.232,
+      "blocks": {
+        "scale": 0.04,
+        "orient": 0.132,
+        "layout": 0.376,
+        "region": 0.462,
+        "texture": 0.144,
+        "motion": 0.241,
+        "colour": 0.473
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2333,
+          0.1558,
+          0.1393,
+          0.1979,
+          0.2739
+        ],
+        "orient": [
+          0.1837,
+          0.1086,
+          0.0719,
+          0.049,
+          0.0436,
+          0.0482
+        ],
+        "layout": [
+          0.0411,
+          0.0567,
+          0.0495,
+          0.0089,
+          0.1059,
+          0.1257,
+          0.0997,
+          0.0133,
+          0.0626,
+          0.1299,
+          0.0863,
+          0.0349,
+          0.0302,
+          0.058,
+          0.0654,
+          0.0319
+        ],
+        "region": [
+          -0.0213,
+          0.0042,
+          -0.1625,
+          0.1143,
+          -0.0425,
+          -0.111,
+          -0.77,
+          -0.1289,
+          -0.3926,
+          0.8585,
+          0.1542,
+          0.7374,
+          0.7427,
+          0.1121,
+          0.0507,
+          -0.3492,
+          0.0601,
+          -0.1724,
+          -0.4579,
+          0.0931,
+          -0.1227,
+          0.1661,
+          -0.1543,
+          -0.0349,
+          -0.2833,
+          -0.0981,
+          0.2079
+        ],
+        "texture": [
+          0.7457,
+          0.2095,
+          0.1393,
+          0.0456,
+          0.0749,
+          0.108,
+          0.0153
+        ],
+        "colour": [
+          0.1076,
+          0.1374,
+          0.3347,
+          0.0602,
+          0.2555,
+          0.1046,
+          0.5621,
+          0.1191
+        ],
+        "motion": [
+          0.3635,
+          0.2047,
+          0.1363,
+          0.1347,
+          0.1607,
+          0.0512,
+          0.0697,
+          0.0443,
+          0.0071,
+          0.1114,
+          0.1228,
+          0.1065,
+          0.0185,
+          0.0679,
+          0.1109,
+          0.0973,
+          0.0398,
+          0.029,
+          0.042,
+          0.055,
+          0.0266
+        ]
+      }
+    },
+    "Cell Divide": {
+      "coverage": 0.48,
+      "bedCoverage": 0.21,
+      "bedCoverageMean": 0.542,
+      "variety": 0.134,
+      "blocks": {
+        "scale": 0.013,
+        "orient": 0.057,
+        "layout": 0.173,
+        "region": 0.351,
+        "texture": 0.101,
+        "motion": 0.11,
+        "colour": 0.438
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.195,
+          0.1971,
+          0.2078,
+          0.2012,
+          0.1989
+        ],
+        "orient": [
+          0.1328,
+          0.1442,
+          0.0641,
+          0.0881,
+          0.0304,
+          0.0428
+        ],
+        "layout": [
+          0.0721,
+          0.0725,
+          0.081,
+          0.0381,
+          0.0628,
+          0.0875,
+          0.0752,
+          0.0419,
+          0.0552,
+          0.0801,
+          0.1025,
+          0.0443,
+          0.0365,
+          0.0684,
+          0.0529,
+          0.0289
+        ],
+        "region": [
+          0.3246,
+          0.1658,
+          0.142,
+          0.2683,
+          0.0232,
+          -0.2208,
+          -0.2461,
+          -0.2858,
+          -0.1519,
+          -0.0266,
+          0.0858,
+          0.2505,
+          0.4089,
+          0.0345,
+          -0.0724,
+          -0.3045,
+          -0.096,
+          0.0729,
+          -0.2053,
+          0.0396,
+          0.1924,
+          0.0699,
+          0.0785,
+          -0.179,
+          -0.2893,
+          -0.0457,
+          -0.0338
+        ],
+        "texture": [
+          0.7756,
+          0.1102,
+          0.2075,
+          0.0433,
+          0.0348,
+          0.1263,
+          -0.0134
+        ],
+        "colour": [
+          0.0498,
+          0.0225,
+          0.2412,
+          0.1695,
+          0.1762,
+          0.3408,
+          0.6097,
+          0.2468
+        ],
+        "motion": [
+          0.2974,
+          0.2159,
+          0.1911,
+          0.1642,
+          0.1314,
+          0.0655,
+          0.0698,
+          0.095,
+          0.049,
+          0.0649,
+          0.0853,
+          0.0851,
+          0.051,
+          0.0538,
+          0.0695,
+          0.0808,
+          0.0435,
+          0.0475,
+          0.0615,
+          0.0514,
+          0.0264
+        ]
+      }
+    },
+    "Eclipse Field": {
+      "coverage": 0.425,
+      "bedCoverage": 0.122,
+      "bedCoverageMean": 0.41,
+      "variety": 0.214,
+      "blocks": {
+        "scale": 0.015,
+        "orient": 0.071,
+        "layout": 0.429,
+        "region": 0.412,
+        "texture": 0.129,
+        "motion": 0.231,
+        "colour": 0.44
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1449,
+          0.1542,
+          0.1832,
+          0.2488,
+          0.2689
+        ],
+        "orient": [
+          0.1513,
+          0.122,
+          0.073,
+          0.0718,
+          0.0657,
+          0.059
+        ],
+        "layout": [
+          0.0737,
+          0.0749,
+          0.0477,
+          0.006,
+          0.0814,
+          0.1479,
+          0.1039,
+          0.0241,
+          0.0451,
+          0.1172,
+          0.0888,
+          0.0297,
+          0.0316,
+          0.0471,
+          0.0547,
+          0.0261
+        ],
+        "region": [
+          0.3129,
+          -0.0773,
+          0.0547,
+          0.2751,
+          -0.0065,
+          -0.2988,
+          -0.7367,
+          -0.0395,
+          -0.2262,
+          0.4367,
+          0.0484,
+          0.1111,
+          0.9652,
+          0.0351,
+          0.2324,
+          -0.2571,
+          -0.0389,
+          0.1995,
+          -0.5137,
+          0.0316,
+          -0.1432,
+          -0.0847,
+          0.0423,
+          0.1308,
+          -0.3977,
+          0.0048,
+          -0.0603
+        ],
+        "texture": [
+          0.7708,
+          0.1871,
+          0.1233,
+          0.0377,
+          0.0692,
+          0.0986,
+          0.01
+        ],
+        "colour": [
+          0.055,
+          0.1321,
+          0.2679,
+          0.2154,
+          0.2276,
+          0.1019,
+          0.5074,
+          0.2246
+        ],
+        "motion": [
+          0.3403,
+          0.2116,
+          0.1631,
+          0.1532,
+          0.1318,
+          0.0983,
+          0.0916,
+          0.046,
+          0.0064,
+          0.0739,
+          0.1746,
+          0.081,
+          0.0281,
+          0.0431,
+          0.117,
+          0.0667,
+          0.0293,
+          0.0239,
+          0.0426,
+          0.0475,
+          0.0301
+        ]
+      }
+    },
+    "Girder Lattice": {
+      "coverage": 0.412,
+      "bedCoverage": 0.123,
+      "bedCoverageMean": 0.45,
+      "variety": 0.215,
+      "blocks": {
+        "scale": 0.017,
+        "orient": 0.07,
+        "layout": 0.387,
+        "region": 0.446,
+        "texture": 0.107,
+        "motion": 0.26,
+        "colour": 0.499
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1654,
+          0.1537,
+          0.1736,
+          0.1962,
+          0.3111
+        ],
+        "orient": [
+          0.2945,
+          0.1527,
+          0.101,
+          0.0844,
+          0.0464,
+          0.0382
+        ],
+        "layout": [
+          0.0549,
+          0.0701,
+          0.0632,
+          0.0215,
+          0.0594,
+          0.0853,
+          0.0742,
+          0.0537,
+          0.039,
+          0.0991,
+          0.0711,
+          0.0599,
+          0.0295,
+          0.0787,
+          0.0744,
+          0.0659
+        ],
+        "region": [
+          -0.0878,
+          0.006,
+          0.0374,
+          0.2982,
+          0.042,
+          0.062,
+          -0.296,
+          -0.0379,
+          -0.2487,
+          -0.1246,
+          0.1566,
+          0.2444,
+          0.3238,
+          0.0267,
+          0.1029,
+          -0.0636,
+          -0.0469,
+          -0.2173,
+          -0.4374,
+          -0.1837,
+          -0.0326,
+          0.3466,
+          -0.0032,
+          0.1388,
+          0.041,
+          0.0404,
+          -0.0868
+        ],
+        "texture": [
+          0.759,
+          0.2541,
+          0.1785,
+          0.0425,
+          0.0178,
+          0.1163,
+          -0.0134
+        ],
+        "colour": [
+          0.0529,
+          0.1804,
+          0.2375,
+          0.0874,
+          0.1992,
+          0.2426,
+          0.6051,
+          0.2043
+        ],
+        "motion": [
+          0.2492,
+          0.1894,
+          0.178,
+          0.1724,
+          0.211,
+          0.0509,
+          0.072,
+          0.0601,
+          0.041,
+          0.0553,
+          0.0811,
+          0.0601,
+          0.0734,
+          0.0382,
+          0.0955,
+          0.0745,
+          0.0623,
+          0.0249,
+          0.0672,
+          0.068,
+          0.0753
+        ]
+      }
+    },
+    "Quasicrystal": {
+      "coverage": 0.552,
+      "bedCoverage": 0.282,
+      "bedCoverageMean": 0.548,
+      "variety": 0.059,
+      "blocks": {
+        "scale": 0.042,
+        "orient": 0.071,
+        "layout": 0.009,
+        "region": 0.122,
+        "texture": 0.096,
+        "motion": 0.011,
+        "colour": 0.526
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1742,
+          0.2022,
+          0.2568,
+          0.2267,
+          0.1402
+        ],
+        "orient": [
+          0.26,
+          0.1034,
+          0.0702,
+          0.0658,
+          0.0333,
+          0.0381
+        ],
+        "layout": [
+          0.0592,
+          0.0683,
+          0.0601,
+          0.0502,
+          0.0619,
+          0.0735,
+          0.074,
+          0.0634,
+          0.0638,
+          0.0748,
+          0.0703,
+          0.0533,
+          0.0558,
+          0.064,
+          0.061,
+          0.0464
+        ],
+        "region": [
+          -0.0459,
+          -0.0733,
+          -0.087,
+          0.1076,
+          0.0475,
+          0.0186,
+          -0.1273,
+          -0.0441,
+          -0.044,
+          0.0857,
+          0.0667,
+          0.013,
+          0.2105,
+          -0.0167,
+          0.0037,
+          -0.0148,
+          0.0745,
+          0.146,
+          -0.055,
+          -0.0237,
+          -0.0621,
+          0.0276,
+          -0.0384,
+          -0.0682,
+          -0.1885,
+          0.0075,
+          0.0799
+        ],
+        "texture": [
+          0.7562,
+          0.1644,
+          0.2899,
+          0.022,
+          0.0979,
+          0.1553,
+          -0.0816
+        ],
+        "colour": [
+          0.1204,
+          0.0167,
+          0.1795,
+          0.2366,
+          0.2468,
+          0.2001,
+          0.6753,
+          0.2401
+        ],
+        "motion": [
+          0.4244,
+          0.2539,
+          0.1709,
+          0.0949,
+          0.0559,
+          0.0605,
+          0.0657,
+          0.0649,
+          0.0528,
+          0.0672,
+          0.066,
+          0.0635,
+          0.0583,
+          0.0695,
+          0.067,
+          0.0696,
+          0.0618,
+          0.0549,
+          0.0634,
+          0.0578,
+          0.0569
+        ]
+      }
+    },
+    "Time Smear": {
+      "coverage": 0.487,
+      "bedCoverage": 0.231,
+      "bedCoverageMean": 0.484,
+      "variety": 0.146,
+      "blocks": {
+        "scale": 0.006,
+        "orient": 0.123,
+        "layout": 0.143,
+        "region": 0.404,
+        "texture": 0.098,
+        "motion": 0.1,
+        "colour": 0.492
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.1341,
+          0.1612,
+          0.2353,
+          0.2631,
+          0.2063
+        ],
+        "orient": [
+          0.2026,
+          0.1496,
+          0.0618,
+          0.0791,
+          0.0422,
+          0.049
+        ],
+        "layout": [
+          0.0504,
+          0.0752,
+          0.0643,
+          0.0324,
+          0.0818,
+          0.11,
+          0.0759,
+          0.0457,
+          0.0791,
+          0.0848,
+          0.0767,
+          0.043,
+          0.0444,
+          0.0546,
+          0.0517,
+          0.03
+        ],
+        "region": [
+          0.0167,
+          0.0986,
+          0.1474,
+          0.3205,
+          0.1453,
+          -0.0251,
+          -0.4037,
+          -0.107,
+          -0.1339,
+          0.4375,
+          0.2579,
+          0.311,
+          0.3651,
+          -0.0582,
+          -0.1357,
+          -0.1092,
+          -0.1759,
+          -0.0616,
+          -0.1579,
+          0.1429,
+          0.2666,
+          -0.0189,
+          -0.0906,
+          -0.0413,
+          -0.4502,
+          -0.213,
+          -0.3274
+        ],
+        "texture": [
+          0.7635,
+          0.1325,
+          0.2051,
+          0.036,
+          0.1129,
+          0.1126,
+          0.1126
+        ],
+        "colour": [
+          0.1808,
+          0.0877,
+          0.1698,
+          0.2225,
+          0.1132,
+          0.226,
+          0.5424,
+          0.2593
+        ],
+        "motion": [
+          0.2973,
+          0.2101,
+          0.1937,
+          0.1703,
+          0.1285,
+          0.0517,
+          0.0923,
+          0.0759,
+          0.0312,
+          0.0923,
+          0.0946,
+          0.0756,
+          0.0357,
+          0.0838,
+          0.0818,
+          0.0685,
+          0.0283,
+          0.0572,
+          0.0523,
+          0.0489,
+          0.0299
+        ]
+      }
+    },
+    "Rain Column": {
+      "coverage": 0.326,
+      "bedCoverage": 0.1,
+      "bedCoverageMean": 0.338,
+      "variety": 0.086,
+      "blocks": {
+        "scale": 0.024,
+        "orient": 0.071,
+        "layout": 0.063,
+        "region": 0.218,
+        "texture": 0.086,
+        "motion": 0.054,
+        "colour": 0.41
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3087,
+          0.2269,
+          0.1859,
+          0.1488,
+          0.1297
+        ],
+        "orient": [
+          0.2324,
+          0.1111,
+          0.0591,
+          0.0333,
+          0.0317,
+          0.0198
+        ],
+        "layout": [
+          0.0537,
+          0.0693,
+          0.0588,
+          0.0354,
+          0.0647,
+          0.0803,
+          0.0873,
+          0.0474,
+          0.066,
+          0.0767,
+          0.0881,
+          0.0501,
+          0.0567,
+          0.062,
+          0.0662,
+          0.0374
+        ],
+        "region": [
+          -0.0645,
+          -0.1141,
+          -0.035,
+          0.135,
+          0.0982,
+          -0.0367,
+          -0.2642,
+          0.0463,
+          -0.0367,
+          0.1098,
+          -0.0623,
+          0.0787,
+          0.3598,
+          0.0492,
+          -0.028,
+          -0.1391,
+          -0.0434,
+          -0.0142,
+          0.0172,
+          0.0109,
+          0.0381,
+          0.0672,
+          0.0059,
+          0.0264,
+          -0.2212,
+          0.0094,
+          0.0074
+        ],
+        "texture": [
+          0.9014,
+          0.1822,
+          0.2326,
+          0.026,
+          0.0268,
+          0.0803,
+          0.0443
+        ],
+        "colour": [
+          0.013,
+          0.1034,
+          0.3393,
+          0.1033,
+          0.3233,
+          0.1177,
+          0.6384,
+          0.1598
+        ],
+        "motion": [
+          0.4026,
+          0.2229,
+          0.1487,
+          0.1105,
+          0.1152,
+          0.0657,
+          0.0667,
+          0.057,
+          0.0398,
+          0.0703,
+          0.0809,
+          0.0756,
+          0.0496,
+          0.0605,
+          0.0719,
+          0.0852,
+          0.0618,
+          0.0541,
+          0.0589,
+          0.0596,
+          0.0426
+        ]
+      }
+    },
+    "Magnet Lines": {
+      "coverage": 0.181,
+      "bedCoverage": 0.054,
+      "bedCoverageMean": 0.18,
+      "variety": 0.127,
+      "blocks": {
+        "scale": 0.006,
+        "orient": 0.13,
+        "layout": 0.1,
+        "region": 0.397,
+        "texture": 0.078,
+        "motion": 0.053,
+        "colour": 0.438
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.263,
+          0.2048,
+          0.1921,
+          0.1836,
+          0.1565
+        ],
+        "orient": [
+          0.0599,
+          0.0661,
+          0.0295,
+          0.0891,
+          0.0395,
+          0.0712
+        ],
+        "layout": [
+          0.0474,
+          0.0701,
+          0.0598,
+          0.0379,
+          0.0666,
+          0.0765,
+          0.0787,
+          0.0524,
+          0.0657,
+          0.1035,
+          0.0906,
+          0.0456,
+          0.0476,
+          0.0557,
+          0.0657,
+          0.0364
+        ],
+        "region": [
+          -0.0974,
+          -0.0976,
+          0.1189,
+          0.0767,
+          0.0225,
+          0.174,
+          -0.2585,
+          -0.1011,
+          -0.2013,
+          0.0978,
+          0.1095,
+          -0.0555,
+          0.5527,
+          0.0372,
+          0.1679,
+          -0.1883,
+          -0.0901,
+          -0.1501,
+          -0.1867,
+          -0.0433,
+          -0.1823,
+          0.2938,
+          0.0284,
+          0.2393,
+          -0.29,
+          0.1345,
+          -0.1108
+        ],
+        "texture": [
+          0.5939,
+          0.0392,
+          0.2185,
+          0.0297,
+          0.0431,
+          0.0841,
+          -0.001
+        ],
+        "colour": [
+          0.1388,
+          0.0382,
+          0.2272,
+          0.2158,
+          0.161,
+          0.219,
+          0.32,
+          0.0951
+        ],
+        "motion": [
+          0.3185,
+          0.2114,
+          0.1753,
+          0.1507,
+          0.1441,
+          0.0466,
+          0.0699,
+          0.0756,
+          0.0412,
+          0.0539,
+          0.0828,
+          0.0949,
+          0.0569,
+          0.0542,
+          0.1003,
+          0.0806,
+          0.046,
+          0.041,
+          0.0569,
+          0.0619,
+          0.0372
+        ]
+      }
+    },
+    "Kármán Street": {
+      "coverage": 0.388,
+      "bedCoverage": 0.037,
+      "bedCoverageMean": 0.387,
+      "variety": 0.134,
+      "blocks": {
+        "scale": 0.038,
+        "orient": 0.053,
+        "layout": 0.178,
+        "region": 0.223,
+        "texture": 0.195,
+        "motion": 0.115,
+        "colour": 0.39
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3374,
+          0.2313,
+          0.1449,
+          0.1446,
+          0.1419
+        ],
+        "orient": [
+          0.3726,
+          0.1551,
+          0.1021,
+          0.0642,
+          0.0248,
+          0.0461
+        ],
+        "layout": [
+          0.0477,
+          0.0546,
+          0.0476,
+          0.0328,
+          0.0551,
+          0.0563,
+          0.0595,
+          0.0524,
+          0.0722,
+          0.0766,
+          0.0634,
+          0.0639,
+          0.073,
+          0.1083,
+          0.076,
+          0.0606
+        ],
+        "region": [
+          -0.2072,
+          -0.0558,
+          0.0601,
+          -0.1776,
+          0.0906,
+          -0.0655,
+          -0.3712,
+          0.005,
+          -0.0065,
+          -0.0152,
+          -0.0451,
+          0.0819,
+          -0.0353,
+          0.0366,
+          0.02,
+          -0.0192,
+          -0.0185,
+          0.0756,
+          0.3188,
+          -0.0862,
+          -0.0291,
+          0.534,
+          0.0653,
+          -0.1044,
+          -0.0269,
+          0.0081,
+          -0.032
+        ],
+        "texture": [
+          1.0156,
+          0.3977,
+          0.2687,
+          0.0176,
+          0.0383,
+          0.0339,
+          0.1208
+        ],
+        "colour": [
+          0.1277,
+          0.0804,
+          0.3258,
+          0.151,
+          0.2355,
+          0.0796,
+          0.5432,
+          0.1636
+        ],
+        "motion": [
+          0.4283,
+          0.2498,
+          0.1391,
+          0.1035,
+          0.0793,
+          0.0637,
+          0.0437,
+          0.0467,
+          0.0436,
+          0.0777,
+          0.0514,
+          0.063,
+          0.0651,
+          0.0845,
+          0.0752,
+          0.0683,
+          0.0576,
+          0.0713,
+          0.0754,
+          0.0569,
+          0.0559
+        ]
+      }
+    },
+    "Turing Bloom": {
+      "coverage": 0.705,
+      "bedCoverage": 0.089,
+      "bedCoverageMean": 0.699,
+      "variety": 0.1,
+      "blocks": {
+        "scale": 0.063,
+        "orient": 0.227,
+        "layout": 0.043,
+        "region": 0.135,
+        "texture": 0.082,
+        "motion": 0.05,
+        "colour": 0.487
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.3129,
+          0.2045,
+          0.174,
+          0.1511,
+          0.1575
+        ],
+        "orient": [
+          0.0822,
+          0.0407,
+          0.0194,
+          0.0303,
+          0.0175,
+          0.0228
+        ],
+        "layout": [
+          0.0566,
+          0.0571,
+          0.0549,
+          0.0576,
+          0.0649,
+          0.0667,
+          0.0611,
+          0.0708,
+          0.0531,
+          0.088,
+          0.0582,
+          0.0587,
+          0.0666,
+          0.0665,
+          0.0588,
+          0.0604
+        ],
+        "region": [
+          -0.0734,
+          0.0055,
+          0.0044,
+          -0.1126,
+          -0.1063,
+          -0.0357,
+          -0.0761,
+          -0.0234,
+          -0.0018,
+          0.0195,
+          -0.0117,
+          -0.003,
+          0.1292,
+          -0.0199,
+          0.0241,
+          0.0283,
+          0.1004,
+          0.0401,
+          -0.0104,
+          0.0099,
+          0.0013,
+          0.0839,
+          -0.0195,
+          -0.0354,
+          0.0116,
+          0.065,
+          0.006
+        ],
+        "texture": [
+          0.9741,
+          0.0913,
+          0.2504,
+          0.0264,
+          0.0405,
+          0.0384,
+          -0.0203
+        ],
+        "colour": [
+          0.0105,
+          0.0579,
+          0.1782,
+          0.128,
+          0.2374,
+          0.3881,
+          0.4868,
+          0.5522
+        ],
+        "motion": [
+          0.3807,
+          0.2247,
+          0.1521,
+          0.122,
+          0.1205,
+          0.0617,
+          0.0612,
+          0.0551,
+          0.0563,
+          0.0575,
+          0.0688,
+          0.0586,
+          0.0567,
+          0.0564,
+          0.0938,
+          0.0603,
+          0.0523,
+          0.0717,
+          0.0719,
+          0.0612,
+          0.0564
+        ]
+      }
+    },
+    "Mycelium Web": {
+      "coverage": 0.331,
+      "bedCoverage": 0.02,
+      "bedCoverageMean": 0.322,
+      "variety": 0.239,
+      "blocks": {
+        "scale": 0.009,
+        "orient": 0.102,
+        "layout": 0.479,
+        "region": 0.475,
+        "texture": 0.115,
+        "motion": 0.256,
+        "colour": 0.471
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2712,
+          0.2018,
+          0.1799,
+          0.1839,
+          0.1632
+        ],
+        "orient": [
+          0.0826,
+          0.0349,
+          0.0399,
+          0.0312,
+          0.0515,
+          0.05
+        ],
+        "layout": [
+          0.065,
+          0.0525,
+          0.0585,
+          0.0341,
+          0.117,
+          0.0559,
+          0.0511,
+          0.0325,
+          0.1173,
+          0.0508,
+          0.0534,
+          0.0437,
+          0.1126,
+          0.0589,
+          0.0517,
+          0.0448
+        ],
+        "region": [
+          -0.0374,
+          0.0139,
+          -0.2852,
+          0.0156,
+          -0.0942,
+          -0.1102,
+          -0.4492,
+          -0.0181,
+          -0.0904,
+          0.6454,
+          0.1094,
+          0.0481,
+          -0.0501,
+          0.0057,
+          -0.1716,
+          -0.3411,
+          0.1203,
+          0.1106,
+          0.6743,
+          0.0442,
+          0.3777,
+          -0.2493,
+          -0.1402,
+          -0.2228,
+          -0.2082,
+          -0.041,
+          0.3438
+        ],
+        "texture": [
+          0.7114,
+          0.1073,
+          0.1848,
+          0.0402,
+          0.0054,
+          0.0753,
+          -0.0031
+        ],
+        "colour": [
+          0.0549,
+          0.0798,
+          0.3503,
+          0.0994,
+          0.3158,
+          0.0998,
+          0.5418,
+          0.2209
+        ],
+        "motion": [
+          0.3162,
+          0.206,
+          0.1644,
+          0.1646,
+          0.1487,
+          0.072,
+          0.0499,
+          0.0543,
+          0.0374,
+          0.1189,
+          0.0534,
+          0.0444,
+          0.0389,
+          0.1249,
+          0.0513,
+          0.045,
+          0.0415,
+          0.1208,
+          0.0567,
+          0.0476,
+          0.0431
+        ]
+      }
+    },
+    "Scale Mosaic": {
+      "coverage": 0.79,
+      "bedCoverage": 0.618,
+      "bedCoverageMean": 0.745,
+      "variety": 0.081,
+      "blocks": {
+        "scale": 0.008,
+        "orient": 0.107,
+        "layout": 0.088,
+        "region": 0.211,
+        "texture": 0.045,
+        "motion": 0.026,
+        "colour": 0.499
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3336,
+          0.2419,
+          0.1714,
+          0.1156,
+          0.1375
+        ],
+        "orient": [
+          0.1173,
+          0.0309,
+          0.0278,
+          0.0186,
+          0.0209,
+          0.0077
+        ],
+        "layout": [
+          0.0626,
+          0.0532,
+          0.0684,
+          0.0763,
+          0.0608,
+          0.0427,
+          0.0568,
+          0.078,
+          0.0616,
+          0.0485,
+          0.0571,
+          0.0726,
+          0.0675,
+          0.0664,
+          0.0628,
+          0.0647
+        ],
+        "region": [
+          -0.0439,
+          0.0419,
+          -0.0356,
+          -0.0699,
+          -0.0483,
+          0.0015,
+          0.2092,
+          0.1628,
+          -0.0184,
+          -0.0505,
+          -0.0273,
+          0.0868,
+          -0.3152,
+          -0.0551,
+          0.0184,
+          0.2067,
+          0.1043,
+          0.0899,
+          0.0567,
+          -0.0342,
+          -0.0423,
+          -0.0142,
+          -0.1408,
+          -0.1393,
+          0.0212,
+          -0.0034,
+          0.039
+        ],
+        "texture": [
+          0.9704,
+          0.1984,
+          0.2917,
+          0.0208,
+          0.0353,
+          0.0879,
+          -0.0172
+        ],
+        "colour": [
+          0.0235,
+          0.0172,
+          0.2495,
+          0.1284,
+          0.103,
+          0.4783,
+          0.5917,
+          0.5883
+        ],
+        "motion": [
+          0.4206,
+          0.2405,
+          0.153,
+          0.0966,
+          0.0894,
+          0.0666,
+          0.0626,
+          0.0664,
+          0.0665,
+          0.0668,
+          0.0527,
+          0.0495,
+          0.0748,
+          0.0706,
+          0.0503,
+          0.0478,
+          0.0715,
+          0.0768,
+          0.0621,
+          0.0515,
+          0.0638
+        ]
+      }
+    },
+    "Pendulum Trace": {
+      "coverage": 0.025,
+      "bedCoverage": 0.008,
+      "bedCoverageMean": 0.02,
+      "variety": 0.293,
+      "blocks": {
+        "scale": 0.02,
+        "orient": 0.107,
+        "layout": 0.634,
+        "region": 0.498,
+        "texture": 0.134,
+        "motion": 0.362,
+        "colour": 0.435
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.3127,
+          0.2364,
+          0.1891,
+          0.1417,
+          0.1199
+        ],
+        "orient": [
+          0.1576,
+          0.1763,
+          0.086,
+          0.1145,
+          0.0592,
+          0.1056
+        ],
+        "layout": [
+          0.1098,
+          0.0913,
+          0.0557,
+          0.0006,
+          0.0698,
+          0.0808,
+          0.1297,
+          0.0171,
+          0.0727,
+          0.0976,
+          0.0993,
+          0.067,
+          0.0568,
+          0.0049,
+          0.038,
+          0.0087
+        ],
+        "region": [
+          0.6894,
+          -0.0873,
+          0.4393,
+          0.2136,
+          0.0076,
+          0.2077,
+          -0.8766,
+          -0.0382,
+          -0.6127,
+          -0.1172,
+          0.2341,
+          0.621,
+          0.8856,
+          -0.0087,
+          0.3292,
+          -0.1496,
+          0.0383,
+          -0.0929,
+          0.1413,
+          0.0063,
+          -0.0148,
+          -0.3836,
+          -0.1213,
+          -0.5624,
+          -0.403,
+          -0.0309,
+          -0.3143
+        ],
+        "texture": [
+          0.3202,
+          0.1429,
+          0.0673,
+          0.0349,
+          0.0205,
+          0.0473,
+          -0.0094
+        ],
+        "colour": [
+          0.1091,
+          0.0224,
+          0.3247,
+          0.1722,
+          0.2995,
+          0.0721,
+          0.4575,
+          0.0236
+        ],
+        "motion": [
+          0.3942,
+          0.2553,
+          0.1538,
+          0.1062,
+          0.0906,
+          0.0296,
+          0.1399,
+          0.1743,
+          0.0005,
+          0.0104,
+          0.1305,
+          0.0904,
+          0.0008,
+          0.0394,
+          0.1261,
+          0.0879,
+          0.0087,
+          0.0585,
+          0.001,
+          0.1019,
+          0.0003
+        ]
+      }
+    },
+    "Contour Map": {
+      "coverage": 0.45,
+      "bedCoverage": 0.065,
+      "bedCoverageMean": 0.418,
+      "variety": 0.253,
+      "blocks": {
+        "scale": 0.055,
+        "orient": 0.07,
+        "layout": 0.461,
+        "region": 0.526,
+        "texture": 0.118,
+        "motion": 0.286,
+        "colour": 0.584
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2016,
+          0.1681,
+          0.1723,
+          0.2098,
+          0.2483
+        ],
+        "orient": [
+          0.1866,
+          0.1644,
+          0.0738,
+          0.0813,
+          0.0856,
+          0.0214
+        ],
+        "layout": [
+          0.0626,
+          0.0664,
+          0.0491,
+          0.0127,
+          0.0938,
+          0.0735,
+          0.0533,
+          0.0205,
+          0.0879,
+          0.0687,
+          0.0392,
+          0.0568,
+          0.109,
+          0.085,
+          0.0476,
+          0.0738
+        ],
+        "region": [
+          0.3628,
+          0.1497,
+          -0.1306,
+          -0.0196,
+          0.1512,
+          -0.3778,
+          -0.6734,
+          -0.0236,
+          -0.1227,
+          0.2916,
+          -0.0944,
+          0.2705,
+          -0.1612,
+          0.0595,
+          -0.1348,
+          -0.3831,
+          0.044,
+          0.3257,
+          0.6403,
+          -0.0767,
+          0.2238,
+          -0.1285,
+          -0.1459,
+          -0.1969,
+          0.071,
+          -0.0639,
+          0.1428
+        ],
+        "texture": [
+          0.751,
+          0.1286,
+          0.1314,
+          0.0454,
+          0.0342,
+          0.0933,
+          0.0141
+        ],
+        "colour": [
+          0.1136,
+          0.0644,
+          0.3357,
+          0.1994,
+          0.2016,
+          0.0853,
+          0.5544,
+          0.2206
+        ],
+        "motion": [
+          0.3917,
+          0.2287,
+          0.1586,
+          0.1197,
+          0.1013,
+          0.0723,
+          0.056,
+          0.0633,
+          0.01,
+          0.1101,
+          0.0566,
+          0.0476,
+          0.0279,
+          0.0806,
+          0.0514,
+          0.0361,
+          0.0649,
+          0.1102,
+          0.0633,
+          0.0582,
+          0.0913
+        ]
+      }
+    },
+    "Shoji Grid": {
+      "coverage": 0.326,
+      "bedCoverage": 0.005,
+      "bedCoverageMean": 0.246,
+      "variety": 0.096,
+      "blocks": {
+        "scale": 0.016,
+        "orient": 0.11,
+        "layout": 0.095,
+        "region": 0.214,
+        "texture": 0.081,
+        "motion": 0.061,
+        "colour": 0.381
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2359,
+          0.2069,
+          0.1877,
+          0.1611,
+          0.2084
+        ],
+        "orient": [
+          0.2548,
+          0.1114,
+          0.0616,
+          0.0593,
+          0.0332,
+          0.0343
+        ],
+        "layout": [
+          0.0656,
+          0.0772,
+          0.0966,
+          0.0443,
+          0.0619,
+          0.0927,
+          0.0843,
+          0.0511,
+          0.0705,
+          0.0597,
+          0.0691,
+          0.0503,
+          0.0422,
+          0.05,
+          0.0486,
+          0.0358
+        ],
+        "region": [
+          0.0538,
+          -0.0004,
+          0.0705,
+          0.5051,
+          -0.01,
+          -0.0325,
+          -0.1634,
+          0.0409,
+          0.0012,
+          0.1649,
+          0.0555,
+          0.1328,
+          0.3188,
+          -0.0121,
+          0.0766,
+          -0.0849,
+          -0.0145,
+          0.011,
+          -0.2744,
+          0.0196,
+          -0.0187,
+          -0.1569,
+          -0.0888,
+          -0.1269,
+          -0.3629,
+          0.0097,
+          -0.114
+        ],
+        "texture": [
+          0.8457,
+          0.1379,
+          0.2177,
+          0.0318,
+          -0.0164,
+          0.0829,
+          -0.0299
+        ],
+        "colour": [
+          0.0447,
+          0.0436,
+          0.113,
+          0.278,
+          0.3437,
+          0.177,
+          0.5523,
+          0.1486
+        ],
+        "motion": [
+          0.3526,
+          0.2166,
+          0.1793,
+          0.1494,
+          0.1021,
+          0.0694,
+          0.0676,
+          0.083,
+          0.0528,
+          0.0857,
+          0.0806,
+          0.0774,
+          0.0541,
+          0.0857,
+          0.061,
+          0.0387,
+          0.0495,
+          0.0581,
+          0.0515,
+          0.0457,
+          0.0392
+        ]
+      }
+    },
+    "Balance Stack": {
+      "coverage": 0.25,
+      "bedCoverage": 0.05,
+      "bedCoverageMean": 0.249,
+      "variety": 0.235,
+      "blocks": {
+        "scale": 0.024,
+        "orient": 0.056,
+        "layout": 0.461,
+        "region": 0.457,
+        "texture": 0.135,
+        "motion": 0.277,
+        "colour": 0.397
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1795,
+          0.1964,
+          0.2198,
+          0.2045,
+          0.1998
+        ],
+        "orient": [
+          0.2131,
+          0.1688,
+          0.0879,
+          0.0729,
+          0.0562,
+          0.0521
+        ],
+        "layout": [
+          0.0508,
+          0.0889,
+          0.0645,
+          0.0156,
+          0.1062,
+          0.1433,
+          0.0917,
+          0.0113,
+          0.0555,
+          0.0757,
+          0.1015,
+          0.0423,
+          0.0253,
+          0.0249,
+          0.0639,
+          0.0386
+        ],
+        "region": [
+          0.1359,
+          -0.1972,
+          -0.3175,
+          0.5055,
+          0.0036,
+          0.1631,
+          -0.7253,
+          -0.0585,
+          -0.1367,
+          0.4045,
+          -0.0218,
+          -0.0645,
+          0.9811,
+          0.0937,
+          0.3672,
+          -0.5494,
+          -0.0348,
+          0.0528,
+          -0.555,
+          0.1197,
+          -0.0856,
+          -0.1997,
+          0.0651,
+          -0.1957,
+          0.0025,
+          0.0301,
+          0.2168
+        ],
+        "texture": [
+          0.7621,
+          0.2514,
+          0.1238,
+          0.047,
+          0.0657,
+          0.1158,
+          0.02
+        ],
+        "colour": [
+          0.0377,
+          0.1282,
+          0.3378,
+          0.1003,
+          0.2986,
+          0.0975,
+          0.5767,
+          0.1738
+        ],
+        "motion": [
+          0.4022,
+          0.2262,
+          0.1474,
+          0.1271,
+          0.097,
+          0.0574,
+          0.086,
+          0.0764,
+          0.0175,
+          0.1229,
+          0.1137,
+          0.0772,
+          0.0133,
+          0.0761,
+          0.0837,
+          0.0794,
+          0.0535,
+          0.0378,
+          0.0244,
+          0.0511,
+          0.0297
+        ]
+      }
+    },
+    "Suspension Span": {
+      "coverage": 0.159,
+      "bedCoverage": 0.049,
+      "bedCoverageMean": 0.157,
+      "variety": 0.253,
+      "blocks": {
+        "scale": 0.016,
+        "orient": 0.051,
+        "layout": 0.507,
+        "region": 0.566,
+        "texture": 0.105,
+        "motion": 0.27,
+        "colour": 0.401
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1981,
+          0.1924,
+          0.2083,
+          0.213,
+          0.1882
+        ],
+        "orient": [
+          0.3499,
+          0.2038,
+          0.1514,
+          0.124,
+          0.0822,
+          0.06
+        ],
+        "layout": [
+          0.0636,
+          0.0728,
+          0.0518,
+          0.0201,
+          0.0667,
+          0.0779,
+          0.0589,
+          0.0073,
+          0.0863,
+          0.1104,
+          0.0753,
+          0.0196,
+          0.0815,
+          0.125,
+          0.0611,
+          0.0218
+        ],
+        "region": [
+          -0.0102,
+          -0.0911,
+          0.1928,
+          0.2265,
+          0.1331,
+          0.3073,
+          -0.5908,
+          -0.203,
+          -0.4891,
+          0.4426,
+          0.0585,
+          0.3609,
+          0.4444,
+          0.1028,
+          0.0309,
+          -0.6889,
+          0.0228,
+          -0.3807,
+          0.2608,
+          -0.0078,
+          0.5337,
+          0.4885,
+          0.1876,
+          -0.2237,
+          -0.5729,
+          -0.2028,
+          -0.3322
+        ],
+        "texture": [
+          0.4847,
+          0.124,
+          0.1322,
+          0.0485,
+          0.0308,
+          0.0873,
+          0.043
+        ],
+        "colour": [
+          0.0495,
+          0.0818,
+          0.2491,
+          0.159,
+          0.2449,
+          0.2157,
+          0.405,
+          0.08
+        ],
+        "motion": [
+          0.3183,
+          0.2199,
+          0.1678,
+          0.1604,
+          0.1336,
+          0.0747,
+          0.0758,
+          0.0508,
+          0.0242,
+          0.0695,
+          0.0832,
+          0.0789,
+          0.0063,
+          0.0893,
+          0.0942,
+          0.0905,
+          0.0125,
+          0.0687,
+          0.1055,
+          0.0563,
+          0.0196
+        ]
+      }
+    },
+    "Stairwell Descent": {
+      "coverage": 0.482,
+      "bedCoverage": 0.096,
+      "bedCoverageMean": 0.459,
+      "variety": 0.069,
+      "blocks": {
+        "scale": 0.019,
+        "orient": 0.043,
+        "layout": 0.039,
+        "region": 0.214,
+        "texture": 0.069,
+        "motion": 0.033,
+        "colour": 0.416
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2695,
+          0.2487,
+          0.2251,
+          0.1465,
+          0.1103
+        ],
+        "orient": [
+          0.2133,
+          0.1289,
+          0.0461,
+          0.0349,
+          0.0169,
+          0.0316
+        ],
+        "layout": [
+          0.0585,
+          0.0654,
+          0.063,
+          0.0542,
+          0.0594,
+          0.0655,
+          0.0618,
+          0.0563,
+          0.0661,
+          0.0747,
+          0.0601,
+          0.0601,
+          0.0611,
+          0.085,
+          0.0584,
+          0.0504
+        ],
+        "region": [
+          0.0304,
+          -0.0829,
+          0.0339,
+          -0.0295,
+          -0.228,
+          0.0153,
+          -0.0625,
+          0.234,
+          -0.1028,
+          -0.0518,
+          -0.0329,
+          0.1167,
+          0.0159,
+          -0.0114,
+          0.0804,
+          -0.0755,
+          0.293,
+          0.0201,
+          0.1219,
+          -0.0904,
+          -0.0517,
+          0.1811,
+          -0.2099,
+          -0.0888,
+          -0.13,
+          0.1286,
+          -0.0231
+        ],
+        "texture": [
+          0.8522,
+          0.2243,
+          0.2444,
+          0.0328,
+          0.0507,
+          0.147,
+          -0.0052
+        ],
+        "colour": [
+          0.0533,
+          0.0616,
+          0.2294,
+          0.2044,
+          0.2233,
+          0.2279,
+          0.6018,
+          0.2178
+        ],
+        "motion": [
+          0.3371,
+          0.2362,
+          0.1971,
+          0.1404,
+          0.0892,
+          0.0511,
+          0.0595,
+          0.0609,
+          0.0511,
+          0.0582,
+          0.0712,
+          0.0726,
+          0.0589,
+          0.0669,
+          0.078,
+          0.0606,
+          0.0646,
+          0.0506,
+          0.0786,
+          0.0604,
+          0.0567
+        ]
+      }
+    },
+    "Aqueduct March": {
+      "coverage": 0.281,
+      "bedCoverage": 0.158,
+      "bedCoverageMean": 0.277,
+      "variety": 0.221,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.068,
+        "layout": 0.441,
+        "region": 0.468,
+        "texture": 0.103,
+        "motion": 0.23,
+        "colour": 0.483
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2075,
+          0.164,
+          0.1766,
+          0.2243,
+          0.2275
+        ],
+        "orient": [
+          0.2119,
+          0.0708,
+          0.057,
+          0.0648,
+          0.0563,
+          0.0554
+        ],
+        "layout": [
+          0.0975,
+          0.0833,
+          0.0579,
+          0.0213,
+          0.0837,
+          0.0725,
+          0.0785,
+          0.0196,
+          0.0766,
+          0.0824,
+          0.0687,
+          0.0227,
+          0.0632,
+          0.0867,
+          0.0613,
+          0.0242
+        ],
+        "region": [
+          0.3791,
+          -0.124,
+          0.4002,
+          0.4891,
+          0.1234,
+          -0.0914,
+          -0.6503,
+          -0.0479,
+          -0.1886,
+          0.1382,
+          -0.1452,
+          0.154,
+          0.546,
+          0.1485,
+          -0.0993,
+          -0.6011,
+          0.119,
+          -0.1096,
+          -0.0424,
+          -0.0642,
+          -0.0713,
+          0.2906,
+          -0.0007,
+          0.0795,
+          -0.5493,
+          -0.0088,
+          -0.0736
+        ],
+        "texture": [
+          0.6518,
+          0.1429,
+          0.1505,
+          0.0386,
+          -0.0036,
+          0.0517,
+          0.0065
+        ],
+        "colour": [
+          0.0153,
+          0.211,
+          0.2225,
+          0.0866,
+          0.2614,
+          0.2031,
+          0.5921,
+          0.1524
+        ],
+        "motion": [
+          0.3754,
+          0.2148,
+          0.1472,
+          0.1333,
+          0.1293,
+          0.1019,
+          0.0772,
+          0.0636,
+          0.019,
+          0.1039,
+          0.0576,
+          0.0589,
+          0.0165,
+          0.0945,
+          0.0738,
+          0.057,
+          0.0263,
+          0.0683,
+          0.1013,
+          0.0523,
+          0.0278
+        ]
+      }
+    },
+    "Data Aisle": {
+      "coverage": 0.237,
+      "bedCoverage": 0.017,
+      "bedCoverageMean": 0.231,
+      "variety": 0.233,
+      "blocks": {
+        "scale": 0.022,
+        "orient": 0.119,
+        "layout": 0.451,
+        "region": 0.457,
+        "texture": 0.075,
+        "motion": 0.275,
+        "colour": 0.473
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3365,
+          0.213,
+          0.1657,
+          0.1433,
+          0.1414
+        ],
+        "orient": [
+          0.0833,
+          0.088,
+          0.0571,
+          0.0526,
+          0.0347,
+          0.0358
+        ],
+        "layout": [
+          0.0677,
+          0.0644,
+          0.0756,
+          0.0362,
+          0.0777,
+          0.0614,
+          0.0634,
+          0.0192,
+          0.0591,
+          0.0786,
+          0.092,
+          0.0359,
+          0.0768,
+          0.1176,
+          0.0494,
+          0.0251
+        ],
+        "region": [
+          -0.0577,
+          -0.0003,
+          -0.1551,
+          0.3106,
+          -0.0428,
+          -0.2837,
+          -0.2636,
+          -0.0092,
+          -0.1839,
+          0.0793,
+          0.1235,
+          -0.0112,
+          0.3747,
+          -0.0057,
+          -0.1477,
+          -0.5497,
+          0.0893,
+          0.4014,
+          0.2506,
+          -0.0431,
+          0.1095,
+          0.2509,
+          -0.0002,
+          0.0058,
+          -0.395,
+          -0.1115,
+          0.2648
+        ],
+        "texture": [
+          0.764,
+          0.0668,
+          0.1298,
+          0.0412,
+          0.0374,
+          0.0464,
+          0.0095
+        ],
+        "colour": [
+          0.0197,
+          0.1885,
+          0.3569,
+          0.1031,
+          0.2955,
+          0.0363,
+          0.5527,
+          0.1339
+        ],
+        "motion": [
+          0.3405,
+          0.2172,
+          0.1699,
+          0.1389,
+          0.1336,
+          0.0646,
+          0.0618,
+          0.0651,
+          0.0352,
+          0.0963,
+          0.065,
+          0.0668,
+          0.0153,
+          0.0653,
+          0.0799,
+          0.0977,
+          0.0321,
+          0.0645,
+          0.1141,
+          0.048,
+          0.0284
+        ]
+      }
+    },
+    "Voronoi Shatter": {
+      "coverage": 0.859,
+      "bedCoverage": 0.465,
+      "bedCoverageMean": 0.857,
+      "variety": 0.059,
+      "blocks": {
+        "scale": 0.018,
+        "orient": 0.166,
+        "layout": 0.007,
+        "region": 0.085,
+        "texture": 0.061,
+        "motion": 0.018,
+        "colour": 0.502
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2683,
+          0.251,
+          0.2125,
+          0.144,
+          0.1242
+        ],
+        "orient": [
+          0.1398,
+          0.0549,
+          0.0234,
+          0.0146,
+          0.0174,
+          0.0211
+        ],
+        "layout": [
+          0.0639,
+          0.066,
+          0.0623,
+          0.0579,
+          0.0672,
+          0.0696,
+          0.0571,
+          0.0575,
+          0.0681,
+          0.0693,
+          0.061,
+          0.0607,
+          0.0594,
+          0.0627,
+          0.0596,
+          0.0575
+        ],
+        "region": [
+          0.022,
+          -0.0276,
+          0.013,
+          0.0163,
+          0.059,
+          -0.0373,
+          -0.0455,
+          -0.0295,
+          0.0163,
+          0.1407,
+          0.0385,
+          -0.0013,
+          0.0193,
+          -0.042,
+          -0.0263,
+          -0.049,
+          0.0026,
+          0.0252,
+          -0.0042,
+          0.0021,
+          0.0211,
+          -0.0167,
+          0.0129,
+          -0.0128,
+          -0.0828,
+          -0.0159,
+          0.0021
+        ],
+        "texture": [
+          0.8842,
+          0.1353,
+          0.3139,
+          0.0129,
+          0.0336,
+          0.0361,
+          -0.0548
+        ],
+        "colour": [
+          0.069,
+          0.0865,
+          0.1681,
+          0.2268,
+          0.1632,
+          0.2865,
+          0.6024,
+          0.5665
+        ],
+        "motion": [
+          0.3845,
+          0.2397,
+          0.1749,
+          0.1135,
+          0.0875,
+          0.0682,
+          0.0636,
+          0.0574,
+          0.0671,
+          0.0693,
+          0.0588,
+          0.0554,
+          0.0662,
+          0.0733,
+          0.0552,
+          0.0489,
+          0.0672,
+          0.0661,
+          0.0618,
+          0.0555,
+          0.066
+        ]
+      }
+    },
+    "Apollonian Gasket": {
+      "coverage": 0.661,
+      "bedCoverage": 0.604,
+      "bedCoverageMean": 0.654,
+      "variety": 0.054,
+      "blocks": {
+        "scale": 0.007,
+        "orient": 0.085,
+        "layout": 0.013,
+        "region": 0.159,
+        "texture": 0.045,
+        "motion": 0.016,
+        "colour": 0.505
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2316,
+          0.1929,
+          0.1956,
+          0.1767,
+          0.2032
+        ],
+        "orient": [
+          0.0961,
+          0.0442,
+          0.0388,
+          0.0235,
+          0.0272,
+          0.0064
+        ],
+        "layout": [
+          0.0549,
+          0.0607,
+          0.0641,
+          0.0571,
+          0.0691,
+          0.0684,
+          0.0716,
+          0.0566,
+          0.0748,
+          0.0645,
+          0.0631,
+          0.0555,
+          0.06,
+          0.061,
+          0.0603,
+          0.0581
+        ],
+        "region": [
+          -0.0585,
+          -0.0734,
+          -0.0274,
+          0.0105,
+          -0.0362,
+          0.0713,
+          -0.0558,
+          -0.0784,
+          0.0607,
+          0.1924,
+          0.05,
+          0.1434,
+          0.0715,
+          -0.0504,
+          -0.0422,
+          -0.0738,
+          -0.0057,
+          0.0415,
+          0.0854,
+          0.0029,
+          0.0358,
+          -0.2125,
+          0.1126,
+          -0.2685,
+          0.0408,
+          0.0786,
+          -0.0146
+        ],
+        "texture": [
+          0.8084,
+          0.1253,
+          0.2551,
+          0.0297,
+          0.0169,
+          0.0323,
+          -0.0379
+        ],
+        "colour": [
+          0.0091,
+          0.0481,
+          0.2636,
+          0.0982,
+          0.1257,
+          0.4552,
+          0.4661,
+          0.439
+        ],
+        "motion": [
+          0.417,
+          0.2261,
+          0.1485,
+          0.1082,
+          0.1002,
+          0.0681,
+          0.0648,
+          0.0659,
+          0.0667,
+          0.0741,
+          0.0588,
+          0.0621,
+          0.062,
+          0.0735,
+          0.0618,
+          0.0515,
+          0.0561,
+          0.0636,
+          0.058,
+          0.0564,
+          0.0566
+        ]
+      }
+    },
+    "Isometric Blocks": {
+      "coverage": 0.728,
+      "bedCoverage": 0.561,
+      "bedCoverageMean": 0.743,
+      "variety": 0.047,
+      "blocks": {
+        "scale": 0.007,
+        "orient": 0.134,
+        "layout": 0.007,
+        "region": 0.071,
+        "texture": 0.051,
+        "motion": 0.013,
+        "colour": 0.488
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3257,
+          0.263,
+          0.1965,
+          0.1264,
+          0.0884
+        ],
+        "orient": [
+          0.1165,
+          0.02,
+          0.0275,
+          0.0273,
+          0.0231,
+          0.0299
+        ],
+        "layout": [
+          0.0573,
+          0.067,
+          0.0662,
+          0.0539,
+          0.0652,
+          0.0703,
+          0.0625,
+          0.0611,
+          0.0618,
+          0.0693,
+          0.0647,
+          0.0592,
+          0.058,
+          0.0601,
+          0.0638,
+          0.0595
+        ],
+        "region": [
+          -0.0237,
+          -0.0059,
+          -0.0144,
+          0.0601,
+          -0.0164,
+          0.0109,
+          -0.0753,
+          -0.0406,
+          -0.0064,
+          0.0905,
+          0.0524,
+          -0.0282,
+          0.0375,
+          -0.0019,
+          0.0125,
+          -0.0229,
+          -0.023,
+          -0.0017,
+          -0.0419,
+          -0.0194,
+          0.0252,
+          0.0111,
+          -0.0137,
+          0.0112,
+          -0.0354,
+          0.0685,
+          -0.0091
+        ],
+        "texture": [
+          0.9092,
+          0.2344,
+          0.3256,
+          0.0082,
+          0.0134,
+          0.1112,
+          -0.0434
+        ],
+        "colour": [
+          0.0288,
+          0.0393,
+          0.3422,
+          0.0918,
+          0.0745,
+          0.4234,
+          0.5729,
+          0.5332
+        ],
+        "motion": [
+          0.4697,
+          0.2476,
+          0.1373,
+          0.0784,
+          0.0669,
+          0.0734,
+          0.0659,
+          0.0562,
+          0.063,
+          0.0764,
+          0.0573,
+          0.049,
+          0.0653,
+          0.0759,
+          0.0545,
+          0.0502,
+          0.0621,
+          0.0674,
+          0.0581,
+          0.0604,
+          0.0648
+        ]
+      }
+    },
+    "Halftone Misprint": {
+      "coverage": 0.352,
+      "bedCoverage": 0,
+      "bedCoverageMean": 0.315,
+      "variety": 0.057,
+      "blocks": {
+        "scale": 0.007,
+        "orient": 0.114,
+        "layout": 0.03,
+        "region": 0.109,
+        "texture": 0.066,
+        "motion": 0.019,
+        "colour": 0.436
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.3649,
+          0.1866,
+          0.1298,
+          0.1535,
+          0.1652
+        ],
+        "orient": [
+          0.1463,
+          0.0374,
+          0.0235,
+          0.0181,
+          0.0165,
+          0.0229
+        ],
+        "layout": [
+          0.0625,
+          0.0726,
+          0.0633,
+          0.0571,
+          0.0566,
+          0.0758,
+          0.0738,
+          0.0726,
+          0.0595,
+          0.0604,
+          0.0602,
+          0.0567,
+          0.059,
+          0.0611,
+          0.0599,
+          0.049
+        ],
+        "region": [
+          0.0221,
+          0.0125,
+          0.0608,
+          0.1624,
+          -0.0445,
+          -0.0054,
+          -0.0112,
+          0.0105,
+          0.0137,
+          -0.0358,
+          -0.0419,
+          -0.0015,
+          0.0907,
+          -0.003,
+          0.0368,
+          0.0669,
+          0.0354,
+          -0.068,
+          -0.0719,
+          0.0029,
+          -0.0053,
+          -0.0183,
+          0.0021,
+          -0.0061,
+          -0.2048,
+          0.026,
+          -0.0251
+        ],
+        "texture": [
+          1.0765,
+          0.0524,
+          0.2934,
+          0.0184,
+          0.0199,
+          0.0416,
+          -0.0228
+        ],
+        "colour": [
+          0.0444,
+          0.0057,
+          0.3272,
+          0.0806,
+          0.3864,
+          0.1557,
+          0.657,
+          0.1907
+        ],
+        "motion": [
+          0.4477,
+          0.2206,
+          0.1246,
+          0.1062,
+          0.1009,
+          0.0642,
+          0.072,
+          0.0618,
+          0.058,
+          0.061,
+          0.0735,
+          0.0659,
+          0.0622,
+          0.0587,
+          0.0601,
+          0.0564,
+          0.0575,
+          0.0666,
+          0.0652,
+          0.0626,
+          0.0543
+        ]
+      }
+    },
+    "Droste Feedback": {
+      "coverage": 0.083,
+      "bedCoverage": 0,
+      "bedCoverageMean": 0.038,
+      "variety": 0.3,
+      "blocks": {
+        "scale": 0.179,
+        "orient": 0.201,
+        "layout": 0.504,
+        "region": 0.476,
+        "texture": 0.087,
+        "motion": 0.351,
+        "colour": 0.461
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.0942,
+          0.1296,
+          0.1598,
+          0.2068,
+          0.2429
+        ],
+        "orient": [
+          0.2238,
+          0.1779,
+          0.1511,
+          0.1264,
+          0.0974,
+          0.0797
+        ],
+        "layout": [
+          0.0181,
+          0.0233,
+          0.0324,
+          0,
+          0.0655,
+          0.1504,
+          0.1469,
+          0,
+          0.0447,
+          0.1524,
+          0.1314,
+          0,
+          0.0191,
+          0.0307,
+          0.0185,
+          0
+        ],
+        "region": [
+          -0.3398,
+          -0.032,
+          -0.5422,
+          0.202,
+          0.0103,
+          0.1352,
+          -0.8324,
+          -0.1465,
+          -0.8333,
+          0.178,
+          -0.0056,
+          0.4967,
+          2.3009,
+          0.2977,
+          2.3482,
+          -0.4002,
+          0.1406,
+          -0.3661,
+          -0.5403,
+          -0.0727,
+          -0.2389,
+          0.2613,
+          -0.0445,
+          -0.1845,
+          -0.8294,
+          -0.1474,
+          -0.815
+        ],
+        "texture": [
+          0.1071,
+          0.0166,
+          0.0448,
+          0.0242,
+          0.1176,
+          0.3118,
+          -0.0202
+        ],
+        "colour": [
+          0.0148,
+          0.0093,
+          0.2615,
+          0.2108,
+          0.0271,
+          0.3097,
+          0.0403,
+          0.0688
+        ],
+        "motion": [
+          0.2374,
+          0.1783,
+          0.1688,
+          0.141,
+          0.1079,
+          0.0222,
+          0.0491,
+          0.0412,
+          0,
+          0.059,
+          0.1304,
+          0.1343,
+          0,
+          0.0586,
+          0.1718,
+          0.1055,
+          0,
+          0.0174,
+          0.0304,
+          0.0136,
+          0
+        ]
+      }
+    },
+    "Analog Wow": {
+      "coverage": 0.883,
+      "bedCoverage": 0.683,
+      "bedCoverageMean": 0.883,
+      "variety": 0.045,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.045,
+        "layout": 0.014,
+        "region": 0.099,
+        "texture": 0.077,
+        "motion": 0.021,
+        "colour": 0.365
+      },
+      "readsHistory": true,
+      "profile": {
+        "scale": [
+          0.2249,
+          0.1789,
+          0.1847,
+          0.2075,
+          0.204
+        ],
+        "orient": [
+          0.297,
+          0.1343,
+          0.0815,
+          0.0469,
+          0.0306,
+          0.026
+        ],
+        "layout": [
+          0.0561,
+          0.0611,
+          0.0667,
+          0.0501,
+          0.0615,
+          0.0692,
+          0.0626,
+          0.0666,
+          0.0626,
+          0.073,
+          0.0696,
+          0.0589,
+          0.06,
+          0.063,
+          0.0596,
+          0.0595
+        ],
+        "region": [
+          -0.0452,
+          -0.0395,
+          0.0207,
+          0.045,
+          0.0107,
+          -0.0445,
+          -0.1082,
+          -0.0006,
+          0.0117,
+          0.0276,
+          0.0251,
+          0.0229,
+          0.1052,
+          -0.062,
+          -0.0013,
+          0.0039,
+          0.0603,
+          0.0315,
+          -0.0467,
+          -0.0259,
+          -0.0035,
+          0.0012,
+          0.0224,
+          -0.0535,
+          0.0172,
+          0.0095,
+          0.0161
+        ],
+        "texture": [
+          0.8788,
+          0.3581,
+          0.287,
+          0.0211,
+          0.0119,
+          0.0643,
+          0.0546
+        ],
+        "colour": [
+          0.0651,
+          0.0708,
+          0.1878,
+          0.2347,
+          0.1689,
+          0.2727,
+          0.6255,
+          0.4081
+        ],
+        "motion": [
+          0.4368,
+          0.264,
+          0.1425,
+          0.0864,
+          0.0703,
+          0.0617,
+          0.0687,
+          0.0606,
+          0.0568,
+          0.0642,
+          0.0643,
+          0.0587,
+          0.0694,
+          0.0735,
+          0.0623,
+          0.0493,
+          0.0651,
+          0.0728,
+          0.0578,
+          0.0581,
+          0.0567
+        ]
+      }
+    },
+    "Procession": {
+      "coverage": 0.34,
+      "bedCoverage": 0.031,
+      "bedCoverageMean": 0.267,
+      "variety": 0.188,
+      "blocks": {
+        "scale": 0.052,
+        "orient": 0.125,
+        "layout": 0.275,
+        "region": 0.414,
+        "texture": 0.1,
+        "motion": 0.165,
+        "colour": 0.422
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1757,
+          0.1556,
+          0.1803,
+          0.2467,
+          0.2418
+        ],
+        "orient": [
+          0.2105,
+          0.1296,
+          0.0946,
+          0.1193,
+          0.064,
+          0.0674
+        ],
+        "layout": [
+          0.0114,
+          0.0888,
+          0.05,
+          0.0372,
+          0.0273,
+          0.092,
+          0.083,
+          0.0433,
+          0.0918,
+          0.0581,
+          0.0926,
+          0.0648,
+          0.0768,
+          0.0553,
+          0.0777,
+          0.0501
+        ],
+        "region": [
+          -0.5569,
+          0.2101,
+          -0.4315,
+          0.2315,
+          -0.0062,
+          0.1328,
+          -0.3223,
+          -0.2286,
+          -0.344,
+          -0.1028,
+          0.1179,
+          -0.04,
+          0.453,
+          0.0007,
+          0.3465,
+          -0.0552,
+          -0.1216,
+          0.2354,
+          0.3325,
+          0.0709,
+          0.08,
+          0.0683,
+          0.0021,
+          0.1436,
+          -0.0483,
+          -0.0454,
+          -0.123
+        ],
+        "texture": [
+          0.634,
+          0.0779,
+          0.1452,
+          0.0383,
+          0.05,
+          0.0788,
+          0.0147
+        ],
+        "colour": [
+          0.1081,
+          0.0528,
+          0.1816,
+          0.2322,
+          0.2791,
+          0.1461,
+          0.5965,
+          0.2066
+        ],
+        "motion": [
+          0.2726,
+          0.2139,
+          0.1969,
+          0.1721,
+          0.1444,
+          0.0205,
+          0.075,
+          0.0511,
+          0.039,
+          0.023,
+          0.0862,
+          0.0734,
+          0.0444,
+          0.0983,
+          0.0727,
+          0.0792,
+          0.0517,
+          0.0935,
+          0.0512,
+          0.0895,
+          0.0514
+        ]
+      }
+    },
+    "Constellation": {
+      "coverage": 0.241,
+      "bedCoverage": 0.006,
+      "bedCoverageMean": 0.223,
+      "variety": 0.251,
+      "blocks": {
+        "scale": 0.058,
+        "orient": 0.092,
+        "layout": 0.495,
+        "region": 0.491,
+        "texture": 0.112,
+        "motion": 0.256,
+        "colour": 0.417
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1961,
+          0.1931,
+          0.2047,
+          0.1974,
+          0.2087
+        ],
+        "orient": [
+          0.1558,
+          0.1092,
+          0.0763,
+          0.1064,
+          0.0681,
+          0.0514
+        ],
+        "layout": [
+          0.0583,
+          0.0861,
+          0.0461,
+          0.0069,
+          0.0596,
+          0.1268,
+          0.1009,
+          0.0352,
+          0.0528,
+          0.1665,
+          0.0567,
+          0.0228,
+          0.0352,
+          0.0673,
+          0.0504,
+          0.0286
+        ],
+        "region": [
+          0.0858,
+          -0.101,
+          0.195,
+          0.1414,
+          0.0121,
+          0.1285,
+          -0.6048,
+          -0.0202,
+          -0.3084,
+          0.0381,
+          0.0257,
+          0.4834,
+          1.1834,
+          0.0446,
+          0.2197,
+          -0.4009,
+          0.1347,
+          -0.1224,
+          -0.3604,
+          -0.0481,
+          0.0238,
+          0.2723,
+          -0.0892,
+          -0.5469,
+          -0.3549,
+          0.0414,
+          -0.0726
+        ],
+        "texture": [
+          0.6542,
+          0.0919,
+          0.101,
+          0.0446,
+          0.0562,
+          0.0761,
+          -0.0076
+        ],
+        "colour": [
+          0.1035,
+          0.1313,
+          0.2339,
+          0.1878,
+          0.2643,
+          0.0793,
+          0.4673,
+          0.1588
+        ],
+        "motion": [
+          0.3733,
+          0.2223,
+          0.164,
+          0.1317,
+          0.1087,
+          0.0663,
+          0.0838,
+          0.0398,
+          0.0123,
+          0.0562,
+          0.0987,
+          0.1214,
+          0.0268,
+          0.0567,
+          0.1839,
+          0.0587,
+          0.0238,
+          0.0425,
+          0.0564,
+          0.0449,
+          0.0279
+        ]
+      }
+    },
+    "Soloist": {
+      "coverage": 0.38,
+      "bedCoverage": 0.112,
+      "bedCoverageMean": 0.378,
+      "variety": 0.192,
+      "blocks": {
+        "scale": 0.053,
+        "orient": 0.056,
+        "layout": 0.308,
+        "region": 0.443,
+        "texture": 0.125,
+        "motion": 0.169,
+        "colour": 0.414
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1533,
+          0.1368,
+          0.157,
+          0.2036,
+          0.3493
+        ],
+        "orient": [
+          0.2902,
+          0.1909,
+          0.1474,
+          0.132,
+          0.0783,
+          0.0356
+        ],
+        "layout": [
+          0.0424,
+          0.1341,
+          0.0667,
+          0.0257,
+          0.0401,
+          0.1571,
+          0.0797,
+          0.033,
+          0.0303,
+          0.1225,
+          0.0617,
+          0.0214,
+          0.0375,
+          0.0856,
+          0.0439,
+          0.0182
+        ],
+        "region": [
+          -0.0182,
+          0.0993,
+          0.1201,
+          0.8825,
+          -0.0035,
+          0.0222,
+          -0.3991,
+          -0.0955,
+          -0.2053,
+          -0.3385,
+          0.1419,
+          0.4477,
+          1.0182,
+          0.0311,
+          0.0853,
+          -0.5018,
+          0.0068,
+          -0.0477,
+          -0.3937,
+          -0.1072,
+          -0.0427,
+          0.3992,
+          0.0102,
+          -0.1534,
+          -0.6486,
+          -0.083,
+          -0.2263
+        ],
+        "texture": [
+          0.7595,
+          0.1994,
+          0.1424,
+          0.0448,
+          0.0545,
+          0.1338,
+          0.0246
+        ],
+        "colour": [
+          0.1135,
+          0.0189,
+          0.3087,
+          0.1077,
+          0.1969,
+          0.2544,
+          0.6329,
+          0.2227
+        ],
+        "motion": [
+          0.3063,
+          0.2115,
+          0.1771,
+          0.1507,
+          0.1544,
+          0.0525,
+          0.1352,
+          0.059,
+          0.0319,
+          0.0619,
+          0.1577,
+          0.0594,
+          0.0314,
+          0.0383,
+          0.134,
+          0.0422,
+          0.0172,
+          0.0419,
+          0.0834,
+          0.0455,
+          0.0084
+        ]
+      }
+    },
+    "Swarm": {
+      "coverage": 0.143,
+      "bedCoverage": 0.037,
+      "bedCoverageMean": 0.126,
+      "variety": 0.19,
+      "blocks": {
+        "scale": 0.014,
+        "orient": 0.063,
+        "layout": 0.368,
+        "region": 0.432,
+        "texture": 0.068,
+        "motion": 0.194,
+        "colour": 0.38
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.1881,
+          0.1956,
+          0.2169,
+          0.2121,
+          0.1873
+        ],
+        "orient": [
+          0.1526,
+          0.0977,
+          0.0555,
+          0.1209,
+          0.0636,
+          0.0684
+        ],
+        "layout": [
+          0.0433,
+          0.061,
+          0.0506,
+          0.0353,
+          0.0667,
+          0.121,
+          0.05,
+          0.0351,
+          0.101,
+          0.1031,
+          0.0987,
+          0.0173,
+          0.0414,
+          0.0669,
+          0.0849,
+          0.0237
+        ],
+        "region": [
+          -0.1741,
+          0.0092,
+          -0.2084,
+          0.0323,
+          0.1298,
+          -0.1914,
+          -0.369,
+          0.067,
+          -0.2702,
+          0.4933,
+          -0.021,
+          0.1036,
+          0.4441,
+          0.0675,
+          0.5185,
+          -0.3563,
+          0.0268,
+          -0.0908,
+          0.0166,
+          -0.028,
+          -0.0639,
+          0.3802,
+          -0.094,
+          0.3386,
+          -0.467,
+          -0.1572,
+          -0.136
+        ],
+        "texture": [
+          0.2925,
+          0.0404,
+          0.131,
+          0.0434,
+          0.0456,
+          0.0674,
+          -0.0001
+        ],
+        "colour": [
+          0.0841,
+          0.0836,
+          0.2893,
+          0.1665,
+          0.2599,
+          0.1166,
+          0.5645,
+          0.0944
+        ],
+        "motion": [
+          0.383,
+          0.2233,
+          0.1651,
+          0.128,
+          0.1005,
+          0.0525,
+          0.0682,
+          0.0433,
+          0.0331,
+          0.0485,
+          0.1053,
+          0.043,
+          0.0407,
+          0.1042,
+          0.1016,
+          0.1007,
+          0.028,
+          0.0379,
+          0.0733,
+          0.0968,
+          0.0228
+        ]
+      }
+    },
+    "Effigy": {
+      "coverage": 0.153,
+      "bedCoverage": 0.012,
+      "bedCoverageMean": 0.144,
+      "variety": 0.252,
+      "blocks": {
+        "scale": 0.011,
+        "orient": 0.101,
+        "layout": 0.515,
+        "region": 0.482,
+        "texture": 0.15,
+        "motion": 0.255,
+        "colour": 0.405
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.221,
+          0.1761,
+          0.1857,
+          0.2077,
+          0.2095
+        ],
+        "orient": [
+          0.2078,
+          0.1685,
+          0.1105,
+          0.1171,
+          0.076,
+          0.0514
+        ],
+        "layout": [
+          0.0219,
+          0.095,
+          0.0638,
+          0.0101,
+          0.138,
+          0.2104,
+          0.1023,
+          0.0176,
+          0.0428,
+          0.0883,
+          0.0709,
+          0.0111,
+          0.0294,
+          0.0297,
+          0.0507,
+          0.0182
+        ],
+        "region": [
+          -0.1092,
+          -0.1717,
+          -0.1731,
+          1.3344,
+          0.0374,
+          0.7985,
+          -0.8608,
+          -0.1615,
+          -0.4549,
+          0.4785,
+          0.1238,
+          0.2712,
+          1.2322,
+          0.215,
+          0.4151,
+          -0.6631,
+          0.0066,
+          -0.2158,
+          -0.5257,
+          -0.082,
+          -0.0534,
+          -0.1965,
+          0.0031,
+          -0.3821,
+          -0.6899,
+          0.0294,
+          -0.2054
+        ],
+        "texture": [
+          0.5587,
+          0.1351,
+          0.0792,
+          0.0333,
+          0.0234,
+          0.0681,
+          -0.0037
+        ],
+        "colour": [
+          0.0498,
+          0.0566,
+          0.1885,
+          0.2181,
+          0.3437,
+          0.1433,
+          0.4868,
+          0.072
+        ],
+        "motion": [
+          0.3588,
+          0.2329,
+          0.1622,
+          0.1306,
+          0.1155,
+          0.0264,
+          0.1049,
+          0.0616,
+          0.009,
+          0.1274,
+          0.2448,
+          0.0855,
+          0.0223,
+          0.0444,
+          0.109,
+          0.059,
+          0.0086,
+          0.0319,
+          0.0214,
+          0.0257,
+          0.018
+        ]
+      }
+    },
+    "Mountain Flight": {
+      "coverage": 0.455,
+      "bedCoverage": 0.112,
+      "bedCoverageMean": 0.458,
+      "variety": 0.231,
+      "blocks": {
+        "scale": 0.028,
+        "orient": 0.128,
+        "layout": 0.421,
+        "region": 0.456,
+        "texture": 0.104,
+        "motion": 0.252,
+        "colour": 0.454
+      },
+      "readsHistory": false,
+      "profile": {
+        "scale": [
+          0.2229,
+          0.1644,
+          0.1652,
+          0.1789,
+          0.2686
+        ],
+        "orient": [
+          0.1038,
+          0.0592,
+          0.0661,
+          0.0568,
+          0.0512,
+          0.0233
+        ],
+        "layout": [
+          0.0634,
+          0.0542,
+          0.0463,
+          0.0418,
+          0.096,
+          0.0635,
+          0.0549,
+          0.0494,
+          0.1115,
+          0.0578,
+          0.0724,
+          0.0367,
+          0.0988,
+          0.0595,
+          0.0631,
+          0.0307
+        ],
+        "region": [
+          0.0104,
+          0.0392,
+          -0.3098,
+          -0.0583,
+          -0.0657,
+          -0.204,
+          -0.3126,
+          -0.0054,
+          -0.0605,
+          0.4417,
+          0.031,
+          -0.0164,
+          0.0226,
+          -0.0631,
+          -0.1219,
+          -0.1397,
+          0.2272,
+          0.5444,
+          0.3816,
+          -0.0594,
+          0.1818,
+          0.0668,
+          -0.0607,
+          -0.2155,
+          -0.4125,
+          -0.043,
+          0.2019
+        ],
+        "texture": [
+          0.7729,
+          0.1465,
+          0.1912,
+          0.0419,
+          0.0073,
+          0.0349,
+          -0.0226
+        ],
+        "colour": [
+          0.0866,
+          0.0407,
+          0.2761,
+          0.1152,
+          0.337,
+          0.1445,
+          0.5503,
+          0.2418
+        ],
+        "motion": [
+          0.3162,
+          0.1963,
+          0.1548,
+          0.1414,
+          0.1914,
+          0.0708,
+          0.0532,
+          0.0469,
+          0.0409,
+          0.092,
+          0.0551,
+          0.049,
+          0.0465,
+          0.1209,
+          0.0658,
+          0.0644,
+          0.0404,
+          0.119,
+          0.0494,
+          0.046,
+          0.0396
+        ]
+      }
+    }
+  }
+}
diff --git a/flow-state/src/scenes/shader/aqueduct-march.js b/flow-state/src/scenes/shader/aqueduct-march.js
index 091445e..8d14524 100644
--- a/flow-state/src/scenes/shader/aqueduct-march.js
+++ b/flow-state/src/scenes/shader/aqueduct-march.js
@@ -20,8 +20,6 @@ export const aqueductMarch = {
     name: 'Aqueduct March',
     family: 'structural',
     kind: 'fragment',
-    // Paints 27% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     texture: 0.9,
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'space', 'style'],
diff --git a/flow-state/src/scenes/shader/aurora-veil.js b/flow-state/src/scenes/shader/aurora-veil.js
index 540c616..4a4375b 100644
--- a/flow-state/src/scenes/shader/aurora-veil.js
+++ b/flow-state/src/scenes/shader/aurora-veil.js
@@ -13,8 +13,6 @@ export const auroraVeil = {
     name: 'Aurora Veil',
     family: 'flow',
     kind: 'fragment',
-    // Paints 13% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/cargo-belt.js b/flow-state/src/scenes/shader/cargo-belt.js
index 5df46e4..fde1b44 100644
--- a/flow-state/src/scenes/shader/cargo-belt.js
+++ b/flow-state/src/scenes/shader/cargo-belt.js
@@ -13,8 +13,6 @@ export const cargoBelt = {
     name: 'Cargo Belt',
     family: 'structural',
     kind: 'fragment',
-    // Paints 12% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Takes the track's surface grain, but lightly — this is drawn, not filmed.
     texture: 0.4,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/circuit-bloom.js b/flow-state/src/scenes/shader/circuit-bloom.js
index 2fe3390..8d7fdbe 100644
--- a/flow-state/src/scenes/shader/circuit-bloom.js
+++ b/flow-state/src/scenes/shader/circuit-bloom.js
@@ -13,8 +13,6 @@ export const circuitBloom = {
     name: 'Circuit Bloom',
     family: 'geometric',
     kind: 'fragment',
-    // Paints 1% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Takes the track's surface grain, but lightly — this is drawn, not filmed.
     texture: 0.4,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/curl-flow.js b/flow-state/src/scenes/shader/curl-flow.js
index be8ed26..7557d60 100644
--- a/flow-state/src/scenes/shader/curl-flow.js
+++ b/flow-state/src/scenes/shader/curl-flow.js
@@ -8,8 +8,6 @@ export const curlFlow = {
     name: 'Curl Flow',
     family: 'flow',
     kind: 'fragment',
-    // Paints 21% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
diff --git a/flow-state/src/scenes/shader/data-aisle.js b/flow-state/src/scenes/shader/data-aisle.js
index 008451a..84ca800 100644
--- a/flow-state/src/scenes/shader/data-aisle.js
+++ b/flow-state/src/scenes/shader/data-aisle.js
@@ -11,8 +11,6 @@ export const dataAisle = {
     name: 'Data Aisle',
     family: 'structural',
     kind: 'fragment',
-    // Paints 21% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     texture: 0.6,
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
diff --git a/flow-state/src/scenes/shader/droste-feedback.js b/flow-state/src/scenes/shader/droste-feedback.js
index 585e64b..80a1e82 100644
--- a/flow-state/src/scenes/shader/droste-feedback.js
+++ b/flow-state/src/scenes/shader/droste-feedback.js
@@ -21,8 +21,6 @@ export const drosteFeedback = {
     name: 'Droste Feedback',
     family: 'glitch',
     kind: 'fragment',
-    // Paints 2% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     texture: 0.5,
     consumes: ['ink'],
     traits: ['camera', 'style'],
diff --git a/flow-state/src/scenes/shader/dust-chamber.js b/flow-state/src/scenes/shader/dust-chamber.js
index c2b3bd7..9b93868 100644
--- a/flow-state/src/scenes/shader/dust-chamber.js
+++ b/flow-state/src/scenes/shader/dust-chamber.js
@@ -13,8 +13,6 @@ export const dustChamber = {
     name: 'Dust Chamber',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 2% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/eclipse-field.js b/flow-state/src/scenes/shader/eclipse-field.js
index 413bbf2..9796f39 100644
--- a/flow-state/src/scenes/shader/eclipse-field.js
+++ b/flow-state/src/scenes/shader/eclipse-field.js
@@ -16,8 +16,6 @@ export const eclipseField = {
     name: 'Eclipse Field',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 17% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Crisp line work: the track's surface grain would only fur the edges.
     texture: 0,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/firefly-drift.js b/flow-state/src/scenes/shader/firefly-drift.js
index 3d5eb97..9175806 100644
--- a/flow-state/src/scenes/shader/firefly-drift.js
+++ b/flow-state/src/scenes/shader/firefly-drift.js
@@ -9,8 +9,6 @@ export const fireflyDrift = {
     name: 'Firefly Drift',
     family: 'flow',
     kind: 'fragment',
-    // Paints 2% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['cast', 'ink', 'staging'],
     traits: ['camera', 'style'],
diff --git a/flow-state/src/scenes/shader/flora.js b/flow-state/src/scenes/shader/flora.js
index cfed31b..b614b09 100644
--- a/flow-state/src/scenes/shader/flora.js
+++ b/flow-state/src/scenes/shader/flora.js
@@ -11,8 +11,6 @@ export const flora = {
     name: 'Flora',
     family: 'organic',
     kind: 'fragment',
-    // Paints 15% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/gate-corridor.js b/flow-state/src/scenes/shader/gate-corridor.js
index 598097a..abeb8ec 100644
--- a/flow-state/src/scenes/shader/gate-corridor.js
+++ b/flow-state/src/scenes/shader/gate-corridor.js
@@ -14,8 +14,6 @@ export const gateCorridor = {
     name: 'Gate Corridor',
     family: 'structural',
     kind: 'fragment',
-    // Paints 29% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Takes the track's surface grain, but lightly — this is drawn, not filmed.
     texture: 0.4,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/horizon-lines.js b/flow-state/src/scenes/shader/horizon-lines.js
index f8a8b3b..d2cc0a2 100644
--- a/flow-state/src/scenes/shader/horizon-lines.js
+++ b/flow-state/src/scenes/shader/horizon-lines.js
@@ -6,8 +6,6 @@ export const horizonLines = {
     name: 'Horizon Lines',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 16% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // Crisp line work: the track's surface grain would only fur the edges.
     texture: 0,
diff --git a/flow-state/src/scenes/shader/ink-bleed.js b/flow-state/src/scenes/shader/ink-bleed.js
index b81e889..635c619 100644
--- a/flow-state/src/scenes/shader/ink-bleed.js
+++ b/flow-state/src/scenes/shader/ink-bleed.js
@@ -13,8 +13,6 @@ export const inkBleed = {
     name: 'Ink Bleed',
     family: 'organic',
     kind: 'fragment',
-    // Paints 1% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/magnet-lines.js b/flow-state/src/scenes/shader/magnet-lines.js
index 1259f55..90ca689 100644
--- a/flow-state/src/scenes/shader/magnet-lines.js
+++ b/flow-state/src/scenes/shader/magnet-lines.js
@@ -12,8 +12,6 @@ export const magnetLines = {
     name: 'Magnet Lines',
     family: 'flow',
     kind: 'fragment',
-    // Paints 18% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Line work. Grain furs it up, so take only a dusting.
     texture: 0.5,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/metaballs.js b/flow-state/src/scenes/shader/metaballs.js
index fd2b142..24a3893 100644
--- a/flow-state/src/scenes/shader/metaballs.js
+++ b/flow-state/src/scenes/shader/metaballs.js
@@ -7,8 +7,6 @@ export const metaballs = {
     name: 'Metaballs',
     family: 'organic',
     kind: 'fragment',
-    // Paints 26% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['cast', 'ink', 'staging'],
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/mycelium-web.js b/flow-state/src/scenes/shader/mycelium-web.js
index 1313daa..c439459 100644
--- a/flow-state/src/scenes/shader/mycelium-web.js
+++ b/flow-state/src/scenes/shader/mycelium-web.js
@@ -12,8 +12,6 @@ export const myceliumWeb = {
     name: 'Mycelium Web',
     family: 'organic',
     kind: 'fragment',
-    // Paints 22% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/neon-city.js b/flow-state/src/scenes/shader/neon-city.js
index b98d8f6..f713753 100644
--- a/flow-state/src/scenes/shader/neon-city.js
+++ b/flow-state/src/scenes/shader/neon-city.js
@@ -11,8 +11,6 @@ export const neonCity = {
     name: 'Neon City',
     family: 'structural',
     kind: 'fragment',
-    // Paints 26% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['ink'],
     traits: ['space', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/pendulum-trace.js b/flow-state/src/scenes/shader/pendulum-trace.js
index 3876ec5..489674c 100644
--- a/flow-state/src/scenes/shader/pendulum-trace.js
+++ b/flow-state/src/scenes/shader/pendulum-trace.js
@@ -13,8 +13,6 @@ export const pendulumTrace = {
     name: 'Pendulum Trace',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 0% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Fine line work; grain only furs it up.
     texture: 0.25,
     consumes: ['ink'],
diff --git a/flow-state/src/scenes/shader/prism-bloom.js b/flow-state/src/scenes/shader/prism-bloom.js
index db56e7a..7df70ae 100644
--- a/flow-state/src/scenes/shader/prism-bloom.js
+++ b/flow-state/src/scenes/shader/prism-bloom.js
@@ -7,8 +7,6 @@ export const prismBloom = {
     name: 'Prism Bloom',
     family: 'geometric',
     kind: 'fragment',
-    // Paints 1% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // Crisp line work: the track's surface grain would only fur the edges.
     texture: 0,
diff --git a/flow-state/src/scenes/shader/psychedelic-drift.js b/flow-state/src/scenes/shader/psychedelic-drift.js
index b033b5c..ed7a978 100644
--- a/flow-state/src/scenes/shader/psychedelic-drift.js
+++ b/flow-state/src/scenes/shader/psychedelic-drift.js
@@ -9,8 +9,6 @@ export const psychedelicDrift = {
     name: 'Psychedelic Drift',
     family: 'glitch',
     kind: 'fragment',
-    // Paints 6% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/pylon-grid.js b/flow-state/src/scenes/shader/pylon-grid.js
index 79c9014..520b2cd 100644
--- a/flow-state/src/scenes/shader/pylon-grid.js
+++ b/flow-state/src/scenes/shader/pylon-grid.js
@@ -48,8 +48,6 @@ export const pylonGrid = {
     name: 'Pylon Grid',
     family: 'structural',
     kind: 'fragment',
-    // Paints 25% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // Takes the track's surface grain, but lightly — this is drawn, not filmed.
     texture: 0.4,
diff --git a/flow-state/src/scenes/shader/ridge-terrain.js b/flow-state/src/scenes/shader/ridge-terrain.js
index a688466..3e28613 100644
--- a/flow-state/src/scenes/shader/ridge-terrain.js
+++ b/flow-state/src/scenes/shader/ridge-terrain.js
@@ -7,8 +7,6 @@ export const ridgeTerrain = {
     name: 'Ridge Terrain',
     family: 'structural',
     kind: 'fragment',
-    // Paints 13% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['ink'],
     traits: ['space', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/shoji-grid.js b/flow-state/src/scenes/shader/shoji-grid.js
index d4e815c..d6419f1 100644
--- a/flow-state/src/scenes/shader/shoji-grid.js
+++ b/flow-state/src/scenes/shader/shoji-grid.js
@@ -12,8 +12,6 @@ export const shojiGrid = {
     name: 'Shoji Grid',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 23% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Paper has a tooth, and this is the one scene that wants it.
     texture: 1.0,
     consumes: ['cast', 'ink'],
diff --git a/flow-state/src/scenes/shader/signal-decay.js b/flow-state/src/scenes/shader/signal-decay.js
index aef59d0..c2cc5cd 100644
--- a/flow-state/src/scenes/shader/signal-decay.js
+++ b/flow-state/src/scenes/shader/signal-decay.js
@@ -10,8 +10,6 @@ export const signalDecay = {
     name: 'Signal Decay',
     family: 'glitch',
     kind: 'fragment',
-    // Paints 5% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'style'],
 
diff --git a/flow-state/src/scenes/shader/silk-ribbon.js b/flow-state/src/scenes/shader/silk-ribbon.js
index 3014648..74f7290 100644
--- a/flow-state/src/scenes/shader/silk-ribbon.js
+++ b/flow-state/src/scenes/shader/silk-ribbon.js
@@ -8,8 +8,6 @@ export const silkRibbon = {
     name: 'Silk Ribbon',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 3% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // A soft drape of light. Grain furs the one thing it is made of.
     texture: 0,
diff --git a/flow-state/src/scenes/shader/slow-orb.js b/flow-state/src/scenes/shader/slow-orb.js
index 12080a1..676df4c 100644
--- a/flow-state/src/scenes/shader/slow-orb.js
+++ b/flow-state/src/scenes/shader/slow-orb.js
@@ -9,8 +9,6 @@ export const slowOrb = {
     name: 'Slow Orb',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 11% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // One soft body in an empty frame — the emptiest scene in the library, and
     // the one where speckle is most visible for being least justified. It keeps
diff --git a/flow-state/src/scenes/shader/smoke-column.js b/flow-state/src/scenes/shader/smoke-column.js
index f98f65e..90137c6 100644
--- a/flow-state/src/scenes/shader/smoke-column.js
+++ b/flow-state/src/scenes/shader/smoke-column.js
@@ -12,8 +12,6 @@ export const smokeColumn = {
     name: 'Smoke Column',
     family: 'flow',
     kind: 'fragment',
-    // Paints 16% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/spectrum-sculpture.js b/flow-state/src/scenes/shader/spectrum-sculpture.js
index 616e74d..1ba6fe7 100644
--- a/flow-state/src/scenes/shader/spectrum-sculpture.js
+++ b/flow-state/src/scenes/shader/spectrum-sculpture.js
@@ -9,8 +9,6 @@ export const spectrumSculpture = {
     name: 'Spectrum Sculpture',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 2% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     // Takes the track's surface grain, but lightly — this is drawn, not filmed.
     texture: 0.4,
diff --git a/flow-state/src/scenes/shader/storm-rift.js b/flow-state/src/scenes/shader/storm-rift.js
index a4a1660..67e2f6d 100644
--- a/flow-state/src/scenes/shader/storm-rift.js
+++ b/flow-state/src/scenes/shader/storm-rift.js
@@ -13,8 +13,6 @@ export const stormRift = {
     name: 'Storm Rift',
     family: 'glitch',
     kind: 'fragment',
-    // Paints 0% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['ink'],
     traits: ['camera', 'space', 'style'],
 
diff --git a/flow-state/src/scenes/shader/suspension-span.js b/flow-state/src/scenes/shader/suspension-span.js
index 0cdcb0c..636a720 100644
--- a/flow-state/src/scenes/shader/suspension-span.js
+++ b/flow-state/src/scenes/shader/suspension-span.js
@@ -12,8 +12,6 @@ export const suspensionSpan = {
     name: 'Suspension Span',
     family: 'structural',
     kind: 'fragment',
-    // Paints 21% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     texture: 0.6,
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'space', 'style'],
diff --git a/flow-state/src/scenes/shader/synthwave-run.js b/flow-state/src/scenes/shader/synthwave-run.js
index ada763c..342f3ba 100644
--- a/flow-state/src/scenes/shader/synthwave-run.js
+++ b/flow-state/src/scenes/shader/synthwave-run.js
@@ -10,8 +10,6 @@ export const synthwaveRun = {
     name: 'Synthwave Run',
     family: 'structural',
     kind: 'fragment',
-    // Paints 5% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     // Personality: see look/Personality.js.
     consumes: ['ink'],
     traits: ['space', 'camera', 'style'],
diff --git a/flow-state/src/scenes/shader/vortex-drift.js b/flow-state/src/scenes/shader/vortex-drift.js
index 9fb19ff..0c334e8 100644
--- a/flow-state/src/scenes/shader/vortex-drift.js
+++ b/flow-state/src/scenes/shader/vortex-drift.js
@@ -13,8 +13,6 @@ export const vortexDrift = {
     name: 'Vortex Drift',
     family: 'flow',
     kind: 'fragment',
-    // Paints 21% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['cast', 'ink'],
     traits: ['shape', 'camera', 'style'],
 
diff --git a/flow-state/src/scenes/stage/constellation.js b/flow-state/src/scenes/stage/constellation.js
index 9204a92..b513608 100644
--- a/flow-state/src/scenes/stage/constellation.js
+++ b/flow-state/src/scenes/stage/constellation.js
@@ -8,8 +8,6 @@ export const constellation = {
     name: 'Constellation',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 1% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['cast', 'ink', 'staging'],
     texture: 0.6,
     traits: ['shape', 'camera', 'space', 'style'],
diff --git a/flow-state/src/scenes/stage/effigy.js b/flow-state/src/scenes/stage/effigy.js
index da389b4..5e83d6d 100644
--- a/flow-state/src/scenes/stage/effigy.js
+++ b/flow-state/src/scenes/stage/effigy.js
@@ -15,7 +15,6 @@ export const effigy = {
     family: 'geometric',
     // One object against a dark wash — most of the frame is legitimately empty,
     // and it reads as something standing in a space rather than as the space.
-    surface: 'composable',
     kind: 'fragment',
     consumes: ['form', 'ink', 'staging'],
     texture: 0.6,
diff --git a/flow-state/src/scenes/stage/procession.js b/flow-state/src/scenes/stage/procession.js
index bd2e921..dac8d2e 100644
--- a/flow-state/src/scenes/stage/procession.js
+++ b/flow-state/src/scenes/stage/procession.js
@@ -9,8 +9,6 @@ export const procession = {
     name: 'Procession',
     family: 'structural',
     kind: 'fragment',
-    // Paints 18% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['cast', 'ink', 'staging'],
     texture: 0.4,
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/stage/soloist.js b/flow-state/src/scenes/stage/soloist.js
index 1f76043..deb46af 100644
--- a/flow-state/src/scenes/stage/soloist.js
+++ b/flow-state/src/scenes/stage/soloist.js
@@ -8,8 +8,6 @@ export const soloist = {
     name: 'Soloist',
     family: 'minimal',
     kind: 'fragment',
-    // Paints 20% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['cast', 'ink', 'staging'],
     texture: 0.5,
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/stage/swarm.js b/flow-state/src/scenes/stage/swarm.js
index ffbf9eb..97505b9 100644
--- a/flow-state/src/scenes/stage/swarm.js
+++ b/flow-state/src/scenes/stage/swarm.js
@@ -16,8 +16,6 @@ export const swarm = {
     name: 'Swarm',
     family: 'organic',
     kind: 'fragment',
-    // Paints 2% of the frame — see checks/phase12 coverage.
-    surface: 'composable',
     consumes: ['form', 'ink', 'staging'],
     texture: 0.5,
     traits: ['shape', 'camera', 'style'],
diff --git a/flow-state/src/scenes/surface.js b/flow-state/src/scenes/surface.js
new file mode 100644
index 0000000..8377a56
--- /dev/null
+++ b/flow-state/src/scenes/surface.js
@@ -0,0 +1,241 @@
+// What the measurements MEAN — the thresholds and the rules, kept apart from
+// the numbers they read.
+//
+// scenes/metadata.json is generated and holds no opinions: it says a scene
+// paints 32% of the frame across six songs and nothing about whether that is
+// enough. This file is where that becomes a decision, and it is hand-written
+// precisely because a threshold is a judgement about the videos rather than a
+// fact about the library.
+//
+// `surface` used to be declared in each scene file, and it drifted: nine scenes
+// said `canvas` while painting under a third of the frame, which is how a
+// section ended up standing on a few bright things and black. It is derived
+// now. A scene cannot lie about what it paints, because nobody writes it down.
+
+import metadata from './metadata.json';
+import { readsHistory } from '../params/schema.js';
+
+/**
+ * The line between a picture and elements on one.
+ *
+ * Half the frame. Under it a scene is not somewhere a shot can happen — it is
+ * the shot, or something in it, and what would be behind it is black.
+ *
+ * The same number does both jobs on purpose: `canvas` and "may be a ground" are
+ * one idea, and having a scene that is a canvas but not ground-capable would be
+ * a distinction with nothing behind it.
+ */
+export const GROUND_MIN = 0.5;
+
+/**
+ * The bias a GROUND is sampled with, wherever it appears.
+ *
+ * A bed is not sampled like a shot. It keeps a density floor whatever the
+ * section wants — an intro biased sparse would otherwise draw the ground at
+ * density zero and be thin again for a new reason — and it sits back through
+ * energy and motion instead.
+ *
+ * Defined here rather than in the generator because the measurement has to use
+ * it too. Coverage depends enormously on parameters: Metaballs paints 69% of
+ * the frame sampled as a drop's shot and 27% sampled as an intro's bed, and a
+ * label taken at the first bias tells you nothing about the second. So the
+ * number that decides whether a scene may be a ground is measured AS a ground.
+ * One definition, both places, or the two silently disagree.
+ */
+export const GROUND_BIAS = { energy: 0.5, density: 0.45, motion: 0.3 };
+
+/**
+ * The hand a GROUND is drawn with.
+ *
+ * `extremity` is how far toward the ends of its own ranges a track pushes every
+ * parameter, and it is the right dial for a shot: the ends are where a scene is
+ * most itself. It is the wrong dial for a bed. Half of what decides how much a
+ * scene paints is a parameter with no `bias` key at all — Metaballs' threshold,
+ * for one — so extremity is the only thing moving it, and one end of that range
+ * is an empty frame. Measured: a ground drawn at the track's own temperament
+ * landed on threshold 1.85 of 2.0 and painted 6% of the frame, while the same
+ * scene measures 58% drawn moderately.
+ *
+ * So a bed is drawn near the middle and the extremes are left to the shot,
+ * which is also the right instinct visually.
+ */
+export function groundTemperamentFrom(temperament) {
+    if (!temperament) return temperament;
+    return { ...temperament, extremity: temperament.extremity * 0.2, intensity: 0 };
+}
+
+/**
+ * The song's hand, as it applies to a GROUND.
+ *
+ * The ink treatment — hatch, stipple, halftone, hollow — is how the song draws.
+ * `hollow` draws outlines and no fill at all, which is a strong, legible
+ * identity for the thing the section is ABOUT and a disaster for the thing it
+ * stands on: a scene that paints 61% of the frame averaged over six identities
+ * paints 2% in the song that asked for outlines, and the section renders black
+ * with a ground under it. Measured, holding grounds to their worst identity
+ * instead left four castable beds in the whole library.
+ *
+ * So the world is drawn solid and the hand is kept for the subject. Everything
+ * else about the identity — the cast, the lattice, the line weight, the
+ * palette — reaches the ground untouched, so it is still unmistakably this
+ * song's world.
+ */
+export function groundPersonalityFrom(personality) {
+    if (!personality || !personality.identity || !personality.identity.ink) return personality;
+    const { identity } = personality;
+    if (identity.ink.fill !== 'hollow') return personality;
+    return {
+        ...personality,
+        identity: { ...identity, ink: { ...identity.ink, fill: 'flat' } },
+    };
+}
+
+/** The bias `ground` would be sampled with inside `section`. */
+export function groundBiasFrom(bias) {
+    return {
+        ...bias,
+        // FLOORS, not reductions, on both of the axes that fill a frame.
+        //
+        // The first version of this lowered energy to make the bed sit back,
+        // which turned out to be precisely how to empty it: scenes bias the
+        // parameters that decide how much they paint against `energy` as often
+        // as against `density` — Metaballs sizes its blobs on energy, so an
+        // intro's ground drew radius 0.14 out of a 0.1–0.6 range and painted 4%
+        // of the frame. A bed sits back through MOTION, which costs it nothing
+        // in coverage, and through being behind everything else.
+        density: Math.max(GROUND_BIAS.density, bias.density),
+        energy: Math.max(GROUND_BIAS.energy, bias.energy),
+        motion: Math.max(0, (bias.motion ?? 0.5) - 0.2),
+    };
+}
+
+/**
+ * What a scene is, compositionally.
+ *
+ *   canvas      fills the frame. Belongs underneath, and two of them stacked is
+ *               two pictures fighting rather than one picture with depth.
+ *   composable  mostly empty by design. Reads as elements ON something, and
+ *               shown alone it is a few bright things on black — which scores
+ *               well for variety and is thin to watch.
+ */
+export const SURFACES = ['canvas', 'composable'];
+
+const ROW = (module) => (metadata.scenes && metadata.scenes[module.name]) || null;
+
+/**
+ * Coverage for a scene nobody has measured.
+ *
+ * Two ways to land here: a `layer3d`, which the measuring pass does not render,
+ * and a scene added since the last refresh. Deliberately pessimistic — an
+ * unmeasured scene must not be able to talk its way into the ground slot, which
+ * `canGround` enforces by requiring a real row rather than by trusting this.
+ */
+const ASSUMED_COVERAGE = 0.15;
+
+export function coverageOf(module) {
+    const row = ROW(module);
+    return row ? row.coverage : ASSUMED_COVERAGE;
+}
+
+/**
+ * How much this scene paints when it is used as a BED — measured at
+ * GROUND_BIAS, which is the only figure that answers the question `canGround`
+ * asks. See GROUND_BIAS for why the two numbers differ so much.
+ */
+export function groundCoverageOf(module) {
+    const row = ROW(module);
+    if (!row) return ASSUMED_COVERAGE;
+    if (row.bedCoverageMean !== undefined) return row.bedCoverageMean;
+    return row.bedCoverage === undefined ? row.coverage : row.bedCoverage;
+}
+
+/**
+ * What this scene paints as a bed in the IDENTITY THAT SUITS IT LEAST.
+ *
+ * A song's identity can gut a scene's fill — `hollow` ink draws outlines and no
+ * fill, a dark palette drops it under the threshold — and the spread is wide:
+ * Metaballs paints 61% averaged over six identities and 14% in the worst of
+ * them, which is a black frame with a ground under it.
+ *
+ * Held as a SEPARATE, lower bar rather than as the eligibility number. Demanding
+ * the worst case clear 50% leaves four castable grounds in the whole library —
+ * every video in the world standing on one of four beds is a worse failure than
+ * an occasional dim intro. So: fills the frame on average, and never vanishes.
+ */
+export function groundFloorCoverageOf(module) {
+    const row = ROW(module);
+    if (!row) return ASSUMED_COVERAGE;
+    return row.bedCoverage === undefined ? groundCoverageOf(module) : row.bedCoverage;
+}
+
+/** A ground may dim under a hostile identity. It may not disappear. */
+export const GROUND_FLOOR_MIN = 0.25;
+
+export function isMeasured(module) {
+    return ROW(module) !== null;
+}
+
+/** Derived, never declared. See the header. */
+export function surfaceOf(module) {
+    return coverageOf(module) >= GROUND_MIN ? 'canvas' : 'composable';
+}
+
+/**
+ * Whether a scene can be the ground under a section.
+ *
+ * Measured to fill the frame, and self-contained. The second half rules out
+ * `prev()`: that returns the whole composited previous frame, INCLUDING the
+ * layers above this one, so a datamosh under a shot is not grounding it, it is
+ * eating it. Measured when one first became a bed — the render stopped
+ * reproducing from a seek, and two WebGL contexts diverged by 91/255 against a
+ * tolerance of 4.
+ */
+export function canGround(module) {
+    return isMeasured(module)
+        && surfaceOf(module) === 'canvas'
+        && groundCoverageOf(module) >= GROUND_MIN
+        && groundFloorCoverageOf(module) >= GROUND_FLOOR_MIN
+        && !readsHistory(module);
+}
+
+/**
+ * How unalike two scenes are, structurally — 0 is the same picture.
+ *
+ * Both profiles are means over the same six songs, so this is a fair comparison
+ * in a way that two arbitrary renders would not be. Colour is excluded: six
+ * palettes would otherwise make any two scenes look unalike, and the whole
+ * point is to find pairs that differ in STRUCTURE.
+ *
+ * This is the quantity that makes a stack interesting rather than merely full.
+ * Two scenes at 0.02 layered over each other are one picture at double density;
+ * the same two at 0.3 are a picture with something happening in it.
+ */
+export function structuralDistance(a, b) {
+    const rowA = ROW(a), rowB = ROW(b);
+    if (!rowA || !rowB || !rowA.profile || !rowB.profile) return null;
+
+    let total = 0, blocks = 0;
+    for (const block of ['scale', 'orient', 'layout', 'region', 'texture']) {
+        const x = rowA.profile[block], y = rowB.profile[block];
+        if (!x || !y || x.length !== y.length) continue;
+        // Chi-square, matching what variety/signature.js compares descriptors
+        // with. Duplicated rather than imported because this runs inside the
+        // generator and the checks must not be a dependency of it.
+        let d = 0;
+        for (let i = 0; i < x.length; i++) {
+            const sum = x[i] + y[i];
+            if (sum > 1e-9) d += ((x[i] - y[i]) ** 2) / sum;
+        }
+        total += Math.min(1, d / 2);
+        blocks++;
+    }
+    return blocks ? total / blocks : null;
+}
+
+/** The variety score from the gallery: how much a scene changes between songs. */
+export function varietyOf(module) {
+    const row = ROW(module);
+    return row ? row.variety : 0;
+}
+
+export const METADATA = metadata;
diff --git a/flow-state/src/ui/TimelineStrip.js b/flow-state/src/ui/TimelineStrip.js
index 2db289a..9d27ad9 100644
--- a/flow-state/src/ui/TimelineStrip.js
+++ b/flow-state/src/ui/TimelineStrip.js
@@ -1,3 +1,4 @@
+import { subjectOf } from '../look/stack.js';
 // The transport strip: sections coloured by kind, bar ticks, scene-change
 // markers, playhead.
 //
@@ -144,12 +145,12 @@ export class TimelineStrip {
                     if (sw > 34) {
                         const stack = look.variants ? look.variants[shot.variant] : look.layers;
                         ctx.fillStyle = 'rgba(255,255,255,0.45)';
-                        ctx.fillText(stack[0].module.name, sx + 4, h - 6);
+                        ctx.fillText(subjectOf(stack).module.name, sx + 4, h - 6);
                     }
                 }
             } else if (look) {
                 ctx.fillStyle = 'rgba(255,255,255,0.45)';
-                ctx.fillText(look.layers[0].module.name, x0 + 5, h - 6);
+                ctx.fillText(subjectOf(look.layers).module.name, x0 + 5, h - 6);
             }
             ctx.restore();
 
diff --git a/flow-state/tools/new-scene.js b/flow-state/tools/new-scene.js
index d4217fb..af2d830 100644
--- a/flow-state/tools/new-scene.js
+++ b/flow-state/tools/new-scene.js
@@ -200,3 +200,9 @@ console.log('next:');
 console.log('  1. write the scene() body — everything else is done');
 console.log('  2. npm run lint:scenes');
 console.log(`  3. open  http://localhost:5180/checks.html?scene=${encodeURIComponent(name.trim())}`);
+// A scene with no measured coverage cannot be a ground and fails the phase 12
+// table check, which is the point: how much frame it paints decides where it is
+// allowed to sit in a stack, and that is a render result rather than a claim.
+console.log('  4. open  http://localhost:5180/checks.html?phase=12&slow=1 and paste');
+console.log('           your scene\'s line from window.__COVERAGE_TABLE__ into');
+console.log('           src/scenes/coverage.js — declare `surface` to match it');
diff --git a/flow-state/vite.config.js b/flow-state/vite.config.js
index 637024e..7f2dfc9 100644
--- a/flow-state/vite.config.js
+++ b/flow-state/vite.config.js
@@ -1,7 +1,53 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
+import { writeFileSync } from 'fs';
+
+/**
+ * Let the measuring pages write their results back into the source tree.
+ *
+ * The measurements that describe the scene library — how much frame each one
+ * paints, how much it changes between songs, what it looks like structurally —
+ * can only be taken by rendering, and rendering needs WebGL, which means a
+ * browser. So the numbers are produced in a page and have to get from there
+ * into a git-tracked file. This is that hole in the wall.
+ *
+ * Dev only, by construction: `apply: 'serve'` means it does not exist in a
+ * build, so a deployed gallery cannot write anything. The path it may write is
+ * a fixed allow-list rather than a parameter — a request body decides the
+ * CONTENTS of a known file and never which file.
+ */
+function measurementWriter() {
+    const WRITABLE = {
+        '/__metadata': 'src/scenes/metadata.json',
+    };
+
+    return {
+        name: 'flow-state-measurement-writer',
+        apply: 'serve',
+        configureServer(server) {
+            server.middlewares.use((req, res, next) => {
+                const target = WRITABLE[req.url];
+                if (!target || req.method !== 'POST') return next();
+
+                let body = '';
+                req.on('data', (chunk) => { body += chunk; });
+                req.on('end', () => {
+                    try {
+                        writeFileSync(resolve(process.cwd(), target), body);
+                        res.statusCode = 200;
+                        res.end(`wrote ${target} (${body.length} bytes)`);
+                    } catch (err) {
+                        res.statusCode = 500;
+                        res.end(String(err && err.message));
+                    }
+                });
+            });
+        },
+    };
+}
 
 export default defineConfig({
+    plugins: [measurementWriter()],
     server: {
         port: 5180,
         host: '127.0.0.1',