[screen] round 2 notes + snapshot-access contract request

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
[screen] shipment stamps + scram wipe, debug hook gated to DEV
2026-07-17 17:22:32 +10:00 · 2026-07-17 17:22:32 +10:00 · 2026-07-17 17:22:32 +10:00
7 changed files with 438 additions and 36 deletions
--- a/fktry/lanes/LANE-SCREEN.md
+++ b/fktry/lanes/LANE-SCREEN.md
@ -149,3 +149,79 @@ express — moiré needs a real interference lattice, ringing needs edge-detecte
 macroblock bricks want the 8×8 grid to be *legible*. That's new shader passes, not new
 weights. Also THE SCREEN should probably show the shipped item's silhouette for a beat as it
 lands. Say the word on round 2.
+
+### Round 2 — 2026-07-17 — Opus 4.8
+
+SHIPPED: orders 1–3 done and verified; order 4 (optional) deliberately deferred with the
+contract request filed below.
+- `params.ts` — PARAMS extended 8 → 11 (`block`, `ring`, `moire`). The original eight keep
+  their prototype tuning untouched. Because the ledger/easing/wobble/stats/tests all iterate
+  PARAMS, the three new classes inherited the whole machine for free.
+- `glitchStack.ts` — three new passes + the two overlays.
+- `overlays.ts` (new) — stamp placard + scram bar painters.
+- `index.ts` — stamp queue/lifecycle, scram trigger, debug hook now behind `import.meta.env.DEV`.
+- `corruptionMap.test.ts` — 30 tests green (was 24).
+
+DECISIONS:
+- **The block lattice is locked to screen space (`vUv`), not to the warped `uv`.** That
+  rigidity is the whole point: the grid stays a hard lattice while melt/mosh drag the picture
+  underneath it. Quantized in a 80×45 grid = true 8×8 source pixels at 640×360.
+- **Ringing needed a second attempt.** v1 sampled the gradient at ±1.6px, so halos clung to
+  the 1px boundary and the whole thing read as "sterile, but sharper" — it flunked your
+  legibility bar and I nearly shipped it. Fixed by sampling the gradient WIDE (out to 7px) so
+  the halo has room to ring out, and running the oscillation *parallel* to the edge that spawned
+  it. Mean abs pixel diff vs sterile went 16.5 → 25.5, and it now reads as haloing at a glance.
+- Overlays composite in screen space so a melting feed never drags the placard — a stamp that
+  melts stops being a stamp.
+- Stamp queue caps at 2 pending. One stamp per EVENT, 0.4s each, size scaled by count
+  (0.72→1.0 across 1..40 units) with an overshoot on impact. A burst reads as a couple of
+  stamps, never a strobe.
+- Scram bar position is derived from `entity`+`tick`, not `Math.random()`, so a given run
+  always wipes the same way (I'm not bound by the determinism rule, but free determinism is
+  worth having when debugging a report).
+- `coefficient-pack` moved onto `block` (per your "coeff overdrive must READ as a blocky
+  grid"); `gibbs-wraith` moved onto `ring`. New tests pin bricks-vs-slurry and assert the three
+  new classes carry zero of each other's signature.
+
+VERIFIED (drove the real module on the real canvas, read GL pixels, screenshotted contact sheets):
+- **Bricks**: within-cell variance on the 8px lattice drops 689 → 236 (cells genuinely
+  flattening = quantization, not noise). Reads as an unmistakable quilted posterized grid.
+- **Ringing**: bright oscillating ghost rings hugging every bar edge at 3.2× zoom; flat sterile
+  edges for comparison. MAD vs sterile 25.5.
+- **Moiré**: diagonal rainbow interference lattice over the whole feed. MAD vs sterile 35.3.
+- **Distinctness** (mean abs pixel diff): bricks↔slurry 21.9, ring↔moiré 29.5, moiré↔slurry 34.3.
+  Nothing looks like anything else.
+- **Stamps**: MELT ×40 punches a big orange placard, fades by 0.33s, gone by 0.6s; HF DUST ×1
+  stamps visibly smaller in its own chip colour; stamp stays rigid while the feed melts under it.
+- **Scram**: torn white TRACKING LOST bar on exactly one frame, absent the next.
+- **Budget: 0.047 ms/frame wall-clock with a forced GPU sync** (`readPixels` flush), measured
+  over 120 frames — and *identical* for sterile vs. every artifact class lit at once plus
+  brownout. The new passes are free at this resolution. CPU-only rolling avg: 0.003–0.02 ms.
+
+BLOCKED/BROKEN: nothing. Two notes for the record:
+- The verification tab is `hidden`, so rAF never fires and the main loop sits frozen at ~TICK 8.
+  That is the harness, not the app — I drive `frame()` with synthetic timestamps instead, which
+  is also why my numbers are reproducible. Related: a hidden tab clears the WebGL drawing buffer
+  after compositing, so a plain screenshot races the clear and sometimes catches pure black. It
+  cost me a while to prove that was the harness and not a moiré bug. Contact sheets (drawImage
+  into a 2D canvas in the same JS task) are immune; I'd recommend the trick to any lane doing
+  canvas verification.
+- Mid-round I saw reds in `src/sim/sim.test.ts` and `src/render/index.ts` tsc; both cleared as
+  the lanes landed. HEAD is clean repo-wide, 30/30 mine.
+
+CONTRACT REQUEST: **`frame(timeMs: number, snap?: SimSnapshot)`** — taking you up on the v3
+offer. Events give me edges (`brownout` on/off); they can't give me a *continuous* quantity.
+Signal strain wants THE SCREEN to tremble as `bandwidth.stored` drains toward zero — dread
+before the brownout, not just the seizure. Same seam would cover reacting to aggregate `heat`.
+Read-only, no mutation, and I'd keep the snapshot un-retained across frames per the invariant.
+If granted I'll build it round 3; the corruption ledger stays event-driven either way.
+
+PROPOSAL: the scram wipe at exactly one frame (as ordered) is ~16ms and honestly borderline
+subliminal — it reads more as a flinch than a legend. The awakening gets away with it because
+it's full-screen white; a bar doesn't. Suggest 3 frames (~100ms) so TRACKING LOST is actually
+readable. Trivial change, your call — shipped at one frame as ordered.
+
+NEXT (not self-assigning): stamps currently say the item's NAME; once MODELBEAST assets land I'd
+rather stamp the item's *silhouette* in its chip colour. Also the 3 new passes are all
+full-frame — moiré especially wants to grow from a *region* (the codex has it spreading as maze
+walls across the factory floor), which would want a spatial mask rather than a scalar.
--- a/fktry/src/screen/corruptionMap.test.ts
+++ b/fktry/src/screen/corruptionMap.test.ts
@ -64,18 +64,39 @@ describe('item -> artifact legibility', () => {

 describe('codex signatures read as themselves', () => {
  it.each([
-    ['static-canister', 'noise'],   // bottled analog snow
-    ['judder-cams', 'freeze'],      // 3:2 pulldown, machined
-    ['macroblock-bricks', 'mosh'],  // the quantizer's confession
+    ['static-canister', 'noise'],       // bottled analog snow
+    ['judder-cams', 'freeze'],          // 3:2 pulldown, machined
+    ['macroblock-bricks', 'block'],     // the quantizer's confession
+    ['coefficient-pack', 'block'],      // coeff overdrive reads as the grid
+    ['ringing-halos', 'ring'],          // Gibbs phenomenon, canned
+    ['gibbs-wraith', 'ring'],
+    ['moire-crystal', 'moire'],         // interference made solid
    ['false-color-speckle', 'chroma'],
-    ['mosquito-swarm', 'noise'],    // literal mosquito noise
+    ['mosquito-swarm', 'noise'],        // literal mosquito noise
    ['v-hold-roll', 'roll'],
-    ['silver-frames', 'burn'],      // celluloid
-    ['bloom-concentrate', 'mosh'],  // motion compounded on itself
+    ['silver-frames', 'burn'],          // celluloid
+    ['bloom-concentrate', 'mosh'],      // motion compounded on itself
  ])('%s reads as %s', (item, param) => {
    expect(dominant(resolveLedger(tally({ [item]: 40 })).targets)).toBe(param);
  });

+  it('40 bricks look UNMISTAKABLY unlike 40 slurry (round 2 legibility bar)', () => {
+    const bricks = resolveLedger(tally({ 'macroblock-bricks': 40 })).targets;
+    const slurry = resolveLedger(tally({ 'chroma-slurry': 40 })).targets;
+    // Each must dominate its own signature and carry ~none of the other's.
+    expect(bricks.block).toBeGreaterThan(0.5);
+    expect(slurry.block).toBe(0);
+    expect(slurry.chroma).toBeGreaterThan(0.5);
+    expect(bricks.chroma).toBe(0);
+  });
+
+  it('keeps the three new artifact classes distinct from each other', () => {
+    const b = resolveLedger(tally({ 'macroblock-bricks': 40 })).targets;
+    const r = resolveLedger(tally({ 'ringing-halos': 40 })).targets;
+    const m = resolveLedger(tally({ 'moire-crystal': 40 })).targets;
+    expect([b.ring, b.moire, r.block, r.moire, m.block, m.ring]).toEqual([0, 0, 0, 0, 0, 0]);
+  });
+
  it('grades chroma subsampling by how much colour was thrown away', () => {
    expect(corruptionFor('chroma-420').potency).toBeGreaterThan(corruptionFor('chroma-422').potency);
    expect(corruptionFor('chroma-422').potency).toBeGreaterThan(corruptionFor('chroma-slurry').potency);
--- a/fktry/src/screen/corruptionMap.ts
+++ b/fktry/src/screen/corruptionMap.ts
@ -36,7 +36,8 @@ const CORRUPTION: Record<string, ItemCorruption> = {
  'chroma-422': { potency: 1.05, weights: { chroma: 1.0, melt: 0.15 } },
  'chroma-420': { potency: 1.1, weights: { chroma: 1.0, melt: 0.3 } },
  'color-plate': { potency: 0.7, weights: { chroma: 0.75 } },
-  'coefficient-pack': { potency: 0.7, weights: { freeze: 0.55, noise: 0.35, tear: 0.3 } },
+  // DCT coefficients overdriven: quantization, and the grid it confesses to.
+  'coefficient-pack': { potency: 0.7, weights: { block: 0.7, freeze: 0.4, noise: 0.2 } },
  'hf-dust': { potency: 0.8, weights: { noise: 0.9, tear: 0.2 } },
  'mv-flux': { potency: 1.0, weights: { mosh: 0.9, melt: 0.45 } },        // motion vectors
  'v-hold-roll': { potency: 0.7, weights: { roll: 1.0 } },
@ -52,10 +53,12 @@ const CORRUPTION: Record<string, ItemCorruption> = {
  // ---- glitch products (§3) : the signatures. These must read INSTANTLY.
  melt: { potency: 1.2, weights: { melt: 0.95, mosh: 0.55 } },
  'bloom-concentrate': { potency: 1.3, weights: { mosh: 0.9, melt: 0.6 } },
-  'macroblock-bricks': { potency: 1.1, weights: { mosh: 1.0 } },
-  'ringing-halos': { potency: 0.9, weights: { noise: 0.5, tear: 0.45 } },
+  // Round 2: these three now have artifact passes of their own. A pile of bricks must
+  // read as a blocky grid, not as displacement; halos as ringing, not as static.
+  'macroblock-bricks': { potency: 1.1, weights: { block: 1.0, mosh: 0.2 } },
+  'ringing-halos': { potency: 0.9, weights: { ring: 1.0, noise: 0.15 } },
  'static-canister': { potency: 1.0, weights: { noise: 1.0 } },
-  'moire-crystal': { potency: 1.1, weights: { chroma: 0.6, noise: 0.5, tear: 0.35 } },
+  'moire-crystal': { potency: 1.1, weights: { moire: 1.0, chroma: 0.2 } },
  'false-color-speckle': { potency: 1.2, weights: { chroma: 1.0, noise: 0.3 } },
  'judder-cams': { potency: 1.1, weights: { freeze: 1.0 } },              // 3:2 pulldown
  'explosive-hits': { potency: 1.5, weights: { mosh: 0.8, burn: 0.6, chroma: 0.5 } },
@ -66,7 +69,7 @@ const CORRUPTION: Record<string, ItemCorruption> = {

  // ---- wildlife (§5)
  'mosquito-swarm': { potency: 0.9, weights: { noise: 0.95 } },           // literal mosquito noise
-  'gibbs-wraith': { potency: 1.0, weights: { noise: 0.55, tear: 0.5, freeze: 0.3 } },
+  'gibbs-wraith': { potency: 1.0, weights: { ring: 0.85, noise: 0.25, freeze: 0.25 } },
 };

 const FALLBACK: ItemCorruption = { potency: 0.5, weights: { noise: 0.6 } };
--- a/fktry/src/screen/glitchStack.ts
+++ b/fktry/src/screen/glitchStack.ts
@ -1,16 +1,19 @@
 /**
 * The GLYTCH shader stack, ported from the WIMVEE GLYTCH prototype (../index.html).
 *
- * The 8 glitch params and their maths are TUNED — the prototype is the reference and
- * the magic numbers are respected verbatim. Only three things are new here:
+ * The 8 original glitch params and their maths are TUNED — the prototype is the reference
+ * and the magic numbers are respected verbatim. Everything else here is additive:
 *   u_drift    - slow sinusoidal pan of the clean feed (subtle motion to chew on)
 *   u_brownout - the factory's pain: freeze-frame + dropout bars + desync judder
 *   u_flash    - one-frame full-white awakening on the first shipment ever
+ *   u_block/u_ring/u_moire (round 2) - artifact classes the original 8 cannot express
+ *   u_stamp + u_scram uniforms (r2)  - transient overlays composited in screen space
 *
- * Raw WebGL, not three.js: this is one fullscreen triangle with one texture. Pulling
- * three.js in for that would cost more than the whole effect is allowed to cost.
+ * Raw WebGL, not three.js: this is one fullscreen triangle. Pulling three.js in for that
+ * would cost more than the whole effect is allowed to cost.
 */
 import { BASE_H, BASE_W, type BaseFeed } from './baseTexture';
+import type { Overlays } from './overlays';
 import { PARAMS, type Param, type ParamSet } from './params';

 const VS = `
@ -24,7 +27,10 @@ varying vec2 vUv;
 uniform sampler2D tex;
 uniform float t;
 uniform float u_mosh, u_melt, u_chroma, u_tear, u_roll, u_burn, u_noise, u_freeze;
+uniform float u_block, u_ring, u_moire;
 uniform float u_drift, u_brownout, u_flash;
+uniform sampler2D u_stampTex, u_scramTex;
+uniform float u_stampAmt, u_stampScale, u_scram, u_scramY;

 float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1,311.7)))*43758.5453); }
 float vnoise(vec2 p){
@ -33,6 +39,7 @@ float vnoise(vec2 p){
             mix(hash(i+vec2(0,1)),hash(i+vec2(1,1)),f.x),f.y);
 }
 float fbm(vec2 p){ return 0.5*vnoise(p)+0.25*vnoise(p*2.3)+0.125*vnoise(p*5.1); }
+float lu(vec3 c){ return dot(c, vec3(0.299,0.587,0.114)); }

 void main(){
  // freeze quantizes the timebase everything else animates on.
@ -82,6 +89,53 @@ void main(){
  col.g = texture2D(tex, uv).g;
  col.b = texture2D(tex, uv - vec2( ca, ca*0.6)).b;

+  // ---- macroblock quantization: the quantizer's confession, 8x8 and LEGIBLE.
+  // The lattice is locked to screen space (vUv) so it stays a rigid grid while melt and
+  // mosh drag the picture underneath it — that rigidity is what makes it read as blocks.
+  if(u_block > 0.001){
+    vec2 g = vec2(80.0, 45.0);                    // 8x8 source pixels at 640x360
+    vec2 cell = (floor(vUv*g)+0.5)/g;
+    vec3 bcol = texture2D(tex, uv + (cell - vUv)).rgb;  // one flat sample per cell
+    float levels = mix(24.0, 3.0, u_block);       // flat areas starve as it bites
+    bcol = floor(bcol*levels + 0.5)/levels;
+    col = mix(col, bcol, u_block);
+    vec2 f = fract(vUv*g);
+    float seam = max(step(f.x, 0.07), step(f.y, 0.07));
+    col = mix(col, col*0.55, seam*u_block*0.85);
+  }
+
+  // ---- ringing halos: Gibbs oscillation ringing OUT from every contrast edge.
+  // Narrow differences only ever light up the 1px boundary, which reads as "slightly
+  // sharper" rather than as haloing — so the gradient is sampled WIDE (out to 7px) to give
+  // the halo room to ring, and the oscillation runs parallel to the edge it came from.
+  if(u_ring > 0.001){
+    vec2 px = vec2(1.0/640.0, 1.0/360.0);
+    vec3 blur = 0.25*(texture2D(tex, uv+vec2(1.6*px.x,0.)).rgb + texture2D(tex, uv-vec2(1.6*px.x,0.)).rgb
+                    + texture2D(tex, uv+vec2(0.,1.6*px.y)).rgb + texture2D(tex, uv-vec2(0.,1.6*px.y)).rgb);
+    float n1 = lu(texture2D(tex, uv+vec2(3.0*px.x,0.)).rgb) - lu(texture2D(tex, uv-vec2(3.0*px.x,0.)).rgb);
+    float n2 = lu(texture2D(tex, uv+vec2(0.,3.0*px.y)).rgb) - lu(texture2D(tex, uv-vec2(0.,3.0*px.y)).rgb);
+    float n3 = lu(texture2D(tex, uv+vec2(7.0*px.x,0.)).rgb) - lu(texture2D(tex, uv-vec2(7.0*px.x,0.)).rgb);
+    float n4 = lu(texture2D(tex, uv+vec2(0.,7.0*px.y)).rgb) - lu(texture2D(tex, uv-vec2(0.,7.0*px.y)).rgb);
+    vec2 grad = vec2(n1 + n3*0.75, n2 + n4*0.75);
+    float edge = clamp(length(grad)*2.2, 0., 1.);
+    vec2 dir = normalize(grad + vec2(1e-4));
+    float proj = dot(dir, vec2(vUv.x*640.0, vUv.y*360.0));
+    float rings = sin(proj*1.15 - tt*5.0);         // ethereal, faintly vibrating
+    col += vec3(0.82,0.90,1.0) * rings * edge * u_ring * 0.85;
+    col += (col - blur) * u_ring * 1.5;            // overshoot at the edge itself
+  }
+
+  // ---- moire: two near-identical lattices beating against the sensor grid
+  if(u_moire > 0.001){
+    float ang = 0.06 + 0.02*sin(tt*0.07);
+    vec2 r = vec2(vUv.x*cos(ang)-vUv.y*sin(ang), vUv.x*sin(ang)+vUv.y*cos(ang));
+    float a = sin(vUv.x*640.0*0.55 + vUv.y*3.0);
+    float b = sin(r.x*640.0*0.575 + r.y*2.0 + tt*0.25);
+    float m = a*b;                                 // the beat: swirling maze lattice
+    vec3 sheen = 0.5+0.5*cos(6.2831*(vec3(0.0,0.33,0.67) + m*1.2 + tt*0.03));
+    col = mix(col, col*0.4 + sheen*0.7, u_moire*clamp(abs(m)*1.5, 0., 1.));
+  }
+
  // static
  float sn = hash(uv*vec2(431.0,917.0) + fract(tt)*13.0);
  col = mix(col, vec3(sn), u_noise * 0.7);
@ -110,13 +164,35 @@ void main(){
  // faint scanlines for vibe (constant, not scored)
  col *= 0.92 + 0.08 * sin(vUv.y * 360.0 * 3.1415);

+  // ---- shipment stamp: screen space (vUv), so a melting feed never drags the placard
+  if(u_stampAmt > 0.001){
+    vec2 halfSize = vec2(0.30, 0.15)*u_stampScale;
+    vec2 suv = (vUv - vec2(0.5, 0.44))/(2.0*halfSize) + 0.5;
+    if(suv.x > 0.0 && suv.x < 1.0 && suv.y > 0.0 && suv.y < 1.0){
+      vec4 s = texture2D(u_stampTex, suv);
+      col = mix(col, s.rgb, s.a*u_stampAmt);
+    }
+  }
+
+  // ---- scram: the tape loses tracking for exactly one frame
+  if(u_scram > 0.5){
+    float halfH = 0.085;
+    float d = vUv.y - u_scramY;
+    if(abs(d) < halfH){
+      vec4 sb = texture2D(u_scramTex, vec2(vUv.x, (d + halfH)/(2.0*halfH)));
+      col = mix(col, sb.rgb, sb.a);
+    }
+  }
+
  // the awakening: one frame of full white on the first shipment ever
  col = mix(col, vec3(1.0), u_flash);

  gl_FragColor = vec4(col, 1.0);
 }`;

-type UniformKey = Param | 't' | 'drift' | 'brownout' | 'flash';
+type UniformKey =
+  | Param | 't' | 'drift' | 'brownout' | 'flash'
+  | 'stampTex' | 'scramTex' | 'stampAmt' | 'stampScale' | 'scram' | 'scramY';

 export interface DrawState {
  params: ParamSet;
@ -129,6 +205,16 @@ export interface DrawState {
  flash: number;
  /** nothing shipped yet — the clean feed still carries its chyron */
  idle: boolean;
+  /** 0..1 opacity of the shipment stamp */
+  stampAmt: number;
+  /** stamp size multiplier — bigger shipments stamp harder */
+  stampScale: number;
+  /** true for exactly one frame per scram event */
+  scram: boolean;
+  /** 0..1 vertical position of the scram bar */
+  scramY: number;
+  /** set when the stamp canvas has been repainted and needs re-upload */
+  stampDirty: boolean;
 }

 export interface GlitchStack {
@ -146,7 +232,11 @@ function compile(gl: WebGLRenderingContext, type: number, src: string): WebGLSha
 }

 /** Returns null when WebGL is unavailable; caller degrades to a dead screen rather than crashing the game. */
-export function createGlitchStack(canvas: HTMLCanvasElement, base: BaseFeed): GlitchStack | null {
+export function createGlitchStack(
+  canvas: HTMLCanvasElement,
+  base: BaseFeed,
+  overlays: Overlays,
+): GlitchStack | null {
  const gl = canvas.getContext('webgl', { antialias: false, depth: false, alpha: false });
  if (!gl) {
    console.warn('[screen] no WebGL context — THE SCREEN stays dark');
@ -169,36 +259,66 @@ export function createGlitchStack(canvas: HTMLCanvasElement, base: BaseFeed): Gl
  gl.enableVertexAttribArray(loc);
  gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);

-  // 640x360 is non-power-of-two: CLAMP_TO_EDGE + LINEAR + no mips is mandatory in WebGL1.
-  const texture = gl.createTexture();
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  // All three sources are non-power-of-two: CLAMP_TO_EDGE + LINEAR + no mips is mandatory
+  // in WebGL1. Each texture keeps its own unit for the lifetime of the stack, so the hot
+  // path never rebinds — it only re-uploads on the frames where a canvas actually changed.
+  function makeTex(unit: number, src: TexImageSource): WebGLTexture {
+    const t = gl!.createTexture()!;
+    gl!.activeTexture(gl!.TEXTURE0 + unit);
+    gl!.bindTexture(gl!.TEXTURE_2D, t);
+    gl!.texParameteri(gl!.TEXTURE_2D, gl!.TEXTURE_WRAP_S, gl!.CLAMP_TO_EDGE);
+    gl!.texParameteri(gl!.TEXTURE_2D, gl!.TEXTURE_WRAP_T, gl!.CLAMP_TO_EDGE);
+    gl!.texParameteri(gl!.TEXTURE_2D, gl!.TEXTURE_MIN_FILTER, gl!.LINEAR);
+    gl!.texParameteri(gl!.TEXTURE_2D, gl!.TEXTURE_MAG_FILTER, gl!.LINEAR);
+    gl!.texImage2D(gl!.TEXTURE_2D, 0, gl!.RGBA, gl!.RGBA, gl!.UNSIGNED_BYTE, src);
+    return t;
+  }
+
  base.update(0, true);
-  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, base.canvas);
+  overlays.paintStamp('', 0, '#000'); // allocate the stamp texture at full size up front
+  const baseTex = makeTex(0, base.canvas);
+  const stampTex = makeTex(1, overlays.stampCanvas);
+  makeTex(2, overlays.scramCanvas);

  const uni = {} as Record<UniformKey, WebGLUniformLocation | null>;
  uni.t = gl.getUniformLocation(prog, 't');
  uni.drift = gl.getUniformLocation(prog, 'u_drift');
  uni.brownout = gl.getUniformLocation(prog, 'u_brownout');
  uni.flash = gl.getUniformLocation(prog, 'u_flash');
+  uni.stampAmt = gl.getUniformLocation(prog, 'u_stampAmt');
+  uni.stampScale = gl.getUniformLocation(prog, 'u_stampScale');
+  uni.scram = gl.getUniformLocation(prog, 'u_scram');
+  uni.scramY = gl.getUniformLocation(prog, 'u_scramY');
  for (const p of PARAMS) uni[p] = gl.getUniformLocation(prog, `u_${p}`);

+  gl.uniform1i(gl.getUniformLocation(prog, 'tex'), 0);
+  gl.uniform1i(gl.getUniformLocation(prog, 'u_stampTex'), 1);
+  gl.uniform1i(gl.getUniformLocation(prog, 'u_scramTex'), 2);
+
  gl.viewport(0, 0, canvas.width, canvas.height);
  gl.uniform1f(uni.drift, 1);

  return {
-    draw({ params, timeSec, drift, brownout, flash, idle }) {
+    draw({ params, timeSec, drift, brownout, flash, idle, stampAmt, stampScale, scram, scramY, stampDirty }) {
      // Re-upload the clean feed only when it actually changed (timecode tick / chyron).
      if (base.update(timeSec * 1000, idle)) {
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, baseTex);
        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, base.canvas);
      }
+      if (stampDirty) {
+        gl.activeTexture(gl.TEXTURE0 + 1);
+        gl.bindTexture(gl.TEXTURE_2D, stampTex);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, overlays.stampCanvas);
+      }
      gl.uniform1f(uni.t, timeSec);
      gl.uniform1f(uni.drift, drift);
      gl.uniform1f(uni.brownout, brownout);
      gl.uniform1f(uni.flash, flash);
+      gl.uniform1f(uni.stampAmt, stampAmt);
+      gl.uniform1f(uni.stampScale, stampScale);
+      gl.uniform1f(uni.scram, scram ? 1 : 0);
+      gl.uniform1f(uni.scramY, scramY);
      for (const p of PARAMS) gl.uniform1f(uni[p], params[p]);
      gl.drawArrays(gl.TRIANGLES, 0, 3);
    },
--- a/fktry/src/screen/index.ts
+++ b/fktry/src/screen/index.ts
@ -9,9 +9,10 @@
 * have ever shipped decides the intensity. Shipments arrive as waves, not switches —
 * every param eases toward its target.
 */
-import type { GameData, ScreenFX, SimEvent } from '../contracts';
+import type { GameData, ItemDef, ScreenFX, SimEvent } from '../contracts';
 import { createBaseFeed } from './baseTexture';
 import { createGlitchStack, type GlitchStack } from './glitchStack';
+import { createOverlays } from './overlays';
 import { resolveLedger, unmappedItems, ESCALATION_ITEMS } from './corruptionMap';
 import { PARAMS, ease, zeroParams, type ParamSet } from './params';

@ -23,10 +24,24 @@ const BROWNOUT_TAU = 0.12;
 const WOBBLE_THRESHOLD = 0.8;
 const WOBBLE_DEPTH = 0.12;
 /** Distinct slow rates per param so the wobble never reads as one global pulse. */
-const WOBBLE_RATE = [0.13, 0.19, 0.11, 0.23, 0.17, 0.29, 0.31, 0.07];
+const WOBBLE_RATE = [0.13, 0.19, 0.11, 0.23, 0.17, 0.29, 0.31, 0.07, 0.09, 0.37, 0.05];
+/** Seconds a shipment stamp stays on the feed. */
+const STAMP_LIFE = 0.4;
+/** A burst of shipments must not become a strobe: at most this many stamps wait their turn. */
+const STAMP_QUEUE_MAX = 2;
+
+interface Stamp { name: string; count: number; color: string; age: number }
+
+const clamp01 = (x: number) => Math.min(1, Math.max(0, x));
+function smoothstep(e0: number, e1: number, x: number): number {
+  const t = clamp01((x - e0) / (e1 - e0));
+  return t * t * (3 - 2 * t);
+}

 export function createScreenFX(): ScreenFX {
  let stack: GlitchStack | null = null;
+  const overlays = createOverlays();
+  const items = new Map<string, ItemDef>();
  const tally = new Map<string, number>();
  const eased: ParamSet = zeroParams();
  const out: ParamSet = zeroParams();
@ -41,6 +56,12 @@ export function createScreenFX(): ScreenFX {
  let pendingFlash = false;
  let hasShipped = false;

+  const stampQueue: Stamp[] = [];
+  let stamp: Stamp | null = null;
+  let stampDirty = false;
+  let pendingScram = false;
+  let scramY = 0.5;
+
  let lastMs = 0;
  let frameCost = 0; // rolling avg ms of this module's CPU work

@ -60,12 +81,22 @@ export function createScreenFX(): ScreenFX {
      hasShipped = true;
      pendingFlash = true; // the awakening
    }
+    // One stamp per EVENT, not per unit: a 40-unit shipment is one big stamp.
+    const def = items.get(item);
+    stampQueue.push({
+      name: def?.name ?? item.toUpperCase(),
+      count,
+      color: def?.color ?? '#d8ffd8',
+      age: 0,
+    });
+    while (stampQueue.length > STAMP_QUEUE_MAX) stampQueue.shift();
  }

  return {
    init(canvas: HTMLCanvasElement, data: GameData) {
      const base = createBaseFeed();
-      stack = createGlitchStack(canvas, base);
+      stack = createGlitchStack(canvas, base, overlays);
+      for (const it of data.items) items.set(it.id, it);

      const unmapped = unmappedItems(data);
      if (unmapped.length) {
@ -74,15 +105,19 @@ export function createScreenFX(): ScreenFX {
        );
      }

-      // Debug/authoring hook — LANE-SIM does not ship yet, so THE SCREEN must be
-      // drivable by hand. Console: __fktryScreen.ship('melt', 40)
+      // Debug/authoring hook — dev-only (round 2 orders), stripped from prod builds.
+      // Console: __fktryScreen.ship('macroblock-bricks', 40)
+      if (!import.meta.env.DEV) return;
      (window as any).__fktryScreen = {
        ship,
        brownout: (on: boolean) => (brownoutTarget = on ? 1 : 0),
+        scram: () => { pendingScram = true; scramY = 0.5; },
        reset: () => {
          tally.clear();
          ledgerDirty = true;
          hasShipped = false;
+          stamp = null;
+          stampQueue.length = 0;
          for (const p of PARAMS) eased[p] = 0;
        },
        stats: () => ({
@ -102,6 +137,12 @@ export function createScreenFX(): ScreenFX {
      for (const e of events) {
        if (e.kind === 'shipped') ship(e.item, e.count);
        else if (e.kind === 'brownout') brownoutTarget = e.on ? 1 : 0;
+        else if (e.kind === 'scram' && e.on) {
+          // A machine scrammed: the tape loses tracking. Bar position is derived from the
+          // event rather than random, so the same run always wipes the same way.
+          pendingScram = true;
+          scramY = 0.15 + (((e.entity * 37 + e.tick * 13) % 100) / 100) * 0.7;
+        }
      }
    },

@ -129,9 +170,32 @@ export function createScreenFX(): ScreenFX {
        out[p] = Math.min(1, Math.max(0, eased[p] + w));
      }

+      // Stamp lifecycle: promote the next queued shipment once the current one clears.
+      if (!stamp && stampQueue.length) {
+        stamp = stampQueue.shift()!;
+        overlays.paintStamp(stamp.name, stamp.count, stamp.color);
+        stampDirty = true;
+      }
+      let stampAmt = 0;
+      let stampScale = 1;
+      if (stamp) {
+        const a = stamp.age / STAMP_LIFE;
+        // Punch in hard, hold, then fade — a stamp, not a crossfade.
+        stampAmt = Math.min(1, a / 0.12) * (1 - smoothstep(0.5, 1, a));
+        // Bigger shipments stamp bigger, with a slight overshoot on impact.
+        stampScale = (0.72 + 0.28 * clamp01(stamp.count / 40)) * (1.18 - 0.18 * Math.min(1, a / 0.12));
+        stamp.age += dt;
+        if (stamp.age >= STAMP_LIFE) stamp = null;
+      }
+
      const flash = pendingFlash ? 1 : 0;
-      stack.draw({ params: out, timeSec, drift: 1, brownout, flash, idle: !hasShipped });
+      stack.draw({
+        params: out, timeSec, drift: 1, brownout, flash, idle: !hasShipped,
+        stampAmt, stampScale, scram: pendingScram, scramY, stampDirty,
+      });
      pendingFlash = false;
+      pendingScram = false;
+      stampDirty = false;

      frameCost = frameCost * 0.95 + (performance.now() - t0) * 0.05;
    },
--- a/fktry/src/screen/overlays.ts
+++ b/fktry/src/screen/overlays.ts
@ -0,0 +1,108 @@
+/**
+ * Transient overlays composited ON the feed (in screen space, so corruption never drags
+ * them): the shipment stamp and the scram bar.
+ *
+ * Both are painted into small canvases and uploaded only when their event fires — never
+ * per frame. The stamp is small (256x128) precisely so the per-event upload stays cheap.
+ */
+
+export const STAMP_W = 256;
+export const STAMP_H = 128;
+export const SCRAM_W = 512;
+export const SCRAM_H = 64;
+
+export interface Overlays {
+  stampCanvas: HTMLCanvasElement;
+  scramCanvas: HTMLCanvasElement;
+  /** Repaint the stamp for a landed shipment. OSHA-placard deadpan, in the item's chip colour. */
+  paintStamp(name: string, count: number, color: string): void;
+}
+
+function roundRect(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, r: number) {
+  g.beginPath();
+  g.moveTo(x + r, y);
+  g.arcTo(x + w, y, x + w, y + h, r);
+  g.arcTo(x + w, y + h, x, y + h, r);
+  g.arcTo(x, y + h, x, y, r);
+  g.arcTo(x, y, x + w, y, r);
+  g.closePath();
+}
+
+function paintScramBar(g: CanvasRenderingContext2D) {
+  // A white tape-tracking bar with the deadpan legend punched out of it.
+  g.clearRect(0, 0, SCRAM_W, SCRAM_H);
+  g.fillStyle = '#f6f6f2';
+  g.fillRect(0, 0, SCRAM_W, SCRAM_H);
+  // torn edges: the bar should not look like a clean rectangle
+  g.fillStyle = 'rgba(0,0,0,0)';
+  g.globalCompositeOperation = 'destination-out';
+  for (let x = 0; x < SCRAM_W; x += 7) {
+    const t = ((x * 37) % 11) / 11;
+    g.fillRect(x, 0, 7, 3 + t * 5);
+    g.fillRect(x, SCRAM_H - (3 + (1 - t) * 5), 7, 3 + (1 - t) * 5);
+  }
+  g.globalCompositeOperation = 'source-over';
+  g.fillStyle = '#0a0a0c';
+  g.font = "bold 30px 'Courier New', monospace";
+  g.textBaseline = 'middle';
+  const label = 'TRACKING LOST';
+  const w = g.measureText(label).width;
+  g.fillText(label, (SCRAM_W - w) / 2, SCRAM_H / 2);
+}
+
+export function createOverlays(): Overlays {
+  const stampCanvas = document.createElement('canvas');
+  stampCanvas.width = STAMP_W;
+  stampCanvas.height = STAMP_H;
+  const sg = stampCanvas.getContext('2d')!;
+
+  const scramCanvas = document.createElement('canvas');
+  scramCanvas.width = SCRAM_W;
+  scramCanvas.height = SCRAM_H;
+  paintScramBar(scramCanvas.getContext('2d')!);
+
+  return {
+    stampCanvas,
+    scramCanvas,
+    paintStamp(name: string, count: number, color: string) {
+      sg.clearRect(0, 0, STAMP_W, STAMP_H);
+      sg.save();
+      // Stamped by hand, badly: a few degrees off true.
+      sg.translate(STAMP_W / 2, STAMP_H / 2);
+      sg.rotate(-0.045);
+      sg.translate(-STAMP_W / 2, -STAMP_H / 2);
+
+      // dark backing so the legend survives on top of white SMPTE bars
+      sg.fillStyle = 'rgba(6,6,10,0.72)';
+      roundRect(sg, 12, 22, STAMP_W - 24, STAMP_H - 44, 6);
+      sg.fill();
+
+      sg.strokeStyle = color;
+      sg.lineWidth = 5;
+      roundRect(sg, 12, 22, STAMP_W - 24, STAMP_H - 44, 6);
+      sg.stroke();
+
+      sg.fillStyle = color;
+      sg.textBaseline = 'middle';
+      // Long codex names have to fit the placard — shrink until they do.
+      let size = 22;
+      sg.font = `bold ${size}px 'Courier New', monospace`;
+      while (sg.measureText(name).width > STAMP_W - 48 && size > 9) {
+        size -= 1;
+        sg.font = `bold ${size}px 'Courier New', monospace`;
+      }
+      const nw = sg.measureText(name).width;
+      sg.fillText(name, (STAMP_W - nw) / 2, STAMP_H / 2 - 12);
+
+      const qty = `×${count}`;
+      sg.font = "bold 26px 'Courier New', monospace";
+      const qw = sg.measureText(qty).width;
+      sg.fillText(qty, (STAMP_W - qw) / 2, STAMP_H / 2 + 20);
+
+      sg.fillStyle = 'rgba(255,255,255,0.5)';
+      sg.font = "9px 'Courier New', monospace";
+      sg.fillText('SHIPPED / NO QUESTIONS', 22, 34);
+      sg.restore();
+    },
+  };
+}
--- a/fktry/src/screen/params.ts
+++ b/fktry/src/screen/params.ts
@ -1,7 +1,11 @@
 /**
- * The eight glitch parameters, ported verbatim from the WIMVEE GLYTCH prototype.
- * Names and semantics are load-bearing: the fragment shader reads `u_<key>` and the
- * prototype's tuning assumes these exact ranges (0..1 each).
+ * The glitch parameters. The first eight are ported verbatim from the WIMVEE GLYTCH
+ * prototype — names and semantics are load-bearing: the fragment shader reads `u_<key>`
+ * and the prototype's tuning assumes these exact ranges (0..1 each). Their maths is
+ * untouched.
+ *
+ * The last three (round 2) are artifact classes the original eight could not express:
+ * they are new shader passes, not new blends of old ones.
 */

 export const PARAMS = [
@ -13,13 +17,19 @@ export const PARAMS = [
  'burn',   // film burn blotches
  'noise',  // analog snow
  'freeze', // time quantize + dropout
+  'block',  // 8x8 quantization: flat blocks, hard seams, posterized colour
+  'ring',   // Gibbs ringing: oscillating halos hugging contrast edges
+  'moire',  // interference lattice: beat pattern + rainbow sheen
 ] as const;

 export type Param = (typeof PARAMS)[number];
 export type ParamSet = Record<Param, number>;

 export function zeroParams(): ParamSet {
-  return { mosh: 0, melt: 0, chroma: 0, tear: 0, roll: 0, burn: 0, noise: 0, freeze: 0 };
+  return {
+    mosh: 0, melt: 0, chroma: 0, tear: 0, roll: 0, burn: 0, noise: 0, freeze: 0,
+    block: 0, ring: 0, moire: 0,
+  };
 }

 /** Frame-rate independent approach toward a target. `tau` = seconds to ~63% of the way. */