Put the frame in a container with no decoder, and find the palette is not free

ROADMAP K2. DLXP1: a 49,664 B record that is 97 sectors exactly, no index and
no length word, because a packed record's length is geometry rather than
content. 582.0 KB/s, which is what FINDINGS 61.9 predicted to the tenth, and it
encodes in 3.3 s because there is no k-means in it.

px68k's own x68k/gvram.c renders the container's bytes index-exact with the
harness computing no interleave -- the only test that can catch an encoder whose
byte order is wrong, since a container round-trips against its own inverse
either way. Both negative controls fail as they must.

The picture is re-derived against this project's builder rather than PIL's
(34.05 dB against 61.9's 34.08) and the GGGGGRRRRRBBBBBI word is charged for the
first time in this tree: 0.53 dB, on every row, so it moves no comparison.

What the control found is the finding. A packed container on a SCENE palette
lands exactly on the codec's ceiling, so the whole +2.31 dB is the per-frame
palette and nothing else -- and 231 of 256 entries change every frame, which
makes a mismatched paint 12.8 dB worse than the correct pairing, on screen for
roughly half of every frame slot if buffer mode does not blank. So B2 now
decides which packed CONTAINER ships, not only which player. The fallback is
already a flag: --scene-palette --no-palette is 30.79 dB, zero churn, 576.0 KB/s
and still +2.07 dB on the shipping codec.

62.5 is priced and is a wash: palette first 20.32 dB, palette last 20.33.

Claude-Session: https://claude.ai/code/session_01194oWYW8DQXK1SZ2DnChW6

docs/ROADMAP.md

@@ -42,6 +42,19 @@ the run bounds the model and not the board, and what a real palette register
 does with a byte write is UNMEASURED. B4 is the cheapest hardware item in the
 project and a negative costs 0.28% of a frame. **K2, the packed container, is
 next.**
+Amended end of session 31: **K2 IS DONE, AND IT COST THE BRANCH SOMETHING
+(FINDINGS 63).** DLXP1 is a 49,664 B record = 97 sectors exactly, no index, no
+decoder, 582.0 KB/s — exactly 61.9's prediction — and px68k's own `gvram.c`
+renders the container's bytes index-exact with the harness computing no
+interleave. 61.9's picture claim survives the real builder: **34.05 dB against
+its 34.08**, and the hardware GRB555 word is charged on top for the first time
+in this project (0.53 dB, on every row, so it moves nothing). **But the control
+row landed exactly on the codec's ceiling**, so the whole +2.31 dB is the
+PER-FRAME PALETTE and nothing else — and 90% of that palette changes every
+frame, which makes a mismatched paint **12.8 dB worse** than the correct
+pairing. **B2 now decides which packed CONTAINER exists, not only which player**
+(63.4). The fallback is a flag: `--scene-palette --no-palette` is 30.79 dB, zero
+churn, 576.0 KB/s and still +2.07 dB on the shipping codec. **K3 is next.**
 
 **THE COMPLETION TARGET IS M3, THE VERTICAL SLICE** (USER DECISION): one scene
 tree — a decision point, two outcomes, a death clip — with audio, streaming from
@@ -128,6 +141,17 @@ the priority register `0xE82500` at `0x0000` (47.3).
 > is dark for **30..113%**. Under MAME's reading the cheap architecture is the
 > dark one. **B2 and B1 are now the same decision from two sides, and B2 is the
 > five-minute half.**
+>
+> **Session 31 raised it again, from the other direction (FINDINGS 63.4).** If
+> buffer mode does NOT blank, the packed player's per-frame palette is not
+> merely visible during the paint — **231 of 256 entries change every frame**,
+> and a picture under the neighbouring frame's palette is **12.8 dB worse** than
+> the correct pairing, on screen for roughly half of every frame slot at 12 fps.
+> So a non-blanking board does not just cost the packed player a blank interval,
+> it may cost it the per-frame palette — which is **the whole +2.31 dB** the
+> branch has over the codec's ceiling. The fallback is already an encoder flag
+> (`pack.py --scene-palette --no-palette`: 30.79 dB, no churn, 576.0 KB/s), so
+> what B2 decides is now **which packed container ships**, not whether one can.
 
 **B4. Does a real palette register take a BYTE write?** (62.4, new session 30.)
 `$E82000` is 256 16-bit registers. The decoder-free packed player's per-frame
@@ -243,14 +267,25 @@ frame is not tied to a scene palette the codec's codewords index into. It costs
   over `memory_array`, whose `write16` is a plain `COMBINE_DATA`, so it has no
   handler to be wrong about and cannot discriminate. And it filed one open
   design choice, 62.5: palette FIRST or 193rd is visible on screen and is not
-  decided.
-- **K2. A packed container.** Quantise to **254** colours (index 0 is the
-  transparency key, black at 255 — 47.2), interleave column *i* with *i+128*,
-  emit a per-frame palette, sector-align the record. Simpler than a coded one:
-  no VQ, no rate control, no mode map, no `lam`. `encode.py` already aligns
-  (DLX5) and `prep_frame.py --pack-transparent` already emits the layout.
-  **Re-derive 61.9's 34.08 dB against `vq.scene_palette` here** — the measured
-  figure is PIL's MEDIANCUT and is a direction, not the player's number.
+  decided. **Session 31 PRICED it and it is a wash — 20.32 dB against 20.33
+  (63.4) — so it is a container flag (`--palette-last`) and K3 runs both.**
+~~**K2. A packed container.**~~
+  **DONE, session 31 — FINDINGS 63.** `tools/encoder/dlxp.py` is DLXP1 and
+  `pack.py` writes it: 254 colours with index 0 held free and black at 255,
+  column *i* interleaved with *i+128*, a per-frame palette, and a **49,664 B
+  record that is 97 sectors EXACTLY** — the alignment that cost session 28 a
+  re-encode is free here because a packed record's length is geometry. **No
+  index and no length word**, for the same reason: nothing has to be walked.
+  **582.0 KB/s, which is 61.9's prediction to the tenth.** Encodes in 3.3 s
+  because there is no k-means in it.
+  **The re-derivation is done and 61.9 survives it: 34.05 dB against 34.08**,
+  and the GRB555 word is charged for the first time (63.3) — 0.53 dB, on every
+  row of the table, so it moves no comparison. **The two reserved entries cost
+  0.0003 dB.**
+  **What it also found** (63.4): the SCENE-palette control lands exactly on the
+  codec's ceiling, so the whole +2.31 dB is the per-frame palette; 90% of that
+  palette changes every frame; and a mismatched paint is 12.8 dB worse, for
+  roughly half of every frame slot, if buffer mode does not blank.
 - **K3. End to end, off the disc.** Palette, page-1 X-scroll 384, priority
   `vc1 = 0x0002`, R20 bit 11; one chained DMA a frame. Gated pixel-exact over the
   same 120-frame window the decoder is gated on.
@@ -261,8 +296,10 @@ DMAC-direct packed player has **no ring** — `ring.i`, `xfer.i` and most of
 simplification that large usually hides something, and 61.7.2 names the specific
 untested thing: a chained transfer has never run back to back at 12 fps.
 
-**K1 and K2 survive a bad answer to B2. K3 does not.** ~~Do K1 first.~~ **K1 is
-done (session 30, FINDINGS 62); K2 is next.**
+**K1 and K2 survive a bad answer to B2. K3 does not.** ~~Do K1 first.~~ ~~K1 is
+done (session 30, FINDINGS 62); K2 is next.~~ **Both are done. K3 is next — and
+63.4 added a second thing for it to run: BOTH palette orders, which is a flag
+(`--palette-last`) and not a re-encode.**
 
 ---
 
@@ -683,6 +720,7 @@ P2 re-encode bundle DONE (60): DLX5, records ARE sectors ───────
                                                                   │
 K1 palette-register DMA? ─> K2 packed container ─> K3 end to end ──┤
   (61.9; K1/K2 survive a bad B2, K3 does not)                     │
+  K1 DONE s30 (62), K2 DONE s31 (63) ── K3 is the open one         │
 P4a WIRING (the channel behind ring.i's mailbox) <- THE LAST ITEM ─┤
 P1 P2 P3 P4b P5 P7, P6 bus cost (52), G1 scene graph (56) ────────┼─> M2 ─>
 B1 seek+rate (sets HEADROOM, not fit) ─────────────────────────────┘   M3 ─> M4