Put the player on a real volume, and find the write window is the frame

ROADMAP K3. src/player/packed.s (2,898 B) brings up its own display, builds
its own 193-entry DMA chain, keeps its own frame clock off V-DISP and fetches
every record itself with READ(10) off a CZ-6BS1. The rig writes no picture
byte, no palette entry and no CRTC register.

120 of 120 frames pixel-exact, every one compared, in both palette orders --
the gate had to grow to do it, because a packed frame is a LITERAL and the
codec's recursion was what made one comparison audit 120.

And the write window turns out to be the frame. A packed write requires R20
bit 11, buffer mode blanks the layer, and a DMAC-direct player holds the
window open for the whole data phase, so

    dark fraction of a slot = record bytes / (DATA-PHASE rate x slot)

which is 1.0 at the container's own 582.0 KB/s: every frame delivered, on
time, pixel-exact, and none of them displayed. The rate in that expression is
the BURST rate, a third hardware number B1 has no test for. It reverses 61.5's
ranking -- a packed player that DMAs to RAM and paints with the measured 27.3%
blit is on screen 72.7% of every slot at any rate, and the two are equal only
at 2,131 KB/s = 3.7x the wire.

And a held channel costs the frame clock half its ticks without the clock
being able to tell: 487 of 1,038 V-DISP edges lost, zero late frames reported,
the player believing 12 fps while the screen ran at 6.37.

FINDINGS 64. ROADMAP K4 opened and fenced behind B2.
check.sh ALL GREEN before and after.

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

tools/bench/mkvol.sh

@@ -3,7 +3,21 @@
 # instantiate the card.  Sourced-by-calling from tools/bench/scsi_run.sh and
 # tools/bench/pace_run.sh so there is ONE copy of the layout.
 #
-#   tools/bench/mkvol.sh [container.dlx]
+#   tools/bench/mkvol.sh [container.dlx | container.dlxp]
+#
+# TWO CONTAINERS, ONE VOLUME BUILDER.  A DLX volume is tools/bench/prep_stream.py's
+# disk image -- the codec's records, laid down from sector 0.  A DLXP volume
+# (ROADMAP K2/K3) needs no preparation at all: the container is ALREADY a
+# sector-aligned image of itself -- a 512 B header, then fixed 97-sector records
+# -- so the file IS the volume and copying it is the whole build.  That is not a
+# convenience, it is the format's central claim (tools/encoder/dlxp.py) arriving
+# at the disc, and a builder that transformed it on the way would be hiding the
+# claim rather than testing it.
+#
+# The two get DIFFERENT CHD NAMES.  Alternating between the packed rig and the
+# codec rig would otherwise rebuild the volume on every run, and -- much worse --
+# a stale CHD under the name the other rig expected would serve one container's
+# bytes to the other's gate, which reads as a decode failure and is not one.
 #
 # ONE COPY, ON PURPOSE.  The volume is tmp/stream_disk.bin -- byte for byte the
 # file the host-file ring rig reads -- laid out as 512 B sectors.  If two scripts
@@ -22,15 +36,24 @@ set -e
 cd "$(dirname "$0")/../.."
 DLX=${1:-tmp/rc_fr_singe_scsi_span.dlx}
 
-[ -f tmp/stream_disk.bin ] || python3 tools/bench/prep_stream.py "$DLX" > /dev/null
-if [ ! -f tmp/dlxdisk.chd ] || [ tmp/stream_disk.bin -nt tmp/dlxdisk.chd ]; then
-  python3 - <<'PY'
-d = open("tmp/stream_disk.bin", "rb").read()
+case "$DLX" in
+  *.dlxp) SRC="$DLX"
+          IMG=tmp/dlxpdisk.img; CHD=tmp/dlxpdisk.chd ;;
+  *)      SRC=tmp/stream_disk.bin
+          IMG=tmp/dlxdisk.img;  CHD=tmp/dlxdisk.chd
+          [ -f "$SRC" ] || python3 tools/bench/prep_stream.py "$DLX" > /dev/null ;;
+esac
+
+if [ ! -f "$CHD" ] || [ "$SRC" -nt "$CHD" ]; then
+  SRC="$SRC" IMG="$IMG" python3 - <<'PY'
+import os
+src, img = os.environ["SRC"], os.environ["IMG"]
+d = open(src, "rb").read()
 n = (len(d) + 511) // 512
-open("tmp/dlxdisk.img", "wb").write(d + b"\0" * (n * 512 - len(d)))
+open(img, "wb").write(d + b"\0" * (n * 512 - len(d)))
 print(f"  disc image: {len(d)} B of records -> {n} sectors")
 PY
-  rm -f tmp/dlxdisk.chd
+  rm -f "$CHD"
   # -c none IS LOAD-BEARING, and it was found by a gate rather than by taste.
   # Session 28, on the DLX5 volume: with the default (lzma/zlib/huff/flac) MAME
   # 0.277 served the CHD FILE'S OWN BYTES as sector data -- the destination
@@ -45,7 +68,7 @@ PY
   # disc space: the failure is SILENT at the transport layer -- every READ(10)
   # reports success and returns the wrong bytes -- and only the byte comparison
   # in tools/bench/scsi.lua catches it.
-  chdman createhd -i tmp/dlxdisk.img -o tmp/dlxdisk.chd -ss 512 -c none > /dev/null 2>&1
+  chdman createhd -i "$IMG" -o "$CHD" -ss 512 -c none > /dev/null 2>&1
 fi
 
 mkdir -p tmp/p4roms/x68k_cz6bs1