A reproducible migration, and the first eighteen scenes through it

The library is sixty-one scenes, which is too many to convert from memory or
from taste, so the migration is a queue with a gate rather than a judgement call
per file.

Three pieces. A classifier reads each shader and assigns a tier from evidence in
the source — drawn, figure, field, treatment — so two passes over the library
reach the same answer and the work has an order. MIGRATION.md is the recipe per
tier, written to be followed mechanically. And a gate makes the result
verifiable: `consumes` is now a schema field, the lint enforces it in both
directions, and the per-scene battery renders each scene under two deliberately
distant identities and requires the picture to change.

That gate is the part that matters. Without it `consumes` is a comment, and the
whole inversion becomes unverifiable at exactly the point where it stops being
checkable by eye. With it, a scene that declares the cast and ignores it fails.

Eighteen scenes migrated. Four by hand at the drawn tier — Firefly Drift,
Metaballs, Floating Geometry, Prism Bloom — and ten at the field tier by script,
which is one declaration and one wrapped return. All eighteen pass.

The field tier is honestly marginal and the gate says so: every one of the ten
moves by 37 to 39 of 255, against 173 to 255 for the drawn tier, and the
uniformity across ten unrelated scenes is the tell. That is one global
posterisation applying, not ten scenes expressing anything. Cheap, real, shallow.

The decomposition moved from identity being worth 54% of the container to 158%,
but the stage set changed underneath the measurement and part of that is
Metaballs expressing a cast better than Constellation did. What survives the
caveat is the useful finding: a migrated library scene carries the identity
better than a stage written from scratch to carry it. The four bespoke stages
were the wrong shape of effort.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

flow-state/src/scenes/shader/metaballs.js

@@ -8,6 +8,7 @@ export const metaballs = {
     family: 'organic',
     kind: 'fragment',
     // Personality: see look/Personality.js.
+    consumes: ['cast', 'ink', 'staging'],
     traits: ['shape', 'camera', 'style'],
 
     params: {
@@ -39,16 +40,18 @@ vec4 scene(vec2 uv, vec2 p) {
         float fi = float(i);
         float s = u_seed + fi * 71.3;
 
-        vec2 centre = vec2(
-            sin(t * (0.7 + fract(s * 0.13)) + s) * u_spread,
-            cos(t * (0.5 + fract(s * 0.29)) + s * 1.7) * u_spread * 0.62
-        );
+        // Homes on the song's lattice, orbited by this scene's own motion.
+        vec3 node = stageNode(fi, float(u_count));
+        vec2 centre = node.xy * u_spread * vec2(1.0, 0.62)
+            + vec2(sin(t * (0.7 + fract(s * 0.13)) + s),
+                   cos(t * (0.5 + fract(s * 0.29)) + s * 1.7)) * 0.25;
 
-        // Distance measured in the track's form rather than as a circle: for a
-        // round personality this is exactly length(p - centre), and for a
-        // hexagonal one the blobs merge as hexagons.
-        float d = sigShape((p - centre) / max(u_radius, 1e-3)) * u_radius + u_radius;
-        float contribution = (u_radius * u_radius) / max(d * d, 1e-4);
+        // Distance measured in the song's FORM rather than as a circle: for a
+        // round cast this is exactly length(p - centre), and for a hexagonal
+        // one the blobs merge as hexagons.
+        float radius = u_radius * node.z;
+        float d = castMain((p - centre) / max(radius, 1e-3)) * radius + radius;
+        float contribution = (radius * radius) / max(d * d, 1e-4);
         field += contribution;
         tint += pal(i) * contribution;
     }
@@ -64,7 +67,7 @@ vec4 scene(vec2 uv, vec2 p) {
     col += tint * rim * u_rim;
     col += sigGrain(uv);
 
-    return vec4(col, 1.0);
+    return vec4(inkValue(col), 1.0);
 }
 `,
 };