req c11,

Still don't have this thing in its final state for  the curse but its close.

.gitignore

@@ -15,3 +15,5 @@ toolchain/PSn00bSDK
 *.a
 .sentry-native
 .vscode/settings.json
+toolchain/lfs
+toolchain/lpeg

.vscode/launch.json

@@ -4,7 +4,7 @@
 	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 	"version": "0.2.0",
 	"configurations": [
-		{
+{
 			"name": "Debug: Hello Psy-Q!",
 			"type": "gdb",
 			"request": "attach",
@@ -12,6 +12,10 @@
 			"remote": true,
 			"cwd": "${workspaceRoot}/build",
 			"valuesFormatting": "parseText",
+			"registerLimit": "1-32",
+			"frameFilters": false,
+			"showDevDebugOutput": false,
+			"printCalls": false,
 			"stopAtConnect": true,
 			"gdbpath": "gdb-multiarch",
 			"windows": {
@@ -20,10 +24,17 @@
 			"osx": {
 				"gdbpath": "gdb"
 			},
-			"executable": "${workspaceRoot}/build/hello_psyq.elf",
+			"executable": "${workspaceRoot}/build/hello_gte.elf",
+			"setupCommands": [
+				{ "text": "set mi-async off" },
+				{ "text": "set remotetimeout 0" },
+				{ "text": "set logging file build/gen/hello_gte.gdb.log" },
+				{ "text": "set logging redirect on" }
+			],
 			"autorun": [
 				"monitor reset shellhalt",
-				"load hello_psyq.elf",
+				"load hello_gte.elf",
+				"source scripts/gdb/gdb_tape_atoms.gdb",
 				"tbreak main",
 				"continue"
 			]
@@ -36,6 +47,10 @@
 			"remote": true,
 			"cwd": "${workspaceRoot}/build",
 			"valuesFormatting": "parseText",
+			"registerLimit": "1-32",
+			"frameFilters": false,
+			"showDevDebugOutput": false,
+			"printCalls": false,
 			"stopAtConnect": true,
 			"gdbpath": "gdb-multiarch",
 			"windows": {
@@ -44,10 +59,16 @@
 			"osx": {
 				"gdbpath": "gdb"
 			},
-			"executable": "${workspaceRoot}/build/hello_gpu.elf",
+			"executable": "${workspaceRoot}/build/hello_gte.elf",
+			"setupCommands": [
+				{ "text": "set mi-async off" },
+				{ "text": "set remotetimeout 0" },
+				{ "text": "set logging file build/gen/hello_gte.gdb.log" },
+				{ "text": "set logging redirect on" }
+			],
 			"autorun": [
 				"monitor reset shellhalt",
-				"load hello_gpu.elf",
+				"load hello_gte.elf",
 				"tbreak main",
 				"continue"
 			]
@@ -60,6 +81,10 @@
 			"remote": true,
 			"cwd": "${workspaceRoot}/build",
 			"valuesFormatting": "parseText",
+			"registerLimit": "1-32",
+			"frameFilters": false,
+			"showDevDebugOutput": false,
+			"printCalls": false,
 			"stopAtConnect": true,
 			"gdbpath": "gdb-multiarch",
 			"windows": {
@@ -69,12 +94,55 @@
 				"gdbpath": "gdb"
 			},
 			"executable": "${workspaceRoot}/build/hello_gte.elf",
+			"setupCommands": [
+				{ "text": "set mi-async off" },
+				{ "text": "set remotetimeout 0" },
+				{ "text": "set logging file build/gen/hello_gte.gdb.log" },
+				{ "text": "set logging redirect on" }
+			],
 			"autorun": [
 				"monitor reset shellhalt",
 				"load hello_gte.elf",
 				"tbreak main",
 				"continue"
 			]
+		},
+		{
+			"name": "Debug: Hello GTE Psy-Q! (atoms debug — DWARF-injected)",
+			"type": "gdb",
+			"request": "attach",
+			"target": "localhost:3333",
+			"remote": true,
+			"cwd": "${workspaceRoot}",
+			"valuesFormatting": "parseText",
+			"registerLimit": "1-32",
+			"frameFilters": false,
+			"showDevDebugOutput": false,
+			"printCalls": false,
+			"stopAtConnect": true,
+			"gdbpath": "gdb-multiarch",
+			"windows": {
+				"gdbpath": "gdb-multiarch.exe"
+			},
+			"osx": {
+				"gdbpath": "gdb"
+			},
+			"executable": "${workspaceRoot}/build/hello_gte.dwarf-injected.elf",
+			"setupCommands": [
+				{ "text": "set mi-async off" },
+				{ "text": "set remotetimeout 0" },
+				{ "text": "set logging file build/gen/hello_gte.gdb.log" },
+				{ "text": "set logging redirect on" }
+			],
+			"autorun": [
+				"monitor reset shellhalt",
+				"load build/hello_gte.dwarf-injected.elf",
+				"source scripts/gdb/gdb_tape_atoms.gdb",
+				"source build/gen/hello_gte.gdbinit",
+				"tbreak main",
+				"continue"
+			]
 		}
 	]
 }
+

code/duffle/atom_dsl.h

@@ -2,437 +2,144 @@
  * atom_dsl.h
  * ============================================================================
  *
- * ATOM DSL — annotation layer for tape atoms (lottes_tape.h).
+ * ATOM DSL: Annotation layer for tape atoms (lottes_tape.h).
+ * The metaprogram (scripts/passes/annotation.lua) reads source-as-written and validates:
+ *   - atom_info(...) shape: up to three sub-calls (atom_bind(Binds_X), atom_reads(...), atom_writes(...)) in any order and are optional.
+ *   - rbind atoms (atom_info(..., atom_bind(Binds_X), ...)) reference a real Binds_* struct declaration.
+ *   - atom word-counts in word_counts.metadata.h match the body's actual .word count.
  *
- * This header turns `__attribute__((annotate(...)))` and `_Pragma(...)` into
+ * Pure macro anntation.
- * a small named DSL that the metaprogram can validate against.
+ * ---------------
- *
+ * Don't want to constraint the macro usage to some attribute placment constraint, etc, don't want ot dela with the compiler.
- *   The C compiler treats every macro below as a no-op:
+ * atom_info, atom_bind, atom_reads, atom_writes, atom_label, atom_dbg_skip each expand to a C comment or to nothing
- *     - atom_init / atom_terminate / atom_bind / atom_setup / atom_commit /
+ * (C preprocessor strips them to whitespace).
- *       atom_annot all expand to `__attribute__((annotate("..."))) MipsAtom_(name)`
- *       — accepted by GCC (with -Wno-attributes), absent at runtime.
- *     - atom_resource / atom_region / atom_group / atom_cadence / atom_async
- *       expand to `_Pragma("...")` — accepted by any C11 preprocessor.
- *
- *   The metaprogram (tape_atom_annotation_pass.lua) reads the source-as-written
- *   and validates:
- *     - every MipsAtom_ has one atom_*() annotation (no orphans)
- *     - phase is recognized (init/bind/setup/work/commit/terminate)
- *     - reads/writes reference canonical wave-context registers
- *     - rbind atoms reference a real Binds_* struct declaration
- *     - word-counts in tapre metadata agree with the body's actual .word count
- *     - resource/region/group/cadence/async pragmas are spelled correctly and
- *       reference known enum values
  *
  * ============================================================================
- *
+ *  Usage:
- *  PUTTING IT ON AN ATOM — the canonical pattern
+ *      MipsAtom_(cube_tri) atom_info(
- *
+ *         atom_reads (R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
- *      _tape_resources_
+ *       , atom_writes(R_PrimCursor, R_FaceCursor)
- *      atom_resource(cube_tri, "model_ship_cube")
+ *      ){
- *      atom_region  (cube_tri, PRIM_ARENA)
- *      atom_group   (cube_tri, GROUP_RENDER_PRIMS)
- *      atom_cadence (cube_tri, CADENCE_FRAME)
- *
- *      atom_annot(cube_tri, phase_work,
- *                 tape_regs(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
- *                 tape_regs(R_PrimCursor, R_FaceCursor))
- *      internal MipsAtom_(cube_tri) {
  *          atom_label(culling),
  *          // ... atom body ...
+ *          atom_offset(culling, bounds_chk)         // branch target, validated
+ *          // ... atom body ...
  *          atom_label(bounds_chk),
  *      };
  *
- *      atom_offset(culling, bounds_chk)         // ← branch target, validated
  *
- *  RBIND pattern — `Binds_*` is the contract
+ *  Data Binding pattern -- atom_bind as a sub-call of atom_info
  *
  *      // Wave-context register layout (declarative):
- *      typedef struct Binds_TrackFaceBatch {
+ *      typedef Struct_(Binds_TrackFaceBatch) { 
- *          U4 R_PrimCursor,  R_FaceCursor,
+ * 					U4 PrimCursor; 
- *            R_VertBase,    R_OtBase;
+ * 					U4 FaceCursor;
- *      } Binds_TrackFaceBatch;
+ *          U4 VertBase;
- *
+ * 					U4 OtBase;
- *      atom_resource(rbind_track_face_batch, "track_face_batch_42")
+ *      };
- *      atom_region  (rbind_track_face_batch, HEAP_3D)
+ *      MipsAtom_(rbind_track_face_batch) atom_info(
- *      atom_group   (rbind_track_face_batch, GROUP_LOAD_FACES)
+ *         atom_bind(Binds_TrackFaceBatch)
- *      atom_cadence (rbind_track_face_batch, CADENCE_ONDEMAND)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
- *      atom_async   (rbind_track_face_batch, true)
+ *      ){ ... };
- *
- *      atom_bind(rbind_track_face_batch, Binds_TrackFaceBatch,
- *                tape_regs(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase))
- *      internal MipsAtom_(rbind_track_face_batch) { ... };
  *
  *  Annotation rules
  *  ----------------
- *      1. Each MipsAtom_(name) needs EXACTLY ONE atom_*() macro on the line
+ *      1. atom_info(...) is OPTIONAL. Atoms without atom_info are silently skipped by the metaprogram.
- *         immediately above. No annotation = orphan (warning). Two annotations
+ *      2. If present, atom_info takes up to three sub-calls, all order-independent within the arg list:
- *         on the same name = duplicate (error).
+ *           - atom_bind(Binds_X)
- *
+ *           - atom_reads(...)
- *      2. atom_init and atom_terminate take only the name.
+ *           - atom_writes(...)
- *
+ *      3. atom_bind(Binds_X): metaprogram cross-references Binds_X against the `typedef struct Binds_X { ... } Binds_X;` declaration.
- *      3. atom_setup and atom_commit take name + reads.
+ *      4. atom_reads(...) and atom_writes(...): Used to to check if registers are used correctly in macros: R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase.
- *
+ *      5. atom_label(name: Utilize with atom_offset as a target location.
- *      4. atom_bind takes name + Binds_* type + writes.
+ *      6. atom_offset(F, T): Resolved by gen/atom_offsets.h, generated from the atom_label markers. Calculated during the offset pass of the lua  metaprogram.
- *
- *      5. atom_annot takes name + phase token + reads + writes.
- *         Phase tokens: phase_init / phase_bind / phase_setup / phase_work /
- *         phase_commit / phase_terminate.
- *
- *      6. Optional pragmas (atom_resource / atom_region / atom_group /
- *         atom_cadence / atom_async) attach metadata to the atom. They can
- *         appear in any order, with one per atom. They're independent of the
- *         atom_*() macro — multiple pragmatics are fine.
- *
- * ============================================================================
- *
- *  WHY A SEPARATE LAYER (not just put everything in source comments)?
- *
- *      Source comments are invisible to the compiler. Annotations live in the
- *      source as actual C tokens, so:
- *        - they can never silently get out of sync with the code (the build
- *          fails at preprocessing if the metaprogram disagrees)
- *        - they can be cross-validated against metadata (build fails if a
- *          WORD_COUNT entry drifts away from the .word count in source)
- *        - they make the C compiler a witness ("there's a marker here, and
- *          it's labelled, and it has arguments") without making the C compile
- *          itself do any work
- *
- * ============================================================================
  */
 
- #ifdef INTELLISENSE_DIRECTIVES
+#ifdef INTELLISENSE_DIRECTIVES
 #pragma once
 // #include <stdint.h>
 #endif
 
 /* ============================================================================
- * PHASE TOKENS — strings, used as the second arg to atom_annot(...)
+ * atom_reads(...) / atom_writes(...)
- *
- * Why strings? They preserve the metaprogram's ability to read phase directly
- * from the source-as-written, even when the macro isn't expanded. The Lua
- * tool also has a MACRO_EXPANSION table for resolving phase_* source-level
- * references.
- *
- *   atom_annot(cube_tri, phase_work, ...)    ← legal
- *   atom_annot(cube_tri, "work", ...)        ← legal (and equivalent)
- *   atom_annot(cube_tri, phase_setup, ...)   ← legal
- *
- * ============================================================================*/
-
-#define phase_init       "init"
-#define phase_bind       "bind"
-#define phase_setup      "setup"
-#define phase_work       "work"
-#define phase_commit     "commit"
-#define phase_terminate  "terminate"
-
-/* ============================================================================
- * WAVE-CONTEXT REGISTERS — canonical register set for the tape wave model.
- *
- * The tape-atom runtime carries four registers across a wave:
- *
- *   R_PrimCursor  output pointer into the prim arena (next OT entry to write)
- *   R_FaceCursor  input pointer into the face array (next face to consume)
- *   R_VertBase    base pointer into the vertex arena (this wave's vertices)
- *   R_OtBase      base pointer into the ordering table (this wave's OT slot)
- *
- * Each atom declares its reads/writes against this canonical set. The Lua
- * tool rejects wave-context positions that reference any other register
- * (warning today — the C compiler's R_T4..R_T7 / R_RA / etc. aliases are
- * implementation details and not part of the typed surface).
- *
- * If your atom needs to touch GTE / SP / DMA / other side state, declare it
- * at the source level as you normally would — but DO NOT put those registers
- * in tape_regs(...). Wave-context is a closed set.
- *
- * ============================================================================*/
-
-/* ============================================================================
- * REGION TOKENS — memory regions atoms may allocate from or write into.
- *
- * Use atom_region(name, REGION) to declare. The Lua tool validates that the
- * region is in this set, AND that:
- *   - rbind atoms declare the source region (usually HEAP_3D or CDROM_STREAM)
- *   - work atoms declare the destination region (the arena they push to)
- *   - commit atoms must declare a region equal to what setup wrote, so the
- *     C-side mirror is consistent
- *
- * Add new regions by extending this list and the metaprogram's KNOWN_REGIONS.
- * Don't add regions ad-hoc — every new region becomes part of the contract.
- *
- * ============================================================================*/
-#define REGION_PRIM_ARENA     prim_arena       /* OT/prim packet arena */
-#define REGION_FACE_ARENA     face_arena       /* face index array */
-#define REGION_VERTEX_ARENA   vertex_arena     /* vertex pool */
-#define REGION_OT_ARENA       ot_arena         /* ordering-table array */
-#define REGION_HEAP_3D        heap_3d_models   /* loaded model heap */
-#define REGION_CDROM_STREAM   cdrom_stream     /* CDROM read buffer */
-#define REGION_VRAM           vram_heap        /* VRAM texture/GPU buffer */
-
-/* ============================================================================
- * CADENCE TOKENS — how often the atom runs.
- *
- *   frame    runs every vsync (rendering, input poll)
- *   once     runs exactly once per process lifetime (init, terminate)
- *   ondemand runs when triggered by event (CDROM load, async DMA complete)
- *
- * Used as a hint for the metaprogram to flag:
- *   - frame-cadence atoms that have side effects (they'll be hit many times,
- *     so avoid global state mutation unless it's idempotent)
- *   - once-cadence atoms inside "if (frame_count == 0)" guards (the guard
- *     is then provably one-shot, the metaprogram can lift initialization)
- *   - ondemand atoms that are missed by the wave scheduler (forces async
- *     and discards yield results without further processing)
- *
- * ============================================================================*/
-#define CADENCE_FRAME     frame
-#define CADENCE_ONCE      once
-#define CADENCE_ONDEMAND  ondemand
-
-/* ============================================================================
- * tape_regs(...) — wave-context register list
- *
- *   tape_regs(R_PrimCursor, R_FaceCursor)  →  (R_PrimCursor, R_FaceCursor)
- *
- * The macro produces a comma-evaluated expression that the C compiler
- * silently discards (it's wrapped in parentheses in the call argument
- * position — the result is never bound). The Lua tool pattern-matches the
- * "tape_regs(...)" token to extract the list.
- *
- * You can have at most one tape_regs(...) in the reads slot and one in the
- * writes slot of atom_annot. To declare multiple disjoint sets (rare), just
- * declare the union — the metaprogram doesn't track which reads need which
- * writes at this granularity.
  *
+ * Used during the static analysis pass of the metaprogram to do
  * ============================================================================*/
 #define atom_reads(...)  (__VA_ARGS__)
 #define atom_writes(...) (__VA_ARGS__)
 
-/* ============================================================================
- * ATOM ANNOTATION MACROS
- *
- *   Each expands to `__attribute__((annotate("kind"))) MipsAtom_(name)` —
- *   the GCC attribute is accepted under -Wno-attributes (already in your
- *   build flags) and stripped at runtime. The annotation string is just the
- *   macro kind ("atom_annot", "atom_bind", etc.) — the metaprogram reads
- *   the macro call's full args list from the source-as-written.
- *
- * ============================================================================*/
-
 /* ----------------------------------------------------------------------------
- * atom_init — entry into tape_runtime_main
+ * atom_reg (per-enum opt-in marker for the DWARF register-alias registry)
  *
- *   atom_init(tape_main)
+ * The bare `atom_reg` token adjacent to an enum entry in mips.h / lottes_tape.h flags that alias as debug-visible for scan_source's register_alias_registry.
- *   internal MipsAtom_(tape_main) { ... };
+ * The C preprocessor strips it to a comment so no runtime symbol is created; the Lua scanner reads the bare token.
- *
- * Implies: no reads, no writes (wave-context not established yet).
  * ----------------------------------------------------------------------------*/
-#define atom_init(name) __attribute__((annotate("atom_init")))
+#define atom_reg /* atom_reg: opt the preceding enum entry into the DWARF registry */
-
-/* ----------------------------------------------------------------------------
- * atom_terminate — exit from tape_runtime_main
- *
- *   atom_terminate(tape_exit)
- *   internal MipsAtom_(tape_exit) { ... };
- *
- * Implies: no reads, no writes (wave-context destroyed at this point).
- * ----------------------------------------------------------------------------*/
-#define atom_terminate(name) __attribute__((annotate("atom_terminate")))
-
-/* ----------------------------------------------------------------------------
- * atom_setup — pre-work atom: prepares engine state (e.g., set_gte_world)
- *
- *   atom_setup(set_gte_world, tape_regs(R_TapePtr))
- *   internal MipsAtom_(set_gte_world) { ... };
- *
- * Reads:   anything (the engine state you're reading)
- * Writes:  engine state (GTE / DMA / etc. — declared in source, not part of
- *          wave-context, so doesn't go in tape_regs)
- *
- * The metaprogram checks that setup is followed (in atomic order) by a work
- * atom in the same wave — there's no point in setting up state if no one
- * reads it.
- * ----------------------------------------------------------------------------*/
-#define atom_setup(name, reads) __attribute__((annotate("atom_setup")))
-
-/* ----------------------------------------------------------------------------
- * atom_commit — post-work atom: flushes wave-context back to C-side state
- *
- *   atom_commit(sync_prim_cursor, tape_regs(R_PrimCursor))
- *   internal MipsAtom_(sync_prim_cursor) { ... };
- *
- * Reads:   wave-context registers (the ones you sync back to C)
- * Writes:  C-side mirror (declared in source — not part of wave-context)
- *
- * The metaprogram checks that commit is preceded (in atomic order) by a
- * work atom that wrote the registers this commit is reading.
- * ----------------------------------------------------------------------------*/
-#define atom_commit(name, reads) __attribute__((annotate("atom_commit")))
-
-/* ----------------------------------------------------------------------------
- * atom_bind — rbind atom: read wave-context registers from tape pointer
- *
- *   atom_bind(rbind_cube_tri, Binds_CubeTri,
- *             tape_regs(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase))
- *   internal MipsAtom_(rbind_cube_tri) { ... };
- *
- * The binds_struct MUST be a typedef'd type (declared via
- * `typedef struct Binds_X { ... } Binds_X;` somewhere in the source).
- * The Lua tool cross-references this. Missing struct = error.
- *
- * Implicit: reads R_TapePtr, writes the four wave-context registers.
- * ----------------------------------------------------------------------------*/
-#define atom_bind(name, binds_struct, writes) __attribute__((annotate("atom_bind")))
-
-/* ----------------------------------------------------------------------------
- * atom_annot — generic work atom with explicit phase
- *
- *   atom_annot(cube_tri, phase_work,
- *              tape_regs(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
- *              tape_regs(R_PrimCursor, R_FaceCursor))
- *   internal MipsAtom_(cube_tri) { ... };
- *
- * Use this for the bulk of your atoms. For init/setup/commit/bind, prefer
- * the convenience macros above — they pin the phase for you.
- *
- * The phase arg is one of: phase_init / phase_bind / phase_setup /
- * phase_work / phase_commit / phase_terminate. Spelling mistakes are errors.
- * ----------------------------------------------------------------------------*/
-#define atom_annot(name, phase, reads, writes) __attribute__((annotate("atom_annot")))
 
 /* ============================================================================
- * RESOURCE / GROUP / CADENCE / REGION / ASYNC — optional atom metadata
+ *   atom_info :
- *
+ *      MipsAtom_(cube_tri) atom_info(
- *   These don't annotate the atom semantically (phase/reads/writes do that).
+ *         atom_reads (R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
- *   They attach extra context that the metaprogram uses to catch:
+ *       , atom_writes(R_PrimCursor, R_FaceCursor)
- *     - same resource loaded twice in different ways
+ *      ){ ... };
- *     - atoms that span multiple regions (likely bug — pick one)
- *     - frame-cadence atoms that should be once-cadence (perf / correctness)
- *     - ondemand atoms that aren't async (CDROM races)
- *
- *   You can use as many as apply to a given atom, in any order, immediately
- *   above the atom_*() macro.
  * 
+ *  - atom_bind(Binds_X): metaprogram cross-references Binds_X against the `typedef struct Binds_X { ... } Binds_X;` declaration.
+ *  - atom_reads(...):    comma-list of registers
+ *  - atom_writes(...):   comma-list of registers
  * ============================================================================*/
+#define atom_info(...)  /* atom_info(__VA_ARGS__) */
 
 /* ----------------------------------------------------------------------------
- * atom_resource — name the logical resource the atom references
+ * DEBUG SOURCE-STEP MARKER
  *
- *   atom_resource(cube_tri, "model_ship_cube")
+ * Place `atom_dbg_skip` (BARE) before a MipsAtom_, MipsAtomComp_, or MipsAtomComp_Proc_.
- *   atom_resource(load_track_faces, "track_lavender_field_0x42")
+ * The following declaration kind determines whether the marker selects a whole atom or a component inline view.
- *   atom_resource(play_engine_sfx, "sfx_engine_loop")
+ * The source scanner associates the marker with that declaration; placement diagnostics are handled by the annotation pass.
  *
- * Use any human-readable string. The metaprogram:
+ * Example:
- *   - validates resource strings are non-empty and don't contain control chars
+ *     atom_dbg_skip MipsAtom_(tape_exit) { jump_reg(rret_addr), nop };
- *   - flags duplicates across atoms with the same name (two atoms claiming
+ *     atom_dbg_skip MipsAtomComp_(ac_yield) { ... };
- *     ownership of a resource is usually a refactor artifact or bug)
+ *     atom_dbg_skip MipsAtomComp_Proc_(ac_format_f3_color, { ... });
- *   - flags references to resources that no atom actually defines
- *
- * The arg is a STRING LITERAL, so it can't accidentally alias a variable.
  * ----------------------------------------------------------------------------*/
-#define atom_resource(name, res_id) //_Pragma("atom " #name " resource=" res_id)
+#define atom_dbg_skip /* atom_dbg_skip: skip the following atom or component source view */
 
 /* ----------------------------------------------------------------------------
- * atom_region — name the memory region the atom touches
+ * Typed-view annotations (Registry for DWARF RR_<R_X> chain resolution)
+ *   atom_type(<T>) -- overloaded:
+ *      (a) enum-site default: `R_Foo = R_Tn, atom_reg atom_type(T)` 
+ *      Sets the per-alias default typed view in the register_alias_registry.
+ *      Consumed by the DWARF chain step (e) when no per-atom atom_ctx / atom_phase / atom_type callsite provides a stronger resolution.
+ *      (b) callsite override: `atom_reads(R_Foo atom_type(T), ...)` Overrides the per-alias default for THIS atom only.
+ *      Last-write-wins per R_Name; conflict -> error.
+ *   atom_ctx(<atom_name>) -- atom-info sub-call:
+ *       Propagate another atom's atom.rbind.fields (its Binds_* typed fields) into THIS atom's typed-view resolution.
+ *       The named atom must be an rbind atom (have `atom_bind(Binds_X)` in its `atom_info`).
+ *       Used as the escape hatch when atom_phase is not the natural correlation.
+ *   atom_phase(<label>) -- atom-info sub-call: 
+ *       Free-form C-identifier label for grouping atoms.
+ *       Within a phase, the FIRST atom in source-order that owns its own atom.rbind provides 
+ *       the Binds_* field types used by all other atoms in the same phase.
+ *       The preferred correlation mechanism; atom_ctx is the escape hatch for non-natural cases.
  *
- *   atom_region(cube_tri,   REGION_PRIM_ARENA)
+ * All three expand to C comments
- *   atom_region(load_faces, REGION_HEAP_3D)
+ * (the bare-token convention matching `atom_reg` and `atom_dbg_skip`).
- *   atom_region(load_tex,   REGION_VRAM)
+ * The Lua scanner reads the bare tokens in source-as-written; the C preprocessor strips them.
- *
- * Use REGION_* tokens above. The metaprogram enforces the closed set.
- *
- * Edge cases the metaprogram catches:
- *   - rbind atom that doesn't declare a SOURCE region (where is it loading from?)
- *   - work atom with no destination region (where is it pushing to?)
- *   - region that disagrees with the Binds_* struct layout (you said it's a
- *     prim_arena rbind but the struct has 4 faces in it — wait, that's wrong)
  * ----------------------------------------------------------------------------*/
-#define atom_region(name, region) //_Pragma("atom " #name " region=" #region)
+#define atom_type(T)        /* atom_type: associate <T> with the preceding enum entry (enum site) or this register (atom-info site) */
+#define atom_ctx(atom_name) /* atom_ctx: propagate <atom_name>'s Binds_* field types into this atom's typed views */
+#define atom_phase(label)   /* atom_phase: tag this atom with <label> for grouped typed-view resolution */
 
 /* ----------------------------------------------------------------------------
- * atom_group — bundle atoms into a logical batch (track-load, sound-load, etc.)
+ * atom_bind(Binds_X) -- rbind sub-call of atom_info
  *
- *   atom_group(load_track_face_42,  GROUP_LOAD_FACES)
+ *   MipsAtom_(rbind_cube_tri) atom_info(
- *   atom_group(load_track_face_43,  GROUP_LOAD_FACES)
+ *         atom_bind(Binds_CubeTri)
- *   atom_group(swap_face_42_43,     GROUP_VISIBILITY_SWAP)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+ *   ){ ... };
  *
- * Use any token as the group id. The metaprogram:
+ * The Binds_X MUST be a typedef'd type (declared via `typedef struct Binds_X { ... } Binds_X;` somewhere in the source).
- *   - validates all atoms in a group emit their waves in the same tb_group
- *     (no spawning other waves inside a group)
- *   - flags groups with only one member (probably a typo — meant to be a group?)
- *   - validates cross-group edges (no atom reads what another group writes,
- *     unless explicitly grouped together)
- *
- * Useful when:
- *   - subdivisible work (track-face batches, polygon subdivision) needs to
- *     confirm that all batches of one logical visible scene are emitted
- *     together
- *   - async loads (CDROM -> VRAM) need to be grouped so all batches complete
- *     before the swap
- *
- * Use GROUPS for sound effects to track which sound plays during which atom,
- * which is needed if the sound tool ever has to validate "this atom is the
- * trigger for an audio play".
  * ----------------------------------------------------------------------------*/
-#define atom_group(name, group_id) //_Pragma("atom " #name " group=" #group_id)
+#define atom_bind(binds_struct)  /* atom_bind(binds_struct) */
-
-/* ----------------------------------------------------------------------------
- * atom_cadence — declare execution frequency
- *
- *   atom_cadence(render_frame,     CADENCE_FRAME)       // every vsync
- *   atom_cadence(load_track_faces, CADENCE_ONDEMAND)    // on demand
- *   atom_cadence(init_heap,        CADENCE_ONCE)        // process lifetime
- *
- * Default (no atom_cadence call) is CADENCE_FRAME — most atoms run every
- * frame. Override explicitly when not.
- *
- * The metaprogram's checks:
- *   - CADENCE_ONCE atoms inside `if (frame == 0)` or `if (!initialized)` are
- *     tagged, validating that guards are required (or warning if missing)
- *   - CADENCE_FRAME atoms that mutate state outside the wave context get
- *     flagged (likely a bug — state should persist through commits)
- *   - CADENCE_ONDEMAND atoms must have atom_async — otherwise the trigger
- *     mechanism is undefined
- * ----------------------------------------------------------------------------*/
-#define atom_cadence(name, cadence) //_Pragma("atom " #name " cadence=" #cadence)
-
-/* ----------------------------------------------------------------------------
- * atom_async — declare whether the atom yields / interacts with CDROM DMA
- *
- *   atom_async(load_track_tex,  true)   // CDROM read yield
- *   atom_async(load_vram,       true)   // VRAM upload DMA
- *   atom_async(render_frame,    false)  // pure compute, no async
- *
- * The metaprogram requires this for CADENCE_ONDEMAND atoms. For
- * CADENCE_FRAME, it's optional but documents intent.
- *
- * Note: CDROM ATOMS in Psy-Q are typically implemented as a chain of
- * "async-init" atom followed by a "wait-for-completion" atom. Both atoms
- * should be marked async=true, and both should have the same resource/group
- * tag (so the metaprogram can verify they're paired).
- * ----------------------------------------------------------------------------*/
-#define atom_async(name, is_async) //_Pragma("atom " #name " async=" #is_async)
-
-/* ============================================================================
- * WORD-COUNT ANNOTATION FOR A #define MAC
- *
- *   tape_words(mac_yield, 1)
- *   #define mac_yield()  \
- *       load_word(R_AtomJmp, R_TapePtr, 0), \
- *       add_ui_self(R_TapePtr, 4), \
- *       jump_reg(R_AtomJmp), \
- *       nop
- *
- * The compiler accepts the unknown _Pragma. The Lua tool reads it and
- * cross-checks against WORD_COUNT(mac_yield, 1) in tape_atom.metadata.h.
- * If they disagree, build fails.
- *
- * Use sparingly — only on multi-word macros (single-word ones don't need
- * drift tracking; they're checked by the .word-count pass anyway).
- *
- * ============================================================================*/
-#define tape_words(name, n) //_Pragma(#name " tape_atom words=" #n)
 
 /* ============================================================================
  * atom_label / atom_offset — branch target machinery
@@ -443,25 +150,11 @@
  *
  *   atom_offset(culling, bounds_chk)         ← resolved by gen/.offsets.h
  *
- * The metaprogram generates gen/atom_offsets.h with one
+ * The metaprogram generates gen/atom_offsets.h with one #define with the offset value per atom_offset(F, T) call.
- *   #define atom_offset__culling__bounds_chk  ((target - branch_pos - 1))
+ * The preprocessor then expands the call to the right immediate value.
- * per atom_offset(F, T) call. The preprocessor then expands your call to
- * the right immediate value.
- *
- * If gen/atom_offsets.h is stale (or atom_label(name) is undefined),
- * `atom_offset__F__T` becomes an undefined macro and the C build fails.
- * This catches:
- *   - typo in atom_label (no anchor → metaprogram doesn't emit the macro)
- *   - .offsets.h not regenerated after body edits
- *   - body edit that broke the offset math (recompile + retest picks it up
- *     in CPU emulator)
  *
+ * If gen/atom_offsets.h is stale (or atom_label(name) is undefined), `atom_offset_F_T` becomes an undefined macro and the C build fails.
  * ============================================================================*/
-
 #define atom_offset(F, T) atom_offset_ ## F ## _ ## T
-/* atom_label is a pure annotation for the metaprogram's offset calculations.
+// atom_label is a pure annotation for the metaprogram's offset calculations.
- * The macro expands to a C comment, so the C preprocessor strips it to
- * whitespace — NO instruction word is emitted in the asm. The metaprogram
- * still recognises the literal `atom_label(name)` token in source and
- * records the marker at the current pos. */
 #define atom_label(name) /* atom_label anchor: name */

code/duffle/dsl.h

@@ -218,3 +218,6 @@ IA_ void assert(U8 cond) { if(cond){return;} else{debug_trap(); ms_exit_process(
 #endif
 #pragma endregion Debug
 #endif
+
+#define GCC_OPTIMIZATION_DISABLE _Pragma("GCC push_options") _Pragma("GCC optimize(\"O0\")")
+#define GCC_OPTIMIZATION_ENABLE  _Pragma("GCC pop_options")

code/duffle/gen/duffle.macs.h

@@ -1,16 +1,20 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #pragma once
 #endif
-// Auto-generated by tape_atom_annotation_pass.lua — DO NOT EDIT
+// Auto-generated by ps1_meta.lua — DO NOT EDIT
 // Source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
 // Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
-// + auto word-counts (so tape_atom.metadata.h stays manual-only
-//   for encoding macros).
 
 #ifndef WORD_COUNT
 #define WORD_COUNT(name, count)  enum { words_##name = (count) };
 #endif
 
+/* atom_dbg_skip */
+/* ---------------------------------------------------------------------------
+ *  MACRO ATOM Components (Reusable Assembly Components)
+ *  These do NOT yield. They are expanded inline inside Tape Atoms.
+ * ---------------------------------------------------------------------------*/
+// The 'Yield' sequence for Tape Atoms (mac_yield).
 #define mac_yield(...) \
 	load_word(R_AtomJmp, R_TapePtr, 0) \
 ,	add_ui_self(         R_TapePtr, S_(MipsCode)) \
@@ -18,6 +22,7 @@
 ,	nop
 WORD_COUNT(mac_yield, 4)
 
+/* atom_dbg_skip */
 /* Words: 3; Loads 3 S2 indices from the face array */
 #define mac_load_tri_indices(...) \
 	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)) \
@@ -25,8 +30,9 @@ WORD_COUNT(mac_yield, 4)
 ,	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2))
 WORD_COUNT(mac_load_tri_indices, 3)
 
+/* atom_dbg_skip */
 /* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
-#define mac_load_tri_verts(...) \
+#define mac_gte_load_tri_verts(...) \
 	shift_lleft(R_AT, R_T0, v3s2_byteoff) \
 ,	add_u_self(R_AT, R_VertBase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
@@ -45,21 +51,21 @@ WORD_COUNT(mac_load_tri_indices, 3)
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	gte_mv_to_data_r(R_V0, C2_VXY2) \
 ,	gte_mv_to_data_r(R_V1, C2_VZ2)
-WORD_COUNT(mac_load_tri_verts, 18)
+WORD_COUNT(mac_gte_load_tri_verts, 18)
 
 /* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
  * Hardcoded for Poly_F3 (5 words). For Poly_G4, use ac_insert_ot_tag_g4. */
 #define mac_insert_ot_tag_f3(...) \
 	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
 ,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
-,	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* AT = old_ot_head */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
-,	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits) /* V0 = (5 - 1) << 24 = 4 << 24 */ \
+,	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (5 - 1) << 24 = 4 << 24 */ \
-,	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
 ,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
-,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)) /* prim->tag = packed(prim_length, old_addr) */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
-,	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
-,	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)) \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* OrderingTable[OTZ] = PrimCursor */
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
 WORD_COUNT(mac_insert_ot_tag_f3, 11)
 
 /* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
@@ -67,26 +73,29 @@ WORD_COUNT(mac_insert_ot_tag_f3, 11)
 #define mac_insert_ot_tag_g4(...) \
 	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
 ,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
-,	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* AT = old_ot_head */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
-,	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits) /* V0 = (9 - 1) << 24 = 8 << 24 */ \
+,	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (9 - 1) << 24 = 8 << 24 */ \
-,	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
 ,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
-,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)) /* prim->tag = packed(prim_length, old_addr) */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
-,	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
-,	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)) \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* OrderingTable[OTZ] = PrimCursor */
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
 WORD_COUNT(mac_insert_ot_tag_g4, 11)
 
-#define mac_pack_color_word(off, code, r, g, b) \
+/* atom_dbg_skip */
-	load_upper_i(R_AT, (code) << 8  | (b)) \
+#define mac_pack_color_word(off, cmd, r, g, b) \
+	load_upper_i(R_AT, (cmd) << 8  | (b)) \
 ,	or_i_self(   R_AT, ((g)  << 8) | (r)) \
 ,	store_word(  R_AT, R_PrimCursor, (off))
 WORD_COUNT(mac_pack_color_word, 3)
 
+/* atom_dbg_skip */
 #define mac_format_f3_color(r, g, b) \
 	mac_pack_color_word(O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b)
 WORD_COUNT(mac_format_f3_color, 3)
 
+/* atom_dbg_skip */
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices to the F3.
  * PIPELINE: post-RTPT (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). */
 #define mac_gte_store_f3_post_rtpt(...) \
@@ -102,10 +111,11 @@ WORD_COUNT(mac_gte_store_f3_post_rtpt, 3)
 ,	mac_pack_color_word(O_(Poly_G4,c3), 0,               r3,g3,b3)
 WORD_COUNT(mac_format_g4_color, 12)
 
+/* atom_dbg_skip */
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
  * G4 triangle portion to p0/p1/p2.
- * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen,
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
- * SXY2=v2.screen). MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
  * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
  * three registers aligned with v0/v1/v2 you must store before RTPS).
  * The macro name declares the pipeline position; check #6 (GTE state-
@@ -116,6 +126,7 @@ WORD_COUNT(mac_format_g4_color, 12)
 ,	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p2))
 WORD_COUNT(mac_gte_store_g4_p012_post_rtpt_pre_rtps, 3)
 
+/* atom_dbg_skip */
 /* Words: 1; Stores the V3 screen coord to the G4's p3 slot.
  * PIPELINE: post-RTPS (SXY2 holds v3.screen because RTPS writes its
  * single-vertex result to SXY2; SXY0 still holds v0.screen from the

code/duffle/gp.h

@@ -1,7 +1,6 @@
 /* ============================================================================
  *  duffle DSL Suffix Conventions
  *  ============================================================================
- *
  *  Every mnemonic in this header follows the same suffix grammar:
  *
  *  Primitive commands: gp0_cmd_poly_f3 = 0x20    (byte opcode)
@@ -26,8 +25,7 @@
  *    0. Opcode IDs             gp0_cmd_poly_f3 = 0x20
  *
  *  Vendor mnemonics (gte_mtc2, gte_mfc2, etc.) are NOT in this header.
- *  They live in the opt-in `gp_vendor_sym.h` for users who prefer the
+ *  They live in the opt-in `gp_vendor_sym.h` for users who prefer the PSYQ-style names.
- *  PSYQ-style names.
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES
@@ -41,20 +39,15 @@
 /* ============================================================================
  *  Hardware MMIO Addresses
  *  ============================================================================
- *
  *  PSX GPU has two 32-bit ports in the I/O register region at KSEG2
  *  0x1F800000+. GP0 (offset 0x10) is the data port (commands + params).
  *  GP1 (offset 0x14) is the control port (status, ctrl writes).
  * ============================================================================ */
 /* IO base address (KSEG2 0x1F800000+ for the I/O register region).
- * The 16-bit upper half `IO_BASE_ADDR_HI16` is the form used by
+ * The 16-bit upper half `IO_BASE_ADDR_HI16` is the form used by tape-side macros that pin a register
- * tape-side macros that pin a register to hold the IO base and access
+ * to hold the IO base and access ports via offsets:
- * ports via offsets — `lui $reg, 0x1F80` (1 word) then `sw $data,
+ *   `lui $reg, 0x1F80` (1 word) then `sw $data, GPIO_PORT*_OFFSET($reg)` (1 word). 
- * GPIO_PORT*_OFFSET($reg)` (1 word). Mirrors the `IO_BASE_ADDR equ
+ * Mirrors the `IO_BASE_ADDR equ 0x1F80` + `gpio_port0 equ 0x1810` pattern from graphics_hello/gp.s. */
- * 0x1F80` + `gpio_port0 equ 0x1810` pattern from graphics_hello/gp.s.
- *
- * See lottes_tape.h `R_GpIoBase` + `mac_gp0_send_imm` for the
- * wave-context form that composes these primitives. */
 enum {
     IO_BASE_ADDR      = 0x1F800000,  /* full 32-bit I/O region base */
     IO_BASE_ADDR_HI16 = 0x1F80,      /* fits in a single `lui $reg, 0x1F80` */
@@ -79,14 +72,11 @@ enum {
 /* ============================================================================
  *  GP0 command byte constants + Layer 1 (GPU bitfield shifts)
  *  ============================================================================
- *
+ *  8-bit GP0 opcodes (the upper byte of a primitive's first word). These are the BYTE only.
- *  8-bit GP0 opcodes (the upper byte of a primitive's first word).
+ *  The layer-1 bitfield-layout constants live in the same enum block so the encoder can reference them by name. 
- *  These are the BYTE only; pre-baked 32-bit words are in §10.4.
+ *  NO macro body past this point uses a raw shift or raw mask.
- *  The layer-1 bitfield-layout constants live in the same enum block
+ *  Every shift/width/mask is named here, named once.
- *  so the encoder in §10.4 can reference them by name. NO macro body
+ *  Mirrors the OPCODE_SHIFT / RS_SHIFT / REG_MASK convention from mips.h.
- *  past this point uses a raw shift or raw mask — every shift/width/mask
- *  is named here, named once. Mirrors the OPCODE_SHIFT / RS_SHIFT /
- *  REG_MASK convention from mips.h.
  * ============================================================================ */
 enum {
     gp0_cmd_Nop             = 0x00,
@@ -120,8 +110,7 @@ enum {
     gp0_cmd_tile_8          = 0x68,
     gp0_cmd_tile_16         = 0x70,
 
-    /* State setters (not drawing primitives; set render context).
+    /* State setters (not drawing primitives; set render context). */
-     * Per PSX-SPX graphicsprocessingunitgpu.md §"GP0 Other Commands". */
     gp0_cmd_DrawModeSetting      = 0xE1,  /* TPage / draw-mode (semi-trans, dither, etc.) */
     gp0_cmd_SetTextureWindow     = 0xE2,
     gp0_cmd_SetDrawArea_TopLeft  = 0xE3,
@@ -130,9 +119,7 @@ enum {
     gp0_cmd_SetMaskBit           = 0xE6,
 
     /* bitfield shifts / widths / masks ----
-     *
+     * Generic GP0/GP1 command byte (upper 8 bits of every word sent to either port). */
-     * Generic GP0/GP1 command byte (upper 8 bits of every word sent
-     * to either port). Used by `enc_gp0_cmd(cmd)` and friends below. */
     gp0_cmd_shift = 24,
     gp0_cmd_width =  8,
     gp0_cmd_mask  = 0xFF,
@@ -151,11 +138,9 @@ enum {
 /* ============================================================================
  *  Layer 1.5 (per-field encoders) + Layer 2 (composite) + Layer 3 (semantic GP0 word builders)
  *  ============================================================================
- *
+ *  Layer 1.5 encoders take one field's value, mask it to its own width, and shift it to its own position. 
- *  Layer 1.5 encoders take one field's value, mask it to its own width,
+ *  Mirrors `enc_op` / `enc_rs` / `enc_rt` in mips.h and `enc_gte_sf` / `enc_gte_mx` in gte.h. 
- *  and shift it to its own position. Mirrors `enc_op` / `enc_rs` /
+ *  Layer-2 composite encoders OR the per-field encoders together; layer-3 semantic macros delegate to the composites.
- *  `enc_rt` in mips.h and `enc_gte_sf` / `enc_gte_mx` in gte.h. Layer-2 composite encoders 
- *  OR the per-field encoders together; layer-3 semantic macros delegate to the composites.
  *  No raw shifts or magic numbers in any macro body below this point.
  * ============================================================================ */
 
@@ -194,10 +179,9 @@ enum {
 /* ============================================================================
  *  GP1 command byte constants + Layer 1 (display-mode + range + draw-area bitfield shifts)
  *  ============================================================================
- *
+ *  GP1 status bits are read from HW_GP1;
- *  GP1 status bits are read from HW_GP1; ctrl writes use GP1 commands
+ *  ctrl writes use GP1 commands packed into 32-bit words 
- *  packed into 32-bit words (cmd byte in the upper 8 bits via
+ *  (cmd byte in the upper 8 bits via `enc_gp0_cmd(cmd)`).
- *  `enc_gp0_cmd(cmd)` — never a raw shift).
  * ============================================================================ */
 enum {
     gp1_cmd_Reset                  = 0x00,
@@ -210,10 +194,9 @@ enum {
     gp1_cmd_VerticalDisplayRange   = 0x07,
     gp1_cmd_DisplayMode            = 0x08,
     /* Note: GP1 only has commands 0x00..0x08. 
-		 * The state-setter commands (SetTextureWindow, * SetDrawArea*, 
+		 * The state-setter commands (SetTextureWindow, * SetDrawArea*, SetDrawOffset, SetMaskBit) 
-		 * SetDrawOffset, SetMaskBit) live in the GP0 enum as * 0xE1..0xE6. 
+		 * live in the GP0 enum as * 0xE1..0xE6.
-		 * DrawArea word builders are below as GP0s * macros 
+		 * DrawArea word builders are below as GP0s * macros (since they emit GP0 commands). */
-		 * (since they emit GP0 commands). */
 
     /* ---- Display-mode payload flags (per PSX-SPX §"GP1 Display Mode").
      * Bit positions match the encoder shifts below; values are the
@@ -267,8 +250,7 @@ enum {
 #define enc_gp1_vrange_word(y1, y2)        (enc_gp0_cmd(gp1_cmd_VerticalDisplayRange)   | enc_gp1_vrange_y1(y1) | enc_gp1_vrange_y2(y2))
 
 /* ---- Layer 2: GP0 state-setter composite encoders ----
- * GP0(0xE3) SetDrawArea top-left and GP0(0xE4) SetDrawArea bottom-right
+ * GP0(0xE3) SetDrawArea top-left and GP0(0xE4) SetDrawArea bottom-right both use the same X/Y 10-bit signed payload as GP1 DisplayRange. */
- * both use the same X/Y 10-bit signed payload as GP1 DisplayRange. */
 #define enc_gp0_draw_area_tl_word(x, y)    (enc_gp0_cmd(gp0_cmd_SetDrawArea_TopLeft)  | enc_gp1_draw_x(x) | enc_gp1_draw_y(y))
 #define enc_gp0_draw_area_br_word(x, y)    (enc_gp0_cmd(gp0_cmd_SetDrawArea_BotRight) | enc_gp1_draw_x(x) | enc_gp1_draw_y(y))
 
@@ -290,16 +272,7 @@ enum {
 /* ============================================================================
  *  Pre-baked GPU state words
  *  ============================================================================
- *
+ *  Common command words for boot-time GPU init and standard display configurations.
- *  Common command words for boot-time GPU init and standard
- *  display configurations. Each one is a pure compile-time integer
- *  constant ready to drop into a `.word` directive.
- *
- *  These are the equivalents of the `gp_HorizontalDisplayRange_3168_608`,
- *  `gp_VerticalDisplayRange_264_24`, `gp_DisplayMode_320x240_15bit_NTSC`,
- *  `gp_SetDrawMode_DrawAllowed`, `gp_DMA_*` `.equ`s from the pre-rewrite
- *  gp.h / graphics_hello/gp.s, rebuilt using the layer-cake encoders so
- *  no magic numbers appear in any body.
  * ============================================================================ */
 
 /* ---- Display enable (1-bit payload on DisplayEnable cmd) ---- */
@@ -339,7 +312,7 @@ enum {
 #define gp1_word_vertical_range_pal    enc_gp1_vrange_word(gp1_vrange_PAL_y1,  gp1_vrange_PAL_y2)
 
 /* ---- Draw-mode setting (TPage / draw-area allowance) ---- */
-/* The pre-baked "drawing enabled" word is the standard post-init state. */
+/* The "drawing enabled" word is the standard post-init state. */
 enum {
     gp0_DrawMode_DrawToDispBit = 10,
 };
@@ -372,17 +345,14 @@ enum {
 /* ============================================================================
  *  Primitive structs (8 polygon variants + tag)
  *  ============================================================================
+ *  Each struct follows the GPU-documented memory layout for the corresponding primitive command. 
+ *  The PolyTag is the OT-link header; the rest of the struct is the primitive's body.
  *
- *  Each struct follows the GPU-documented memory layout for the corresponding
+ *  The current working layouts match the existing demo 
- *  primitive command. The PolyTag is the OT-link header; the rest of the
+ *  (floor_tri uses Poly_F3; cube_tri uses Poly_G4). 
- *  struct is the primitive's body.
+ *  They are NOT necessarily byte-identical to the PSX-SPX reference layout. 
- *
+ *  The demo layout uses color+vertex interleaving that doesn't match the standard PSX SDK file format. 
- *  The current working layouts match the existing demo (floor_tri uses
+ *  For PSX-SDK file compatibility, the textured variants (FT*, GT*) would need layout adjustments.
- *  Poly_F3; cube_tri uses Poly_G4). They are NOT necessarily byte-identical
- *  to the PSX-SPX reference layout — the demo layout uses color+vertex
- *  interleaving that doesn't match the standard PSX SDK file format. For
- *  PSX-SDK file compatibility, the textured variants (FT*, GT*) would need
- *  layout adjustments; out of scope for this track.
  * ============================================================================ */
 
 /* ---------- RGB8 (3-byte packed color) ---------- */
@@ -391,12 +361,12 @@ typedef Struct_(RGB8) { B1 r; B1 g; B1 b; };
 
 /* ---------- PolyTag (the OT-link header; 1 word) ---------- */
 enum {
-    polytag_len_bits  =  8,
+    PolyTag_len_bits  =  8,
-    polytag_addr_bits = 24,
+    PolyTag_addr_bits = 24,
 };
 typedef Struct_(PolyTag) {
 	union {
-		U4 bf_addr_len;
+		U4 code;
 		struct {
 			U4 addr: 24;
 			U4 len:  8;
@@ -404,15 +374,14 @@ typedef Struct_(PolyTag) {
 	};
 };
 
-/* DSL cast convention: every cast uses `C_()`, every pointer qualifier
+/* DSL cast convention: every cast uses `C_()`, every pointer qualifier is `R_` (restrict) or `V_` (volatile).
- * is `R_` (restrict) or `V_` (volatile). No raw C-style casts. RHS values
+ * No raw C-style casts. RHS values are assumed to be `U4` — caller passes a `U4` directly. */
- * are assumed to be `U4` — caller passes a `U4` directly. */
 #define set_len(tag,v)  (C_(PolyTag_R,tag)->len  = u4_(v))
 #define set_addr(tag,v) (C_(PolyTag_R,tag)->addr = u4_(v))
-/* `set_code` is no longer in the new PolyTag design — the code byte lives
+/* `set_code` is no longer in the new PolyTag design — the code byte lives in the primitive body
- *  in the primitive body (e.g. `((Poly_F3*)(p))->code`), not in the tag.
+ * (e.g. `((Poly_F3*)(p))->code`), not in the tag.
- *  Use the typed primitive structs (Poly_F3, Poly_G4, etc.) and the
+ *  Use the typed primitive structs (Poly_F3, Poly_G4, etc.) and the `set_poly_*` setters,
- *  `set_poly_*` setters, which set both the tag's length and the code. */
+ *  which set both the tag's length and the code. */
 #define get_len(tag)  C_(U4,C_(PolyTag_R,tag)->len)
 #define get_addr(tag) C_(U4,C_(PolyTag_R,tag)->addr)
 
@@ -438,7 +407,7 @@ typedef Struct_(Poly_F4) {
     };
 };
 
-/* ---------- Poly_G3 (Gouraud Triangle; 6 words) ---------- */
+/* ---------- Poly_G3 (Gouraud Triangle; 7 words) ---------- */
 typedef Struct_(Poly_G3) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -446,7 +415,7 @@ typedef Struct_(Poly_G3) {
     V2_S2 p2;
 };
 
-/* ---------- Poly_G4 (Gouraud Quad; 5 words in the demo's interleaved layout) ---------- */
+/* ---------- Poly_G4 (Gouraud Quad; 9 words) ---------- */
 typedef Struct_(Poly_G4) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -468,7 +437,7 @@ typedef Struct_(Poly_FT3) {
     V2_S2 p2; U1 u2; U1 v2;
 };
 
-/* ---------- Poly_FT4 (Flat Textured Quad; placeholder layout) ---------- */
+/* ---------- Poly_FT4 (Flat Textured Quad) ---------- */
 typedef Struct_(Poly_FT4) {
     U4   tag;
     RGB8 color;
@@ -481,7 +450,7 @@ typedef Struct_(Poly_FT4) {
     V2_S2 p3; U1 u3; U1 v3;
 };
 
-/* ---------- Poly_GT3 (Gouraud Textured Triangle; placeholder layout) ---------- */
+/* ---------- Poly_GT3 (Gouraud Textured Triangle) ---------- */
 typedef Struct_(Poly_GT3) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -494,7 +463,7 @@ typedef Struct_(Poly_GT3) {
     V2_S2 tp2; U1 u2; U1 v2;
 };
 
-/* ---------- Poly_GT4 (Gouraud Textured Quad; placeholder layout) ---------- */
+/* ---------- Poly_GT4 (Gouraud Textured Quad) ---------- */
 typedef Struct_(Poly_GT4) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -509,7 +478,7 @@ typedef Struct_(Poly_GT4) {
     V2_S2 tp3; U1 u3; U1 v3;
 };
 
-/* ---------- Primitive setters (C-level, no emitted words) ----------
+/* ---------- Primitive setters (C-level) ----------
  * DSL cast convention: every cast via C_(), every pointer via R_/V_. */
 #define set_poly_f3(p)  set_len(p, 4),  C_(Poly_F3_R, p)->code = gp0_cmd_poly_f3
 #define set_poly_ft3(p) set_len(p, 7),  C_(Poly_FT3_R,p)->code = gp0_cmd_poly_ft3
@@ -530,7 +499,6 @@ typedef Struct_(Poly_GT4) {
 /* ============================================================================
  *  Texture Page (TPage) bit layout
  *  ============================================================================
- *
  *  The TPage data word sent via GP0(0x2X) has:
  *    bits  0..3   = texture page X    (4 bits, 64-px units, 0..16)
  *    bit   4      = texture page Y    (1 bit,  64-px units, 0/1)
@@ -594,7 +562,6 @@ typedef Struct_(TexturePage) { U4 raw; };
 /* ============================================================================
  *  CLUT (Color Look-Up Table) semantics
  *  ============================================================================
- * 
  *  CLUT is loaded into VRAM by sending a GP0 command whose payload is:
  *    bits  0..5   = Y in 16-px units (palette row)
  *    bits  6..14  = X in 16-px units (palette column)
@@ -627,7 +594,6 @@ enum {
 /* ============================================================================
  *  TIM file format constants and headers
  *  ============================================================================
- *
  *  TIM (Sony .TIM texture image) file structure:
  *    +0x00  U4 file_id (always 0x10 = TIM magic)
  *    +0x04  U4 version (always 0x00 for v1)
@@ -645,9 +611,8 @@ enum {
  *         +0x06 U2 px_height
  *         +0x08 ... pixel data
  *
- *  Future?: add `tim_load_to_vram(tim_ptr, vram_addr)` that
+ *  Future?: add `tim_load_to_vram(tim_ptr, vram_addr)` that emits the necessary GP0 commands.
- *  emits the necessary GP0 commands. Stoppped for now at the
+ *  Stoppped for now at the struct + enum level.
- *  struct + enum level for this track.
  * ============================================================================ */
 enum {
     tim_file_id_magic = 0x10,
@@ -678,35 +643,24 @@ typedef Struct_(TIM_SectionHeader) {
  *  Tape-side GPU operations (NOT in this header)
  *  ============================================================================
  *
- *  No `mac_gp0_send` or related macros live in gp.h. Rationale: the
+ *  No `mac_gp0_send` or related macros live in gp.h.
- *  Lottes tape model uses OT-DMA for primitive submission, so atom bodies
+ *  Rationale: the Lottes tape model uses OT-DMA for primitive submission, so atom bodies write to main RAM (the OT/primitive buffer)
- *  write to main RAM (the OT/primitive buffer) and to GTE state — never
+ *  and to GTE state — never directly to the GPU ports at 0x1F801810 / 0x1F801814.
- *  directly to the GPU ports at 0x1F801810 / 0x1F801814. See
+ *  See `mac_format_f3_color`, `mac_insert_ot_tag`, `mac_gte_store_f3` in lottes_tape.h for the patterns atom bodies actually use.
- *  `mac_format_f3_color`, `mac_insert_ot_tag`, `mac_gte_store_f3` in
- *  lottes_tape.h for the patterns atom bodies actually use.
  *
- *  If a feature need arises requires tape-side GPU port writes (e.g. DMA-kick to
+ *  If a feature need arises requires tape-side GPU port writes 
- *  start GPU consumption of the OT, VBlank sync via GP1 status poll),
+ *  (e.g. DMA-kick to start GPU consumption of the OT, VBlank sync via GP1 status poll),
- *  the right home is `lottes_tape.h` alongside the rest of the `mac_*`
+ *  the right home is `lottes_tape.h` alongside the rest of the `mac_*` family:
- *  family — the encoder infrastructure is already in place:
+ *    1. The caller pins a register to hold the IO base, e.g. register U4 r_io rgcc(R_T4) = IO_BASE_ADDR;
+ *       The compiler emits `lui R_T4, IO_BASE_ADDR_HI16` outside the atom body (in the C prologue before tape_run).
+ *    2. The atom body uses `store_word(R_data, R_T4, GPIO_PORT0_OFFSET)` to write to GP0, and `store_word(R_data, R_T4, GPIO_PORT1_OFFSET)`
+ *       to write to GP1. Both are preprocessor-encodable because R_T4 is a fixed register and the GPIO_PORT*_OFFSET constants
+ *       fit in the `sw`'s 16-bit signed offset field. No placeholder-pun, no asm constraints, no hidden register choice.
+ *       Same pattern as the old graphics_hello/hello_gp_routines.s `reg_io_offset`/`gcmd_push` convention.
  *
- *    1. The caller pins a register to hold the IO base, e.g.
+ *  This mirrors the existing tape-side wave-context discipline: 
- *         register U4 r_io rgcc(R_T4) = IO_BASE_ADDR;
+ *  the caller binds the IO-base register via `rgcc()`, the macro assumes the binding is in effect,
- *       The compiler emits `lui R_T4, IO_BASE_ADDR_HI16` outside the
+ *  and the encoding falls out at preprocessor time. 
- *       atom body (in the C prologue before tape_run).
+ *  No additional GPU-domain macro layer required.
- *
- *    2. The atom body uses `store_word(R_data, R_T4, GPIO_PORT0_OFFSET)`
- *       to write to GP0, and `store_word(R_data, R_T4, GPIO_PORT1_OFFSET)`
- *       to write to GP1. Both are preprocessor-encodable because R_T4 is
- *       a fixed register and the GPIO_PORT*_OFFSET constants fit in the
- *       `sw`'s 16-bit signed offset field. No placeholder-pun, no asm
- *       constraints, no hidden register choice. Same pattern as the
- *       old graphics_hello/hello_gp_routines.s `reg_io_offset`/`gcmd_push`
- *       convention.
- *
- *  This mirrors the existing tape-side wave-context discipline: the
- *  caller binds the IO-base register via `rgcc()`, the macro assumes
- *  the binding is in effect, and the encoding falls out at preprocessor
- *  time. No additional GPU-domain macro layer required.
  * ============================================================================ */
 #pragma endregion Tape-Side Macros

code/duffle/gp_vendor_sym.h

@@ -2,10 +2,8 @@
  *  duffle DSL — GPU Vendor Mnemonics (opt-in)
  *  ============================================================================
  *
- *  Provides the PSYQ-style CamelCase aliases for the canonical duffle GPU
+ *  Provides the PSYQ-style CamelCase aliases for the duffle GPU primitive setters and OT operations.
- *  primitive setters and OT operations. The duffle snake_case names are
+ *  The duffle snake_case names are primary; this header is for users who prefer the PSYQ SDK function names from the legacy C API.
- *  primary; this header is for users who prefer the PSYQ SDK function
- *  names from the legacy C API.
  *
  *  USAGE:   #include "duffle/gp_vendor_sym.h"   // after gp.h
  *
@@ -23,15 +21,11 @@
  *    OT operations:
  *      AddPrim(ot, p)  -> orderingtbl_add_primitive(ot, p)
  *
- *  The gp0_cmd_* / gp1_cmd_* byte constants are already short and
+ *  The gp0_cmd_* / gp1_cmd_* byte constants are already short and descriptive; no vendor alias is provided for them.
- *  descriptive; no vendor alias is provided for them.
- *
- *  The vendor mnemonics are NOT registered with the duffle word-count
- *  metadata (tape_atom.metadata.h). They expand to the duffle canonical
- *  macros which DO have word-count entries (the ones emitted by
- *  mac_format_f3_color / mac_gte_store_f3 / etc.). Verification: V13
- *  (objdump byte-identical) holds.
  *
+ *  The vendor mnemonics are NOT registered with the duffle word-count metadata (word_counts.metadata.h).
+ *  They expand to the duffle macros which DO have word-count entries
+ *  (the ones emitted by mac_format_f3_color / mac_gte_store_f3 / etc.). Verification: V13 (objdump byte-identical) holds.
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES

code/duffle/gte.h

@@ -37,49 +37,6 @@
  *  Hand-rolled DSL for emitting GTE/MIPS instruction words as raw `.word`
  *  constants from C. No GCC inline-assembly string syntax in the code body.
  *
- *  PHILOSOPHY
- *  ----------
- *  1. A 32-bit instruction word is composed from per-field encoders. Each
- *     encoder knows only its own bit range; the composite ORs them together.
- *     No magic numbers inside any encoder body. Every shift and mask is a
- *     named constant from the bitfield-layout enum below.
- *
- *  2. Pure (compile-time) instructions. Every GTE *command* (RTPS, RTPT,
- *     NCLIP, MVMVA, …) and every COP2 *transfer* (ctc2/cfc2) with a constant
- *     rs/rt/rd — are emitted as a single integer constant via
- *     `asm_inline(...)` from gcc_asm.h. The C compiler constant-folds
- *     these into `.word` directives in .rodata.
- *
- *  3. Runtime-base-register instructions (lwc2, swc2, lw, sw, …) cannot be
- *     a pure compile-time word because the `rs` field is chosen by the
- *     compiler at codegen. For these we use a "placeholder-pun" pattern:
- *     a fixed register number (R_T4 = $12) is baked into the rs field of
- *     the `.word` constant, and the macro declares a `"r"(arg)` input
- *     constraint plus a clobber on the same register. The compiler is
- *     therefore *forced* to bind `arg` to that exact register, and the
- *     constant is correct.
- *
- *  USAGE
- *  -----
- *      // Pure command sequence — all bits compile-time:
- *      asm volatile(
- *          asm_inline( gte_cmd_rtpt , gte_cmd_nclip , gte_cmd_avsz3 )
- *          asm_clobber( clbr_volatile_gprs )
- *      );
- *
- *      // Runtime-base-register load — caller picks the base GPR:
- *      register V3_S2* p_in_12 __asm__("$12") = verts[0].ptr;
- *      gte_load_v0(p_in_12, R_T4);   // R_T4 = 12 = $t4 = $12
- *
- *      // Three independent bases for an RTPT pipeline:
- *      register V3_S2* p0 gcc_reg(R_T4) = verts[0].ptr;
- *      register V3_S2* p1 gcc_reg(R_T5) = verts[1].ptr;
- *      register V3_S2* p2 gcc_reg(R_T6) = verts[2].ptr;
- *      gte_load_v0(p0, R_T4);
- *      gte_load_v1(p1, R_T5);
- *      gte_load_v2(p2, R_T6);
- *      gte_rtpt();
- *
  *  STYLE NOTES
  *  -----------
  *  - Per-field encoders are named `enc_gte_<field>(value)` and each one
@@ -94,8 +51,7 @@
  *
  *  SEE ALSO
  *  --------
- *  - gcc_asm.h: the `.word` emitter (`asm_inline`, `asm_clobber`, clobbers)
+ *  - mips.h: The MIPS encoder layer this builds on.
- *  - mips.h:    the MIPS encoder layer this builds on
  */
 
 /* C2 data registers */
@@ -222,8 +178,8 @@ enum {
  *                                    \_____ GTE_PAYLOAD _____/       \__ GTE_CMD __/
  *
  * Shifts/masks below are the *bit positions* and *bit widths* of each
- * configurable field, used by the ENC_GTE_CMD encoder. Mirrors the
+ * configurable field, used by the ENC_GTE_CMD encoder. 
- * OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
+ * Mirrors the OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
  */
 
 	gte_shift_sf  = 19,  gte_width_sf  = 1,  gte_mask_sf  = 0x1,
@@ -397,41 +353,34 @@ enum { _C2_TX_SUBS_ = 0
 
 /* GTE command words for the common cases.
  *
- * These are pure compile-time integer constants — the C compiler
+ * These are pure compile-time integer constants — the C compiler constant-folds them into `.word` directives in .rodata.
- * constant-folds them into `.word` directives in .rodata. Use them
+ * Use them inside `asm_inline(...)` blocks (see `gte_rtpt` below for the idiom).
- * inside `asm_inline(...)` blocks (see `gte_rtpt` below for the
- * canonical idiom).
  *
  * Decomposition (per the `enc_gte_<field>` definitions above):
  *   gte_cmdw_<name> = gte_cmd_base | enc_gte_cmd(<cmd>)
  
- * The SF/MX/V/CV/LM fields are all zero in the common cases (standard
+ * The SF/MX/V/CV/LM fields are all zero in the common cases 
- * rotation-matrix, no scaling factor, V0 vector, translation vector,
+ * (standard rotation-matrix, no scaling factor, V0 vector, translation vector, no clamp),
- * no clamp), so the only varying bits are the `cmd` field.
+ * so the only varying bits are the `cmd` field.
  *
- * Naming follows the file's convention: `gte_cmd_*` is the raw
+ * Naming follows the file's convention: `gte_cmd_*` is the raw 6-bit `cmd` field id, `gte_cmdw_*`
- * 6-bit `cmd` field id, `gte_cmdw_*` is the fully-encoded 32-bit
+ *  is the fully-encoded 32-bit instruction word ready to drop into a `.word` directive.
- * instruction word ready to drop into a `.word` directive.
  *
  * --------------------------------------------------------------------------
  *  PsyQ-compatibility note (RTPS/RTPT):
- *  The original Sony PsyQ `inline_n.h` ships RTPT as `cop2 0x0280030` and
+ *  The original Sony PsyQ `inline_n.h` ships RTPT as `cop2 0x0280030` and RTPS as `cop2 0x0180001`.
- *  RTPS as `cop2 0x0180001`. Both have `0x20` set in the upper-reserved
+ *  Both have `0x20` set in the upper-reserved region (bit 21) AND `sf=1` (bit 19) — i.e. the "no division" flag.
- *  region (bit 21) AND `sf=1` (bit 19) — i.e. the "no division" flag.
+ *  Per psx-spec these bits are reserved/must-be-zero,
- *  Per psx-spec these bits are reserved/must-be-zero, but the real GTE
+ *  but the real GTE hardware and PCSX-Redux's GTE model both IGNORE them on these two commands
- *  hardware and PCSX-Redux's GTE model both IGNORE them on these two
+ *  (the perspective divide happens regardless of `sf`).
- *  commands (the perspective divide happens regardless of `sf`).
  *
- *  If we emit a strictly-spec-compliant word (`sf=0`, reserved bits
+ *  If we emit a strictly-spec-compliant word (`sf=0`, reserved bits clear),
- *  clear), PCSX-Redux's GTE checks those bits more strictly than the
+ *  PCSX-Redux's GTE checks those bits more strictly than the silicon does and RTPT silently no-ops — 
- *  silicon does and RTPT silently no-ops — the floor's screen
+ *  the floor's screen coordinates come out as raw projection-of-rotation (Z never divided),
- *  coordinates come out as raw projection-of-rotation (Z never
+ *  `nclip` ends up wrong, and the triangle is culled.
- *  divided), `nclip` ends up wrong, and the triangle is culled.
  *
- *  So for RTPS and RTPT we OR-in the `0x28` "PsyQ compat" pattern to
+ *  So for RTPS and RTPT we OR-in the `0x28` "PsyQ compat" pattern to match the working bit pattern everyone has shipped for 25 years.
- *  match the working bit pattern everyone has shipped for 25 years.
+ *  NCLIP/OP/MVMVA stay spec-clean — their reserved bits really are zero in the original PsyQ source.
- *  NCLIP/OP/MVMVA stay spec-clean — their reserved bits really are
- *  zero in the original PsyQ source.
  * --------------------------------------------------------------------------
  */
 #define gte_cmdw_psyq_compat  (1u << 21 | enc_gte_sf(gte_sf_integer))
@@ -440,6 +389,8 @@ enum { _C2_TX_SUBS_ = 0
 #define gte_cmdw_rtpt   (gte_cmd_base | enc_gte_cmd(gte_cmd_rtpt ) | gte_cmdw_psyq_compat)
 #define gte_cmdw_nclip  (gte_cmd_base | enc_gte_cmd(gte_cmd_nclip))
 #define gte_cmdw_op     (gte_cmd_base | enc_gte_cmd(gte_cmd_op   ))
+#define gte_cmdw_outer_product gte_cmdw_op      /* "outer product" -- NOCASH/Sdk terminology */
+#define gte_cmdw_wedge        gte_cmdw_op      /* "wedge product"  -- geometric-algebra terminology */
 #define gte_cmdw_mvmva  (gte_cmd_base | enc_gte_cmd(gte_cmd_mvmva))
 
 #define gte_cmdw_rotate_translate_perspective_single gte_cmdw_rtps
@@ -467,8 +418,8 @@ enum { _C2_TX_SUBS_ = 0
  * (XY at offset 0) and C2_VZ0 (Z at offset 4) using `lwc2`.
  *
  * Uses string-style GCC inline asm with `%0` substitution because the 
- * base register `r0` is a runtime GPR chosen by the compiler — it cannot
+ * base register `r0` is a runtime GPR chosen by the compiler.
- * be encoded into a static `.word` constant.
+ * It cannot be encoded into a static `.word` constant.
  *
  * Usage:
  *   asm_gte_load_v0(svector_ptr);
@@ -500,26 +451,21 @@ enum {
 
 /* gte_load_vN(r_ptr, base) — placeholder-punned lwc2 loaders
  *
- * Emits `.word` constants encoding `lwc2 $N, off(<base>)` for the chosen
+ * Emits `.word` constants encoding `lwc2 $N, off(<base>)` for the chosen GTE vector register, where `<base>` is the GPR number you pass in
- * GTE vector register, where `<base>` is the GPR number you pass in
  * (typically one of R_T4..R_T9 for the standard "3-pointer" pattern).
  *
  * The caller MUST bind `r_ptr` to that same GPR via a register variable:
  *     register V3_S2* p_in_12 __asm__("$12") = my_ptr;
  *     gte_load_v0(p_in_12, R_T4);   // R_T4 = 12, base is $12
  *
- * Then `"r"(r_ptr)` inside the asm binds to $12 (the only register
+ * Then `"r"(r_ptr)` inside the asm binds to $12 (the only register `p_in_12` can live in),
- * `p_in_12` can live in), which is exactly the register the .word
+ * which is exactly the register the .word constants expect. A `"$12"` clobber would conflict with the register-variable binding
- * constants expect. A `"$12"` clobber would conflict with the
+ * ("asm specifier for variable conflicts with asm clobber list"), so we omit it.
- * register-variable binding ("asm specifier for variable conflicts
+ * The other ABI-clobbers ($2/$8/$9/$31) stay because the GTE instructions don't touch caller-saved GPRs but the kernel does treat them as volatile.
- * with asm clobber list"), so we omit it. The other ABI-clobbers
- * ($2/$8/$9/$31) stay because the GTE instructions don't touch
- * caller-saved GPRs but the kernel does treat them as volatile.
  *
  * WHICH REGISTER TO PICK
  * ----------------------
- * Any caller-saved GPR is safe. Recommended default for an RTPT-style
+ * Any caller-saved GPR is safe. Recommended default for an RTPT-style 3-pointer pipeline:
- * 3-pointer pipeline:
  *   gte_load_v0(p0, R_T4);  // $12
  *   gte_load_v1(p1, R_T5);  // $13
  *   gte_load_v2(p2, R_T6);  // $14
@@ -532,8 +478,7 @@ enum {
  *   clobbers section   : "$2", "$8", ..., "memory"      (from asm_clobber)
  *   3 colons total, GCC-legal. No string-syntax mnemonics in the .word body.
  *
- * The `asm_clobber(...)` helper from gcc_asm.h prepends the colon that
+ * The `asm_clobber(...)` helper from gcc_asm.h prepends the colon that starts the clobbers section. */
- * starts the clobbers section. */
 #define gte_load_v0(r_ptr, base) asm volatile(       \
 	asm_words( gte_lw_v0_xy(base), gte_lw_v0_z(base) ) \
 	asm_rpins,   r_use(r_ptr)                          \
@@ -552,11 +497,11 @@ enum {
 	asm_clobber: rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain \
 )
 
-/* gte_load_v0v1v2(p0, p1, p2, b0, b1, b2) — the canonical prelude to gte_cmd_rtpt.
+/* gte_load_v0v1v2(p0, p1, p2, b0, b1, b2) — prelude to gte_cmd_rtpt.
  *
  * Loads all three GTE input vectors (6 words) from three separate pointers,
- * one per GTE vector register, each loaded from its own base GPR. Caller
+ * one per GTE vector register, each loaded from its own base GPR.
- * must bind each `pN` to `bN` via a register variable.
+ * Caller must bind each `pN` to `bN` via a register variable.
  *
  *   register V3_S2* p0 rgcc(R_T4) = verts[0].ptr;  // → __asm__("$12")
  *   register V3_S2* p1 rgcc(R_T5) = verts[1].ptr;  // → __asm__("$13")
@@ -713,14 +658,14 @@ enum {
 		asm_words(                          \
 			  load_word(R_T5, R_T4,  0)       \
 			, load_word(R_T6, R_T4,  4)       \
-			, gte_mt(   R_T5,        0)       \
+			, gte_mv_to_data_r(   R_T5,  0)   \
-			, gte_mt(   R_T6,        1)       \
+			, gte_mv_to_data_r(   R_T6,  1)   \
 			, load_word(R_T5, R_T4,  8)       \
 			, load_word(R_T6, R_T4, 12)       \
 			, load_word(R_T4, R_T4, 16)       \
-			, gte_mt(   R_T5,  2)             \
+			, gte_mv_to_data_r(   R_T5,  2)   \
-			, gte_mt(   R_T6,  3)             \
+			, gte_mv_to_data_r(   R_T6,  3)   \
-			, gte_mt(   R_T4,  4)             \
+			, gte_mv_to_data_r(   R_T4,  4)   \
 		)                                   \
 		, r_use(r0)                         \
 		asm_clobber: clbr_volatile_gprs, rlit(R_T4), rlit(R_T5), rlit(R_T6) \

code/duffle/gte_vendor_sym.h

@@ -2,10 +2,8 @@
  *  duffle DSL — GTE Vendor Mnemonics (opt-in)
  *  ============================================================================
  *
- *  Provides the textbook MIPS assembly mnemonics for the GTE/COP2
+ *  Provides the textbook MIPS assembly mnemonics for the GTE/COP2 instructions as thin aliases to the duffle macros in gte.h.
- *  instructions as thin aliases to the canonical duffle macros in gte.h.
+ *  The duffle names are primary; this header is for users who prefer the textbook mnemonics.
- *  The duffle names are primary; this header is for users who prefer
- *  the textbook mnemonics.
  *
  *  USAGE:   #include "duffle/gte_vendor_sym.h"   // after gte.h
  *
@@ -21,12 +19,6 @@
  *      gte_swc2(rt, base, off)  -> gte_sw(rt, base, off)
  *      (the lower-level vector variants gte_lw_v0_xy etc. don't have
  *      vendor mnemonics; they're already gte_-prefixed and short)
- *
- *  The vendor mnemonics are NOT registered with the duffle word-count
- *  metadata (tape_atom.metadata.h). They expand to the duffle canonical
- *  macros which DO have word-count entries. Verification: V3 (objdump
- *  byte-identical) holds.
- *
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES

code/duffle/lottes_tape.h

@@ -14,41 +14,34 @@ typedef U4 const MipsCode;
 typedef Slice_(MipsCode);
 typedef Slice_MipsCode MipsAtom;
 
-#define MipsAtom_(sym) MipsCode tmpl(code,sym) [] align_(4) =
+#define MipsAtom_(sym) MipsCode sym [] align_(4) =
 
-// Bare form: file-scope declaration with hardcoded body.
+// Used for components with no args (e.g., ac_load_tri_indices) or identifier-args (hardcoded register names).
-// Used for components with no args (e.g., ac_load_tri_indices) or
-// identifier-args (hardcoded register names).
 //   MipsAtomComp_(ac_X) { body }
 // expands to:
 //   MipsCode ac_X[] align_(4) = { body };
 #define MipsAtomComp_(sym) MipsCode sym [] align_(4) =
 
-// Function form: function-body block that returns a MipsAtom slice.
 // Used for components with value-args (e.g., ac_format_f3_color).
 //   FI_ MipsAtom ac_X(args) MipsAtomComp_Proc_(ac_X, { body })
 // expands to:
 //   FI_ MipsAtom ac_X(args) { MipsCode ac_X[] align_(4) = { body }; return slice_from_array(MipsCode, ac_X); }
 #define MipsAtomComp_Proc_(sym, ...) { MipsCode sym [] align_(4) = __VA_ARGS__; return slice_from_array(MipsCode, sym); }
 
-// Auto-generated component macros (<module>/gen/<dir>/<dir>.macs.h)
+// Auto-generated component macros (<module>/gen/<dir>/<dir>.macs.h) are included manually by the unity build.
-// are included manually by the unity build. The metaprogram puts them
 
-/* Register aliases (moved up from the Tape Drive region below so that
+/* Register aliases */
- * mac_yield's body and the Mips Atom Builder functions can reference
- * them. The C compiler processes the file top-to-bottom, so the enum
- * must be visible before any use.) */
 enum {
-	R_AtomJmp    = R_T9,
+	R_AtomJmp    = R_T9 atom_reg,  /* debug-visible; tape yield handshake scratch */
-	R_TapePtr    = R_T8,  /* The Instruction Stream Pointer */
+	R_TapePtr    = R_T8 atom_reg,  /* The Instruction Stream Pointer */
-	R_InCursor   = R_T4,  /* Input data cursor */
+	R_InCursor   = R_T4,
 
-	R_PrimCursor = R_T7,  /* VRAM output cursor (primitive buffer) */
+	R_PrimCursor = R_T7 atom_reg atom_type(U4 *),    /* VRAM output cursor (primitive buffer) */
-	R_FaceCursor = R_T4,  /* Input data cursor (indices/faces) */
+	R_FaceCursor = R_T4 atom_reg atom_type(V4_S2 *), /* Cube face-index cursor (V4_S2*); floor context switches to V3_S2* via atom_phase */
-	R_VertBase   = R_T5,  /* Base address of the vertex array */
+	R_VertBase   = R_T5 atom_reg atom_type(V3_S2 *), /* Base address of the vertex array */
-	R_OtBase     = R_T6,  /* Base address of the Ordering Table */
+	R_OtBase     = R_T6 atom_reg atom_type(U4 *),    /* Base address of the Ordering Table */
 
-/* Stringification codes for the GCC inline assembler clobber lists */
+/* Stringification codes for the GCC inline assembler clobber lists. */
 #define R_TapePtr_Code     R_T8_Code
 #define R_InCursor_Code    R_T4_Code
 
@@ -64,10 +57,10 @@ enum {
  * ---------------------------------------------------------------------------*/
 
 /* The 'Exit' Atom */
-MipsAtom_(tape_exit) { jump_reg(rret_addr), nop };
+atom_dbg_skip MipsAtom_(tape_exit) { jump_reg(rret_addr), nop };
 
 /* Generalized Tape Engine Runner */
-FI_ void tape_run(Slice_U4 tape) { register U4* tp rgcc(R_TapePtr) = tape.ptr; asm volatile(
+NI_ void tape_run(Slice_MipsCode tape) { register U4* tp rgcc(R_TapePtr) = u4_r(tape.ptr); asm volatile(
 	asm_words(
 			add_ui(     R_SP, R_SP, -MipsStackAlignment) /* Allocate stack space */
 		, store_word( R_RA, R_SP,           0)         /* Safely backup $ra to the stack */
@@ -94,13 +87,13 @@ FI_ void        tb_init(TapeBuilder* tb, FArena* arena) { tb->ptr = arena->start
 FI_ TapeBuilder tb_make_old(             FArena* arena) { return (TapeBuilder){ arena->start, 0 }; }
 FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ mem.ptr, mem.len, 0 }; }
 
-#define tb_emit_(tb, atom) tb_emit(tb, tmpl(code,atom))
+#define tb_emit_(tb, atom) tb_emit(tb, atom)
 FI_ void tb_emit(TapeBuilder* tb, MipsCode* atom) { u4_r(tb->ptr)[tb->used] = u4_(atom); ++ tb->used; }
 FI_ void tb_data(TapeBuilder* tb, U4        data) { u4_r(tb->ptr)[tb->used] = u4_(data); ++ tb->used; }
 
-FI_ Slice_U4 tb_end  (TapeBuilder* tb) { tb_emit(tb,code_tape_exit); return (Slice_U4){ C_(U4*,tb->ptr), tb->used }; }
+FI_ Slice_MipsCode tb_end  (TapeBuilder* tb) { tb_emit(tb,tape_exit); return (Slice_MipsCode){ C_(U4*,tb->ptr), tb->used }; }
-FI_ Slice_U4 tb_slice(TapeBuilder  tb) {                             return (Slice_U4){ C_(U4*,tb.ptr),  tb.used }; }
+FI_ Slice_MipsCode tb_slice(TapeBuilder  tb) {                        return (Slice_MipsCode){ C_(U4*,tb.ptr),  tb.used }; }
-#define tb_scope(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,code_tape_exit))
+#define tb_scope(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,tape_exit))
 
 #pragma endregion Tape Drive
 
@@ -111,22 +104,21 @@ FI_ Slice_U4 tb_slice(TapeBuilder  tb) {                             return (Sli
  * ---------------------------------------------------------------------------*/
 
 // The 'Yield' sequence for Tape Atoms (mac_yield). 
-MipsAtomComp_(ac_yield) {
+atom_dbg_skip MipsAtomComp_(ac_yield) {
 	load_word(R_AtomJmp, R_TapePtr, 0),
 	add_ui_self(         R_TapePtr, S_(MipsCode)),
-	jump_reg( R_AtomJmp),
+	jump_reg( R_AtomJmp), nop,
-	nop,
 };
 
 /* Words: 3; Loads 3 S2 indices from the face array */
-MipsAtomComp_(ac_load_tri_indices) {
+atom_dbg_skip MipsAtomComp_(ac_load_tri_indices) {
 	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
 	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)),
 	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
 };
 
 /* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
-MipsAtomComp_(ac_load_tri_verts) {
+atom_dbg_skip MipsAtomComp_(ac_gte_load_tri_verts) {
 	shift_lleft(R_AT, R_T0, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
 	shift_lleft(R_AT, R_T1, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
 	shift_lleft(R_AT, R_T2, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
@@ -137,14 +129,14 @@ MipsAtomComp_(ac_load_tri_verts) {
 MipsAtomComp_(ac_insert_ot_tag_f3) {
 	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
 	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
-	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // AT = old_ot_head
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
-	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits), // V0 = (5 - 1) << 24 = 4 << 24
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (5 - 1) << 24 = 4 << 24
-	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
 	or_u(        R_AT, R_AT, R_V0),                            // Merge length
-	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)), // prim->tag = packed(prim_length, old_addr)
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
-	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
-	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)),
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // OrderingTable[OTZ] = PrimCursor
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
 };
 
 /* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
@@ -152,36 +144,33 @@ MipsAtomComp_(ac_insert_ot_tag_f3) {
 MipsAtomComp_(ac_insert_ot_tag_g4) {
 	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
 	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
-	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // AT = old_ot_head
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
-	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits), // V0 = (9 - 1) << 24 = 8 << 24
+	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (9 - 1) << 24 = 8 << 24
-	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
 	or_u(        R_AT, R_AT, R_V0),                            // Merge length
-	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)), // prim->tag = packed(prim_length, old_addr)
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
-	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
-	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)),
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // OrderingTable[OTZ] = PrimCursor
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
 };
 
 /* Words: 3; Emits one (cmd|color) word to R_PrimCursor at the given
- * byte offset. Internal helper used by the *_format_*_color macros.
+ * byte offset. Internal helper used by the *_format_*_color macros. */
- * Args: off = U4 byte offset, code = GP0 cmd byte (0 for c1/c2/c3 of
+FI_ MipsAtom ac_pack_color_word(U4 off, U4 cmd, U1 r, U1 g, U1 b)
- * a Poly_G4), r/g/b = 8-bit RGB byte values. */
+atom_dbg_skip MipsAtomComp_Proc_(ac_pack_color_word, {
-FI_ MipsAtom ac_pack_color_word(U4 off, U4 code, U1 r, U1 g, U1 b)
+	load_upper_i(R_AT, (cmd) << 8  | (b)),
-MipsAtomComp_Proc_(ac_pack_color_word, {
-	load_upper_i(R_AT, (code) << 8  | (b)),
 	or_i_self(   R_AT, ((g)  << 8) | (r)),
 	store_word(  R_AT, R_PrimCursor, (off)),
 })
 
 /* Words: 3; Emits the F3 command+color word (cmd byte | BLUE | GREEN | RED)
- * Args: _r, _g, _b are 8-bit RGB byte values (not raw 16-bit fields).
+ * Args: _r, _g, _b are 8-bit RGB byte values (not raw 16-bit fields). */
- * Migrated from hello_gte_tape.c; takes RGB form per the Phase 3 convention. */
 FI_ MipsAtom ac_format_f3_color(U1 r, U1 g, U1 b)
-MipsAtomComp_Proc_(ac_format_f3_color, { mac_pack_color_word(O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b) })
+atom_dbg_skip MipsAtomComp_Proc_(ac_format_f3_color, { mac_pack_color_word(O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b) })
 
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices to the F3.
  * PIPELINE: post-RTPT (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). */
-MipsAtomComp_(ac_gte_store_f3_post_rtpt) {
+atom_dbg_skip MipsAtomComp_(ac_gte_store_f3_post_rtpt) {
 	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_F3,p0)),
 	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_F3,p1)),
 	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_F3,p2)),
@@ -203,13 +192,13 @@ MipsAtomComp_Proc_(ac_format_g4_color, {
 
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
  * G4 triangle portion to p0/p1/p2.
- * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen,
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
- * SXY2=v2.screen). MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
  * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
  * three registers aligned with v0/v1/v2 you must store before RTPS).
  * The macro name declares the pipeline position; check #6 (GTE state-
  * machine validation) verifies the call site matches the declaration. */
-MipsAtomComp_(ac_gte_store_g4_p012_post_rtpt_pre_rtps) {
+atom_dbg_skip MipsAtomComp_(ac_gte_store_g4_p012_post_rtpt_pre_rtps) {
 	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_G4,p0)),
 	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_G4,p1)),
 	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p2)),
@@ -221,7 +210,7 @@ MipsAtomComp_(ac_gte_store_g4_p012_post_rtpt_pre_rtps) {
  * earlier RTPT — DO NOT read SXY0 here, that's the bug this name
  * prevents).
  */
-MipsAtomComp_(ac_gte_store_g4_p3_post_rtps) { gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3)) };
+atom_dbg_skip MipsAtomComp_(ac_gte_store_g4_p3_post_rtps) { gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3)) };
 
 #pragma endregion Macro Atom Components
 
@@ -244,9 +233,8 @@ FI_ void atombuilder_unroll(MipsAtomBuilder_R ab, Slice_MipsCode_R code) {
 
 // When done authoring, utilize this to cap-off the atom
 FI_ void atombuilder_end(MipsAtomBuilder_R ab) {
-	LP_ MipsAtom_(yield) { mac_yield() };
+	mem_copy(ab->start, u4_(ac_yield), S_(ac_yield));
-	mem_copy(ab->start, u4_(code_yield), S_(code_yield));
+	mem_bump(ab->start, ab->capacity, & ab->used, S_(ac_yield));
-	mem_bump(ab->start, ab->capacity, & ab->used, S_(code_yield));
 }
 
 #define mipsatom_from_builder(ab) (MipsAtom){ab.start, ab.used}
@@ -276,8 +264,7 @@ internal MipsAtom_(mips_flush_icache) {
 	store_word(rret_addr, rstack_ptr, S_(U4)),           // sw  $ra,   4($sp) 
 	add_ui(rret_0, rdiscard, bios_flushcache),           // addiu $a0, $0, 0x44 
 	add_ui(rtmp_0, rdiscard, bios_table_addr),           // addiu $t0, $0, 0xA0 
-	jump_link(rtmp_0, rret_addr),                        // jalr  $t0, $ra 
+	jump_link(rtmp_0, rret_addr), nop,                   // jalr  $t0, $ra, BD slot
-	nop,                                                 // BD slot 
 	load_word(rret_addr, rstack_ptr, S_(U4)),            // lw   $ra, 4($sp) 
 	jump_reg(rret_addr),                                 // jr   $ra 
 	add_ui(rstack_ptr, rstack_ptr, MipsStackAlignment),  // sp += 8 (BD) 
@@ -287,7 +274,10 @@ internal MipsAtom_(mips_flush_icache) {
 typedef Struct_(Binds_SetGteWorld) {
 	M3_S2* transform;
 };
-internal MipsAtom_(set_gte_world) {
+internal MipsAtom_(set_gte_world) atom_info(
+		atom_bind(Binds_SetGteWorld)
+	,	atom_reads(R_TapePtr)
+){
 	/* Pop matrix address from tape into R_T3 ($11) */
 	load_word(R_T3, R_TapePtr, O_(Binds_SetGteWorld,transform)),
 	add_ui_self(    R_TapePtr, S_(Binds_SetGteWorld)),
@@ -304,7 +294,6 @@ internal MipsAtom_(set_gte_world) {
 /* DIAGNOSTIC 1: Pure tape loop test */
 internal MipsAtom_(diag_yield) { mac_yield() };
 
-// TODO(Ed): Reduce magic numbers/offsets
 /* DIAGNOSTIC 2: Pure memory test (No GTE). Draws a fixed cyan triangle. */
 internal MipsAtom_(diag_color) {
 	store_word(  R_0, R_T7, 0), 
@@ -322,9 +311,9 @@ internal MipsAtom_(diag_color) {
 	add_u_self(      R_T1,       R_T6),         
 	
 	load_word(   R_AT, R_T1, 0),        
-	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits),
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits),
 	store_word(  R_AT, R_T7, 0),       
-	shift_lleft(R_AT, R_T7, S_(polytag_len_bits)), shift_lright(R_AT, R_AT, S_(polytag_len_bits)),         
+	shift_lleft(R_AT, R_T7, S_(PolyTag_len_bits)), shift_lright(R_AT, R_AT, S_(PolyTag_len_bits)),         
 	or_u_self(  R_AT, R_V0),          
 	store_word( R_AT, R_T1, 0),       
 
@@ -333,7 +322,6 @@ internal MipsAtom_(diag_color) {
 	mac_yield()
 };
 
-// TODO(Ed): Reduce magic numbers/offsets
 /* DIAGNOSTIC 3: Pure GTE test (No Memory Writes) */
 internal MipsAtom_(diag_gte) {
 	/* Load 3 indices */

code/duffle/mips.h

@@ -1,38 +1,28 @@
 /* ============================================================================
  *  duffle DSL Suffix Conventions
  *  ============================================================================
- *
  *  Every mnemonic in this header follows the same suffix grammar:
- *
+ *    _i: Immediate value (16-bit constant operand). 
- *    _i        Immediate value (16-bit constant operand). Combine with
+ *        Combine with _u or _s (single-letter modifier + type combined): add_ui, add_si.
- *              _u or _s (single-letter modifier + type combined): add_ui,
+ *        Examples: add_ui, add_si, and_i, or_i, xor_i, load_upper_i. and_i is sign-agnostic (andi zero-extends).
- *              add_si. Examples: add_ui, add_si, and_i, or_i, xor_i,
+ *        load_upper_i is a unique verb; _i is the immediate marker, not a modifier+type combination.
- *              load_upper_i. and_i is sign-agnostic (andi zero-extends).
+ *    _u: Unsigned (no-overflow, no-sign-extension).
- *              load_upper_i is a unique verb; _i is the immediate marker,
+ *        R-type arithmetic examples: add_u, sub_u, mult_u, div_u. I-type (combined with _i): add_ui.
- *              not a modifier+type combination.
+ *    _s: Signed (overflow-traps, sign-extends). 
- *
+ *        R-type: add_s, sub_s, mult_s, div_s, set_lt_s. I-type (combined with _i): add_si.
- *    _u        Unsigned (no-overflow, no-sign-extension). R-type
- *              arithmetic examples: add_u, sub_u, mult_u, div_u. I-type
- *              (combined with _i): add_ui.
- *
- *    _s        Signed (overflow-traps, sign-extends). R-type: add_s,
- *              sub_s, mult_s, div_s, set_lt_s. I-type (combined with _i):
- *              add_si.
  *
  *  --- Shift family (R-type): verb-modifier-direction ---
- *    The shift macros use `shift_<modifier><direction>`. Modifier is
+ *    The shift macros use `shift_<modifier><direction>`.
- *    the single letter `l` (logical) or `a` (arithmetic). Direction
+ *    Modifier is the single letter `l` (logical) or `a` (arithmetic).
- *    is the word `left` or `right`. Combined: `_lleft`, `_lright`,
+ *    Direction is the word `left` or `right`. Combined: `_lleft`, `_lright`, `_aright`.
- *    `_aright`. Examples: shift_lleft( rd, rt, shamt) (= sll)
+ *    Examples: shift_lleft( rd, rt, shamt) (= sll)
  *              shift_lright(rd, rt, shamt) (= srl)
  *              shift_aright(rd, rt, shamt) (= sra)
- *    (no `_aleft`; MIPS has no `sla` — arithmetic-left is bit-identical
+ *    (no `_aleft`; MIPS has no `sla` — arithmetic-left is bit-identical to logical-left, so use shift_lleft for that case)
- *    to logical-left, so use shift_lleft for that case)
  *
  *  --- Jump/Call family ---
- *    Simple jumps keep the original short names: jump (j), jump_reg
+ *    Simple jumps keep the original short names: jump (j), jump_reg (jr), jump_link (jalr rs, rd).
- *    (jr), jump_link (jalr rs, rd). The jump-and-link-to variants
+ *    The jump-and-link-to variants (jal, jalr rs with default $ra) get the `call_` verb instead:
- *    (jal, jalr rs with default $ra) get the `call_` verb instead:
  *    call_addr (jal), call_reg (jalr rs, default $ra).
  *    Examples: jump(off)         (= j)
  *              jump_reg(rs)      (= jr)
@@ -40,30 +30,20 @@
  *              call_reg(rs)      (= jalr rs, default $ra)
  *              call_addr(off)    (= jal)
  *
- *    _r        Register marker — used only when the register type needs
+ *    _r: Register marker — used only when the register type needs disambiguation (e.g., GTE data register vs control register).
- *              disambiguation (e.g., GTE data register vs control
+ *        NOT used in plain R-type arithmetic (the R-type is implicit). Examples: gte_mv_to_data_r, gte_mv_to_ctrl_r.
- *              register). NOT used in plain R-type arithmetic (the
+ *    _self:     Destination equals one source operand.
- *              R-type is implicit). Examples: gte_mv_to_data_r,
+ *               Examples: add_ui_self (I-type, to self), add_u_self (R-type, to self).
- *              gte_mv_to_ctrl_r.
+ *    _mv_to_:   Direction: data flows into X.
- *
- *    _self     Destination equals one source operand.
- *              Examples: add_ui_self (I-type, to self),
- *                        add_u_self (R-type, to self).
- *
- *    _mv_to_   Direction: data flows into X.
  *               Example: gte_mv_to_data_r, gte_mv_to_ctrl_r.
- *
+ *    _mv_from_: Direction: data flows out of X.
- *    _mv_from_ Direction: data flows out of X.
  *               Example: gte_mv_from_data_r, gte_mv_from_ctrl_r.
- *
+ *    _str:      String-form — emits inline-asm string instead of `.word`.
- *    _str      String-form — emits inline-asm string instead of `.word`.
  *               Example: gte_rtpt_asm_str.
- *
+ *    _2w / _1w: Word count of the emitted sequence.
- *    _2w / _1w Word count of the emitted sequence.
  *               Example: load_imm_2w.
  *
- *    _cop2     RESERVED — DO NOT USE in macro names. The `gte_` namespace
+ *    _cop2: RESERVED — DO NOT USE in macro names. The `gte_` namespace prefix already implies coprocessor 2. Use `c2` only in:
- *              prefix already implies coprocessor 2. Use `c2` only in:
  *      (a) integer opcode enums (op_lwc2 = 0x32, op_swc2 = 0x3A)
  *      (b) vendor-mnemonic macro aliases (gte_mtc2, gte_mfc2)
  *
@@ -80,9 +60,8 @@
  *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
  *            load_upper_i       (load-upper + immediate, unique verb)
  *
- *  Vendor mnemonics (sll, srl, sra, jr, j, jal, jalr) are NOT in this
+ *  Vendor mnemonics (sll, srl, sra, jr, j, jal, jalr) are NOT in this header.
- *  header. They live in the opt-in `mips_vendor_sym.h` for users who
+ *  They live in the opt-in `mips_vendor_sym.h` for users who prefer the textbook MIPS assembly mnemonics.
- *  prefer the textbook MIPS assembly mnemonics.
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES
@@ -98,19 +77,17 @@ enum {
 /* ============================================================================
  *  REGISTER INTEGER IDS (preprocessor-visible)
  * ============================================================================
- *  Every R_* enum below has a parallel R_*_Code `#define` so that the
+ *  Every R_* enum below has a parallel R_*_Code `#define` so that the preprocessor can stringify the integer
- *  preprocessor can stringify the integer (e.g. for asm clobber lists and
+ *  (e.g. for asm clobber lists and register-variable declarations via `rgcc(R_X)`).
- *  register-variable declarations via `rgcc(R_X)`). The enum value is
+ *  The enum value is bound to the `#define` so the two forms cannot drift apart.
- *  bound to the `#define` so the two forms cannot drift apart.
  *
- *  Only registers that get stringified need a `_Code` form; the rest are
+ *  Only registers that get stringified need a `_Code` form; the rest are plain enum values.
- *  plain enum values. If you need to add a new one, follow the pattern:
+ *  If you need to add a new one, follow the pattern:
  *      #define R_T7_Code 15
  *      R_T7 = R_T7_Code,     // in the enum
  *
- *  User code should always reference the enum form (`R_T4`) at arithmetic
+ *  User code should always reference the enum form (`R_T4`) at arithmetic sites and let
- *  sites and let `rlit(R_T4_Code)` / `rgcc(R_T4)` handle the stringify
+ *  `rlit(R_T4_Code)` / `rgcc(R_T4)` handle the stringify cases — never write the bare number `12`.
- *  cases — never write the bare number `12`.
  * ============================================================================ */
 #define R_0_Code    0
 #define R_AT_Code   1
@@ -225,7 +202,6 @@ enum {
 	/* 2F: N/A */
 	// , op_lwc0
 
-
 	// , op_load_addr  = op_la
 	// , op_load_imm   = op_li
 	, op_jump       = op_j
@@ -404,12 +380,9 @@ enum { _BitOffsets = 0
  * mult_s / mult_u → mult / multu   (writes HI/LO; result in LO)
  * div_s / div_u   → div / divu     (LO = quot, HI = rem)
  *
- * NOTE: dsl.h defines `add_s`/`sub_s`/`mut_s`/`gt_s`/etc. as
+ * NOTE: dsl.h defines `add_s`/`sub_s`/`mut_s`/`gt_s`/etc. as _Generic-based signed integer-arithmetic helpers for U1/U2/U4.
- * _Generic-based signed integer-arithmetic helpers for U1/U2/U4. Those
+ * Those live in a different conceptual layer (generic arithmetic on DSL types) and would collide with the instruction encoders here.
- * live in a different conceptual layer (generic arithmetic on DSL
+ * The `#undef` below lets the gas-style names below win; if a file needs both, the dsl.h versions can be reached via their long forms
- * types) and would collide with the instruction encoders here. The
- * `#undef` below lets the gas-style names below win; if a file needs
- * both, the dsl.h versions can be reached via their long forms
  * (e.g. `def_signed_op`-style or the underlying `add_s1/s2/s4`). */
 #undef add_s
 #undef sub_s
@@ -463,7 +436,7 @@ enum { _BitOffsets = 0
 /* --- Shift-amount alias (matches the gas convention `\p3 = shamt`) --- */
 #define shift_amount(rd, rt, n)     shift_lleft(rd, rt, n)
 
-/* nop — canonical sll $0, $0, 0 */
+/* nop — sll $0, $0, 0 */
 #define nop  shift_lleft(rdiscard, rdiscard, 0)
 #define nop2 nop, nop
 
@@ -472,22 +445,18 @@ enum { _BitOffsets = 0
 
 /* load_imm_2w — unconditional 2-word `li` form: `lui` + (ori | addi).
  *
- * Granular companion to `load_imm`: skips the compile-time range checks
+ * Granular companion to `load_imm`: skips the compile-time range checks and always emits 2 .words. Use this when:
- * and always emits 2 .words. Use this when:
  *   - you know `imm` is > 0xFFFF (otherwise you're wasting a word), OR
  *   - `imm` is not a compile-time constant and you want predictable
  *     2-word emission without the `__builtin_constant_p` branches.
  *
  * The lo16 strategy is still chosen at expansion time on the lo half:
- *   lo16 in 0x0000..0x7FFF  →  addi (sign-ext is harmless, the lui
+ *   lo16 in 0x0000..0x7FFF  →  addi (sign-ext is harmless, the lui already cleared bits 15..0)
- *                              already cleared bits 15..0)
+ *   lo16 in 0x8000..0xFFFF  →  ori  (zero-extends to preserve the intended bit pattern)
- *   lo16 in 0x8000..0xFFFF  →  ori  (zero-extends to preserve the
- *                              intended bit pattern)
  *
- * For situations where you need to bypass even this choice (e.g. to
+ * For situations where you need to bypass even this choice 
- * force a specific encoding for a known discontiguous high/low pair),
+ * (e.g. to force a specific encoding for a known discontiguous high/low pair),
  * see `load_imm_2w_ori_forced` and `load_imm_2w_addi_forced` below.
- *
  * Statement-level (not expression-level): emits its own `asm volatile(...)`.
  */
 #define load_imm_2w(rt, imm) do {                         \
@@ -518,9 +487,8 @@ enum { _BitOffsets = 0
 } while (0)
 
 /* load_imm_2w_addi_forced — force the `lui` + `addi` form regardless of lo16 sign.
- * Use when you know sign-extension is fine (e.g. lo16 is treated as
+ * Use when you know sign-extension is fine (e.g. lo16 is treated as signed downstream) 
- * signed downstream) and you want a smaller effective instruction
+ * and you want a smaller effective instruction (the assembler/MIPS hardware will sign-extend the imm16). */
- * (the assembler/MIPS hardware will sign-extend the imm16). */
 #define load_imm_2w_addi_forced(rt, imm) do {   \
 	/*U4 _li2a_imm_ = (U4)(imm);*/                \
 	asm volatile(asm_words(                       \
@@ -532,23 +500,17 @@ enum { _BitOffsets = 0
 
 /* load_imm rt, imm — true `li` semantics (assembler `li` pseudo)
  *
- * Dispatches at compile time on the immediate's range, picking the
+ * Dispatches at compile time on the immediate's range, picking the smallest single-instruction form when possible:
- * smallest single-instruction form when possible:
- *
  *   imm in 0       .. 0x7FFF     →  addi  rt, $0, imm   (1 word)
  *   imm in 0x8000  .. 0xFFFF     →  ori   rt, $0, imm   (1 word; sign-bit must be zeroed)
  *   imm in 0x10000 .. 0xFFFFFFFF →  lui + (ori | addi)  (2 words)
  *
- * Statement-level (not expression-level): the macro emits its own
+ * Statement-level (not expression-level): the macro emits its own `asm volatile(...)` block with 1 or 2 .word constants.
- * `asm volatile(...)` block with 1 or 2 .word constants. Callers can
+ * Callers can group multiple `load_imm` calls in a single volatile by using the lower-level encoders directly:
- * group multiple `load_imm` calls in a single volatile by using the
- * lower-level encoders directly:
- *
  *      load_imm(R_T4, 0x12345678);          // emits 2 .words
  *
- * Falls back to a 2-word form if `imm` is not a compile-time constant,
+ * Falls back to a 2-word form if `imm` is not a compile-time constant, but that path is unusual
- * but that path is unusual (load_imm is most useful with literal
+ * (load_imm is most useful with literal addresses and magic numbers). */
- * addresses and magic numbers). */
 #define load_imm(rt, imm) do {                                     \
 	if (cexpr_(imm) && ((imm) <= 0x7FFFU)) {                         \
 		/* Small positive: addi rt, $0, imm */                         \
@@ -588,9 +550,8 @@ enum { _BitOffsets = 0
 
 
 /* Standard clobber list for pure-MIPS asm volatile blocks: caller-saved
- * GPRs that the kernel treats as volatile (v0/v1/t0/t1/ra) plus the
+ * GPRs that the kernel treats as volatile (v0/v1/t0/t1/ra) plus the "memory" barrier.
- * "memory" barrier. The register ids are passed through `rlit` so
+ * The register ids are passed through `rlit` so the R_*_Code `#define`s are stringified into "$N" at expansion time. */
- * the R_*_Code `#define`s are stringified into "$N" at expansion time. */
 #define clbr_volatile_gprs rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain
 
 #define asm_mips_flush_icache() asm volatile( asm_words( \

code/duffle/mips_vendor_sym.h

@@ -2,9 +2,8 @@
  *  duffle DSL — MIPS Vendor Mnemonics (opt-in)
  *  ============================================================================
  *
- *  Provides the textbook MIPS assembly mnemonics as thin aliases to the
+ *  Provides the textbook MIPS assembly mnemonics as thin aliases to the duffle macros in mips.h.
- *  canonical duffle macros in mips.h. The duffle names are primary; this
+ *  The duffle names are primary; this header is for users who prefer the textbook mnemonics.
- *  header is for users who prefer the textbook mnemonics.
  *
  *  USAGE:   #include "duffle/mips_vendor_sym.h"   // after mips.h
  *
@@ -21,12 +20,6 @@
  *      jal  -> call_addr         (jump-and-link to immediate address)
  *      jalr -> call_reg          (jump-and-link to register, default $ra)
  *      (for the 2-arg `jalr rs, rd`, use `jump_link(rs, rd)` directly)
- *
- *  The vendor mnemonics are NOT registered with the duffle word-count
- *  metadata (tape_atom.metadata.h). They expand to the duffle canonical
- *  macros which DO have word-count entries. Verification: V2 (objdump
- *  byte-identical) holds.
- *
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES

code/duffle/word_count.metadata.h

@@ -1,15 +1,14 @@
-// tape_atom.metadata.h
+// word_count.metadata.h
 // Single source of truth for instruction-word counts.
 // Used by C (to define compile-time constants) AND Python (to count positions).
 //
 // Format: WORD_COUNT(MACRO_NAME, COUNT)
 // One line per macro that appears in your atom sources.
 //
-// This file is encoding-macros-only. The auto-generated component
+// This file is encoding-macros-only. 
-// macros (mac_X) live in duffle/gen/<dir>.macs.h (included separately
+// The auto-generated component macros (mac_X) live in duffle/gen/<dir>.macs.h (included separately by the unity build).
-// by the unity build). The unity build should include THIS file and
+// The unity build should include THIS file and the .macs.h file in the same TU, with both wrapped 
-// the .macs.h file in the same TU, with both wrapped (or the
+// (or the include guard order handled) to avoid WORD_COUNT redeclaration.
-// include guard order handled) to avoid WORD_COUNT redeclaration.
 //
 // To regenerate: hand-count the instructions in each macro definition.
 // (You'll only need to do this once per macro — they don't change often.)

code/graphics_hello_psyq/hello_gpu.c

@@ -17,19 +17,19 @@ enum {
 };
 
 typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
-typedef def_farray(OrderingTable_Buffer, 2);
+typedef Array_(OrderingTable_Buffer, 2);
 
 typedef B1 PrimitiveBuffer[PrimitiveBuff_Len];
-typedef def_farray(PrimitiveBuffer, 2);
+typedef Array_(PrimitiveBuffer, 2);
-typedef def_struct(PrimitiveArena) {
+typedef Struct_(PrimitiveArena) {
 	A2_PrimitiveBuffer buf;
 	U4                 used;
 };
 
 #define Cube_num_verts 8
-typedef def_farray(V3_S2, Cube_num_verts);
+typedef Array_(V3_S2, Cube_num_verts);
 #define Cube_num_faces 6
-typedef def_farray(V4_S2, Cube_num_faces);
+typedef Array_(V4_S2, Cube_num_faces);
 void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
 	memory_copy(verts, & (A8_V3_S2) {
 		{ -128, -128, -128 },
@@ -40,7 +40,7 @@ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
 		{  128,  128, -128 },
 		{  128,  128,  128 },
 		{ -128,  128,  128 }
-	}, size_of(A8_V3_S2) );
+	}, S_(A8_V3_S2) );
 	memory_copy(faces, & (A6_V4_S2) {
 		{ 3, 2, 0, 1 },
 		{ 0, 1, 4, 5 },
@@ -48,10 +48,10 @@ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
 		{ 1, 2, 5, 6 },
 		{ 2, 3, 6, 7 },
 		{ 3, 0, 7, 4 },
-	}, size_of(A6_V4_S2) );
+	}, S_(A6_V4_S2) );
 	return;
 }
-typedef def_struct(Ent_Cube) {
+typedef Struct_(Ent_Cube) {
 	V3_S4 accel;
 	V3_S4 vel;
 	V3_S4 pos;
@@ -62,22 +62,22 @@ typedef def_struct(Ent_Cube) {
 };
 
 #define Floor_num_verts 4
-typedef def_farray(V3_S2, Floor_num_verts);
+typedef Array_(V3_S2, Floor_num_verts);
 #define Floor_num_faces 2
-typedef def_farray(V3_S2, Floor_num_faces);
+typedef Array_(V3_S2, Floor_num_faces);
 void ent_floor_init(A4_V3_S2* verts, A2_V3_S2* faces) {
 	memory_copy(verts, &(A4_V3_S2) {
 		{ -900, 0, -900 },
 		{ -900, 0,  900 },
 		{  900, 0, -900 },
 		{  900, 0,  900 },
-	}, size_of(A8_V3_S2));
+	}, S_(A8_V3_S2));
 	memory_copy(faces, & (A2_V3_S2) {
 		{ 0, 1, 2 },
 		{ 1, 3, 2 },
-	}, size_of(A2_V3_S2));
+	}, S_(A2_V3_S2));
 };
-typedef def_struct(Ent_Floor) {
+typedef Struct_(Ent_Floor) {
 	V3_S4 accel;
 	V3_S4 pos;
 	V3_S4 scale;
@@ -86,7 +86,7 @@ typedef def_struct(Ent_Floor) {
 	A2_V3_S2 faces;
 };
 
-typedef def_struct(SMemory) {
+typedef Struct_(SMemory) {
 	DoubleBuffer            screen_buf;
 	A2_OrderingTable_Buffer ordering_tbl;
 	PrimitiveArena          primitives;
@@ -108,7 +108,7 @@ B1* prim__alloc(U4 type_width, Str8 type_name) {
 	pa->used += type_width;
 	return next;
 }
-#define prim_alloc(type) (type*)prim__alloc(size_of(type), txt( stringify(type)))
+#define prim_alloc(type) (type*)prim__alloc(S_(type), slit( stringify(type)))
 
 void gp_screen_init_c11(DoubleBuffer* screen_buf, S2* active_buf_id)
 {

code/graphics_hello_psyq/hello_gpu.h

@@ -5,8 +5,8 @@
 #	include "duffle/gp.h"
 #endif
 
-typedef def_struct(DrawEnv_Packed) { U4 tag; U4 code[15]; };
+typedef Struct_(DrawEnv_Packed) { U4 tag; U4 code[15]; };
-typedef def_struct(DrawEnv) {
+typedef Struct_(DrawEnv) {
 	Rect_S2 clip_area;
 	A2_S2   drawing_offset;
 	Rect_S2 texture_window;
@@ -17,7 +17,7 @@ typedef def_struct(DrawEnv) {
 	RGB8    initial_bg_color;
 	DrawEnv_Packed dr_env; // reserved
 };
-typedef def_struct(DisplayEnv) {
+typedef Struct_(DisplayEnv) {
 	Rect_S2 display_area;
 	Rect_S2 screen;
 	B1      vinterlace;
@@ -25,9 +25,9 @@ typedef def_struct(DisplayEnv) {
 	B1      pad0;
 	B1      pad1;
 };
-typedef def_farray(DrawEnv,    2);
+typedef Array_(DrawEnv,    2);
-typedef def_farray(DisplayEnv, 2);
+typedef Array_(DisplayEnv, 2);
-typedef def_struct(DoubleBuffer) {
+typedef Struct_(DoubleBuffer) {
 	A2_DrawEnv    draw;
 	A2_DisplayEnv display;
 };
@@ -58,7 +58,7 @@ U4 vsync(U4 mode)     __asm__("VSync");
 
 void draw_orderingtbl(U4* buf) __asm__("DrawOTag");
 
-typedef def_struct(PolyTag) {
+typedef Struct_(PolyTag) {
 	U4   addr: 24;
 	U4   len:  8;
 	RGB8 color;
@@ -106,7 +106,7 @@ typedef def_struct(PolyTag) {
 // #define setLineF4(p)	set_len(p, 6),  set_code(p, 0x4c),(p)->pad = 0x55555555
 // #define setLineG4(p)	set_len(p, 9),  set_code(p, 0x5c),(p)->pad = 0x55555555, (p)->p2 = 0, (p)->p3 = 0
 
-typedef def_struct(Poly_F3) {
+typedef Struct_(Poly_F3) {
 	U4   tag;
 	RGB8 color;
 	B1   code;
@@ -120,14 +120,14 @@ typedef def_struct(Poly_F3) {
 	};
 };
 
-typedef def_struct(Poly_G3) {
+typedef Struct_(Poly_G3) {
 	U4    tag; RGB8 c0; B1 code;
 	V2_S2 p0;  RGB8 c1; B1 pad1;
 	V2_S2 p1;  RGB8 c2; B1 pad2;
 	V2_S2 p2;
 };
 
-typedef def_struct(Poly_F4) {
+typedef Struct_(Poly_F4) {
 	U4   tag;
 	RGB8 color;
 	B1   code;
@@ -142,7 +142,7 @@ typedef def_struct(Poly_F4) {
 	};
 };
 
-typedef def_struct(Poly_G4) {
+typedef Struct_(Poly_G4) {
 	U4    tag; RGB8 c0; B1 code;
 	V2_S2 p0;  RGB8 c1; B1 pad1;
 	V2_S2 p1;  RGB8 c2; B1 pad2;
@@ -150,7 +150,7 @@ typedef def_struct(Poly_G4) {
 	V2_S2 p3;
 };
 
-typedef def_struct(Tile) {
+typedef Struct_(Tile) {
 	U4      tag;
 	RGB8    color;
 	B1      code;
@@ -169,7 +169,7 @@ M3_S2* m3s2_scale      (M3_S2* mat, V3_S4* vec) __asm__("ScaleMatrix");
 // Rotation, Translation, Perspective
 
 S4 rtp_v3s2_raw(V3_S2* vec, S4* xy, S4* pp, S4* flag) __asm__("RotTransPers");
-FI_ S4 rtp_v3s2(V3_S2* vec, V2_S2* xy, A2_S2* pp, S4* flag) { return rtp_v3s2_raw(vec, cast(S4*R_, & xy->x), cast(S4*R_, pp), r_(flag)); }
+FI_ S4 rtp_v3s2(V3_S2* vec, V2_S2* xy, A2_S2* pp, S4* flag) { return rtp_v3s2_raw(vec, C_(S4*R_, & xy->x), C_(S4*R_, pp), r_(flag)); }
 
 S4 rtp_avg_nclip_a3_v3s2_raw(V3_S2* v0, V3_S2* v1, V3_S2* v2, S4* xy1, S4* xy2, S4* xy3, S4* pp, S4* otz, S4* flag) __asm__("RotAverageNclip3");
 FI_  S4 rtp_avg_nclip_a3_v3s2(
@@ -179,8 +179,8 @@ FI_  S4 rtp_avg_nclip_a3_v3s2(
 ){
 	return rtp_avg_nclip_a3_v3s2_raw(
 		v0, v1, v2, 
-		cast(S4*R_, xy0), cast(S4*R_, xy1), cast(S4*R_, xy2),
+		C_(S4*R_, xy0), C_(S4*R_, xy1), C_(S4*R_, xy2),
-		cast(S4*R_, pp),  cast(S4*R_, otz), cast(S4*R_, flag)
+		C_(S4*R_, pp),  C_(S4*R_, otz), C_(S4*R_, flag)
 	);
 }
 
@@ -192,8 +192,8 @@ FI_ S4 rtp_avg_nclip_a4_v3s2(
 ){
 	return rtp_avg_nclip_a4_v3s2_raw(
 		v0, v1, v2, v3,
-		cast(S4*R_, xy0), cast(S4*R_, xy1), cast(S4*R_, xy2), cast(S4*R_, xy3),
+		C_(S4*R_, xy0), C_(S4*R_, xy1), C_(S4*R_, xy2), C_(S4*R_, xy3),
-		cast(S4*R_, pp),  cast(S4*R_, otz), cast(S4*R_, flag)
+		C_(S4*R_, pp),  C_(S4*R_, otz), C_(S4*R_, flag)
 	);
 }
 

code/gte_hello/gen/gte_hello.offsets.h

@@ -15,9 +15,9 @@ enum {
     atom_offset_bounds_chk_cube_g4_face_exit = _atom_offset_bounds_chk_cube_g4_face_exit,
 };
 
-// --- atom: floor_f3_face (66 words) ---
+// --- atom: floor_f3_face (58 words) ---
 
-#define _atom_offset_culling_floor_f3_face_exit       29
+#define _atom_offset_culling_floor_f3_face_exit       25
 #define _atom_offset_bounds_chk_floor_f3_face_exit    13
 
 enum {

code/gte_hello/hello_gte.c

@@ -1,6 +1,6 @@
-#include "stdio.h"
+#include <stdio.h>
 #include <stdlib.h>
-#include "assert.h"
+#include <assert.h>
 // #include "libgpu.h"
 // #include "libetc.h"
 // #include "libgte.h"
@@ -18,8 +18,8 @@
 #	include "duffle/gen/duffle.offsets.h"
 #include "duffle/atom_dsl.h"
 #include "duffle/lottes_tape.h"
+#include "duffle/word_count.metadata.h"
 
-#	include "tape_atom.metadata.h"
 #	include "gen/gte_hello.offsets.h"
 #include "hello_gte.h"
 
@@ -99,8 +99,13 @@ typedef Struct_(Ent_Floor) {
 	A2_V3_S2 faces;
 };
 
-enum { scratchpad_size = 1024, };
+enum { 
+	Scratchpad_Len = 1024, 
+	MemTape_Len    = 512,
+};
 typedef Struct_(SMemory) {
+	U4 MemTape[MemTape_Len];
+
 	DoubleBuffer            screen_buf;
 	A2_OrderingTable_Buffer ordering_tbl;
 	PrimitiveArena          primitives;
@@ -182,6 +187,7 @@ void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_
 void render(void) {
 }
 
+GCC_OPTIMIZATION_DISABLE
 void update(PrimitiveArena* pa, U4* ordering_buf) 
 {
 	orderingtbl_clear_reverse(ordering_buf, OrderingTbl_Len);
@@ -207,6 +213,8 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	A2_S2 p;    //???
 	S4 flag; //????
 
+	TapeBuilder tb = tb_make(slice_ut_arr(smem.MemTape));
+
 	// Draw Cube
 	if (0)
 	{
@@ -259,9 +267,8 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
 		U4 prim_cursor = prim_base + pa->used;
 
-		LP_ U4 mem_temp_tape[512]; FArena tape_arena; farena_init(& tape_arena, slice_ut_arr(mem_temp_tape));
+		tb.used = 0; tb_scope(& tb) {
-		TapeBuilder tb = tb_make_old(&tape_arena); tb_scope(& tb) {
+			tb_emit(& tb, rbind_cube_g4_face);
-			tb_emit(& tb, code_rbind_cube_g4_face);
 				tb_data(& tb, prim_cursor);
 				tb_data(& tb, u4_(smem.cube.faces));
 				tb_data(& tb, u4_(smem.cube.verts));
@@ -269,10 +276,10 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 
 			for (U4 i = 0; i < Cube_num_faces; i++) {
 				// Two triangles per quad face: (x,y,z) and (x,z,w)
-				tb_emit(& tb, code_cube_g4_face);
+				tb_emit(& tb, cube_g4_face);
 			}
 
-			tb_emit(& tb, code_sync_primitive_arena);
+			tb_emit(& tb, sync_primitive_arena);
 				tb_data(& tb, u4_(& pa->used));
 				tb_data(& tb, prim_base);
 		}
@@ -344,48 +351,40 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
 		U4 prim_cursor = prim_base + pa->used;
 
-		// TODO(Ed): We should do a bounds check beforehand to confirm pa can hold all tris.
+		// TODO(Ed): We should do a bounds check beforehand to confirm pa can hold all tris?
 		// The tape atoms in-flight should not need to care.
 
 		// Prepare the tape. (Push protocol to tape)
-		LP_ U4 mem_temp_tape[512];
+		tb.used = 0; tb_scope(& tb) {
-		TapeBuilder tb = tb_make(slice_ut_arr(mem_temp_tape)); tb_scope(& tb) {
+			tb_emit(& tb, set_gte_world);
-			tb_emit(& tb, code_set_gte_world);
 				tb_data(& tb, u4_(& smem.tform_world));
 
-			tb_emit(& tb, code_rbind_floor_f3_face);
+			tb_emit(& tb, rbind_floor_f3_face);
 			// TODO(Ed): Just use a single context struct ref
 				tb_data(& tb, prim_cursor);
 				tb_data(& tb, u4_(smem.floor.faces));
 				tb_data(& tb, u4_(smem.floor.verts));
 				tb_data(& tb, u4_(ordering_buf));
 			for (U4 i = 0; i < Floor_num_faces; i++) {
-				tb_emit(& tb, code_floor_f3_face);
+				tb_emit(& tb, floor_f3_face);
 			}
-			// After code_floor_f3_face iterations complete, the primitive arena's used counter needs updating.
+			// After floor_f3_face iterations complete, the primitive arena's used counter needs updating.
-			tb_emit(& tb, code_sync_primitive_arena);
+			tb_emit(& tb, sync_primitive_arena);
 				tb_data(& tb, u4_(& pa->used));
 				tb_data(& tb, prim_base);
 		}
-
 		tape_run(tb_slice(tb));// Fire off the tape.
 
 		// C-side state (pa->used) has already been updated by the tape!
 		smem.floor.rot.y += 5;
 	}
 	// --- TAPE DIAGNOSTICS ---
-	if (1)
+	if (0)
 	{
 		LP_ U4 mem_temp_tape[512]; FArena tape_arena; farena_init(& tape_arena, slice_ut_arr(mem_temp_tape));
 		TapeBuilder tb = tb_make_old(& tape_arena); tb_scope(& tb) {
 			// Skip set_gte_world atom for diagnostics to isolate the triangle loop
 			for (U4 i = 0; i < Floor_num_faces; i++) {
-				// =======================================================
-				// SWAP EMIT TO TEST DIFFERENT PARTS OF THE PIPELINE:
-				// =======================================================
-				// 1. code_diag_yield -> Tests Tape Engine jump logic
-				// 2. code_diag_color -> Tests OT and Prim Arena memory
-				// 3. code_diag_gte   -> Tests Vertex arrays and GTE Math
 				// tb_emit(& tb, code_diag_yield);
 				// tb_emit(& tb, code_diag_color);
 				// tb_emit(& tb, code_diag_gte); 
@@ -394,9 +393,9 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		B1* prim_cursor = (B1*)r_(pa->buf)[smem.active_buf_id] + pa->used;
 		tape_run(tb_slice(tb));
 		pa->used = (U4)prim_cursor - (U4)r_(pa->buf)[smem.active_buf_id];
-		smem.floor.rot.y += 5;
 	}
 }
+GCC_OPTIMIZATION_ENABLE
 
 int main(void)
 {

code/gte_hello/hello_gte_tape.c

@@ -3,7 +3,7 @@
 #	include "duffle/gen/duffle.offsets.h"
 #	include "duffle/atom_dsl.h"
 #	include "duffle/lottes_tape.h"
-#	include "tape_atom.metadata.h"
+#	include "duffle/word_count.metadata.h"
 #	include "gen/gte_hello.offsets.h"
 #	include "hello_gte.h"
 #endif
@@ -22,88 +22,61 @@ typedef Struct_(Binds_CubeTri) {
 	V3_S2* VertBase;
 	U4*    OtBase;
 };
-internal MipsAtom_(rbind_cube_g4_face) {
+internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri), atom_phase(cube_g4)
+,	atom_reads(R_TapePtr)
+,	atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+){
 	/* Pop 4 arguments from the tape directly into the workspace registers */
 	load_word(R_PrimCursor, R_TapePtr, O_(Binds_CubeTri,PrimCursor)),
 	load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,FaceCursor)),
 	load_word(R_VertBase,   R_TapePtr, O_(Binds_CubeTri,VertBase)),
 	load_word(R_OtBase,     R_TapePtr, O_(Binds_CubeTri,OtBase)),
 	add_ui_self(            R_TapePtr, S_(Binds_CubeTri)),
-	// Note(Ed): This entire thing is argument shuffle?
-	// TODO(Ed): Eliminate
 	mac_yield()
 };
 
-/* ============================================================================
+ // cube_g4_face — Draw one cube face (Gouraud-shaded quad) via the GTE tape pipeline
- *  cube_g4_face — Draw one cube face (Gouraud-shaded quad) via the GTE tape pipeline
- * ============================================================================
- *
- *  Reads 4 indices from R_FaceCur (V4_S2 = 8 bytes), loads 4 vertices into
- *  the GTE, runs the PsyQ RotAverageNclip4 sequence, and renders a Poly_G4.
- */
-	atom_region  (cube_g4_face, REGION_PRIM_ARENA)
-	atom_group   (cube_g4_face, GROUP_RENDER_PRIMS)
-	atom_cadence (cube_g4_face, CADENCE_FRAME)
-	atom_annot(cube_g4_face, phase_work,
-			atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
-			atom_writes(R_PrimCursor, R_FaceCursor))
 internal
-MipsAtom_(cube_g4_face) {
+MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
-	/* ── 1. Load 4 face indices from R_FaceCur (V4_S2 = 8 bytes) ───────── */
+		atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
+		atom_writes(R_PrimCursor, R_FaceCursor)
+){
 	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
 	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)),
 	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
 	load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)),
 
-	/* ── 2. Load V0, V1, V2 into GTE (parallel to mac_load_tri_verts) ── */
+	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
-	mac_load_tri_verts(R_T0, R_T1, R_T2),
-
-	/* ── 3. RTPT — transforms V0/V1/V2 → SXY0/SXY1/SXY2 + SZ1/SZ2/SZ3 ─── */
 	nop2, gte_cmdw_rotate_translate_perspective_triple,
-
-	/* ── 4. NCLIP — backface culling on SXY0/SXY1/SXY2 (p0,p1,p2) ──────── */
-	/*     MUST be done BEFORE V3-RTPS overwrites SXY0 with p3.             */
 	nop2, gte_cmdw_nclip,
 
-	/* ── 5. Cull check: skip format/insert if MAC0 ≤ 0 (backface) ───────── */
 	nop2,  gte_mv_from_data_r(R_T0, C2_MAC0),
-	nop,                                                          /* COP2 stall */
+	nop,
-	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)),
+	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)), nop,
-	nop,                                                          /* BD slot    */
 
-	/* ── 6. Format c0..c3 (color+code words) BEFORE V3-RTPS ─────────────── */
 	store_word(R_0, R_PrimCursor, O_(Poly_G4, tag)),
 	mac_format_g4_color(
 		/* c0 magenta */ 0xFF, 0x00, 0xFF,
 		/* c1 yellow  */ 0xFF, 0xFF, 0x00,
 		/* c2 cyan    */ 0x00, 0xFF, 0xFF,
 		/* c3 green   */ 0x00, 0xFF, 0x00),
-
-	/* ── 7. Store p0..p2 BEFORE V3-RTPS overwrites SXY0 ─────────────────── */
 	mac_gte_store_g4_p012_post_rtpt_pre_rtps(),
 
-	/* ── 8. Load V3 = verts[face->w] into V0 ─────────────────────────────── */
 	shift_lleft(R_AT, R_T3, v3s2_byteoff), add_u(R_AT, R_AT, R_VertBase),
 	load_word(R_V0, R_AT, O_(V3_S2, x)),   load_word(R_V1, R_AT, O_(V3_S2, z)),
 	gte_mv_to_data_r(R_V0, C2_VXY0),       gte_mv_to_data_r(R_V1, C2_VZ0),
 
-	/* ── 9. RTPS — transforms V0 (now V3) → SXY0 (p3) + SZ3 ─────────────── */
 	nop2, gte_cmdw_rotate_translate_perspective_single,
 	mac_gte_store_g4_p3_post_rtps(),
 
-	/* ── 10. AVSZ4 — average Z from SZ0/SZ1/SZ2/SZ3 ─────────────────────── */
 	nop2, gte_cmdw_avg_sort_z4,
 	nop2, gte_mv_from_data_r(R_T1, C2_OTZ),
 
-	/* ── 11. Bounds check OTZ < OrderingTbl_Len ─────────────────────────── */
 	add_ui(      R_AT, R_0,  OrderingTbl_Len),
 	set_lt_u(    R_AT, R_T1, R_AT),
 	branch_equal(R_AT, R_0,  atom_offset(bounds_chk, cube_g4_face_exit)), nop,
-
-	/* ── 12. Insert into Ordering Table (length = 8 words for Poly_G4) ──── */
 	mac_insert_ot_tag_g4(),
 
-	/* ── 13. Advance cursors & yield (both branch targets land here) ────── */
 atom_label(cube_g4_face_exit)
 	add_ui_self(R_PrimCursor, S_(Poly_G4)),     /* 9 words = Poly_G4 */
 	add_ui_self(R_FaceCursor, S_(S2) * 4),      /* 4 × S2 = 8 bytes */
@@ -116,14 +89,11 @@ typedef Struct_(Binds_FloorTri) {
 	V3_S2* VertBase;
 	U4*    OtBase;
 };
-	atom_region(rbind_floor_f3_face, REGION_PRIM_ARENA)
-	atom_group(rbind_floor_f3_face, GROUP_RENDER_FLOOR)
-	atom_cadence(rbind_floor_f3_face, CADENCE_FRAME)
-	atom_annot(rbind_floor_f3_face, phase_bind
-		, atom_reads()
-		, atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase))
 internal
-MipsAtom_(rbind_floor_f3_face) {
+MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri), atom_phase(floor_f3)
+	, atom_reads(R_TapePtr)
+	, atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+){
 	/* Pop 4 arguments from the tape directly into the workspace registers */
 	load_word(R_PrimCursor, R_TapePtr, O_(Binds_FloorTri,PrimCursor)),
 	load_word(R_FaceCursor, R_TapePtr, O_(Binds_FloorTri,FaceCursor)),
@@ -133,31 +103,27 @@ MipsAtom_(rbind_floor_f3_face) {
 	mac_yield()
 };
 
-	atom_region( floor_f3_face, REGION_PRIM_ARENA)
+atom_dbg_skip
-	atom_group(  floor_f3_face, GROUP_RENDER_FLOOR)
-	atom_cadence(floor_f3_face, CADENCE_FRAME)
-	atom_annot(  floor_f3_face, phase_work,
-		atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
-		atom_writes(R_PrimCursor, R_FaceCursor)) 
 internal
-MipsAtom_(floor_f3_face) {
+MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
-	mac_load_tri_indices(R_T0, R_T1, R_T2),
+	, atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
-	mac_load_tri_verts(  R_T0, R_T1, R_T2),
+	, atom_writes(R_PrimCursor, R_FaceCursr)
-	nop2, gte_cmdw_rotate_translate_perspective_triple,
+) {
-	nop2, gte_cmdw_nclip,
+	mac_load_tri_indices(  R_T0, R_T1, R_T2),
+	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
+	nop2, gte_cmdw_rotate_translate_perspective_triple, // 2 nops retire the final cpu -> gte writes before RTPT
+	gte_cmdw_nclip,
 
 	/* Culling (Branch forward if Backface) */
-	nop2, gte_mv_from_data_r(R_T0, C2_MAC0),
+	gte_mv_from_data_r(R_T0, C2_MAC0),
-	nop,
+	nop, branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop, // required gte -> cpu load-delay slot. 
-	branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop,
 	/* Format Primitive */
-	// mac_format_f3_color(0x20FF, 0xFFFF),  // works
 	mac_format_f3_color(0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
 	mac_gte_store_f3_post_rtpt(),
 
 	/* Calculate Depth */
-	nop2, gte_avg_sort_z3,            
+	gte_avg_sort_z3,
-	nop2, gte_mv_from_data_r(R_T1, C2_OTZ),      
+	gte_mv_from_data_r(R_T1, C2_OTZ),
 	/* Bounds Check OTZ < 2048 (Branch forward to skip insertion) */
 	add_ui(      R_AT, R_0,  OrderingTbl_Len),
 	set_lt_u(    R_AT, R_T1, R_AT),
@@ -174,13 +140,10 @@ atom_label(floor_f3_face_exit)
 };
 
 typedef Struct_(Binds_SyncPrimitiveArena) { U4 used; U4 cursor; };
-	atom_region( sync_primitive_arena, REGION_PRIM_ARENA)
+internal MipsAtom_(sync_primitive_arena) atom_info(atom_bind(Binds_SyncPrimitiveArena)
-	atom_group(  sync_primitive_arena, GROUP_RENDER_FLOOR)
+	, atom_reads( R_TapePtr, R_PrimCursor)
-	atom_cadence(sync_primitive_arena, CADENCE_FRAME)
+	, atom_writes(R_TapePtr)
-	atom_annot(  sync_primitive_arena, phase_work,
+){
-		atom_reads( R_TapePtr, R_PrimCursor),
-		atom_writes(R_TapePtr)) 
-internal MipsAtom_(sync_primitive_arena) {
 	load_word(R_AT, R_TapePtr, O_(Binds_SyncPrimitiveArena,used)),
 	load_word(R_T0, R_TapePtr, O_(Binds_SyncPrimitiveArena,cursor)),
 	add_ui_self(    R_TapePtr, S_(Binds_SyncPrimitiveArena)),

readme.md

@@ -6,19 +6,34 @@ A rest from the usual.
 
 ## Dependencies
 
-I will be programming from a Windows 11 machine:
+I will be programming from a Windows 11 machine (may eventually try this on the Steam Deck...):
 ![system_info](./docs/assets/system_info.png)
 
-```ps1
-# not really used yet for scripts (may never)
-scoop install lua
-```
-
 [armips](https://github.com/Kingcom/armips)
 
 * Supports doing bare-metal assembly for the ps1
 * `scoop install armips` or just clone and build..
 
+[luajit-2.1](https://github.com/LuaJIT/LuaJIT.git)
+
+```
+scoop install luajit
+```
+
+* Used for lua scripts
+* Particularly, ps1_meta.lua which is a staged metaprogram pass for the custom C11 Assembly DSL used in this codebase.
+
+[lpeg](https://github.com/roberto-ieru/LPeg.git)
+
+* Lua is slow (even jitted) so this helps.
+
+[lfs (LuaFileSystem)](https://github.com/lunarmodules/luafilesystem)
+
+* Native directory enumeration + `mkdir` for the build scripts.
+* Used by `passes/word_count_eval.lua :: scan_dir` (native walk vs. `dir /b /s` subprocess,
+  ~2ms vs. ~56ms) and by `duffle.lua :: ensure_dir` + `to_absolute_path` (avoids
+  `cmd.exe mkdir` + `cd` shell spawns, ~50ms each).
+
 [pscx-redux](https://github.com/grumpycoders/pcsx-redux/): A collection of tools, research, hardware design, and libraries aiming at development and reverse engineering on the PlayStation 1.
 
 * Used as the runtime sandbox emulated the ps1
@@ -57,3 +72,4 @@ scoop install lua
 ![polys!](./docs/assets/pcsx-redux.main_2025-08-03_20-45-35.png)  
 ![hello_psyq!](./docs/assets/pcsx-redux_2025-08-05_23-01-19.png)
 ![cube!](./docs/assets/pcsx-redux_2025-10-11_03-04-01.png)
+![cube and floor!](./docs/assets/pcsx-redux_2026-07-10_22-47-02.png)

scratch/gte_debug.lua

@@ -0,0 +1,30 @@
+-- gte_debug.lua — defensive version + prints error context.
+local ok, err = pcall(function()
+    print("[debug] PCSX exists:", PCSX ~= nil)
+    print("[debug] PCSX.WebServer exists:", PCSX and PCSX.WebServer ~= nil)
+    print("[debug] PCSX.WebServer.Handlers exists:", PCSX and PCSX.WebServer and PCSX.WebServer.Handlers ~= nil)
+    if not PCSX.WebServer then
+        print("[debug] creating PCSX.WebServer...")
+        PCSX.WebServer = {}
+    end
+    if not PCSX.WebServer.Handlers then
+        print("[debug] creating PCSX.WebServer.Handlers...")
+        PCSX.WebServer.Handlers = {}
+    end
+    print("[debug] type of Handlers:", type(PCSX.WebServer.Handlers))
+
+    PCSX.WebServer.Handlers.gte = function(req)
+        local r = PCSX.getRegisters()
+        local out = { "pc=0x" .. string.format("%x", r.pc) }
+        for i = 0, 31 do
+            out[#out + 1] = string.format("D[%d]=0x%08x C[%d]=0x%08x",
+                i, r.CP2D.r[i], i, r.CP2C.r[i])
+        end
+        return table.concat(out, "\n")
+    end
+    print("[debug] handler registered")
+end)
+
+if not ok then
+    print("[debug] ERROR: " .. tostring(err))
+end

scripts/audit_lua_nesting.lua

@@ -0,0 +1,217 @@
+--- audit_lua_nesting.lua — Walk Lua source files and flag any block nesting deeper than 5 levels.
+---
+--- Usage:
+---   luajit scripts/audit_lua_nesting.lua scripts/duffle.lua scripts/ps1_meta.lua
+---   luajit scripts/audit_lua_nesting.lua scripts/passes/
+---
+--- Output: for each file, a list of {line, depth} entries where depth > 5.
+--- Returns exit code 1 if any violations found, 0 if clean.
+---
+--- **Implementation**: a hand-rolled depth tracker that counts:
+---   - `do`, `function`, `if`, `for`, `while`, `repeat`  -> depth +1
+---   - `end`, `until`                                    -> depth -1
+---   - `else`, `elseif`                                  -> depth unchanged
+---
+--- **Caveats**: doesn't fully handle string/comment state (will miscount braces inside multi-line strings or block comments). 
+--- For our metaprogram files (no embedded code generation), this is acceptable.
+
+local M = {}
+
+local BLOCK_OPEN = {
+	["do"]       = true,
+	["function"] = true,
+	["if"]       = true,
+	["for"]      = true,
+	["while"]    = true,
+	["repeat"]   = true,
+}
+
+local function is_block_close(token) return token == "end" or token == "until" end
+
+-- (internal) Walk one source file and return a list of
+-- {line, depth, token} entries where depth > max_nesting.
+local function audit_file(path, max_nesting)
+	local  f = io.open(path, "r")
+	if not f then error("Cannot open " .. path) end
+	local content = f:read("*a")
+	f:close()
+
+	local violations = {}
+	local depth      = 0
+	local line       = 1
+	local pos        = 1
+	local src_len    = #content
+	local token_idx  = 0
+
+	local function read_ident_at(start_pos)
+		local ident_start = start_pos
+		if ident_start > src_len then return nil end
+		local first_ch = content:sub(ident_start, ident_start)
+		if not (first_ch:match("[%a_]")) then return nil end
+		local scan = start_pos + 1
+		while scan <= src_len do
+			local ch = content:sub(scan, scan)
+			if not (ch:match("[%w_]")) then break end
+			scan = scan + 1
+		end
+		return content:sub(ident_start, scan - 1), scan
+	end
+
+	-- Skip past a string literal or comment starting at `start_pos`.
+	-- Returns the position just past the construct, or nil if `start_pos`
+	-- is not the start of a string/comment.
+	local function skip_string_or_comment(start_pos)
+		local ch = content:sub(start_pos, start_pos)
+		if    ch == '"' or ch == "'" then
+			local scan = start_pos + 1
+			while scan <= src_len do
+				local  c = content:sub(scan, scan)
+				if     c == "\\" then        scan = scan + 2
+				elseif c == ch   then return scan + 1
+				else                         scan = scan + 1
+				end
+			end
+			return src_len + 1
+		elseif ch == "-" and content:sub(start_pos + 1, start_pos + 1) == "-" then
+			local scan = start_pos + 2
+			if content:sub(scan, scan + 1) == "[[" and content:sub(scan + 2, scan + 3) == "[" then
+				-- Long bracket comment [==[ ... ]==]
+				scan = scan + 2
+				local eq = ""
+				while content:sub(scan, scan) == "=" do
+					eq = eq .. "="
+					scan = scan + 1
+				end
+				local close_marker = "]" .. eq .. "]"
+				local close_pos = content:find(close_marker, scan, true)
+				if close_pos then
+					return close_pos + #close_marker
+				else
+					return src_len + 1
+				end
+			else
+				while scan <= src_len and content:sub(scan, scan) ~= "\n" do scan = scan + 1 end
+				return scan + 1
+			end
+		elseif ch == "[" and content:sub(start_pos + 1, start_pos + 1) == "[" then
+			local scan = start_pos + 2
+			local eq = ""
+			while content:sub(scan, scan) == "=" do
+				eq   = eq .. "="
+				scan = scan + 1
+			end
+			local close_marker = "]" .. eq .. "]"
+			local close_pos = content:find(close_marker, scan, true)
+			if close_pos then
+				return close_pos + #close_marker
+			else
+				return src_len + 1
+			end
+		end
+		return nil
+	end
+
+	while pos <= src_len do
+		local ch = content:sub(pos, pos)
+		if ch == "\n" then line = line + 1 end
+
+		local skip_to = skip_string_or_comment(pos)
+		if skip_to then
+			for scan = pos, skip_to - 1 do
+				if content:sub(scan, scan) == "\n" then line = line + 1 end
+			end
+			pos = skip_to
+		elseif ch:match("[%a_]") then
+			local tok, next_pos = read_ident_at(pos)
+			token_idx = token_idx + 1
+			if BLOCK_OPEN[tok] then
+				depth = depth + 1
+				if depth > max_nesting then
+					violations[#violations + 1] = {
+						line  = line,
+						depth = depth,
+						token = tok,
+					}
+				end
+			elseif is_block_close(tok) then
+				depth = depth - 1
+			end
+			pos = next_pos
+		else
+			pos = pos + 1
+		end
+	end
+
+	return violations
+end
+
+--- Audit one file. Returns nil if clean, else a list of violations.
+--- @param path string
+--- @param max_nesting integer  -- default 5
+--- @return table|nil
+function M.audit(path, max_nesting)
+	local  violations = audit_file(path, max_nesting or 5)
+	if     #violations == 0 then return nil end
+	return violations
+end
+
+-- Module CLI.
+if arg and arg[1] then
+	local max_nesting = 5
+	local files = {}
+	for arg_idx = 1, #arg do
+		if arg[arg_idx] == "--max" and arg[arg_idx + 1] then
+			max_nesting = tonumber(arg[arg_idx + 1]) or 5
+		else
+			files[#files + 1] = arg[arg_idx]
+		end
+	end
+
+	-- Accept either a directory or a file path. Directory args are
+	-- expanded via lfs.dir (native, no subprocess).
+	local lfs = require("lfs")
+	local function is_dir(p)
+		return lfs.attributes(p, "mode") == "directory"
+	end
+	local function list_lua(dir)
+		local out = {}
+		if not is_dir(dir) then return out end
+		for entry in lfs.dir(dir) do
+			if entry:match("%.lua$") then
+				out[#out + 1] = dir .. "/" .. entry
+			end
+		end
+		return out
+	end
+
+	local to_check = {}
+	for _, f in ipairs(files) do
+		if is_dir(f) then
+			for _, sub in ipairs(list_lua(f)) do to_check[#to_check + 1] = sub end
+		else
+			to_check[#to_check + 1] = f
+		end
+	end
+
+	local total_violations = 0
+	for _, f in ipairs(to_check) do
+		local v = M.audit(f, max_nesting)
+		if v then
+			io.write(string.format("\n%s\n", f))
+			for _, x in ipairs(v) do
+				io.write(string.format("  line %d: depth %d (after '%s')\n", x.line, x.depth, x.token))
+			end
+			total_violations = total_violations + #v
+		end
+	end
+
+	if total_violations == 0 then
+		io.write("OK: no files exceed max nesting of " .. max_nesting .. "\n")
+		os.exit(0)
+	else
+		io.write(string.format("\n%d nesting violation(s) found.\n", total_violations))
+		os.exit(1)
+	end
+end
+
+return M

scripts/build_psyq.ps1

@@ -81,19 +81,6 @@ $path_psyq          = join-path $path_toolchain  'psyq-4_7'
 $path_psyq_iwyu     = join-path $path_toolchain  'psyq_iwyu'
 $path_psyq_imyu_inc = join-path $path_psyq_iwyu  'include'
 
-function Get-SourceFiles { param([Parameter(Mandatory=$true)] [string[]]$paths, [Parameter(Mandatory=$true)] [string[]]$extensions)
-	$files = @()
-	foreach ($p in $paths) {
-		if (-not (test-path $p)) { continue }
-		foreach ($ext in $extensions) {
-			Get-ChildItem -Path $p -File -Recurse -Filter "*$ext" -ErrorAction SilentlyContinue | ForEach-Object {
-				$files += $_.FullName
-			}
-		}
-	}
-	return ($files | Sort-Object -Unique)
-}
-
 function assemble-unit { param(
 	[string]  $unit,
 	[string]  $link_module,
@@ -153,7 +140,7 @@ function compile-unit { param(
 		$f_arch_no_shared,
 		$f_arch_no_stack_prot
 	)
-	# $compile_args    += $f_std_c23
+	$compile_args    += $f_std_c11
 	$compile_args    += ($f_include + $path_psyq_imyu_inc)
 	$compile_args    += ($f_include + $path_nugget)
 
@@ -243,6 +230,52 @@ function make-binary { param([string]$elf, [string]$exe)
 	if ($LASTEXITCODE -ne 0) { Write-Error "Objcopy failed. Aborting."; exit 1 }
 }
 
+function ps1-meta { param(
+		[string]$unity_root,
+		[string[]]$sources,
+		[Parameter(Mandatory=$true)][string]$metadata,
+		[string]$out_root = (join-path $path_build 'gen'),
+		[string[]]$passes = @('--pre-link'),
+		[string[]]$extra_args = @()
+	)
+	# `--unity-root` and `--source` are
+	# mutually exclusive. Exactly one of `$unity_root` / `$sources` must
+	# be supplied; the other must be absent.
+	if ($null -ne $unity_root -and $unity_root -ne '') 
+	{
+		if ($null -ne $sources -and $sources.Count -gt 0) {
+			write-error 'ps1-meta: -unity_root and -sources are mutually exclusive'
+			exit 2
+		}
+	} 
+	elseif ($null -eq $sources -or $sources.Count -eq 0) {
+		write-error 'ps1-meta: either -unity_root <file> or -sources <file...> is required'
+		exit 2
+	}
+
+	$script = join-path $path_scripts 'ps1_meta.lua'
+	$input_summary = if ($null -ne $unity_root -and $unity_root -ne '') {
+		"unity=$unity_root"
+	}
+	else {
+		"$($sources.Count) source(s)"
+	}
+	write-host "ps1-meta  $input_summary, passes=$($passes -join ',')" ` -ForegroundColor Magenta
+
+	$arg_list = @($passes) + @('--metadata', $metadata) + @('--out-root', $out_root) + @($extra_args)
+	if ($null -ne $unity_root -and $unity_root -ne '') {
+		$arg_list += @('--unity-root', $unity_root)
+	}
+	else {
+		foreach ($s in $sources) { $arg_list += @('--source', $s) }
+	}
+	& luajit $script @arg_list
+	if ($LASTEXITCODE -ne 0) {
+		write-error "ps1-meta failed (exit $LASTEXITCODE). Aborting."
+		exit $LASTEXITCODE
+	}
+}
+
 function build-hello_psyqo {
 	$includes += @()
 
@@ -317,57 +350,16 @@ function build-graphis_hello {
 }
 # build-graphis_hello
 
-# ps1-meta orchestrator. Replaces generate-TapeAtomOffsets +
-# generate-TapeAtomAnnotations with a single invocation. Dispatches
-# the 6 passes (word-counts / components / annotation / offsets /
-# static-analysis / report) in dependency-topological order.
-
-function any-stale {
-	param([Parameter(Mandatory=$true)][string[]]$sources,
-	      [Parameter(Mandatory=$true)][string]$metadata,
-	      [Parameter(Mandatory=$true)][string]$out_root)
-	if (-not (test-path $out_root)) { return $true }
-	$out_mtime  = (get-item $out_root).LastWriteTimeUtc
-	$src_mtime  = ($sources  | ForEach-Object { (get-item $_).LastWriteTimeUtc } | Measure-Object -Maximum).Maximum
-	$meta_mtime = (get-item $metadata).LastWriteTimeUtc
-	return ($src_mtime -gt $out_mtime) -or ($meta_mtime -gt $out_mtime)
-}
-
-function ps1-meta {
-	param(
-		[Parameter(Mandatory=$true)][string[]]$sources,
-		[Parameter(Mandatory=$true)][string]$metadata,
-		[string]$out_root = (join-path $path_build 'gen'),
-		[string[]]$passes  = @('--all')
-	)
-	$script = join-path $path_scripts 'ps1_meta.lua'
-	write-host "ps1-meta  $($sources.Count) source(s), passes=$($passes -join ',')" `
-		-ForegroundColor Magenta
-	$arg_list = @($passes) + @('--metadata', $metadata) + @('--out-root', $out_root)
-	foreach ($s in $sources) { $arg_list += @('--source', $s) }
-	& luajit $script @arg_list
-	if ($LASTEXITCODE -ne 0) {
-		write-error "ps1-meta failed (exit $LASTEXITCODE). Aborting."
-		exit $LASTEXITCODE
-	}
-}
-
 function build-gte_hello {
 	$includes += @()
 
 	$path_module        = join-path $path_code   'gte_hello'
 	$path_duffle        = join-path $path_code   'duffle'
-	$path_atom_metadata = join-path $path_module 'tape_atom.metadata.h'
+	$path_atom_metadata = join-path $path_duffle 'word_count.metadata.h'
+	$path_build_gen     = join-path $path_build   'gen'
 
-	$source_dirs  = @($path_duffle, $path_module)
+	$src_c = join-path $path_module 'hello_gte.c'
-	$atom_sources = Get-SourceFiles -paths $source_dirs -extensions @('.h', '.c')
+	ps1-meta -unity_root $src_c -metadata $path_atom_metadata -out_root $path_build_gen
-
-	if (any-stale -sources $atom_sources -metadata $path_atom_metadata -out_root (join-path $path_build 'gen')) {
-		ps1-meta -sources $atom_sources -metadata $path_atom_metadata -out_root (join-path $path_build 'gen')
-	} else {
-		write-host "ps1-meta  all $($atom_sources.Count) source(s) up-to-date" `
-			-ForegroundColor DarkGray
-	}
 
 	$assemble_args = @()
 	$assemble_args += $f_debug
@@ -383,7 +375,6 @@ function build-gte_hello {
 
 	# assemble-unit $src_asm $module_asm $includes $assemble_args
 
-	$src_c    = join-path $path_module 'hello_gte.c'
 	$module_c = join-path $path_build  'hello_gte_c.o'
 
 	$compile_args = @()
@@ -407,23 +398,78 @@ function build-gte_hello {
 	)
 	link-modules $link_modules $elf $link_args
 	make-binary $elf $exe
+
+	# Post-link: gdb-runtime + dwarf-injection in a single Lua invocation (one luajit cold start).
+	ps1-meta -unity_root $src_c -metadata $path_atom_metadata -out_root $path_build_gen -passes @('--post-link') ` -extra_args @('--elf', $elf)
+
+	$dwarfLineBin     = join-path $path_build_gen 'hello_gte.dwarf_line.bin'
+	$dwarfArangesBin  = join-path $path_build_gen 'hello_gte.dwarf_aranges.bin'
+	$dwarfRnglistsBin = join-path $path_build_gen 'hello_gte.dwarf_rnglists.bin'
+	$injectElf        = join-path $path_build 'hello_gte.dwarf-injected.elf'
+	if ((Test-Path $dwarfLineBin) -and (Test-Path $dwarfArangesBin) -and (Test-Path $dwarfRnglistsBin))
+	{
+		Write-Host "[build] DWARF-injecting $elf -> $injectElf"
+		Copy-Item -LiteralPath $elf -Destination $injectElf -Force
+		# Objcopy call: 3x --update-section for (line, aranges, rnglists).
+		$f_args = @(
+			"--update-section=.debug_line=$dwarfLineBin",
+			"--update-section=.debug_aranges=$dwarfArangesBin",
+			"--update-section=.debug_rnglists=$dwarfRnglistsBin"
+		)
+		& $Objcopy @f_args $injectElf 2>&1 | Out-Null
+		if ($LASTEXITCODE -ne 0) {
+			Write-Warning "[build] objcopy F' splice failed (exit $LASTEXITCODE); removing $injectElf"
+			Remove-Item -LiteralPath $injectElf -ErrorAction SilentlyContinue
+			return;
+		}
+
+		$dwarfInfoBin     = join-path $path_build_gen 'hello_gte.dwarf_info.bin'
+		$dwarfAbbrevBin   = join-path $path_build_gen 'hello_gte.dwarf_abbrev.bin'
+		$dwarfStrBin      = join-path $path_build_gen 'hello_gte.dwarf_str.bin'
+		$dwarfLocBin      = join-path $path_build_gen 'hello_gte.dwarf_loc.bin'
+		$dwarfLoclistsBin = join-path $path_build_gen 'hello_gte.dwarf_loclists.bin'
+		$g_args = @(
+			"--update-section=.debug_info=$dwarfInfoBin",
+			"--update-section=.debug_abbrev=$dwarfAbbrevBin",
+			"--update-section=.debug_str=$dwarfStrBin",
+			"--add-section=.debug_loc=$dwarfLocBin",
+			"--add-section=.debug_loclists=$dwarfLoclistsBin"
+		)
+		& $Objcopy @g_args $injectElf 2>&1 | Out-Null
+		if ($LASTEXITCODE -ne 0) {
+			Write-Warning "[build] objcopy G' splice failed (exit $LASTEXITCODE); removing $injectElf"
+			Remove-Item -LiteralPath $injectElf -ErrorAction SilentlyContinue
+			return;
+		}
+
+		# Baked atoms execute from RAM but are emitted as C data arrays, so their ELF sections lack SHF_EXECINSTR.
+		# GDB discards line rows for non-code sections. Mark only the debug-copy sections executable.
+		# The original ELF and PS-EXE remain byte/flag unchanged.
+		& $Objcopy `
+			--set-section-flags ".rodata=alloc,load,readonly,code,contents" `
+			--set-section-flags ".data=alloc,load,data,code,contents" `
+			$injectElf 2>&1 | Out-Null
+		if ($LASTEXITCODE -ne 0) {
+			Write-Warning "[build] atom-section flag update failed (exit $LASTEXITCODE); removing $injectElf"
+			Remove-Item -LiteralPath $injectElf -ErrorAction SilentlyContinue
+		} 
+		else {
+			Write-Host "[build] DWARF-injected ELF: $injectElf"
+		}
+	}
 }
 build-gte_hello
 
 
 # NO idea if this works yet...
-function Send-ToEmulator { param(
+function Send-ToEmulator { param( [string]$exePath )
-    [string]$exePath
-)
     $uri = "http://localhost:8080/api/v1/load-exec"
 
     # Absolute path is safest for the emulator web server
     $absolutePath = [System.IO.Path]::GetFullPath($exePath)
 
     # Create JSON payload pointing to your compiled .ps-exe
-    $body = @{
+    $body = @{ filename = $absolutePath } | ConvertTo-Json
-        filename = $absolutePath
-    } | ConvertTo-Json
 
     Write-Host "Pushing hot-reload to PCSX-Redux..." -ForegroundColor Magenta
     try {

scripts/duffle_paths.lua

@@ -0,0 +1,92 @@
+--- duffle_paths.lua — Single-line bootstrap helper for the tape-atom Lua scripts.
+---
+--- Each entry script (ps1_meta.lua + the 7 passes/*.lua files) starts with one of:
+---   ```lua
+---   -- Entry script (ps1_meta.lua — `arg[0]` is set):
+---   local duffle = dofile((arg[0]:match("(.*[/\\])") or "./") .. "duffle_paths.lua")
+---
+---   -- Pass module (debug.getinfo path resolution; works both standalone and when require'd):
+---   local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+---   local duffle = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+---   ```
+---
+--- That small bootstrap: (a) locates this helper via `arg[0]` / `debug.getinfo`,
+--- (b) loads it (which sets `package.path` + `package.cpath`),
+--- (c) at the bottom calls `require("duffle")` (now resolvable since `package.path` was just set) and returns the duffle M.
+--- Net effect: the caller gets the duffle module in one statement; no separate `dofile(...)` + `require("duffle")` dance.
+---
+
+local M = {}
+
+-- Cache key for the repo root. Stored in `package.loaded` (process-global) so all 8 entry scripts + passes scripts share one resolution.
+local CACHE_KEY = "__duffle_repo_root__"
+
+--- Resolve the repo root from this script's own path. Zero shell spawn.
+--- `duffle_paths.lua` always lives at `<repo>/scripts/duffle_paths.lua`, so the repo root is the
+--- parent of the directory containing this script. We derive it directly from `debug.getinfo(1, "S").source`
+--- (returns `@<path>` for the currently-running chunk).
+---
+--- If `debug.getinfo` can't parse this script's path (shouldn't happen — dofile always populates source),
+--- return nil and let `M.setup()` fail loud.
+--- @return string|nil
+local function find_repo_root()
+	if package.loaded[CACHE_KEY] then return package.loaded[CACHE_KEY] end
+
+	local source = debug.getinfo(1, "S").source
+	-- Strip the leading `@` (Lua's dofile marker) and the trailing `/duffle_paths.lua` filename.
+	-- What remains is the directory containing this script, i.e. `<repo>/scripts/`.
+	local scripts_dir = source and source:match("^@?(.*)[/\\]duffle_paths%.lua$")
+	if not scripts_dir then return nil end
+
+	-- The repo root is the parent of `scripts/`. Strip the trailing `scripts/` (with or without trailing slash).
+	local root = scripts_dir:gsub("scripts[\\/]?$", "")
+	root = root:gsub("\\", "/")
+	if root == "" then root = "./" end
+	if not root:match("/$") then root = root .. "/" end
+	package.loaded[CACHE_KEY] = root
+	return root
+end
+
+--- Set `package.path` (for `require("duffle")` + `require("passes.X")`) and
+--- `package.cpath` (for `lpeg.dll`).
+---
+--- This script does NOT touch the OS environment: no `os.setenv`, no `os.putenv`, no `$PATH` mods. 
+--- It just sets `package.path` and `package.cpath` (the standard Lua way to register module search dirs). 
+--- lpeg is built by `update_deps.ps1` to `toolchain/lpeg/`, 
+--- which we wire into `package.cpath` here (so `require("lpeg")` from `duffle.lua` resolves without any global state).
+function M.setup()
+	local repo_root = find_repo_root()
+	if not repo_root then
+		-- Unreachable in practice: find_repo_root() derives the repo root from this script's
+		-- own source path via debug.getinfo(1, "S").source (no subprocess, no git CLI, <1ms).
+		-- A nil return means the source path did not match the expected
+		-- <repo>/scripts/duffle_paths.lua layout — a packaging bug, not a "missing git repo"
+		-- condition. os.exit(2) is retained so a real failure surfaces loud rather than
+		-- silently producing an unconfigured module table.
+		os.exit(2)
+	end
+
+	local scripts_dir = repo_root .. "scripts/"
+	local passes_dir  = repo_root .. "scripts/passes/"
+	package.path = scripts_dir .. "?.lua;"
+		.. scripts_dir .. "?/init.lua;"
+		.. passes_dir  .. "?.lua;"
+		.. passes_dir  .. "?/init.lua;"
+		.. package.path
+
+	-- lpeg: built by `update_deps.ps1` to `toolchain/lpeg/lpeg.dll`.
+	-- lfs: compiled from pcsx-redux's vendored luafilesystem source to `toolchain/lfs/lfs.dll`.
+	-- Wire both directories into cpath so `require("lpeg")` and `require("lfs")` resolve.
+	local lpeg_dir = repo_root .. "toolchain/lpeg/"
+	local lfs_dir  = repo_root .. "toolchain/lfs/"
+	package.cpath = lpeg_dir .. "?.dll;"
+		.. lfs_dir  .. "?.dll;"
+		.. package.cpath
+end
+
+-- Run the setup as a side effect.
+M.setup()
+
+-- Now that package.path includes scripts/, `require("duffle")` resolves. Return the duffle module
+-- so callers can do `local duffle = dofile(...duffle_paths.lua)` in one line.
+return require("duffle")

scripts/elf_dwarf.lua

@@ -0,0 +1,794 @@
+--- elf_dwarf.lua — ELF32 + DWARF + atoms source-map utilities.
+--- All ELF32 + DWARF-specific code lives here.
+---
+--- **What this module contains:**
+---   - **Format-constant tables** (the byte-offset / opcode / size encyclopedias for ELF32, DWARF4 aranges, DWARF5 rnglists, DWARF line-program, MIPS).
+---     Every constant carries a spec:` comment naming the spec section that defines it.
+---   - **I/O helpers**: little-endian byte read/write, ELF32 section walker, nm symbol reader, source-map parser, native directory glob.
+---
+--- **Conventions:** tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Native dependencies
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- lfs is wired into package.cpath by `duffle_paths.lua` (vendored under `toolchain/lfs/lfs.dll`). 
+local lfs = require("lfs")
+
+local M = {}
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- DWARF tag + form constants
+-- ════════════════════════════════════════════
+-- (DWARF5 §7.5.5 "Tag Encodings" + Table 7.1; gcc emits these exact values for the DWARF3-extension and DWARF5 line units.)
+
+M.DW_TAG = {
+	compile_unit       = 0x11,
+	subprogram         = 0x2E,
+	variable           = 0x34,
+	structure_type     = 0x13,
+	member             = 0x0D,
+	base_type          = 0x24,
+	typedef            = 0x2A,
+	pointer_type       = 0x0F,
+	const_type         = 0x26,
+	volatile_type      = 0x27,
+	inlined_subroutine = 0x1D,
+	-- We index the canonical gcc-emitted tags. Anything else falls through.
+}
+
+M.DW_AT = {
+	name                  = 0x03,
+	low_pc                = 0x11,
+	high_pc               = 0x12,
+	language              = 0x13,
+	location              = 0x02,
+	comp_dir              = 0x1B,
+	byte_size             = 0x0B,
+	encoding              = 0x3E,
+	data_member_location  = 0x38,
+	type                  = 0x49,
+	linkage_name          = 0x6E,
+	external              = 0x3F,
+	abstract_origin       = 0x31,
+	call_file             = 0x58,
+	call_line             = 0x59,
+	inline                = 0x20,
+	decl_file             = 0x3A,
+	decl_line             = 0x3B,
+}
+
+M.DW_FORM = {
+	addr        = 0x01,
+	data1       = 0x0B,
+	data2       = 0x05,
+	data4       = 0x06,
+	string      = 0x08,
+	strp        = 0x0E,
+	exprloc     = 0x18,
+	ref4        = 0x13,
+	udata       = 0x0F,
+	ref_sig8    = 0x20,
+	implicit_const = 0x21,
+	flag_present = 0x19,
+	sec_offset  = 0x17,
+}
+
+M.DW_ATE = {
+	address       = 0x01,
+	boolean       = 0x02,
+	complex_float = 0x03,
+	float         = 0x04,
+	signed        = 0x05,
+	signed_char   = 0x06,
+	unsigned      = 0x07,
+	unsigned_char = 0x08,
+}
+
+-- DWARF5 §7.5.6 DW_FORM_implicit_const
+local DW_FORM_implicit_const = 0x21
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Format-constant tables
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- ----------------------------------------------------------------------------
+-- MIPS sizes
+-- ----------------------------------------------------------------------------
+
+--- spec: MIPS o32 ABI §"Register Usage" — 32-bit general-purpose registers
+M.MIPS_BYTES_PER_WORD = 0x04
+
+
+-- ----------------------------------------------------------------------------
+-- ELF32 (System V ABI gABI v1.2)
+-- ----------------------------------------------------------------------------
+--- **Wire-offset contract:** format offsets, fixed-width reader offsets, LEB/parser cursors,
+--- and section-relative values are zero-based wire offsets. Only Lua string APIs receive
+--- a `+ 1` conversion at their boundary (`byte`, `sub`, and `find`).
+---
+--- ELF/DWARF field offsets are expressed in hex so they map directly to the
+--- zero-based byte positions in the binary file.
+
+
+--- spec: System V ABI gABI v1.2 §"ELF Header" (Table 1) + §"Section Header Table"
+M.ELF32 = {
+	magic_offset          = 0x00,         -- 4-byte magic "\127ELF" at file offset 0x00
+	magic                 = "\127ELF",
+	class_offset          = 0x04,         -- 1-byte; 1 = ELF32, 2 = ELF64
+	class_elf32           = 1,
+	endian_offset         = 0x05,         -- 1-byte; 1 = little-endian, 2 = big-endian
+	endian_little         = 1,
+	header_bytes          = 0x34,         -- spec: gABI v1.2 §"ELF Header" — ELF32 header is 52 bytes total
+	e_shoff_offset        = 0x20,         -- 4-byte LE; section-header table file offset
+	e_shentsize_offset    = 0x2E,         -- 2-byte LE; section-header entry size in bytes
+	e_shnum_offset        = 0x30,         -- 2-byte LE; number of section headers
+	e_shstrndx_offset     = 0x32,         -- 2-byte LE; index of section-name string table
+	sh_size_bytes         = 0x28,         -- spec: gABI v1.2 §"Section Header Table" — each entry is 40 bytes
+	sh_name_offset        = 0x00,         -- 4-byte LE; offset into .shstrtab
+	sh_type_offset        = 0x04,         -- 4-byte LE; section type (SHT_*)
+	sh_offset_offset      = 0x10,         -- 4-byte LE; section's file offset
+	sh_size_offset        = 0x14,         -- 4-byte LE; section's size in bytes
+	dw_dwarf32_terminator = 0xFFFFFFFF,   -- spec: DWARF4 spec §7.4 — 32-bit DWARF initial-length terminator
+}
+
+-- ----------------------------------------------------------------------------
+-- DWARF4 .debug_aranges (per DWARF5 spec §7.4 — Address Range Table)
+-- ----------------------------------------------------------------------------
+-- All offsets are zero-based wire offsets.
+
+--- spec: DWARF5 spec §7.4 (Address Range Table) — 32-bit DWARF form
+M.DWARF4_ARANGES = {
+	unit_length_offset = 0x00,    -- 4-byte LE; length of unit body (excludes these 4 bytes)
+	version_offset     = 0x04,    -- 2-byte LE; expected = 2
+	cu_offset_offset   = 0x06,    -- 4-byte LE; CU DIE offset in .debug_info
+	addr_size_offset   = 0x0A,    -- 1-byte;  expected = 4 (32-bit MIPS)
+	seg_size_offset    = 0x0B,    -- 1-byte;  expected = 0
+	entry_size         = 0x08,    -- 4-byte addr + 4-byte length (per §7.4)
+	terminator_size    = 0x08,    -- 8 zero bytes (per §7.4 end-of-list marker)
+	version_expected   = 2,
+	addr_size_expected = 4,
+	seg_size_expected  = 0,
+}
+
+-- ----------------------------------------------------------------------------
+-- DWARF5 .debug_rnglists (per DWARF5 spec §2.17 + §7.21)
+-- ----------------------------------------------------------------------------
+-- All offsets are zero-based wire offsets.
+
+--- spec: DWARF5 spec §2.17 + §7.21 (Range List Table) — 32-bit DWARF form
+M.DWARF5_RNGLISTS = {
+	unit_length_offset    = 0x00,    -- 4-byte LE
+	version_offset        = 0x04,    -- 2-byte LE; expected = 5
+	addr_size_offset      = 0x06,    -- 1-byte;  expected = 4
+	seg_size_offset       = 0x07,    -- 1-byte;  expected = 0
+	offset_count_offset   = 0x08,    -- 4-byte LE; expected = 0
+	first_entry_offset    = 0x0C,
+	end_of_list           = 0x00,    -- spec: DWARF5 §7.7 — DW_RLE_end_of_list byte value
+	start_length          = 0x07,    -- spec: DWARF5 §7.7 — DW_RLE_start_length byte value
+	version_expected      = 5,
+	addr_size_expected    = 4,
+	seg_size_expected     = 0,
+	offset_count_expected = 0,
+}
+
+-- ----------------------------------------------------------------------------
+-- DWARF line-program opcodes (per DWARF5 spec §6.2.5)
+-- ----------------------------------------------------------------------------
+-- Opcode VALUES stay in decimal — they're identifiers (DW_LNS_copy = 1), not binary positions.
+-- Compare to the *_offset fields above which are hex.
+
+--- spec: DWARF5 spec §6.2.5 (Line Number Program Opcodes)
+M.DWARF_LINE_OPS = {
+	-- Standard opcodes (§6.2.5.2)
+	DW_LNS_extended     = 0,    -- spec: §6.2.5.2 — extended opcode marker byte
+	DW_LNS_copy         = 1,
+	DW_LNS_advance_pc   = 2,
+	DW_LNS_advance_line = 3,
+	DW_LNS_set_file     = 4,
+	DW_LNS_negate_stmt  = 6,    -- spec: §6.2.5.2 — toggle the line-state is_stmt register
+	-- Extended sub-opcodes (§6.2.5.3)
+	DW_LNE_end_sequence = 1,    -- spec: §6.2.5.3
+	DW_LNE_set_address  = 2,    -- spec: §6.2.5.3
+	-- Standard opcode header (§6.2.5.1)
+	-- opcode_base + line_range are 1-byte header fields; hex so they map
+	-- directly to their position in the line-program header byte sequence.
+	-- line_base stays signed decimal (=-5) since 0xFB obscures the spec semantics.
+	opcode_base              = 0x0D,
+	line_base                = -5,
+	line_range               = 0x0E,
+	-- Extended opcode payload sizes (include the sub-opcode byte; §6.2.5.3)
+	-- Hex so they match the byte positions in the line-program wire format.
+	end_sequence_payload_size = 0x01,   -- size = sub_opcode only
+	set_address_payload_size  = 0x05,   -- size = sub_opcode(1) + addr(4)
+}
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- I/O helpers: little-endian byte read/write
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Read a 4-byte little-endian unsigned integer from `buf` at zero-based wire offset `off`.
+--- Equivalent to `string.unpack("<I4", buf, off + 1)` but avoids the table-return shape + works under LuaJIT 2.1
+--- (which has partial `string.unpack` coverage).
+---
+--- **Convention:** `off` is a zero-based wire offset; `+ 1` is applied only at the `string.byte` boundary.
+---
+--- **Byte weights** are written as `0x100`, `0x10000`, `0x1000000` (i.e. 2^8, 2^16, 2^24) so the LE byte positions are visually explicit:
+--- byte 0 contributes its value directly; byte 1 is shifted left by 8
+--- (= 0x100); byte 2 by 16 (= 0x10000); byte 3 by 24 (= 0x1000000).
+--- @param buf string
+--- @param off integer  -- zero-based wire offset
+--- @return integer
+function M.read_u32_le(buf, off)
+	local byte_off = off + 1
+	return buf:byte(byte_off)
+		+ buf:byte(byte_off + 0x01) * 0x00000100
+		+ buf:byte(byte_off + 0x02) * 0x00010000
+		+ buf:byte(byte_off + 0x03) * 0x01000000
+end
+
+--- Read a 2-byte little-endian unsigned integer from `buf` at zero-based wire offset `off`.
+--- (`off` is zero-based; `+ 1` is applied only at the `string.byte` boundary.)
+--- @param buf string
+--- @param off integer  -- zero-based wire offset
+--- @return integer
+function M.read_u16_le(buf, off)
+	local byte_off = off + 1
+	return buf:byte(byte_off) + buf:byte(byte_off + 0x01) * 0x00000100
+end
+
+-- Pure-Lua 5.3 LEB128 readers (no `bit` library). `2^shift` arithmetic matches the existing parser.
+-- Offsets are 0-based; returns (value, next_pos).
+-- Promoted from `local function` to M.* exports so passes/dwarf_injection.lua
+-- can import them as file-scope locals per the 2nd-caller lift precedent
+-- (the uleb128 + sleb128 encoders were promoted the same way).
+function M.read_uleb128_at(buf, pos)
+	local value, shift = 0, 0
+	local len = #buf
+	while pos < len do
+		local b = buf:byte(pos + 1)
+		value = value + (b % 0x80) * (2 ^ shift)
+		shift = shift + 7
+		pos   = pos + 1
+		if b < 0x80 then return value, pos end
+	end
+	return nil, pos
+end
+
+function M.read_sleb128_at(buf, pos)
+	local value, shift = 0, 0
+	local len = #buf
+	while pos < len do
+		local b = buf:byte(pos + 1)
+		value = value + (b % 0x80) * (2 ^ shift)
+		shift = shift + 7
+		pos   = pos + 1
+		if b < 0x80 then
+			if b >= 0x40 then value = value - (2 ^ shift) end
+			return value, pos
+		end
+	end
+	return nil, pos
+end
+
+-- Find the 0-based offset of the table-terminator byte (a single 0) for the abbrev table starting at `table_start`.
+-- Returns nil on truncated input. Walks declaration headers
+-- (code, tag, has_children, attr/form pairs, DW_FORM_implicit_const constant) until it finds a 0 byte that follows a complete declaration.
+function M.find_abbrev_table_end(table_bytes, table_start)
+	local pos, len = table_start, #table_bytes
+	if    pos >= len or table_bytes:byte(pos + 1) == 0 then return pos end
+	while pos < len do
+		local  _code, code_end = M.read_uleb128_at(table_bytes, pos)
+		if not _code then return nil end
+		pos = code_end
+		local  _tag, tag_end = M.read_uleb128_at(table_bytes, pos)
+		if not _tag then return nil end
+		pos = tag_end
+		if pos >= len then return nil end
+		pos = pos + 1   -- has_children byte
+		while pos < len do
+			local  attr, attr_end = M.read_uleb128_at(table_bytes, pos)
+			if not attr then return nil end
+			pos = attr_end
+			local  form, form_end = M.read_uleb128_at(table_bytes, pos)
+			if not form then return nil end
+			pos = form_end
+			if attr == 0 and form == 0 then break end
+			if form == DW_FORM_implicit_const then
+				local _c, ce = M.read_sleb128_at(table_bytes, pos)
+				if not _c then return nil end
+				pos = ce
+			end
+		end
+		if pos >= len then return nil end
+		if table_bytes:byte(pos + 1) == 0 then return pos end
+	end
+	return nil
+end
+
+-- Read the null-terminated C string at 0-based offset `off` in `buf`.
+-- Stops at the first 0 byte or end of buffer.
+local function read_c_string_at(buf, off)
+	local len = #buf
+	local start = off
+	while off < len and buf:byte(off + 1) ~= 0 do off = off + 1 end
+	return buf:sub(start + 1, off)
+end
+
+-- Walk the .debug_abbrev table starting at 0-based offset `table_start` and return a list of declarations:
+-- {code, tag, has_children, attrs={ {name, form}, ... }}.
+-- Stops at the table terminator.
+local function parse_abbrev_table(table_bytes, table_start)
+	local table_end = M.find_abbrev_table_end(table_bytes, table_start)
+	if not table_end then return nil, "no terminator" end
+	local decls = {}
+	local pos = table_start
+	while pos < table_end do
+		local  code, code_end = M.read_uleb128_at(table_bytes, pos)
+		if not code then return nil, "truncated code" end
+		pos = code_end
+		local  tag, tag_end = M.read_uleb128_at(table_bytes, pos)
+		if not tag then return nil, "truncated tag" end
+		pos = tag_end
+		local has_children = table_bytes:byte(pos + 1)
+		pos = pos + 1
+		local attrs = {}
+		while true do
+			local  attr, attr_end = M.read_uleb128_at(table_bytes, pos)
+			if not attr then return nil, "truncated attr" end
+			pos = attr_end
+			local form, form_end = M.read_uleb128_at(table_bytes, pos)
+			if not form then return nil, "truncated form" end
+			pos = form_end
+			if attr == 0 and form == 0 then break end
+			attrs[#attrs + 1] = { name = attr, form = form }
+			if form == DW_FORM_implicit_const then
+				local  _c, ce = M.read_sleb128_at(table_bytes, pos)
+				if not _c then return nil, "truncated const" end
+				pos = ce
+			end
+		end
+		decls[#decls + 1] = { code = code, tag = tag, has_children = has_children, attrs = attrs }
+	end
+	return decls
+end
+
+-- Read a ULEB attribute value at 0-based offset `pos` for the given `form`.
+-- Returns (value, next_pos). For DW_FORM_string we return the inline string.
+-- For DW_FORM_strp we return the inline string resolved from `str_buf`.
+-- For DW_FORM_ref4 we return the absolute CU-relative offset.
+-- The caller decides whether to interpret that as a section offset.
+local function read_form_value(buf, str_buf, pos, form)
+	if form == M.DW_FORM.addr then
+		return M.read_u32_le(buf, pos), pos + 4
+	elseif form == M.DW_FORM.string then
+		local s = read_c_string_at(buf, pos)
+		return s, pos + #s + 1
+	elseif form == M.DW_FORM.strp then
+		-- DW_FORM_strp: 4-byte offset into .debug_str.
+		local strp_off = M.read_u32_le(buf, pos)
+		return read_c_string_at(str_buf, strp_off), pos + 4
+	elseif form == M.DW_FORM.udata then return M.read_uleb128_at(buf, pos)
+	elseif form == M.DW_FORM.data1 then return buf:byte(pos + 1), pos + 1
+	elseif form == M.DW_FORM.data2 then return M.read_u16_le(buf, pos), pos + 2
+	elseif form == M.DW_FORM.data4 then return M.read_u32_le(buf, pos), pos + 4
+	elseif form == M.DW_FORM.ref4  then return M.read_u32_le(buf, pos), pos + 4
+	elseif form == M.DW_FORM.sec_offset then
+		-- DW_FORM_sec_offset: 4-byte offset (size depends on DWARF version;
+		-- on DWARF5 32-bit it's always 4 bytes).
+		return M.read_u32_le(buf, pos), pos + 4
+	elseif form == M.DW_FORM.flag_present then
+		return 1, pos
+	elseif form == M.DW_FORM.exprloc then
+		-- DW_FORM_exprloc: ULEB byte count + that many bytes of DW_OP_*.
+		local  len, ne = M.read_uleb128_at(buf, pos)
+		if not len then return nil, pos end
+		return nil, ne + len
+	elseif form == DW_FORM_implicit_const then
+		-- The constant is declared in the abbrev; no value bytes in the DIE.
+		return nil, pos
+	elseif form == M.DW_FORM.ref_sig8 then
+		-- DW_FORM_ref_sig8 (DWARF5 §7.4.2): an 8-byte value identifying a type
+		-- by signature. The low 4 bytes (LE) are the type signature (content hash);
+		-- the high 4 bytes (LE) are a CU-relative offset into the matching type unit.
+		-- Consumers use the low 4 to look up the type unit (see M.find_type_unit_by_signature)
+		-- then the high 4 to resolve the specific type within it.
+		-- Return the low 4 as the primary value to preserve the (value, next_pos) shape;
+		-- the high 4 is exposed via M.read_ref_sig8 (which returns both halves).
+		local _, _, next_pos = M.read_ref_sig8(buf, pos)
+		return M.read_u32_le(buf, pos), next_pos
+	else
+		return nil, pos
+	end
+end
+
+--- Read a `DW_FORM_ref_sig8` value at 0-based offset `pos` from `buf`.
+--- Returns the low 4 bytes (LE) as `low`, the high 4 bytes (LE) as `high`, and the cursor position after the 8-byte value as `next_pos`.
+--- Callers that need the full type-unit + type-offset pair (e.g. to resolve a type identifier embedded as a signature)
+--- should use this directly rather than going through `read_form_value`,
+--- which only exposes the low 4 bytes to preserve its existing (value, next_pos) return shape.
+--- @param buf string
+--- @param pos integer  -- zero-based wire offset
+--- @return integer  -- low 4 bytes (LE), the type signature
+--- @return integer  -- high 4 bytes (LE), the offset within the matching type unit
+--- @return integer  -- cursor after the 8-byte value
+function M.read_ref_sig8(buf, pos)
+	return M.read_u32_le(buf, pos), M.read_u32_le(buf, pos + 4), pos + 8
+end
+
+-- DWARF5 §7.5.6 (Type Entries).
+-- Walk all units in `info` and return the 0-based offset of the first unit
+-- whose `DW_AT_type_signature` (8-byte value at the end of the unit header) equals `target_sig`.
+-- The signature is interpreted as two 32-bit halves (low/high) per the read_ref_sig8 contract;
+-- we match both halves (i.e. the 8-byte value as a whole). Returns nil if no matching unit exists.
+--
+-- Unit header layout (from pos 0):
+--   unit_length(4) + version(2) + unit_type(1) + address_size(1) + debug_abbrev_offset(4)
+--   followed by type_unit_specific fields: type_signature(8) + type_offset(4)
+-- The type_signature is at byte offset 8 of the body (right after debug_abbrev_offset).
+-- @param info string  -- the .debug_info section bytes
+-- @param target_sig_lo integer  -- low 4 bytes (LE) of the desired signature
+-- @param target_sig_hi integer  -- high 4 bytes (LE) of the desired signature
+-- @return integer|nil, integer|nil  -- unit offset, type_offset within the unit
+function M.find_type_unit_by_signature(info, target_sig_lo, target_sig_hi)
+	local pos = 0
+	local section_len = #info
+	while pos + 4 < section_len do
+		local unit_length = M.read_u32_le(info, pos)
+		if unit_length == 0xFFFFFFFF then
+			return nil, nil  -- DWARF64 not supported
+		end
+		-- unit_length is the body size, NOT including the 4-byte unit_length field itself.
+		local body_start = pos + 4
+		local body_end   = body_start + unit_length
+		if body_end > section_len then
+			return nil, nil  -- malformed
+		end
+		-- Per DWARF5 §7.5.6, the type_unit (DW_UT_type = 0x02) body layout is:
+		--   0:  version (2)
+		--   2:  unit_type (1) -- DW_UT_type = 0x02
+		--   3:  address_size (1)
+		--   4:  debug_abbrev_offset (4)
+		--   8:  type_signature (8)
+		--   16: type_offset (4)
+		--   20: <children>
+		if body_end - body_start >= 20 then
+			-- read_ref_sig8 / write_u32_le / etc. are 1-indexed (string:byte);
+			-- pos / body_start / body_end are 0-based wire offsets, so the
+			-- 1-indexed byte at 0-based wire offset X is string:byte(X + 1).
+			-- Per DWARF5 §7.5.6, the type_unit body is laid out as:
+			--   byte 0-1: version (2)
+			--   byte 2:   unit_type (1) -- DW_UT_type = 0x02
+			--   byte 3:   address_size (1)
+			--   byte 4-7: debug_abbrev_offset (4)
+			--   byte 8-15: type_signature (8)
+			--   byte 16-19: type_offset (4)
+			local unit_type = info:byte(body_start + 2 + 1)  -- 0-based +2 = unit_type in 1-indexed
+			if unit_type == 0x02 then  -- DW_UT_type
+				local sig_lo, sig_hi, _ = M.read_ref_sig8(info, body_start + 8)  -- 0-based +8 = type_signature in 1-indexed
+				if sig_lo == target_sig_lo and sig_hi == target_sig_hi then
+					local type_offset = M.read_u32_le(info, body_start + 16)  -- 0-based +16 = type_offset in 1-indexed
+					return pos, type_offset
+				end
+			end
+		end
+		-- Advance to the next unit (the 4-byte unit_length + the body).
+		pos = body_end
+	end
+	return nil, nil
+end
+
+--- Return a 4-byte little-endian byte string for `value`.
+--- Caller concatenates with `..` if composing multi-word blobs.
+--- **Byte weights** written as `0x100` etc. (see `M.read_u32_le` for rationale).
+--- @param value integer  -- 0 ≤ value ≤ 0xFFFFFFFF
+--- @return string
+function M.write_u32_le(value)
+	return string.char(
+		value                          % 0x00000100,
+		math.floor(value / 0x00000100) % 0x00000100,
+		math.floor(value / 0x00010000) % 0x00000100,
+		math.floor(value / 0x01000000) % 0x00000100)
+end
+
+--- Return a 2-byte little-endian byte string for `value`.
+--- @param value integer  -- 0 ≤ value ≤ 0xFFFF
+--- @return string
+function M.write_u16_le(value)
+	return string.char(value % 0x00000100, math.floor(value / 0x00000100) % 0x00000100)
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- I/O helpers: ELF32 / DWARF / symbols
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Read the named sections from a post-link ELF32 by walking the ELF32 section-header table directly
+--- (no subprocess; lfs only for the existence check). Returns `{[name] = bytes_or_empty_string, ...}`.
+---
+--- **Convention:** ELF/DWARF offsets are zero-based wire offsets. Direct Lua string APIs add `+ 1` at the boundary.
+--- Every requested name has an entry in the returned dict;
+--- missing sections have an empty string (NOT nil) so callers can do `sections[".debug_x"] or ""` for the missing case.
+---
+--- **Cost:** one file open + one `f:seek` + one `f:read` per section header 
+--- (we walk all `e_shnum` headers regardless of how many names are requested, to find the .shstrtab first).
+--- For frequent callers, pass the union of all needed sections in one call.
+--  Can add `.debug_info` + `.debug_loc` + `.debug_str_offsets` to the list without writing a 2nd ELF walker.
+--- @param elf_path Path
+--- @param section_names string[]  -- list of section names to read
+--- @return table<string, string>
+function M.read_elf_sections(elf_path, section_names)
+	-- Initialize result with all requested names set to "" so callers can do `sections[X] 
+	-- or ""` for missing sections without nil-checks.
+	local result = {}
+	for _, name in ipairs(section_names) do result[name] = "" end
+
+	-- O(1) lookup set.
+	local wanted = {}
+	for _, name in ipairs(section_names) do wanted[name] = true end
+
+	-- Existence check (lfs.attributes avoids an io.open-vs-fail race).
+	if lfs.attributes(elf_path, "mode") ~= "file" then
+		io.stderr:write(string.format("[elf_dwarf.read_elf_sections] ELF not found: %s\n", elf_path))
+		return result
+	end
+
+	local f = io.open(elf_path, "rb")
+	if not f then
+		io.stderr:write(string.format("[elf_dwarf.read_elf_sections] io.open failed: %s\n", elf_path))
+		return result
+	end
+
+	-- Read the ELF32 header.
+	local header = f:read(M.ELF32.header_bytes)
+	if not header or #header < M.ELF32.header_bytes then
+		io.stderr:write("[elf_dwarf.read_elf_sections] ELF too small for ELF32 header\n")
+		f:close()
+		return result
+	end
+
+	-- Sanity-check magic + class + endianness.
+	if header:sub(M.ELF32.magic_offset + 1, M.ELF32.magic_offset + 0x04) ~= M.ELF32.magic then
+		io.stderr:write("[elf_dwarf.read_elf_sections] not an ELF file\n")
+		f:close()
+		return result
+	end
+	if header:byte(M.ELF32.class_offset + 1) ~= M.ELF32.class_elf32 then
+		io.stderr:write(string.format("[elf_dwarf.read_elf_sections] not ELF32 (class=%d)\n", header:byte(M.ELF32.class_offset + 1)))
+		f:close()
+		return result
+	end
+	if header:byte(M.ELF32.endian_offset + 1) ~= M.ELF32.endian_little then
+		io.stderr:write("[elf_dwarf.read_elf_sections] not little-endian; unsupported\n")
+		f:close()
+		return result
+	end
+
+	-- Parse section-header table location + dimensions from the header.
+	local e_shoff     = M.read_u32_le(header, M.ELF32.e_shoff_offset)
+	local e_shentsize = M.read_u16_le(header, M.ELF32.e_shentsize_offset)
+	local e_shnum     = M.read_u16_le(header, M.ELF32.e_shnum_offset)
+	local e_shstrndx  = M.read_u16_le(header, M.ELF32.e_shstrndx_offset)
+
+	-- Read the section-header string table (.shstrtab) so we can resolve section names from their `sh_name` offsets.
+	f:seek("set", e_shoff + e_shstrndx * e_shentsize)
+	local strtab_hdr = f:read(e_shentsize)
+	if not strtab_hdr or #strtab_hdr < e_shentsize then
+		io.stderr:write("[elf_dwarf.read_elf_sections] could not read .shstrtab header\n")
+		f:close()
+		return result
+	end
+	local strtab_offset = M.read_u32_le(strtab_hdr, M.ELF32.sh_offset_offset)
+	local strtab_size   = M.read_u32_le(strtab_hdr, M.ELF32.sh_size_offset)
+	f:seek("set", strtab_offset)
+	local strtab = f:read(strtab_size) or ""
+
+	-- Walk all section headers; collect (offset, size) for the wanted names.
+	local function read_section_bytes(sh_offset, sh_size)
+		f:seek("set", sh_offset)
+		return f:read(sh_size) or ""
+	end
+
+	for sh_idx = 0, e_shnum - 1 do
+		f:seek("set", e_shoff + sh_idx * e_shentsize)
+		local sh = f:read(e_shentsize)
+		if not sh or #sh < e_shentsize then break end
+		local sh_name   = M.read_u32_le(sh, M.ELF32.sh_name_offset)
+		local sh_offset = M.read_u32_le(sh, M.ELF32.sh_offset_offset)
+		local sh_size   = M.read_u32_le(sh, M.ELF32.sh_size_offset)
+
+		-- Extract the name (null-terminated C string in strtab).
+		local name_end = strtab:find("\0", sh_name + 1, true) or (sh_name + 1)
+		local name     = strtab:sub(sh_name + 1, name_end - 1)
+		if wanted[name] then
+			result[name] = read_section_bytes(sh_offset, sh_size)
+		end
+	end
+
+	f:close()
+	return result
+end
+
+--- Read ELF symbol addresses by walking the `.symtab` + `.strtab` sections directly (no `nm` subprocess). 
+--- Returns a map `{name -> {addr, size_bytes}}` for every `code_<name>` symbol.
+---
+--- **Conventions:**
+--- - ELF32 symtab entry = 16 bytes (`st_name:4 + st_value:4 + st_size:4 + st_info:1 + st_other:1 + st_shndx:2`); offsets within each entry are zero-based wire offsets.
+--- - Direct Lua `string.byte`/`string.sub`/`string.find` boundaries receive `+ 1`.
+--- - We filter on STB_GLOBAL (high nibble of st_info = 1) to match `nm`'s default (external symbols only). STB_WEAK excluded.
+--- - The `code_` prefix is stripped (MipsAtom_ macros emit bare atom names, no `code_` prefix).
+--- - `st_size > 0` filter excludes undefined/imported symbols.
+--- @param elf_path Path
+--- @return table<string, {integer, integer}>
+function M.read_nm(elf_path)
+	local addrs = {}
+
+	-- Read .symtab + .strtab via the existing ELF walker (no subprocess).
+	local sections = M.read_elf_sections(elf_path, {".symtab", ".strtab"})
+	local symtab   = sections[".symtab"]
+	local strtab   = sections[".strtab"]
+	if not symtab or not strtab or #symtab == 0 or #strtab == 0 then
+		-- No symbol table (e.g. stripped ELF). Return empty.
+		return addrs
+	end
+
+	-- Iterate the 16-byte ELF32 symtab entries.
+	-- Each entry (zero-based): st_name at 0, st_value at 4, st_size at 8, st_info at 12, st_other at 13, st_shndx at 14.
+	local SYM_ENTRY_BYTES = 0x10
+	local SYM_ST_NAME     = 0x00
+	local SYM_ST_VALUE    = 0x04
+	local SYM_ST_SIZE     = 0x08
+	local SYM_ST_INFO     = 0x0C
+	local n_syms = #symtab / SYM_ENTRY_BYTES
+	for i = 0, n_syms - 1 do
+		local entry_off  = i * SYM_ENTRY_BYTES
+		local st_info    = symtab:byte(entry_off + SYM_ST_INFO + 1)
+		-- High nibble = binding (STB_LOCAL=0, STB_GLOBAL=1, STB_WEAK=2).
+		-- Use math.floor(/16) instead of bit.rshift for LuaJIT 2.1 compat
+		-- (LuaJIT's `>>` is 5.3+, but math.floor(x/16) works on all versions).
+		local binding    = math.floor(st_info / 16)
+		if binding == 0 or binding == 1 then            -- STB_LOCAL or STB_GLOBAL
+			local st_size   = M.read_u32_le(symtab, entry_off + SYM_ST_SIZE)
+			if st_size > 0 then
+				local st_name_off = M.read_u32_le(symtab, entry_off + SYM_ST_NAME)
+				-- Extract the name from .strtab (null-terminated C string).
+				local name_end = strtab:find("\0", st_name_off + 1, true) or (st_name_off + 1)
+				local name     = strtab:sub(st_name_off + 1, name_end - 1)
+				-- Filter: keep all symbol-table symbols (atoms emit their name as the bare `<name>` — MipsAtom_ macros strip the `code_` prefix).
+				-- The atoms_source_map pass already filters out non-atom symbols via the source-map.txt cross-ref.
+				if name and #name > 0 then
+					local st_value = M.read_u32_le(symtab, entry_off + SYM_ST_VALUE)
+					addrs[name] = { st_value, st_size }
+				end
+			end
+		end
+	end
+
+	return addrs
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- LEB128 encoders (Unsigned + Signed Little-Endian Base 128)
+-- ════════════════════════════════════════════════════════════════════════════
+--
+-- DWARF uses LEB128 to encode variable-length integers in its wire format (line-program opcodes, DW_AT values, etc.).
+-- Both encoders pack 7 bits of data per byte + 1 bit of "more bytes follow" signaling.
+--
+-- Per-byte layout:
+--     bit:   7 6 5 4 3 2 1 0
+--           │ └───── 7-bit data ─────┘
+--           └─ continuation flag (LEB_CONT_BIT = 0x80)
+--
+-- For SLEB128 (signed), bit 6 of the 7-bit data is the sign bit that the
+-- decoder uses for sign extension:
+--     bit 6 = 0 → value is positive (or zero); zero-extend on decode
+--     bit 6 = 1 → value is negative;            one-extend on decode
+--
+-- The signed encoder must emit the MINIMUM number of bytes whose final 7-bit payload already has the correct sign bit set 
+-- (otherwise the decoder would round-trip to a different value).
+--
+-- Spec: DWARF5 §7.6 "Variable-Length Data" / Appendix C.
+
+-- Top bit of each LEB128 byte. Set if more bytes follow in the encoding.
+local LEB_CONT_BIT = 0x80
+
+-- Low 7 bits of each LEB128 byte. The actual data payload.
+local LEB_DATA_MASK = 0x7F
+
+-- Bit 6 of the 7-bit data (i.e. 0x40). For SLEB128: the sign-bit position used by the decoder for sign extension.
+-- Encoders MUST stop when the next byte would be redundant AND the sign bit in the last byte matches the value's sign.
+local SLEB_SIGN_BIT = 0x40
+
+--- ULEB128 (Unsigned Little-Endian Base 128) encoder. Returns the byte string for the non-negative integer `n`.
+--- Algorithm:
+---   - Extract the low 7 bits of `n` (LEB_DATA_MASK = 0x7F).
+---   - Shift `n` right by 7 bits.
+---   - If more bytes remain, OR in the continuation flag (LEB_CONT_BIT).
+---   - Repeat until `n` is fully consumed.
+--- @param n integer  -- non-negative
+--- @return string
+function M.uleb128(n)
+	if n == nil or type(n) ~= "number" then
+		io.stderr:write("[elf_dwarf.uleb128] got " .. type(n) .. ": " .. tostring(n) .. "\n")
+		io.stderr:write(debug.traceback() .. "\n")
+		error("uleb128 requires non-negative number")
+	end
+	assert(n >= 0, "uleb128 requires non-negative input")
+	local bytes = {}
+	repeat
+		local b = n % (LEB_DATA_MASK + 1)      -- extract low 7 bits
+		n = (n - b) / (LEB_DATA_MASK + 1)      -- shift right by 7 bits
+		if n > 0 then b = b + LEB_CONT_BIT end -- set continuation bit if more bytes follow
+		bytes[#bytes + 1] = string.char(b)
+	until n == 0
+	return table.concat(bytes)
+end
+
+--- SLEB128 (Signed Little-Endian Base 128) encoder. Returns the byte string for the integer `n` (may be negative).
+--- Algorithm differs from ULEB128 by the termination condition: 
+--- stop when the remaining bits can be inferred from the sign bit in the last byte's 7-bit data payload.
+---   - If `n == 0`  (no more value bits)   AND bit 6 of the data = 0 → positive terminator (sign bit says "zero-extend").
+---   - If `n == -1` (sign-extended all-1s) AND bit 6 of the data = 1 → negative terminator (sign bit says "one-extend").
+---
+--- Without these checks, the decoder would round-trip to a different value
+--- (e.g. encoding `0` as `0x80 0x00` decodes to `0` correctly but is 2 bytes long; the termination check picks the 1-byte `0x00` form).
+--- @param n integer  -- any integer (negative allowed)
+--- @return string
+function M.sleb128(n)
+	local bytes = {}
+	local more = true
+	while more do
+		local b = n % (LEB_DATA_MASK + 1) -- extract low 7 bits
+		n = (n - b) / (LEB_DATA_MASK + 1) -- arithmetic shift right by 7
+		-- Termination: remaining value bits fit in the sign bit of the last byte.
+		if     n == 0  and b <  SLEB_SIGN_BIT then more = false end  -- positive terminator
+		if     n == -1 and b >= SLEB_SIGN_BIT then more = false end  -- negative terminator
+		if more then b = b + LEB_CONT_BIT end
+		bytes[#bytes + 1] = string.char(b)
+	end
+	return table.concat(bytes)
+end
+
+--- ULEB128 byte-length: number of bytes the encoder M.uleb128 would produce for `n`.
+--- Used by callers that need to size a buffer before encoding (e.g. compute_loclists_offsets
+--- needs the encoded length of an `uleb128(4)` for a `DW_OP_piece + uleb128(U4_BYTE_SIZE)` tail).
+--- @param n integer  -- non-negative
+--- @return integer  -- 1..5 for n in [0, 2^32)
+function M.uleb128_size(n)
+	assert(n >= 0, "uleb128_size requires non-negative input")
+	if n == 0 then return 1 end
+	local bytes = 1
+	while n >= 0x80 do
+		n = (n - (n % (LEB_DATA_MASK + 1))) / (LEB_DATA_MASK + 1)  -- arithmetic shift right by 7
+		bytes = bytes + 1
+	end
+	return bytes
+end
+
+--- SLEB128 byte-length: number of bytes the encoder M.sleb128 would produce for `n`.
+--- Used by callers that need to size a buffer before encoding.
+--- (e.g. compute_loclists_offsets needs the encoded length of an `sleb128(field.offset)` in a tape piece).
+--- Handles the signed DWARF5 termination: positive terminator if (n == 0) and bit 6 of last byte is unset;
+--- negative terminator if (n == -1) and bit 6 of last byte is set.
+--- @param n integer  -- any integer (negative allowed)
+--- @return integer
+function M.sleb128_size(n)
+	local more = true
+	local bytes = 0
+	local v = n
+	while more do
+		local b = v % (LEB_DATA_MASK + 1) -- extract low 7 bits
+		v = (v - b) / (LEB_DATA_MASK + 1) -- arithmetic shift right by 7
+		if     v == 0  and b <  SLEB_SIGN_BIT then more = false end  -- positive terminator
+		if     v == -1 and b >= SLEB_SIGN_BIT then more = false end  -- negative terminator
+		if more then b = b + LEB_CONT_BIT end
+		bytes = bytes + 1
+	end
+	return bytes
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- I/O helpers: atoms source-map + native directory glob
+-- ════════════════════════════════════════════════════════════════════════════
+
+return M

scripts/gdb/gdb_tape_atoms.gdb

@@ -0,0 +1,105 @@
+# scripts/gdb/gdb_tape_atoms.gdb
+#
+# Wrapper for the tape-atom step-debug helpers.
+# The 9 user commands are defined here as STUBS (degraded-state messages). 
+# The real implementations + the per-atom data tables are emitted by `passes/atoms_source_map.lua` 
+# (post-link invocation: `ps1_meta.lua --atoms-source-map --gdb-runtime --elf <elf>`) into `build/gen/gdb_tape_atoms_runtime.gdb`.
+# Sourcing that file RE-DEFINES the commands with real implementations.
+#
+# If `build/gen/gdb_tape_atoms_runtime.gdb` is missing or stale, the stubs remain (E1: no source map).
+# The user just needs to re-run `build_psyq.ps1` to regenerate.
+
+# ── Stub commands (defined here so they're always present, even if the runtime file is missing). The runtime file overrides these if sourced. ──
+
+define tape_atoms
+  echo "[gdb_tape_atoms] STUB: runtime file build/gen/gdb_tape_atoms_runtime.gdb not found."
+  echo "[gdb_tape_atoms] STUB: run .\\build_psyq.ps1 to regenerate, then re-source this file."
+end
+document tape_atoms
+  List every tape atom symbol in the loaded ELF (code_<name>) with its .rodata address and word count.
+  STUB state: runtime file not sourced. Run build_psyq.ps1 to regenerate.
+end
+
+define break_atom
+  echo "[gdb_tape_atoms] STUB: build/gen/gdb_tape_atoms_runtime.gdb not sourced. Run build_psyq.ps1."
+end
+document break_atom
+  Set a breakpoint at the start of tape atom <name>. STUB state.
+end
+
+define step_atom
+  echo "[gdb_tape_atoms] STUB: build/gen/gdb_tape_atoms_runtime.gdb not sourced. Run build_psyq.ps1."
+end
+document step_atom
+  Resume execution until the next atom boundary. STUB state.
+end
+
+define next_atom
+  echo "[gdb_tape_atoms] STUB: build/gen/gdb_tape_atoms_runtime.gdb not sourced. Run build_psyq.ps1."
+end
+document next_atom
+  Alias for step_atom. STUB state.
+end
+
+define where_in_atom
+  echo "[gdb_tape_atoms] STUB: build/gen/gdb_tape_atoms_runtime.gdb not sourced. Run build_psyq.ps1."
+end
+document where_in_atom
+  Report current atom name, .rodata addr, word offset, and source line (if known). STUB state.
+end
+
+define stepi_inside_atom
+  echo "[gdb_tape_atoms] STUB: build/gen/gdb_tape_atoms_runtime.gdb not sourced. Run build_psyq.ps1."
+end
+document stepi_inside_atom
+  One MIPS-instruction step, then where_in_atom. STUB state.
+end
+
+define show_c2
+  printf "C2[ 0]   0x%08x\n", $c2_data[0]
+  printf "C2[ 7]   0x%08x  [otz]\n", $c2_data[7]
+  printf "C2[12]   0x%08x  [sxy0]\n", $c2_data[12]
+  printf "C2[13]   0x%08x  [sxy1]\n", $c2_data[13]
+  printf "C2[14]   0x%08x  [sxy2]\n", $c2_data[14]
+  printf "C2[24]   0x%08x  [mac0]\n", $c2_data[24]
+  printf "...\n"
+   echo "(STUB state: only 7 representative regs shown. Run build_psyq.ps1 for full dump.)"
+end
+document show_c2
+  Pretty-print all 32 C2 data registers as hex + named alias. STUB state (7 reg subset).
+end
+
+define show_c2ctl
+  printf "C2CTL[ 0]  0x%08x\n", $c2_control[0]
+  printf "...\n"
+  echo "(STUB state: only 1 reg shown. Run build_psyq.ps1 for full dump.)"
+end
+document show_c2ctl
+  Pretty-print all 32 C2 control registers. STUB state (1 reg subset).
+end
+
+define wave_ctx
+  printf "$t4 = R_FaceCursor     0x%08x\n", $t4
+  printf "$t5 = R_VertBase       0x%08x\n", $t5
+  printf "$t6 = R_OtBase         0x%08x\n", $t6
+  printf "$t7 = R_PrimCursor     0x%08x\n", $t7
+end
+document wave_ctx
+  Pretty-print the 4 wave-context GPRs ($t4..$t7). (wave_ctx works in stub state too.)
+end
+
+
+# ── Source the runtime file (re-defines commands with real impls + data). ──
+
+# Try to source from project-root-relative path first (the typical case).
+# If the user is in a different CWD, the source will fail and stubs remain.
+# The runtime file path is computed relative to the ELF's source map convention (build/gen/gdb_tape_atoms_runtime.gdb).
+echo [gdb_tape_atoms] Wrapper loaded. Sourcing runtime file...
+# Suppress the "Redefine command" prompts that would otherwise appear when the runtime file overrides the 9 stub commands defined above.
+# The runtime's `define` blocks are intended to overwrite — there's no ambiguity to confirm.
+set confirm off
+
+# Source the runtime file (re-defines commands with real impls + data).
+source build/gen/gdb_tape_atoms_runtime.gdb
+set confirm on
+echo [gdb_tape_atoms] Runtime sourced successfully (9 commands now have real implementations).

scripts/launch_pcsx_debug.ps1

@@ -0,0 +1,94 @@
+# scripts/launch_pcsx_debug.ps1
+#
+# One-shot launcher for debug sessions: starts pcsx-redux with the .ps-exe
+# loaded, the gdb stub enabled, AND the pcsx_debug_helper Lua plugin loaded
+# so external CLI tools (gdb's `shell` command, etc.)
+# can read GTE state via http://localhost:8080/api/v1/lua/gte
+# (the gdb stub doesn't expose COP2 at all).
+#
+# usage:
+#   .\scripts\launch_pcsx_debug.ps1
+#   .\scripts\launch_pcsx_debug.ps1 -ExePath build\hello_gte.ps-exe
+#   .\scripts\launch_pcsx_debug.ps1 -HelperZip scripts\pcsx_debug_helper.zip
+#
+# After launch:
+#   - gdb: target remote localhost:3333
+#   - web: curl http://localhost:8080/api/v1/lua/gte
+#
+# Companion: scripts/debug_psyq.ps1 (bare launch — no .ps-exe, no helper).
+
+[CmdletBinding()]
+param(
+    [string]$PcsxPath = (Join-Path $PSScriptRoot '..\toolchain\pcsx-redux\vsprojects\x64\Release\pcsx-redux.exe'),
+    [string]$ExePath  = (Join-Path $PSScriptRoot '..\build\hello_gte.ps-exe'),
+    [string]$HelperZip = (Join-Path $PSScriptRoot 'pcsx_debug_helper.zip'),
+    [int]   $GdbPort  = 3333,
+    [int]   $WebPort  = 8080
+)
+
+$ErrorActionPreference = 'Stop'
+
+# ── Pre-checks ──
+foreach ($p in @($PcsxPath, $ExePath, $HelperZip)) {
+    if (-not (Test-Path $p)) {
+        Write-Error "Missing: $p"
+        exit 1
+    }
+}
+
+# Kill any existing pcsx-redux so the archive file isn't locked.
+Get-Process pcsx-redux -ErrorAction SilentlyContinue | Stop-Process -Force
+Start-Sleep -Seconds 2
+
+# ── Launch ──
+$absExe  = [System.IO.Path]::GetFullPath($ExePath)
+$absZip  = [System.IO.Path]::GetFullPath($HelperZip)
+
+$args = @(
+    '-gdb', '-run'
+    '-loadexe', "`"$absExe`""
+    '-archive', "`"$absZip`""
+)
+
+Write-Host "Launching pcsx-redux..." -ForegroundColor Cyan
+Write-Host "  ps-exe    : $absExe"
+Write-Host "  helper zip: $absZip"
+Write-Host "  gdb       : localhost:$GdbPort"
+Write-Host "  web       : localhost:$WebPort/api/v1/lua/gte"
+Write-Host ""
+
+Start-Process -FilePath $PcsxPath -ArgumentList $args | Out-Null
+
+# ── Wait for both endpoints to come up ──
+$deadline = (Get-Date).AddSeconds(15)
+while ((Get-Date) -lt $deadline) {
+    $gdbUp = $false
+    $webUp = $false
+    try {
+        $tcp = New-Object System.Net.Sockets.TcpClient
+        $tcp.BeginConnect('localhost', $GdbPort, $null, $null) | Out-Null
+        Start-Sleep -Milliseconds 100
+        $gdbUp = $tcp.Connected
+        $tcp.Close()
+    } catch { $gdbUp = $false }
+    try {
+        $r = Invoke-WebRequest -Uri "http://localhost:$WebPort/" -UseBasicParsing -TimeoutSec 1 -ErrorAction SilentlyContinue
+        $webUp = $r.StatusCode -ne 0
+    } catch { $webUp = $false }
+    if ($gdbUp -and $webUp) { break }
+    Start-Sleep -Milliseconds 500
+}
+
+# ── Smoke-test the gte handler ──
+try {
+    $r = Invoke-WebRequest -Uri "http://localhost:$WebPort/api/v1/lua/gte" -UseBasicParsing -TimeoutSec 5
+    $firstLine = ([System.Text.Encoding]::UTF8.GetString($r.Content) -split "`n")[0]
+    Write-Host "GTE handler OK: $firstLine" -ForegroundColor Green
+} catch {
+    Write-Warning "GTE handler NOT responding: $_"
+    Write-Host "Check the pcsx-redux Lua Console for debug cli messages." -ForegroundColor Yellow
+}
+
+Write-Host ""
+Write-Host "pcsx-redux running. PIDs:" -ForegroundColor Cyan
+Get-Process pcsx-redux | Select-Object Id, ProcessName | Format-Table

scripts/passes/atoms_source_map.lua

@@ -0,0 +1,535 @@
+--- passes/atoms_source_map.lua — Per-.word source-line map emitter for tape atoms.
+---
+--- Writer: this pass, given `atom.paths` (the per-atom mutable surface owned by `emission_model`). Readers:
+--- `passes/dwarf_injection.lua` (synthesizes DW_TAG_inlined_subroutine + per-word line program rows) and the gdb-runtime
+--- wrapper at `scripts/gdb/gdb_tape_atoms.gdb` (loads the source map via `source <path>`).
+---
+--- Inputs from `atom.paths`: the ordered `items` stream, dense `word_events`, `invocations` views. Outputs: one
+--- `WORD N LINE L TEXT T` line per emitted `.word`, plus the per-word provenance form that DWARF synthesis consumes.
+---
+--- **Two output forms** (per the workspace's per-emission-form pattern from `guide_metaprogram_ssdl.md`):
+---   1. **Sourcemap.txt form** — `<out_root>/<basename>.atoms.sourcemap.txt`. Format-version-tagged for forward-compat.
+---      Lives in `<out_root>/` (build/gen). Mirrors the convention used by `annotation.lua`
+---      (`<out_root>/<basename>.errors.h`) and `static_analysis.lua` (`<out_root>/<basename>.static_analysis.txt`).
+---      Compile artifacts (`*.macs.h`, `*.offsets.h`) stay in `<source_dir>/gen/`.
+---   2. **gdb-runtime form** — `<ctx.out_root>/gdb_tape_atoms_runtime.gdb`. A pure gdb command script — addresses come
+---      from `nm`, the 9 user commands are static `define ... end` blocks. Emitted when `ctx.flags.gdb_runtime` is true
+---      AND `ctx.flags.elf_path` points to an existing ELF. Useful for `gdb-multiarch --without-python` users
+---      (the common case on Windows MinGW builds) — `source <path>` loads it with no Python / Tcl / Guile required.
+---
+--- **Output format** (sourcemap.txt form):
+---   ```
+---   # FORMAT_VERSION 1
+---   # auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT
+---   ATOM <name> "<abs-source-path>" <total_words>
+---   WORD 0  LINE 49  TEXT load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
+---   WORD 1  LINE 49  TEXT load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
+---   ... (one WORD line per .word emitted by the atom body) ...
+---   ENDATOM
+---   ATOM <next-name> "<abs-source-path>" <total_words>
+---   ...
+---   ENDATOM
+---   ```
+---
+--- Marker records are zero-width in `atom.paths.items`, so they emit no WORD rows in the dense word view.
+---
+--- **Conventions:** tabs (1/level), EmmyLua annotations, no regex, Lua 5.3 compatible.
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module-scope requires + package.path setup
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` 
+-- (works both standalone + when require'd). `duffle_paths.lua` sets package.path then returns `require("duffle")` 
+-- at the bottom, so the dofile value IS the duffle module.
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle    = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local elf_dwarf = require("elf_dwarf")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Format version emitted as the first line. Bump + add a migration test if the format changes; 
+-- the gdb runtime loader rejects mismatches (E2).
+local FORMAT_VERSION = 1
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class AtomSourceMapCtx
+--- @field shared             table   -- `ctx.shared`
+--- @field shared.corpus      table   -- source-order registry; single writer is build_ctx
+--- @field shared.word_counts table
+--- @field out_root           string  -- output root (e.g. "build/gen")
+--- @field flags              table   -- `ctx.flags`; reads `flags.gdb_runtime` + `flags.elf_path`
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Atom-path renderers
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Join word boundaries (from `items`) to per-word call text + source lines (from `word_events`).
+--- @param atom table
+--- @return table[], integer
+local function canonical_word_entries(atom)
+	local paths = atom.paths or {}
+	local events = paths.word_events or {}
+	local word_items = {}
+	for _, item in ipairs(paths.items or {}) do
+		if item.kind == "word" then word_items[#word_items + 1] = item end
+	end
+
+	local entries = {}
+	for index, event in ipairs(events) do
+		local item = word_items[index] or {}
+		entries[#entries + 1] = {
+			pos        = event.i or (index - 1),
+			line       = event.call_line or item.line or 0,
+			text       = event.call_text or item.call_text or "",
+			body_line  = event.body_line or item.body_line or item.line or 0,
+			invocation = (event.outermost_invocation_id
+				and paths.invocations
+				and paths.invocations[event.outermost_invocation_id]) or nil,
+		}
+	end
+	return entries, #events
+end
+
+--- Render one atom's provenance stanza. Format 1 line shapes:
+---   `WORD N  CALL <src-path>:<src-line>  MACRO <name> "<def-path>:<def-line>" BODY <line>` (component invocation)
+---   `WORD N  CALL <src-path>:<src-line>  RAW` (raw `.word` outside any mac_* component)
+--- Component identity comes from the outermost invocation record; the count-table lookup confirms the component was
+--- declared in `corpus.word_counts` (populated by word_count_eval + components passes).
+--- @param src table
+--- @param atom table
+--- @param wc table -- identity alias of corpus.word_counts
+--- @return string[], integer
+local function emit_provenance_stanza(src, atom, wc)
+	local lines    = {}
+	local rel_path = src.path:gsub("\\\\", "/")
+	local entries, total = canonical_word_entries(atom)
+
+	lines[#lines + 1] = string.format('ATOM %s "%s" 0', atom.raw_name or atom.name, rel_path)
+
+	for _, entry in ipairs(entries) do
+		local inv = entry.invocation
+		local macro_count = inv and wc["mac_" .. inv.component_name]
+		if inv and macro_count ~= nil then
+			lines[#lines + 1] = string.format(
+				'WORD %d  CALL %s:%d  MACRO %s "%s:%d" BODY %d',
+				entry.pos, rel_path, entry.line, inv.component_name,
+				inv.def_path or "", inv.def_line or 0, entry.body_line)
+		else
+			lines[#lines + 1] = string.format(
+				"WORD %d  CALL %s:%d  RAW", entry.pos, rel_path, entry.line)
+		end
+	end
+
+	lines[1] = lines[1]:gsub(" 0$", " " .. tostring(total))
+	lines[#lines + 1] = "ENDATOM"
+	return lines, total
+end
+
+--- Render the full provenance file content for one source.
+--- @param src table
+--- @param wc table
+--- @return string
+local function render_provenance(src, wc)
+	local lines = {}
+	lines[#lines + 1] = "# FORMAT_VERSION 1"
+	lines[#lines + 1] = "# auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT"
+	lines[#lines + 1] = "# Per-.word provenance: maps each emitted .word to its call site (atom body"
+	lines[#lines + 1] = "# file:line) and, when the word was emitted by a `mac_X(...)` component invocation,"
+	lines[#lines + 1] = "# the component's definition file:line + the per-word BODY line. Used by"
+	lines[#lines + 1] = "# dwarf_injection to synthesize DW_TAG_inlined_subroutine instances + per-word"
+	lines[#lines + 1] = "# line program rows for native source-level step into component bodies."
+
+	local function append(atom)
+		local stanza = emit_provenance_stanza(src, atom, wc)
+		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
+	end
+	for _, atom in ipairs(src.scan.atoms or {}) do
+		if atom.paths then append(atom) end
+	end
+	for _, atom in ipairs(src.scan.raw_atoms or {}) do
+		if atom.paths then append(atom) end
+	end
+
+	return table.concat(lines, "\n") .. "\n"
+end
+
+--- Render one atom's stanza for the sourcemap.txt form (ATOM header line, N WORD lines, ENDATOM marker).
+--- Returns (lines, total_words).
+--- @param src    table
+--- @param atom   table
+--- @param wc     table
+--- @return string[], integer
+local function emit_atom_stanza(src, atom)
+	local lines    = {}
+	local rel_path = src.path:gsub("\\\\", "/")
+	local entries, total = canonical_word_entries(atom)
+
+	lines[#lines + 1] = string.format('ATOM %s "%s" 0', atom.raw_name or atom.name, rel_path)
+	for _, entry in ipairs(entries) do
+		lines[#lines + 1] = string.format("WORD %d  LINE %d  TEXT %s",
+			entry.pos, entry.line, entry.text)
+	end
+	lines[1] = lines[1]:gsub(" 0$", " " .. tostring(total))
+	lines[#lines + 1] = "ENDATOM"
+	return lines, total
+end
+
+--- Render the full source map file content for one source (one .atoms.sourcemap.txt per source). Mirrors offsets.lua's
+--- `project_atoms` shape: scan.atoms + scan.raw_atoms, no kind filter.
+--- @param src table
+--- @param wc table
+--- @return string
+local function render_source_map(src)
+	local lines = {}
+	lines[#lines + 1] = "# FORMAT_VERSION " .. FORMAT_VERSION
+	lines[#lines + 1] = "# auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT"
+
+	local function append(atom)
+		local stanza = emit_atom_stanza(src, atom)
+		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
+	end
+	for _, atom in ipairs(src.scan.atoms or {}) do
+		if atom.paths then append(atom) end
+	end
+	for _, atom in ipairs(src.scan.raw_atoms or {}) do
+		if atom.paths then append(atom) end
+	end
+
+	return table.concat(lines, "\n") .. "\n"
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- gdb-runtime emission (post-link, addresses via nm)
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Escape a string for embedding in a gdb `set $var = "..."` literal.
+--- gdb uses C-style escaping; we escape `\` and `"` (newlines were flattened earlier).
+--- @param s string
+--- @return string
+local function gdb_escape(s)
+	return (s:gsub("\\", "\\\\"):gsub('"', '\\"'))
+end
+
+--- Build the list of atoms with addresses + word entries. Shared helper for the gdb-runtime file emission.
+--- @param ctx PassCtx
+--- @return table[] -- list of {idx, name, src_path, file_base, addr, size_bytes, words, entries}
+local function build_atom_table(ctx)
+	local addrs = elf_dwarf.read_nm(ctx.flags.elf_path)
+	local corpus = ctx.shared and ctx.shared.corpus
+	local matched = {}
+
+	for _, src in ipairs(corpus.source_order or {}) do
+		local file_base = src.path:match("([^/\\\\]+)$") or src.path
+		local function append(atom)
+			if not atom.paths then return end
+			local name = atom.raw_name or atom.name
+			local info = addrs[name]
+			if not info then return end
+			local entries, total = canonical_word_entries(atom)
+			matched[#matched + 1] = {
+				name       = name,
+				src_path   = src.path,
+				file_base  = file_base,
+				addr       = info[1],
+				size_bytes = info[2],
+				words      = total,
+				entries    = entries,
+			}
+		end
+		for _, atom in ipairs((src.scan or {}).atoms or {}) do append(atom) end
+		for _, atom in ipairs((src.scan or {}).raw_atoms or {}) do append(atom) end
+	end
+
+	-- Deterministic order: sort by address (matches `nm` output ordering).
+	table.sort(matched, function(a, b) return a.addr < b.addr end)
+	for i, a in ipairs(matched) do a.idx = i - 1 end
+	return matched
+end
+
+--- Append the 9 gdb command definitions to `lines`. Pure gdb scripting — addresses come from `nm`, the convenience
+--- vars set in `emit_gdb_runtime` provide printf args, and each command is a static sequence of `printf` / `tbreak` /
+--- `if ... end` blocks. The Lua pass emits N atoms' worth of lines; runtime iteration is gdb's job.
+---
+--- Why hardcoded per-atom: gdb's `$` substitution doesn't concat inside var names — `$__atom_name_$__i` in a `while`
+--- loop resolves to one literal identifier, not `name_i`. Compile-time emission is the only path.
+--- @param lines   table  -- output line buffer (mutated in place)
+--- @param matched table  -- list of atom records from `build_atom_table`
+local function append_gdb_commands(lines, matched)
+	-- ── tape_atoms ──
+	-- Hardcoded one printf per atom. No loop.
+	lines[#lines + 1] = "define tape_atoms"
+	for _, a in ipairs(matched) do
+		-- gdb 12.1 quirk: literals in printf args require an attached target.
+		-- Use the per-atom convenience vars set above as printf args.
+		lines[#lines + 1] = string.format('  printf "  code_%%-32s @ 0x%%08x  %%4d words\\n", $__atom_name_%d, $__atom_addr_%d, $__atom_words_%d',
+			a.idx, a.idx, a.idx)
+	end
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document tape_atoms"
+	lines[#lines + 1] = "  List every tape atom symbol in the loaded ELF (code_<name>) with .rodata addr + word count."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	-- ── break_atom (generic) + per-atom break_atom_X ──
+	lines[#lines + 1] = "define break_atom"
+	lines[#lines + 1] = '  echo "Usage: break_atom_<exact_name>  (pick from the list below)"'
+	for _, a in ipairs(matched) do
+		lines[#lines + 1] = string.format('  printf "  break_atom_%%-32s\\n", $__atom_name_%d', a.idx)
+	end
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document break_atom"
+	lines[#lines + 1] = "  Generic help: lists the per-atom break_atom_<name> commands."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	for _, a in ipairs(matched) do
+		lines[#lines + 1] = string.format("define break_atom_%s", a.name)
+		lines[#lines + 1] = string.format("  break *$__atom_addr_%d", a.idx)
+		lines[#lines + 1] = string.format('  printf "  Breakpoint set at code_%s (0x%%08x)\\n", $__atom_addr_%d', a.name, a.idx)
+		lines[#lines + 1] = "end"
+		lines[#lines + 1] = string.format("document break_atom_%s", a.name)
+		lines[#lines + 1] = string.format("  Set a breakpoint at code_%s.", a.name)
+		lines[#lines + 1] = "end"
+		lines[#lines + 1] = ""
+	end
+
+	-- ── step_atom / next_atom ──
+	-- Hardcoded one tbreak per atom. No loop.
+	lines[#lines + 1] = "define step_atom"
+	for _, a in ipairs(matched) do
+		lines[#lines + 1] = string.format("  tbreak *$__atom_addr_%d", a.idx)
+	end
+	lines[#lines + 1] = "  continue"
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document step_atom"
+	lines[#lines + 1] = "  Set one-shot BPs at every atom + continue. Stops at the next atom boundary."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	lines[#lines + 1] = "define next_atom"
+	lines[#lines + 1] = "  step_atom"
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document next_atom"
+	lines[#lines + 1] = "  Alias for step_atom."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	-- ── where_in_atom ──
+	-- Hardcoded one outer-if per atom; inside, one inner-if per WORD entry.
+	lines[#lines + 1] = "define where_in_atom"
+	lines[#lines + 1] = "  set $__pc = (unsigned int)$pc"
+	lines[#lines + 1] = "  set $__matched = 0"
+	for _, a in ipairs(matched) do
+		-- Precompute end_addr (gdb 12.1's expression evaluator chokes on `addr + words*4`).
+		lines[#lines + 1] = string.format("  set $__end_%d = $__atom_addr_%d + $__atom_words_%d * 4", a.idx, a.idx, a.idx)
+		lines[#lines + 1] = string.format("  if $__pc >= $__atom_addr_%d && $__pc < $__end_%d", a.idx, a.idx)
+		lines[#lines + 1] = string.format('    printf "atom:    code_%%s\\n", $__atom_name_%d', a.idx)
+		lines[#lines + 1] = '    printf "addr:    0x%08x\\n", $__pc'
+		lines[#lines + 1] = string.format("    set $__word = ($__pc - $__atom_addr_%d) / 4", a.idx)
+		lines[#lines + 1] = string.format('    printf "word:    %%d/%%d\\n", $__word, $__atom_words_%d', a.idx)
+		-- One inner-if per WORD entry. Each word's line + text hardcoded.
+		for _, we in ipairs(a.entries) do
+			lines[#lines + 1] = string.format("    if $__word == %d", we.pos)
+			-- Escape TEXT for printf format string.
+			local escaped_text = we.text:gsub("%%", "%%%%"):gsub('"', '\\"')
+			lines[#lines + 1] = string.format('      printf "source:  %%s:%%d  %%s\\n", $__atom_file_%d, %d, "%s"', a.idx, we.line, escaped_text)
+			lines[#lines + 1] = "    end"
+		end
+		-- Fallback for words beyond the source map (shouldn't happen if nm matches).
+		local max_word = 0
+		if #a.entries > 0 then max_word = a.entries[#a.entries].pos end
+		lines[#lines + 1] = string.format('    if $__word > %d', max_word)
+		lines[#lines + 1] = '      printf "source:  (no source-map entry for word %%d; map may be stale)\\n", $__word'
+		lines[#lines + 1] = "    end"
+		lines[#lines + 1] = "    set $__matched = 1"
+		lines[#lines + 1] = "  end"
+	end
+	lines[#lines + 1] = "  if !$__matched"
+	lines[#lines + 1] = '    echo PC is not inside any known atom (in .text or unmapped region).'
+	lines[#lines + 1] = "  end"
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document where_in_atom"
+	lines[#lines + 1] = "  Report current atom name, .rodata addr, word offset, and source line."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	-- ── stepi_inside_atom ──
+	-- Hardcoded one if-containment-check per atom (no loop).
+	-- Precompute end_addr in Lua so we don't ask gdb to evaluate `addr + words*4` inside the if condition
+	-- (gdb 12.1's expression evaluator chokes on the `*` and emits a misleading 'function malloc' error in some gdb builds).
+	lines[#lines + 1] = "define stepi_inside_atom"
+	lines[#lines + 1] = "  set $__in_atom = 0"
+	lines[#lines + 1] = "  set $__did_step = 0"
+	lines[#lines + 1] = "  set $__pc = (unsigned int)$pc"
+	for _, a in ipairs(matched) do
+		-- Precompute end_addr in the convenience var (single expression gdb handles).
+		lines[#lines + 1] = string.format("  set $__end_%d = $__atom_addr_%d + $__atom_words_%d * 4", a.idx, a.idx, a.idx)
+		lines[#lines + 1] = string.format("  if $__pc >= $__atom_addr_%d && $__pc < $__end_%d", a.idx, a.idx)
+		lines[#lines + 1] = "    set $__in_atom = 1"
+		lines[#lines + 1] = "    stepi"
+		lines[#lines + 1] = "    set $__did_step = 1"
+		lines[#lines + 1] = "  end"
+	end
+	lines[#lines + 1] = "  if !$__did_step"
+	lines[#lines + 1] = '    echo [gdb_tape_atoms] stepi_inside_atom: PC is not inside any atom; refusing to step.'
+	lines[#lines + 1] = "  end"
+	lines[#lines + 1] = "  where_in_atom"
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document stepi_inside_atom"
+	lines[#lines + 1] = "  One MIPS-instruction step, then where_in_atom. The step-and-see-source-line workflow."
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = ""
+
+	-- ── wave_ctx ──
+	lines[#lines + 1] = "define wave_ctx"
+	lines[#lines + 1] = '  printf "$t4 = R_FaceCursor     0x%08x\\n", $t4'
+	lines[#lines + 1] = '  printf "$t5 = R_VertBase       0x%08x\\n", $t5'
+	lines[#lines + 1] = '  printf "$t6 = R_OtBase         0x%08x\\n", $t6'
+	lines[#lines + 1] = '  printf "$t7 = R_PrimCursor     0x%08x\\n", $t7'
+	lines[#lines + 1] = "end"
+	lines[#lines + 1] = "document wave_ctx"
+	lines[#lines + 1] = "  Pretty-print the 4 wave-context GPRs ($t4=R_FaceCursor, $t5=R_VertBase, $t6=R_OtBase, $t7=R_PrimCursor). Requires target attached."
+	lines[#lines + 1] = "end"
+end
+
+--- Emit the gdb-runtime file (post-link). Pure gdb scripting — addresses come from `mipsel-none-elf-nm -S`, get embedded
+--- in `<ctx.out_root>/gdb_tape_atoms_runtime.gdb`, and load via `set $var = ...` + `define ... end` blocks at gdb
+--- source-time.
+--- @param ctx PassCtx
+local function emit_gdb_runtime(ctx)
+	if not (ctx.flags and ctx.flags.gdb_runtime) then return end
+	local  elf_path = ctx.flags.elf_path
+	if not elf_path or elf_path == "" then
+		io.stderr:write("[atoms_source_map] --gdb-runtime requires --elf <elf>\n")
+		return
+	end
+	if lfs.attributes(elf_path, "mode") ~= "file" then
+		io.stderr:write(string.format(
+			"[atoms_source_map] --gdb-runtime: ELF not found at %s\n", elf_path))
+		return
+	end
+
+	local matched = build_atom_table(ctx)
+	if #matched == 0 then
+		io.stderr:write("[atoms_source_map] --gdb-runtime: no atoms matched against nm symbols (stale scan?).\n")
+		return
+	end
+
+	local lines = {}
+	lines[#lines + 1] = "# Auto-generated by ps1_meta.lua (passes/atoms_source_map.lua)"
+	lines[#lines + 1] = "# DO NOT EDIT — re-run ps1_meta.lua --atoms-source-map --gdb-runtime to regenerate"
+	lines[#lines + 1] = "# Sourced by scripts/gdb/gdb_tape_atoms.gdb (the wrapper)."
+	lines[#lines + 1] = "# Pure gdb scripting — no Python, no Tcl, no Guile required."
+	lines[#lines + 1] = "# Commands are FULLY HARDCODED per-atom because gdb doesn't do nested"
+	lines[#lines + 1] = "# `$` substitution in var names (`$foo_$i` is one literal identifier)."
+	lines[#lines + 1] = "# Per-atom convenience vars ($__atom_name_<i> etc.) are set so gdb's"
+	lines[#lines + 1] = "# `printf` has valid expression args (gdb 12.1 quirks: literals in"
+	lines[#lines + 1] = "# printf args require an attached target; convenience-var args do not)."
+	lines[#lines + 1] = string.format("# %d atoms from ELF: %s", #matched, elf_path)
+	lines[#lines + 1] = ""
+
+	-- Format version + count + ELF path (the latter is referenced by the load-line).
+	lines[#lines + 1] = "set $__atom_format_version = " .. FORMAT_VERSION
+	lines[#lines + 1] = string.format("set $__atom_count = %d", #matched)
+	lines[#lines + 1] = string.format('set $__elf_path = "%s"', gdb_escape(elf_path))
+	lines[#lines + 1] = ""
+
+	-- Per-atom convenience vars (used as printf args; literals aren't accepted
+	-- without an attached target on gdb 12.1).
+	for _, a in ipairs(matched) do
+		lines[#lines + 1] = string.format('set $__atom_name_%d = "%s"', a.idx, gdb_escape(a.name))
+		lines[#lines + 1] = string.format("set $__atom_addr_%d = 0x%x", a.idx, a.addr)
+		lines[#lines + 1] = string.format("set $__atom_words_%d = %d", a.idx, a.words)
+		lines[#lines + 1] = string.format('set $__atom_file_%d = "%s"', a.idx, gdb_escape(a.file_base))
+	end
+	lines[#lines + 1] = ""
+
+	-- The 9 commands (each `define ... end` overrides the wrapper's stub).
+	lines[#lines + 1] = "# ── 9 user commands (overrides wrapper stubs) ──"
+	append_gdb_commands(lines, matched)
+	lines[#lines + 1] = ""
+
+	-- Confirmation line for the source operator.
+	lines[#lines + 1] = 'printf "[gdb_tape_atoms] runtime loaded %d atoms from %s\\n", $__atom_count, $__elf_path'
+
+	local out_path = ctx.out_root .. "/gdb_tape_atoms_runtime.gdb"
+	duffle.ensure_dir(duffle.dirname(out_path))
+	duffle.write_file_lf(out_path, table.concat(lines, "\n") .. "\n")
+	-- io.stderr:write(string.format("[atoms_source_map] wrote %s (%d atoms)\n", out_path, #matched))
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M — module exports
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+--- Pass entry. For each source that declares at least one `MipsAtom_(name)` / `MipsCode code_<name>`, emit two files
+--- in `<out_root>/`: `<basename>.atoms.sourcemap.txt` (per-word call-site map) and `<basename>.atoms.provenance.txt`
+--- (per-word definition + body line, resolved via the outermost `mac_X(...)` invocation). When `ctx.flags.gdb_runtime`
+--- is true and `ctx.flags.elf_path` exists, also emit the post-link gdb script `<ctx.out_root>/gdb_tape_atoms_runtime.gdb`.
+--- @param ctx PassCtx
+--- @return PassResult
+function M.run(ctx)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	local corpus = ctx.shared and ctx.shared.corpus
+	if type(corpus) ~= "table" or type(corpus.source_order) ~= "table" then
+		error("atoms_source_map.run requires ctx.shared.corpus.source_order (canonical corpus).", 0)
+	end
+
+	-- Word counts come from `corpus.word_counts` (populated by word_count_eval + components passes).
+	local wc = corpus.word_counts or {}
+	if not next(wc) then
+		warnings[#warnings + 1] = {
+			line = 0,
+			msg  = "atoms_source_map: corpus.word_counts is empty; the word-counts + components passes may not have populated it. Check the PASSES dep edges.",
+		}
+	end
+
+	-- Always emit the text form (per-source).
+	for _, src in ipairs(corpus.source_order) do
+		local has_projection = false
+		for _, atom in ipairs((src.scan or {}).atoms or {}) do
+			if (atom.kind == "atom" or atom.kind == "raw_atom") and atom.paths then
+				has_projection = true; break
+			end
+		end
+		if not has_projection then
+			for _, atom in ipairs((src.scan or {}).raw_atoms or {}) do
+				if atom.paths then has_projection = true; break end
+			end
+		end
+		if has_projection then
+			local basename = duffle.basename_no_ext(src.path)
+			-- (1) atoms.sourcemap.txt — format-1 per-word call-site map.
+			local sourcemap_path = ctx.out_root .. "/" .. basename .. ".atoms.sourcemap.txt"
+			local sourcemap_body = render_source_map(src)
+			-- (2) atoms.provenance.txt — format-1 per-word definition/body map.
+			local prov_path = ctx.out_root .. "/" .. basename .. ".atoms.provenance.txt"
+			local prov_body = render_provenance(src, wc)
+			duffle.ensure_dir(duffle.dirname(sourcemap_path))
+			duffle.write_file_lf(sourcemap_path, sourcemap_body)
+			duffle.write_file_lf(prov_path,    prov_body)
+			outputs[#outputs + 1] = { kind = "report", path = sourcemap_path }
+			outputs[#outputs + 1] = { kind = "report", path = prov_path }
+		end
+	end
+
+	-- Optionally emit the gdb-runtime form (post-link, one file per build).
+	if ctx.flags and ctx.flags.gdb_runtime then
+		emit_gdb_runtime(ctx)
+	end
+
+	return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/emission_model.lua

@@ -0,0 +1,239 @@
+--- passes/emission_model.lua: Per-atom emission projection.
+---
+--- The `emission-model` pass owns `atom.paths`, the canonical per-atom mutable surface for atoms and raw atoms with bodies in `ctx.shared.corpus.source_order`.
+--- For each atom, the pass invokes `duffle.project_emission(body_text, component_index, word_counts, components)`.
+--- It stores the ordered `items` stream plus the dense `word_events` / `markers` / `invocations` views on `atom.paths`.
+---
+--- Public boundary:
+---   * `M.run(ctx)` is the only entry point.
+---   * The pass returns `{outputs = {}, errors = ..., warnings = ...}`.
+---     Pass kind = `validation` → `PASS_KIND_STOP_ON_ERROR.validation` preserves the existing build-stopping policy.
+---
+--- Source-order discipline:
+---   * `corpus.source_order` sets the source-record order.
+---   * Within each source, the pass visits `src.scan.atoms` and `src.scan.raw_atoms` in declaration order.
+---
+--- Per-atom projection fields on `atom.paths`:
+---   `tokens`, `line_in_body`, `items`, `word_events`, `markers`, `invocations`, `errors`, `warnings`.
+---   The construction walk appends `items` and derives each dense view from that ordered stream.
+---
+--- Component expansion and construction validation:
+---   * known `mac_X(...)` calls recursively expand component bodies;
+---   * invocation records retain monotonic IDs, parent IDs, immediate call text, and the immutable outermost root call text;
+---   * invocation construction stamps `debug_skip` from `corpus.components[name].debug_skip` at the construction site (no second pass, no source parse, no parallel lookup);
+---   * component cycles close balanced invocation boundaries and emit a `cycle` construction error at the recursive edge;
+---   * declared-vs-measured component word counts emit `count_mismatch` construction errors; opaque uncounted macros emit warnings.
+---
+--- `passes.scan_source` strips its private `_code_macros` / `_code_macro_bodies` tables before this pass runs.
+
+local M = {}
+
+-- ─────────────────────────────────────────────────────────────────────────
+-- Bootstrap: load `duffle_paths.lua` via debug.getinfo so the module works standalone (run as `luajit passes/emission_model.lua`) and when require'd from the orchestrator.
+-- ─────────────────────────────────────────────────────────────────────────
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- ─────────────────────────────────────────────────────────────────────────
+-- Helpers
+-- ─────────────────────────────────────────────────────────────────────────
+
+-- Convert the recursive walk's body-relative line numbers into physical source lines once.
+-- The walker builds `line_of` from `body_text` and stamps body-relative line numbers (1..N) into `item.line` and `invocation.call_line`.
+-- This function converts those values to physical source lines at the close site with the forwarded source `line_of` closure.
+--
+-- `call_line` discipline:
+--   * ROOT invocations (`inv.parent_id == 0`) receive body-relative `call_line` values directly from `M.LineIndex(body_text)` in the walker.
+--     The source `line_of` closure supplies physical lines at the close site, so this function converts each root value exactly once.
+--   * INNER invocations (`inv.parent_id ~= 0`) receive physical `call_line` values directly from the COMPONENT's `line_of` in the walker.
+--     Recursive descent forwards that closure through `corpus.component_body_index[name].line_of`; those values arrive physical and remain unchanged.
+--
+-- After this function, every `inv.call_line` is physical. DWARF and provenance output read it directly.
+-- The word-event loop forwards the already-physical `outer_inv.call_line` into `we.call_line` for words inside an invocation.
+local function stamp_root_provenance(projection, atom_record, src, corpus)
+	local root_line_of   = src.scan and src.scan.line_of
+	assert(type(root_line_of) == "function"
+		, "emission_model: src.scan.line_of is required (canonical LineIndex closure over the source text) to stamp physical provenance")
+	assert(type(atom_record.body_off) == "number"
+		, "emission_model: atom_record.body_off (byte offset of the body's first byte in source) is required to derive `root_body_line`. The scanner must populate body_off for every atom record.")
+	-- `root_body_line` is the physical source line of the ATOM HEADER byte containing the opening `{`; that byte is one byte BEFORE `atom_record.body_off`.
+	-- The walker assigns line 2 to the body's first content line because line 1 is the trailing `\n` after `{`. Body-text line k therefore maps to `root_body_line + (k - 1)`.
+	-- `body_off - 1` points at the opening `{`, whose line index identifies the header line. `body_off` points after `{` and would shift every word row forward by one line.
+	local root_body_line = root_line_of(atom_record.body_off - 1)
+		or atom_record.line or 0
+	local component_index = corpus.component_body_index or {}
+	local word_items = {}
+
+	for _, item in ipairs(projection.items) do
+		if item.kind == "word" then word_items[#word_items + 1] = item end
+	end
+
+	-- Resolve one word's physical body line, where the byte containing that word appears in source.
+	--   * Component expansions carry `invocation_ids`; the component's full-file `line_of` leaves `item.line` physical.
+	--   * Raw tokens in the root atom body carry an empty `invocation_ids` list and a body-relative `item.line`; convert them here.
+	local function body_line_for(event, item)
+		local ids = event.invocation_ids or {}
+		-- The innermost open invocation identifies which line index the walker used.
+		-- A component `line_of` makes `item.line` physical; the atom's `body_text` line index makes it body-relative.
+		if ids and #ids > 0 then
+			local inner_id  = ids[#ids]
+			local inner_inv = inner_id and projection.invocations[inner_id]
+			if inner_inv then
+				local component = component_index[inner_inv.component_name]
+				if component and component.line_of then
+					-- Walker used `comp.line_of`, which is the source's physical LineIndex. item.line is already physical.
+					return item.line or 0
+				end
+			end
+		end
+		-- RAW root-body word: item.line is body-text's 1-based line number (the first content line is line 2 because line 1 is the trailing `\n` after `{`).
+		-- Convert body-text-relative → physical using `root_body_line + (item.line - 1)`.
+		return (root_body_line or 0) + (item.line or 1) - 1
+	end
+
+	-- Stamp the root source path onto invocation records whose `call_path` the walker left empty.
+	-- The walker passes `body_entry.source` to `emit_invoke_begin`; `M.project_emission` creates the root `body_entry` with source `""`, leaving its `call_path` empty.
+	-- This stamp gives every invocation a physical `call_path` matching `passes/atoms_source_map.lua`'s in-memory provenance projection.
+	local root_path = src.path or ""
+	for _, inv in ipairs(projection.invocations) do
+		if inv.call_path == nil or inv.call_path == "" then
+			inv.call_path = root_path
+		end
+	end
+
+	-- Normalize `inv.call_line` to a physical source line.
+	--   * ROOT invocations (`parent_id == 0`) carry body-relative `call_line` values from `M.LineIndex(body_text)`; convert them once with `root_body_line`.
+	--   * INNER invocations (`parent_id ~= 0`) carry physical `call_line` values from the component's `line_of`; retain them unchanged.
+	for _, inv in ipairs(projection.invocations) do
+		if inv.parent_id == 0 then
+			inv.call_line = (root_body_line or 0) + (inv.call_line or 1) - 1
+		end
+	end
+
+	-- Build `body_lines` for each invocation.
+	-- `atoms_source_map` and `dwarf_injection` read `inv.body_lines[k]` directly from the invocation record created here.
+	-- Component words already carry physical `item.line` values from the walker's COMPONENT line index, so `body_line_for` returns them unchanged.
+	for _, inv in ipairs(projection.invocations) do
+		local sw = inv.start_word
+		local ew = inv.end_word
+		local bls = {}
+		for i = sw, ew do
+			local it = projection.items and projection.items[i]
+			if it and it.kind == "word" then
+				local fake_event = { invocation_ids = { inv.id } }
+				bls[#bls + 1] = body_line_for(fake_event, it) or 0
+			end
+		end
+		inv.body_lines = bls
+	end
+
+	-- Resolve each `word_event`'s physical `body_line` and `call_line`.
+	-- For words inside an invocation, `we.call_line` identifies the OUTER atom source line containing the `mac_X(...)` token that triggered expansion.
+	-- The root-invocation conversion above makes every `inv.call_line` physical; forward it directly and use each raw word's `body_line` as the fallback.
+	for index, we in ipairs(projection.word_events) do
+		local item      = word_items[index] or {}
+		local body_line = body_line_for(we, item)
+		item.line    = body_line
+		we.body_line = body_line
+
+		local call_line = body_line
+		local outer_id  = we.outermost_invocation_id or 0
+		local outer_inv = projection.invocations[outer_id]
+		if outer_inv then
+			-- `outer_inv.call_line` is physical after the conversion loop above, so use it directly.
+			call_line = outer_inv.call_line
+		end
+		we.call_line = call_line
+
+		if we.def_path  == nil or we.def_path  == "" then we.def_path  = src.path         or "" end
+		if we.def_line  == nil or we.def_line  == 0  then we.def_line  = atom_record.line or 0  end
+		if we.call_path == nil or we.call_path == "" then we.call_path = src.path         or "" end
+	end
+end
+
+-- Project one atom record into `atom.paths`.
+-- Mutates the atom record in-place and returns the projection (for pass-level error/warning accumulation).
+local function project_atom(atom_record, src, corpus)
+	local body  = atom_record.body or ""
+	local wc    = corpus.word_counts or {}
+	local cbi   = corpus.component_body_index or {}
+	-- That construction site stamps `invocation.debug_skip` while appending each record to `proj.invocations`.
+	local proj  = duffle.project_emission(body, cbi, wc, corpus.components)
+	local paths = {
+		tokens       = atom_record.body_tokens or {},
+		line_in_body = duffle.build_body_line_index(body),
+		items        = proj.items,
+		word_events  = proj.word_events,
+		markers      = proj.markers,
+		invocations  = proj.invocations,
+		errors       = proj.errors,
+		warnings     = proj.warnings,
+	}
+	stamp_root_provenance(proj, atom_record, src, corpus)
+	atom_record.paths = paths
+	return proj
+end
+
+-- ─────────────────────────────────────────────────────────────────────────
+-- Run the emission-model pass.
+-- ─────────────────────────────────────────────────────────────────────────
+
+--- @param ctx PassCtx  -- { shared = { corpus = ... }, out_root, ... }
+--- @return PassResult
+function M.run(ctx)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	local corpus = ctx and ctx.shared and ctx.shared.corpus
+	if type(corpus)              ~= "table" then error("emission_model: ctx.shared.corpus is required (canonical projection)", 0) end
+	if type(corpus.source_order) ~= "table" then error("emission_model: ctx.shared.corpus.source_order is required", 0) end
+
+	-- Project once, collect errors + warnings for one atom.
+	-- Kind must be one of: atom | raw_atom | comp_bare | comp_proc.
+	local function process_atom(atom, src)
+		if not (atom and atom.body) then return end
+		local kind = atom.kind
+		if kind ~= "atom" and kind ~= "raw_atom" and kind ~= "comp_bare" and kind ~= "comp_proc" then
+			return
+		end
+		local proj = project_atom(atom, src, corpus)
+		for _, e in ipairs(proj.errors) do
+			-- Preserve `kind` (cycle / count_mismatch / unbalanced) so readers dispatch on the diagnostic class and leave the message string as display text.
+			errors[#errors + 1] = {
+				kind   = e.kind,
+				line   = e.line,
+				msg    = e.msg,
+				source = e.source or src.path,
+			}
+		end
+		for _, w in ipairs(proj.warnings) do
+			warnings[#warnings + 1] = {
+				kind = w.kind,
+				line = w.line,
+				msg  = w.msg,
+			}
+		end
+	end
+
+	-- Walk `corpus.source_order`; within each source, visit atoms followed by raw_atoms.
+	-- Recognized kinds (atom | raw_atom | comp_bare | comp_proc) each receive the atom.paths projection via duffle.project_emission.
+	-- Components are macros inlined into atom bodies; focused tests and isolated component analyses consume atom.paths directly.
+	for _, src in ipairs(corpus.source_order) do
+		local scan = src.scan or {}
+		for _, atom in ipairs(scan.atoms or {}) do
+			process_atom(atom, src)
+		end
+		for _, atom in ipairs(scan.raw_atoms or {}) do
+			process_atom(atom, src)
+		end
+	end
+
+	return {
+		outputs  = outputs,
+		errors   = errors,
+		warnings = warnings,
+	}
+end
+
+return M

scripts/passes/offsets.lua

@@ -1,319 +1,181 @@
--- passes/offsets.lua
+--- passes/offsets.lua — Branch-offset generator.
---
+---
--- Generate <module>/gen/<basename>.offsets.h with branch offset
+--- Reads the pre-scanned SourceScan payload (produced once upstream by `duffle.scan_source`)
--- immediates for every atom_offset(F, T) reference in atom bodies.
+--- for `MipsAtom_(name)` and `MipsCode code_<name>` declarations, computes the word offset
--- Ported from scripts/tape_atom.offset_gen.meta.lua:148-389.
+--- from each `atom_offset(F, T)` marker to its target `atom_label(T)` declaration, and emits
---
+--- `<dir_basename>.offsets.h` with one `#define _atom_offset_F_T = N` per branch.
--- The branch offset regression we just fixed in commit 98e27c2 must
+---
--- NOT return. The fix was in duffle.lua's split_top_level_commas +
+--- The offset is `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding: branch_offset = relative_pc_in_words - 1).
--- tape_atom_annotation_pass.lua's compute_component_word_count.
+---
--- word_count_eval.count_token_words preserves the fix.
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
---
+--- Lua 5.3 compatible.
--- THIS MODULE ALSO REQUIRES the recent fix to duffle.lua's
--- split_top_level_commas (the second-half of the 98e27c2 fix):
--- top-level comments must be appended to the previous token, not
--- stripped, so the emit path preserves `// trailing comment` text
--- for convert_line_comments_to_block to convert to `/* */`.
---
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
-local script_path = arg and arg[0] or "?"
+-- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
-local last_sep = 0
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
-for i = 1, #script_path do
+-- Uses `debug.getinfo` to find this file's own directory, so it works
-	local c = script_path:sub(i, i)
+-- both standalone and when require'd from the orchestrator.
-	if c == "/" or c == "\\" then last_sep = i end
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
-end
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
-package.path   = script_dir .. "../?.lua;" .. script_dir .. "../?/init.lua;" .. script_dir .. "?.lua;" .. package.path
+local duffle = dofile(_bootstrap_dir .. "../duffle_paths.lua")
-
-local duffle              = require("duffle")
-local trim                = duffle.trim
-local read_ident          = duffle.read_ident
-local is_space            = duffle.is_space
-local is_alpha            = duffle.is_alpha
-local is_alnum            = duffle.is_alnum
-local skip_ws_and_cmt     = duffle.skip_ws_and_cmt
-local skip_str_or_cmt     = duffle.skip_str_or_cmt
-local split_top_level_commas = duffle.split_top_level_commas
-local read_parens         = duffle.read_parens
-local read_braces         = duffle.read_braces
-local write_file          = duffle.write_file
-local dirname             = duffle.dirname
-local basename_no_ext     = duffle.basename_no_ext
-local ensure_dir          = duffle.ensure_dir
-
-local word_count_eval     = require("word_count_eval")
-local count_token_words   = word_count_eval.count_token_words
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Local helpers (ported from offset_gen.meta.lua lines 67-93)
+-- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
-local function starts_with(s, prefix)
+-- Offset macro/enum naming prefixes (the emitted header uses these).
-	if #s < #prefix then return false end
+local OFFSET_MACRO_PREFIX = "_atom_offset_"
-	for i = 1, #prefix do
+local OFFSET_ENUM_PREFIX  = "atom_offset_"
-		if s:sub(i, i) ~= prefix:sub(i, i) then return false end
-	end
-	return true
-end
 
-local function to_upper(s) return s:upper() end
+-- Column width for the `#define _atom_offset_F_T = N` alignment.
-
+local OFFSET_MACRO_COL = 44
-local function to_alnum_underscore(s)
-	local out = ""
-	for i = 1, #s do
-		local c = s:sub(i, i)
-		if is_alnum(c) then out = out .. c
-		else out = out .. "_" end
-	end
-	return out
-end
-
-local function pad_right(s, w) return s .. string.rep(" ", w - #s) end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Marker-call helpers (ported from offset_gen.meta.lua lines 148-205)
+-- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Extract comma-separated identifier args from a parenthesized group
+--- @class SourceFile
---- after a function-like macro call.
+--- @field path     string  -- absolute path to the source file
-local function extract_ident_args(token, after_ident)
+--- @field text     string  -- the full source text
-	local arg_start = skip_ws_and_cmt(token, after_ident)
+--- @field dir      string  -- the directory containing the source
-	if token:sub(arg_start, arg_start) ~= "(" then return {}, nil end
+--- @field basename string  -- filename without extension
-	local inner, after_paren = read_parens(token, arg_start)
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
 
-	local args = {}
+--- @class PassCtx
-	local n    = 1
+--- @field shared             table                  -- cross-pass shared state
-	local len  = #inner
+--- @field shared.corpus      table                  -- canonical corpus projection
-	while n <= len do
+--- @field shared.word_counts table
-		n = skip_ws_and_cmt(inner, n)
+--- @field out_root           string                 -- output root (e.g. "build/gen")
-		if n > len then break end
-		local ident, after = read_ident(inner, n)
-		if ident and ident ~= "" then
-			table.insert(args, ident)
-			n = after
-		else
-			n = n + 1
-		end
-		n = skip_ws_and_cmt(inner, n)
-		if n <= len and inner:sub(n, n) == "," then n = n + 1 end
-	end
 
-	return args, after_paren
+--- @class PassResult
-end
+--- @field outputs  table[]  -- {kind=, path=} entries describing emit files
+--- @field errors   table[]  -- {line=, msg=} entries; build-stops
+--- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
 
---- Scan a single token for atom_label/atom_offset markers, walking through
+--- @class BranchOffset
---- balanced groups transparently (so nested calls are found).
+--- @field tag         string   -- the marker tag (e.g. "F" in `atom_offset(F, T)`)
-local function scan_for_atom_markers(token, at_pos, labels, branches)
+--- @field target      string   -- the target label name (e.g. "T" in `atom_offset(F, T)`)
-	local i   = 1
+--- @field branch_word integer  -- branch word position within the atom body
-	local len = #token
+--- @field offset      integer  -- computed `target_word - branch_word - 1`
-	while i <= len do
-		i = skip_ws_and_cmt(token, i)
-		if i > len then break end
-		local c = token:sub(i, i)
-		if is_alpha(c) then
-			local ident, after = read_ident(token, i)
-			if ident == "atom_label" then
-				local args, after_paren = extract_ident_args(token, after)
-				if #args >= 1 then labels[args[1]] = at_pos end
-				if after_paren then i = after_paren else i = after end
-			elseif ident == "atom_offset" then
-				local args, after_paren = extract_ident_args(token, after)
-				if #args >= 2 then table.insert(branches, {pos = at_pos, target = args[2], tag = args[1]}) end
-				if after_paren then i = after_paren else i = after end
-			else
-				i = after
-			end
-		else
-			local nx = skip_str_or_cmt(token, i)
-			if nx > i then i = nx else i = i + 1 end
-		end
-	end
-end
 
---- Find the end position (just past the closing ')') of the first
+--- @class AtomData
---- atom_label/atom_offset call in `tok`. Returns 0 if no such call.
+--- @field name        string         -- atom name
-local function find_marker_call_end(tok)
+--- @field total_words integer        -- total word count of the atom body
-	local i   = 1
+--- @field offsets     BranchOffset[] -- per-branch offset list
-	local len = #tok
-	while i <= len do
-		i = skip_ws_and_cmt(tok, i)
-		if i > len then break end
-		local c = tok:sub(i, i)
-		if is_space(c) then
-			i = i + 1
-		elseif c == "/" then
-			-- comment — skip past it (delegated to duffle.skip_str_or_cmt)
-			local nx = skip_str_or_cmt(tok, i)
-			if nx > i then i = nx else i = i + 1 end
-		else
-			local ident, after = read_ident(tok, i)
-			if ident == "atom_label" or ident == "atom_offset" then
-				local j = skip_ws_and_cmt(tok, after)
-				if tok:sub(j, j) == "(" then
-					local _, end_paren = read_parens(tok, j)
-					return end_paren - 1
-				end
-				return 0
-			end
-			i = after or (i + 1)
-		end
-	end
-	return 0
-end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Atom scanner (ported from offset_gen.meta.lua lines 245-321)
+-- Canonical marker projection
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Skip C qualifier keywords (static, const, etc.) and return the position
+-- MARKER_PROJECTORS is the marker-kind data table.
---- past the last qualifier.
+-- The emission-model pass already records marker word positions;
-local function skip_qualifiers(source, i)
+-- this pass only projects those records into the label/branch lookup shape needed by offset computation.
-	local keywords = {
+local MARKER_PROJECTORS = {
-		["static"]  = true, ["const"]    = true, ["volatile"] = true,
+	label = function(state, marker)
-		["extern"]  = true, ["register"] = true, ["auto"]     = true,
+		state.labels[marker.name] = marker.word_index
-		["inline"]  = true, ["typedef"]  = true,
+	end,
-		["internal"]= true, ["LP_"]      = true, ["global"]   = true, ["gkknown"] = true,
+	offset = function(state, marker)
+		state.branches[#state.branches + 1] = {
+			tag         = marker.name,
+			target      = marker.target,
+			branch_word = marker.word_index,
 		}
-	while true do
+	end,
-		i = skip_ws_and_cmt(source, i)
+}
-		local ident, after = read_ident(source, i)
-		if not ident       then                return i end
-		if keywords[ident] then i = after else return i end
-	end
-end
 
---- Find every MipsAtom_(name) { ... } in a source.
+--- Project canonical marker records into the two lookup tables used by the offset renderer.
-local function find_atoms(source_text)
+--- No source text, body text, or body token is inspected.
-	local atoms = {}
+--- @param markers table[] -- atom.paths.markers
-	local len   = #source_text
+--- @return table<string, integer>, table[]
-	local i     = 1
+local function project_markers(markers)
-
+	local state = { labels = {}, branches = {} }
-	local function try_wrapped(after_pos)
+	for _, marker in ipairs(markers or {}) do
-		local paren_pos = skip_ws_and_cmt(source_text, after_pos)
+		local project = MARKER_PROJECTORS[marker.kind]
-		if source_text:sub(paren_pos, paren_pos) ~= "(" then return nil end
+		if project then project(state, marker) end
-		local inner, after_paren = read_parens(source_text, paren_pos)
-		local n = 1
-		while n <= #inner and is_space(inner:sub(n, n)) do n = n + 1 end
-		local ns = n
-		while n <= #inner and is_alnum(inner:sub(n, n)) do n = n + 1 end
-		local name = inner:sub(ns, n - 1)
-		if name == "" then return nil end
-		-- Find the brace after the parens.
-		local brace_pos = duffle.scan_to_char(source_text, "{", after_paren)
-		if not brace_pos then return nil end
-		local body, after_brace = read_braces(source_text, brace_pos)
-		return {name = name, body = body, after_brace = after_brace}
 	end
-
+	return state.labels, state.branches
-	local function try_raw(after_pos)
-		local next_pos = skip_ws_and_cmt(source_text, after_pos)
-		local next_ident, next_after = read_ident(source_text, next_pos)
-		if not next_ident then return nil end
-		if not starts_with(next_ident, "code_") then return nil end
-		if #next_ident <= 5 then return nil end
-		local atom_name = next_ident:sub(6)
-		local brace_pos = duffle.scan_to_char(source_text, "{", next_after)
-		if not brace_pos then return nil end
-		local body, after_brace = read_braces(source_text, brace_pos)
-		return {name = atom_name, body = body, after_brace = after_brace}
-	end
-
-	while i <= len do
-		i = skip_ws_and_cmt(source_text, i); if i > len then break end
-		i = skip_qualifiers(source_text, i); if i > len then break end
-		local ident, after = read_ident(source_text, i)
-		if not ident then
-			i = i + 1
-		elseif ident == "MipsAtom_" then
-			local atom = try_wrapped(after)
-			if atom then
-				table.insert(atoms, {name = atom.name, body = atom.body})
-				i = atom.after_brace
-			else
-				i = i + 1
-			end
-		elseif ident == "MipsCode" then
-			local atom = try_raw(after)
-			if atom then
-				table.insert(atoms, {name = atom.name, body = atom.body})
-				i = atom.after_brace
-			else
-				i = after
-			end
-		else
-			i = after
-		end
-	end
-	return atoms
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Per-atom body scan (ported from offset_gen.meta.lua lines 207-239)
+-- Offset computation + header generation
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Scan an atom body for labels + branches, count total words.
+--- Compute branch offsets as `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding).
---- Returns (labels, branches, total_words).
+--- @param labels table<string, integer>
-local function scan_atom_body(body, word_counts)
+--- @param branches table[]
-	local pos      = 0
+--- @return BranchOffset[]
-	local labels   = {}
-	local branches = {}
-	for _, tok in ipairs(split_top_level_commas(body)) do
-		local k    = 1
-		local tlen = #tok
-		while k <= tlen and is_space(tok:sub(k, k)) do k = k + 1 end
-		local leading_ident = read_ident(tok, k)
-		if leading_ident == "atom_label" or leading_ident == "atom_offset" then
-			-- Marker call: record at the current pos, do NOT advance pos.
-			-- But the source pattern may bundle the marker with the next
-			-- instruction on a new line (no top-level comma between them).
-			-- In that case, the rest of `tok` after the marker call is
-			-- a real instruction that must still be counted.
-			scan_for_atom_markers(tok, pos, labels, branches)
-			local marker_end = find_marker_call_end(tok)
-			if marker_end > 0 and marker_end < #tok then
-				local rest = trim(tok:sub(marker_end + 1))
-				if rest ~= "" then
-					local rest_words = count_token_words(rest, word_counts)
-					pos = pos + rest_words
-				end
-			end
-		else
-			local words = count_token_words(tok, word_counts)
-			scan_for_atom_markers(tok, pos, labels, branches)
-			pos = pos + words
-		end
-	end
-	return labels, branches, pos
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Offset computation + header generation (ported lines 327-383)
--- ════════════════════════════════════════════════════════════════════════════
-
---- Compute branch offsets as (target_word - branch_word - 1).
 local function compute_offsets(labels, branches)
 	local results = {}
 	for _, br in ipairs(branches) do
 		local target = labels[br.target]
 		if not target then
-			error("Branch target '" .. br.target .. "' has no atom_label (at word " .. br.pos .. ")")
+			error("Branch target '" .. br.target .. "' has no atom_label (at word " .. br.branch_word .. ")")
 		end
-		table.insert(results, {target = br.target, tag = br.tag, offset = target - br.pos - 1})
+		results[#results + 1] = {
+			target      = br.target,
+			tag         = br.tag,
+			branch_word = br.branch_word,
+			offset      = target - br.branch_word - 1,
+		}
 	end
 	return results
 end
 
+--- Right-pad `s` with spaces to width `w`. If `s` is already `w` or wider, no padding is added.
+--- @param s string
+--- @param w integer
+--- @return string
+local function pad_right(s, w)
+	return s .. string.rep(" ", math.max(0, w - #s))
+end
+
+--- (internal) Build a constant-table entry `{macro_name, enum_name, value}` from a BranchOffset.
+--- @param bo BranchOffset
+--- @return table
+local function make_offset_const(bo)
+	return {
+		macro_name = OFFSET_MACRO_PREFIX .. bo.tag .. "_" .. bo.target,
+		enum_name  = OFFSET_ENUM_PREFIX  .. bo.tag .. "_" .. bo.target,
+		value      = bo.offset,
+	}
+end
+
+--- (internal) Emit one atom's offset constants + enum into the lines buffer.
+--- @param add  fun(s: string)
+--- @param atom AtomData
+local function emit_atom_offsets(add, atom)
+	if #atom.offsets == 0 then return end
+	add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
+	add("")
+	local consts = {}
+	for _, r in ipairs(atom.offsets) do
+		consts[#consts + 1] = make_offset_const(r)
+	end
+	for _, c in ipairs(consts) do
+		add("#define " .. pad_right(c.macro_name, OFFSET_MACRO_COL) .. "  " .. c.value)
+	end
+	add("")
+	add("enum {")
+	for _, c in ipairs(consts) do
+		add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
+	end
+	add("};")
+	add("")
+end
+
 --- Generate the per-source .offsets.h header.
+--- @param source_path string
+--- @param atoms_data  AtomData[]
+--- @return string
 local function generate_header(source_path, atoms_data)
-	local basename = basename_no_ext(source_path)
+	local basename = duffle.basename_no_ext(source_path)
 
 	local lines = {}
-	local function add(s) table.insert(lines, s) end
+	local function add(s) lines[#lines + 1] = s end
 
 	add("// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT")
 	add("// Source: " .. source_path)
@@ -323,42 +185,48 @@ local function generate_header(source_path, atoms_data)
 	add("")
 	add("")
 	for _, atom in ipairs(atoms_data) do
-		if #atom.offsets > 0 then
+		emit_atom_offsets(add, atom)
-			add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
-			add("")
-			local consts = {}
-			for _, r in ipairs(atom.offsets) do
-				table.insert(consts, {
-					macro_name = "_atom_offset_" .. r.tag .. "_" .. r.target,
-					enum_name  = "atom_offset_"  .. r.tag .. "_" .. r.target,
-					value      = r.offset,
-				})
-			end
-			for _, c in ipairs(consts) do
-				add("#define " .. pad_right(c.macro_name, 44) .. "  " .. c.value)
-			end
-			add("")
-			add("enum {")
-			for _, c in ipairs(consts) do
-				add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
-			end
-			add("};")
-			add("")
-		end
 	end
 	add("#pragma endregion " .. basename)
 	add("")
 	return table.concat(lines, "\n") .. "\n"
 end
 
--- ════════════════════════════════════════════════════════════════════════════
--- M.run — orchestrator entry
--- ════════════════════════════════════════════════════════════════════════════
-
---- @class M
-
 local M = {}
 
+--- (internal) Process one source: render offsets from canonical atom paths.
+--- Returns the offsets_h path if a header was written, or nil.
+--- @param ctx PassCtx
+--- @param src SourceFile
+--- @return string|nil  -- the offsets_h path
+local function process_source(ctx, src)
+	local atoms_data = {}
+	local scan = src.scan or {}
+
+	local function append_atom(atom)
+		local paths = atom and atom.paths
+		if not paths then return end
+		local labels, branches = project_markers(paths.markers)
+		atoms_data[#atoms_data + 1] = {
+			name        = atom.raw_name or atom.name,
+			total_words = #(paths.word_events or {}),
+			offsets     = compute_offsets(labels, branches),
+		}
+	end
+
+	for _, atom in ipairs(scan.atoms or {}) do append_atom(atom) end
+	for _, atom in ipairs(scan.raw_atoms or {}) do append_atom(atom) end
+	if #atoms_data == 0 then return nil end
+
+	local out_path = src.dir .. "/gen/" .. duffle.basename_no_ext(src.dir) .. ".offsets.h"
+	duffle.ensure_dir(duffle.dirname(out_path))
+	duffle.write_file(out_path, generate_header(src.path:gsub("/", "\\"), atoms_data))
+	return out_path
+end
+
+--- Run the offsets pass.
+--- For each canonical source, emits a per-module `<dir_basename>.offsets.h`
+--- containing constants for every marker recorded in atom.paths.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -366,26 +234,15 @@ function M.run(ctx)
 	local errors   = {}
 	local warnings = {}
 
-	for _, src in ipairs(ctx.sources) do
+	local corpus = ctx.shared and ctx.shared.corpus
-		local atoms = find_atoms(src.text)
+	if type(corpus) ~= "table" or type(corpus.source_order) ~= "table" then
-		if #atoms > 0 then
+		error("offsets.run requires ctx.shared.corpus.source_order (canonical corpus).", 0)
-			local atoms_data = {}
-			for _, atom in ipairs(atoms) do
-				local labels, branches, total = scan_atom_body(atom.body, ctx.shared.word_counts)
-				local offsets = compute_offsets(labels, branches)
-				table.insert(atoms_data, {
-					name        = atom.name,
-					total_words = total,
-					offsets     = offsets,
-				})
 	end
 
-			local out_path = src.dir .. "/gen/" .. basename_no_ext(src.dir) .. ".offsets.h"
+	for _, src in ipairs(corpus.source_order) do
-			if not ctx.dry_run then
+		local out_path = process_source(ctx, src)
-				ensure_dir(dirname(out_path))
+		if out_path then
-				write_file(out_path, generate_header(src.path, atoms_data))
+			outputs[#outputs + 1] = { offsets_h = out_path }
-			end
-			table.insert(outputs, { offsets_h = out_path })
 		end
 	end
 

scripts/passes/report.lua

@@ -1,124 +1,343 @@
--- passes/report.lua
+--- passes/report.lua — Per-MODULE annotation report renderer +
---
+--- project-wide summary writer.
--- Render the per-project summary (build/gen/annotation_validation.txt)
+---
--- + the per-source annotation reports (build/gen/<basename>.annotations.txt).
+--- Two output files per build:
--- Aggregates errors + warnings from upstream annotation pass results.
+---   - `build/gen/<dir_basename>.annotations.txt` — one per source-directory containing atoms; aggregates across all sources in the directory.
---
+---   - `build/gen/annotation_validation.txt` — the project summary.
--- The annotation pass stashes its per-source results in ctx.flags._annot_results
+---
--- (set by passes/annotation.lua). This report pass renders them.
+--- The annotation pass emits `errors.h` files per module and the canonical `corpus.sources_by_dir` projection groups sources by directory.
---
+--- This pass iterates the canonical dir projection directly and re-validates each source via `annotation.validate()` to get the detailed per-source results.
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex.
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
-local script_path = arg and arg[0] or "?"
+-- Resolve `arg[0]` to an absolute-ish script directory so that `require("duffle")` resolves against `scripts/` regardless of CWD.
-local last_sep = 0
+-- Bootstrap: see `ps1_meta.lua` for the rationale.
-for i = 1, #script_path do
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
-	local c = script_path:sub(i, i)
+-- Uses `debug.getinfo` to find this file's own directory, so it works
-	if c == "/" or c == "\\" then last_sep = i end
+-- both standalone and when require'd from the orchestrator.
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- Load the annotation pass so we can re-validate each source against the canonical corpus projection.
+-- The annotation pass exposes `M.validate`, which returns the per-source AnnotationResult (atoms / annots / macros / binds / errors / warnings)
+-- that the report pass renders into the per-module `<dir_basename>.annotations.txt` output.
+local annotation    = dofile(_bootstrap_dir .. "annotation.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Section separators used in the rendered text reports.
+-- The thin rules are hand-tuned to align with the per-section content width; do not change without also checking the section renderers below.
+local RULE_THICK = "========================================================"
+local SECTION_HEADER_ATOMS     = "── Atoms ────────────────────────────────────────────────"
+local SECTION_HEADER_ANNOTS    = "── Annotations ──────────────────────────────────────────"
+local SECTION_HEADER_BINDS     = "── Binds_* structs ──────────────────────────────────────"
+local SECTION_HEADER_MACROS    = "── Macro word-count declarations ─────────────────────────"
+local SECTION_HEADER_ERRORS    = "── Errors ──────────────────────────────────────────────"
+local SECTION_HEADER_WARNINGS  = "── Warnings ────────────────────────────────────────────"
+
+-- Lua pattern that captures the basename (last path segment) of a
+-- forward- or back-slash separated path.
+local BASENAME_PATTERN = "([^/\\]+)$"
+
+-- Debug flag name — set to truthy in `_G` to enable verbose logging.
+local DEBUG_FLAG = "_DEBUG_REPORT"
+
+-- Pass identifier for log messages.
+local PASS_NAME = "report"
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+
+--- @class PassCtx
+--- @field sources            SourceFile[]         -- all source files in the build
+--- @field metadata_path      string               -- path to word_count.metadata.h
+--- @field shared             table                -- cross-pass shared state
+--- @field out_root           string               -- output root (e.g. "build/gen")
+--- @field project_root       string               -- project root (e.g. "code/")
+--- @field upstream           table<string, table> -- per-pass upstream outputs
+--- @field flags              table                -- CLI flags + per-pass stash
+--- @field verbose            boolean              -- if true, log diagnostic info
+
+--- @class PassResult
+--- @field outputs  table[]  -- {kind=, path=} entries describing emit files
+--- @field errors   table[]  -- {line=, msg=} entries; build-stops
+--- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
+
+-- Shapes produced by `passes/annotation.lua`'s `M.validate()`.
+
+--- @class AtomEntry
+--- @field name string   -- atom name (e.g. "cube_g4_face")
+--- @field line integer  -- source line of the atom declaration
+
+--- @class AnnotEntry
+--- @field line    integer  -- source line
+--- @field macro   string   -- the macro name (e.g. "atom_reads")
+--- @field name    string   -- the atom name (if a `name(...)` was given)
+--- @field kind    string   -- "atom_info" | "atom_bind" | ...
+--- @field binds   string|nil  -- Binds_X name if any
+--- @field reads   string[]    -- R_* names (read targets)
+--- @field writes  string[]    -- R_* names (write targets)
+--- @field error   string|nil  -- error message if annotation was malformed
+
+--- @class BindsField
+--- @field name   string   -- field name
+--- @field offset integer  -- byte offset within the Binds_X struct
+
+--- @class BindsStruct
+--- @field name   string         -- struct name (e.g. "Binds_Floor")
+--- @field line   integer        -- source line of the typedef
+--- @field bytes  integer        -- total byte size
+--- @field fields BindsField[]   -- the field list
+
+--- @class MacroEntry
+--- @field name  string   -- macro name (e.g. "WORD_COUNT(my_macro, 4)")
+--- @field line  integer  -- source line
+--- @field words integer  -- declared word count
+
+--- @class Finding
+--- @field line integer  -- source line
+--- @field msg  string   -- finding message
+
+--- @class AnnotationResult
+--- @field source   string         -- set by this pass; original source path
+--- @field atoms    AtomEntry[]    -- atom declarations in this source
+--- @field annots   AnnotEntry[]   -- annotation entries
+--- @field macros   MacroEntry[]   -- macro word-count declarations
+--- @field binds    BindsStruct[]  -- Binds_* struct declarations
+--- @field errors   Finding[]      -- errors from validation
+--- @field warnings Finding[]      -- warnings from validation
+--- @field info     table          -- info summary (not rendered here)
+
+--- @class ModuleEntry
+--- @field dir          string   -- absolute directory path
+--- @field dir_basename string   -- basename (e.g. "duffle", "gte_hello")
+--- @field atoms_count  integer  -- pre-counted atoms for filtering
+
+--- @class ModuleReport
+--- @field dir       string             -- module directory
+--- @field sources   SourceFile[]       -- sources in this module
+--- @field results   AnnotationResult[] -- per-source validate() results
+
+--- @class ProjectReport
+--- @field results AnnotationResult[]  -- all per-source results
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-MODULE annotation report (aggregated across all sources in a dir)
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Extract the basename (last path segment) of a forward- or back-slash separated path. Returns the input unchanged if no separator is found.
+--- @param path string
+--- @return string
+local function source_basename(path)
+	return path:match(BASENAME_PATTERN) or path
 end
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
-package.path   = script_dir .. "../?.lua;" .. script_dir .. "../?/init.lua;" .. script_dir .. "?.lua;" .. package.path
 
-local duffle        = require("duffle")
+--- (internal) Format a single annotation entry as one rendered line.
-local ensure_dir    = duffle.ensure_dir
+--- @param a AnnotEntry
-local write_file    = duffle.write_file
+--- @param src_name string
-
+--- @return string
--- ════════════════════════════════════════════════════════════════════════════
+local function format_annot_line(a, src_name)
--- Per-source annotation report (ported from tape_atom_annotation_pass.lua:1411-1486)
--- ════════════════════════════════════════════════════════════════════════════
-
-local function render_source_report(source_path, result)
-	local lines = {}
-	local function add(s) lines[#lines + 1] = s end
-
-	add("========================================================")
-	add("ANNOTATION PASS — " .. source_path)
-	add("========================================================")
-	add("")
-	add(string.format("Atoms: %d   Annotations: %d   Pragmas: %d   Binds structs: %d   Macro decls: %d",
-		#result.atoms, #result.annots,
-		(result.pragmas and #result.pragmas or 0),
-		#result.binds, #result.macros))
-	add("")
-
-	add("── Atoms ────────────────────────────────────────────────")
-	for _, a in ipairs(result.atoms) do
-		add(string.format("  MipsAtom_(%s)   line %d", a.name, a.line))
-	end
-	add("")
-
-	add("── Annotations ──────────────────────────────────────────")
-	for _, a in ipairs(result.annots) do
 	if a.error then
-			add(string.format("  ✗ line %d  %s  [ERROR: %s]", a.line, a.macro or "?", a.error))
+		return string.format("  ✗ line %d  %s  [ERROR: %s]  [%s]", a.line, a.macro or "?", a.error, src_name)
-		else
+	end
-			local line = string.format("  %s  line %d  %s  phase=%s",
+	local line = string.format("  ●  line %d  %s  [%s]", a.line, a.name, src_name)
-				a.kind == "work" and "●" or (a.kind == "bind" and "◆" or "○"),
-				a.line, a.name, a.phase or a.kind)
 	if a.binds       then line = line .. "  binds="   .. a.binds end
 	if #a.reads  > 0 then line = line .. "  reads={"  .. table.concat(a.reads,  ",") .. "}" end
 	if #a.writes > 0 then line = line .. "  writes={" .. table.concat(a.writes, ",") .. "}" end
-			add(line)
+	return line
+end
+
+--- (internal) Tally totals across all results in a module.
+--- @param results AnnotationResult[]
+--- @return integer, integer, integer, integer, integer, integer
+local function tally_module_totals(results)
+	local total_atoms, total_annots, total_binds, total_macros = 0, 0, 0, 0
+	local total_errors, total_warnings = 0, 0
+	for _, r in ipairs(results) do
+		total_atoms    = total_atoms    + #r.atoms
+		total_annots   = total_annots   + #r.annots
+		total_binds    = total_binds    + #r.binds
+		total_macros   = total_macros   + #r.macros
+		total_errors   = total_errors   + #r.errors
+		total_warnings = total_warnings + #r.warnings
+	end
+	return total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings
+end
+
+-- (internal) Section renderer: per-source atom declarations.
+local function render_module_atoms_section(add, results)
+	add(SECTION_HEADER_ATOMS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, a in ipairs(r.atoms) do
+			add(string.format("  MipsAtom_(%s)   line %d   [%s]", a.name, a.line, src_name))
 		end
 	end
 	add("")
+end
 
-	add("── Binds_* structs ──────────────────────────────────────")
+-- (internal) Section renderer: per-source annotation entries.
-	for _, b in ipairs(result.binds) do
+local function render_module_annots_section(add, results)
-		add(string.format("  %s   line %d   %d bytes", b.name, b.line, b.bytes))
+	add(SECTION_HEADER_ANNOTS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, a in ipairs(r.annots) do
+			add(format_annot_line(a, src_name))
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source Binds_* struct declarations.
+local function render_module_binds_section(add, results)
+	add(SECTION_HEADER_BINDS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, b in ipairs(r.binds) do
+			add(string.format("  %s   line %d   %d bytes   [%s]", b.name, b.line, b.bytes, src_name))
 			for _, f in ipairs(b.fields) do
 				add(string.format("    +%2d: %s", f.offset, f.name))
 			end
 		end
-	add("")
-
-	add("── Macro word-count declarations ─────────────────────────")
-	for _, m in ipairs(result.macros) do
-		add(string.format("  %s  line %d  words=%d", m.name, m.line, m.words))
 	end
 	add("")
+end
 
-	add("── Atom pragmas (resource / region / group / cadence / async) ─")
+-- (internal) Section renderer: per-source macro word-count declarations.
-	if not result.pragmas or #result.pragmas == 0 then add("  (none)") end
+local function render_module_macros_section(add, results)
-	for _, p in ipairs(result.pragmas or {}) do
+	add(SECTION_HEADER_MACROS)
-		local kvs = {}
+	for _, r in ipairs(results) do
-		for k, v in pairs(p.attrs) do kvs[#kvs + 1] = k .. "=" .. v end
+		local src_name = source_basename(r.source)
-		table.sort(kvs)
+		for _, m in ipairs(r.macros) do
-		add(string.format("  ◇ line %d  %s  {%s}", p.line, p.name, table.concat(kvs, ", ")))
+			add(string.format("  %s  line %d  words=%d  [%s]", m.name, m.line, m.words, src_name))
+		end
 	end
 	add("")
+end
 
-	add("── Errors ──────────────────────────────────────────────")
+-- (internal) Section renderer: per-source errors (one-line + "(none)" if empty).
-	if #result.errors == 0 then add("  (none)") end
+local function render_module_errors_section(add, results, total_errors)
-	for _, e in ipairs(result.errors) do
+	add(SECTION_HEADER_ERRORS)
-		add(string.format("  ✗ line %d  %s", e.line, e.msg))
+	if total_errors == 0 then
+		add("  (none)")
+	else
+		for _, r in ipairs(results) do
+			local src_name = source_basename(r.source)
+			for _, e in ipairs(r.errors) do
+				add(string.format("  ✗ line %d  %s  [%s]", e.line, e.msg, src_name))
+			end
+		end
 	end
 	add("")
+end
 
-	add("── Warnings ────────────────────────────────────────────")
+-- (internal) Section renderer: per-source warnings (one-line + "(none)" if empty).
-	if #result.warnings == 0 then add("  (none)") end
+local function render_module_warnings_section(add, results, total_warnings)
-	for _, w in ipairs(result.warnings) do
+	add(SECTION_HEADER_WARNINGS)
-		add(string.format("  ⚠ line %d  %s", w.line, w.msg))
+	if total_warnings == 0 then
+		add("  (none)")
+	else
+		for _, r in ipairs(results) do
+			local src_name = source_basename(r.source)
+			for _, w in ipairs(r.warnings) do
+				add(string.format("  ⚠ line %d  %s  [%s]", w.line, w.msg, src_name))
+			end
+		end
 	end
 	add("")
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- SECTION_RENDERERS — data-driven section dispatch (the plex pattern)
+-- ════════════════════════════════════════════════════════════════════════════
+--
+-- Each entry maps a section to its (header, render_fn). The render_fn signature:
+--   render_fn(add, results, totals)
+--     add    -- the `add(line)` closure from the surrounding report renderer
+--     results -- AnnotationResult[] (per-source results)
+--     totals -- {atoms, annots, binds, macros, errors, warnings} counts
+--
+-- Sections that need to render "(none)" vs iterate use totals.errors / totals.warnings;
+-- other sections ignore the totals arg.
+-- Adding a new section = 1 row here + 1 render_<thing>_section function.
+local SECTION_RENDERERS = {
+	{ header = SECTION_HEADER_ATOMS,    render = render_module_atoms_section     },
+	{ header = SECTION_HEADER_ANNOTS,   render = render_module_annots_section    },
+	{ header = SECTION_HEADER_BINDS,    render = render_module_binds_section     },
+	{ header = SECTION_HEADER_MACROS,   render = render_module_macros_section    },
+	{ header = SECTION_HEADER_ERRORS,   render = function(add, results, totals) return render_module_errors_section(add, results, totals.errors)   end },
+	{ header = SECTION_HEADER_WARNINGS, render = function(add, results, totals) return render_module_warnings_section(add, results, totals.warnings) end },
+}
+
+--- Render the per-MODULE annotation report (one `<dir_basename>.annotations.txt`).
+--- @param dir string                  -- module directory path
+--- @param sources SourceFile[]        -- sources in this module
+--- @param results AnnotationResult[]  -- per-source validate() results
+--- @return string                     -- the rendered report text
+local function render_module_report(dir, sources, results)
+	local lines = {}
+	local function add(s) lines[#lines + 1] = s end
+
+	add(RULE_THICK)
+	add("ANNOTATION PASS — module " .. source_basename(dir))
+	add(RULE_THICK)
+	add(string.format("Sources: %d", #sources))
+	for _, s in ipairs(sources) do add("  " .. s.path) end
+	add("")
+
+	local total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings = tally_module_totals(results)
+	add(string.format("Atoms: %d   Annotations: %d   Binds structs: %d   Macro decls: %d",
+		total_atoms, total_annots, total_binds, total_macros))
+	add("")
+
+	-- Bundle the totals so the section renderers don't need separate parameter lists.
+	-- Errors/warnings sections need their total count to decide "(none)" vs iterate.
+	-- Sections without totals (atoms/annots/binds/macros) ignore this arg.
+	local totals = {
+		atoms    = total_atoms,  annots = total_annots,  binds  = total_binds,
+		macros   = total_macros, errors = total_errors,  warnings = total_warnings,
+	}
+
+	-- THE per-section dispatch. ONE loop over SECTION_RENDERERS.
+	-- Each renderer writes its header + content via the `add` closure (pre-bound above).
+	-- Adding a new section = 1 row here + 1 render_<thing>_section function.
+	for _, section in ipairs(SECTION_RENDERERS) do
+		section.render(add, results, totals)
+	end
 
 	return table.concat(lines, "\n") .. "\n"
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Per-project summary (ported from tape_atom_annotation_pass.lua:1488-1528)
+-- Per-project summary
 -- ════════════════════════════════════════════════════════════════════════════
 
+--- Render the per-project summary (`build/gen/annotation_validation.txt`).
+--- Aggregates totals across all sources; lists per-source error counts if any source has errors.
+--- @param all_results AnnotationResult[]
+--- @return string
 local function render_project_report(all_results)
 	local lines = {}
 	local function add(s) lines[#lines + 1] = s end
 
 	local total_atoms, total_annots, total_macros, total_binds = 0, 0, 0, 0
 	local total_errors, total_warnings = 0, 0
-
 	for _, r in ipairs(all_results) do
 		total_atoms    = total_atoms    + #r.atoms
 		total_annots   = total_annots   + #r.annots
@@ -128,9 +347,9 @@ local function render_project_report(all_results)
 		total_warnings = total_warnings + #r.warnings
 	end
 
-	add("========================================================")
+	add(RULE_THICK)
 	add("ANNOTATION VALIDATION — project summary")
-	add("========================================================")
+	add(RULE_THICK)
 	add("")
 	add(string.format("Atoms:        %d", total_atoms))
 	add(string.format("Annotations:  %d", total_annots))
@@ -145,7 +364,8 @@ local function render_project_report(all_results)
 		add("Per-source error counts:")
 		for _, r in ipairs(all_results) do
 			if #r.errors > 0 then
-				add(string.format("  %s : %d error(s)", r.source, #r.errors))
+				local src_name = source_basename(r.source)
+				add(string.format("  %s : %d error(s)", src_name, #r.errors))
 			end
 		end
 		add("")
@@ -155,13 +375,59 @@ local function render_project_report(all_results)
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- M.run — orchestrator entry
+-- Orchestration helpers
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class M
+--- (internal) Re-validate every source in a directory against the canonical corpus projection.
+--- Calls `annotation.validate()` per source to produce the per-source AnnotationResult (atoms / annots / macros / binds / errors / warnings)
+--- that the report renderer consumes. Eeach report pass run is reproducible from the corpus.
+--- Returns the list of module results + the flat list of all results (for the project-wide summary).
+--- @param ctx PassCtx
+--- @param dir_sources SourceFile[]
+--- @return AnnotationResult[], AnnotationResult[]
+local function lookup_module_results(ctx, dir_sources)
+	local module_results = {}
+	local all_results    = {}
+	for _, src in ipairs(dir_sources) do
+		if src.scan then
+			local result = annotation.validate(ctx, src, nil)
+			result.source = src.path                                    -- tag for downstream rendering
+			module_results[#module_results + 1] = result
+			all_results[#all_results + 1] = result
+		end
+	end
+	return module_results, all_results
+end
+
+--- (internal) Does this module's results contain anything worth emitting?
+--- @param module_results AnnotationResult[]
+--- @return boolean
+local function module_has_content(module_results)
+	for _, r in ipairs(module_results) do
+		if #r.atoms  > 0 or #r.annots > 0 or #r.binds    > 0
+		or #r.macros > 0 or #r.errors > 0 or #r.warnings > 0 then
+			return true
+		end
+	end
+	return false
+end
+
+--- (internal) Log a debug message if `_G[DEBUG_FLAG]` is truthy.
+--- @param fmt string
+local function debug_log(fmt, ...)
+	if _G[DEBUG_FLAG] then
+		io.stderr:write(string.format("[%s] " .. fmt, PASS_NAME, ...))
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M — module exports
+-- ════════════════════════════════════════════════════════════════════════════
 
 local M = {}
 
+--- Run the report pass. 
+--- Renders one `<dir_basename>.annotations.txt` per source-directory that has content, plus the project-wide `annotation_validation.txt` summary.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -169,36 +435,38 @@ function M.run(ctx)
 	local errors   = {}
 	local warnings = {}
 
-	-- The annotation pass stashes per-source results in ctx.flags._annot_results.
+	-- Module grouping comes from `corpus.sources_by_dir` (the canonical projection).
-	-- Render each as build/gen/<basename>.annotations.txt and aggregate into
+	-- Iterate it directly; no private cache, no per-pass stash.
-	-- build/gen/annotation_validation.txt.
+	local corpus = ctx.shared and ctx.shared.corpus
-	local annot_results = (ctx.flags and ctx.flags._annot_results) or {}
+	local by_dir = (corpus and corpus.sources_by_dir) or {}
 
-	-- Render per-source reports.
+	duffle.ensure_dir(ctx.out_root)
-	for _, entry in ipairs(annot_results) do
+
-		local src = entry.source
+	local all_results_for_summary = {}
-		local result = entry.result
+	for dir, dir_sources in pairs(by_dir) do
-		local out_path = ctx.out_root .. "/" .. src.basename .. ".annotations.txt"
+		local dir_basename = dir:match("([^/\\]+)$") or dir
-		if not ctx.dry_run then
+		debug_log("dir=%s basename=%s sources=%d\n", dir, dir_basename, #dir_sources)
-			ensure_dir(ctx.out_root)
+
-			write_file(out_path, render_source_report(src.path, result))
+		if #dir_sources > 0 then
-		end
+			local module_results, all_results = lookup_module_results(ctx, dir_sources)
-		table.insert(outputs, { annotations_txt = out_path })
+			for _, r in ipairs(all_results) do
+				all_results_for_summary[#all_results_for_summary + 1] = r
 			end
 
-	-- Render project summary.
+			if module_has_content(module_results) then
-	if not ctx.dry_run then
+				local out_path = ctx.out_root .. "/" .. dir_basename .. ".annotations.txt"
-		-- The project report references each source by its absolute path.
+				duffle.write_file(out_path, render_module_report(dir, dir_sources, module_results))
-		-- Augment the entries with a .source field for the per-source error counts.
+				outputs[#outputs + 1] = { annotations_txt = out_path }
-		local all_results = {}
+			else
-		for _, entry in ipairs(annot_results) do
+				debug_log("  -> no content; skipping\n")
-			entry.result.source = entry.source.path
-			table.insert(all_results, entry.result)
 			end
-		ensure_dir(ctx.out_root)
+		end
+	end
+
+	if #all_results_for_summary > 0 then
 		local summary_path = ctx.out_root .. "/annotation_validation.txt"
-		write_file(summary_path, render_project_report(all_results))
+		duffle.write_file(summary_path, render_project_report(all_results_for_summary))
-		table.insert(outputs, { summary_txt = summary_path })
+		outputs[#outputs + 1] = { summary_txt = summary_path }
 	end
 
 	return { outputs = outputs, errors = errors, warnings = warnings }

scripts/passes/word_count_eval.lua

@@ -0,0 +1,128 @@
+--- word_count_eval.lua — Word-counting logic for the tape-atom metaprogram pipeline.
+---
+--- Two responsibilities:
+---   1. **Public utility** `M.count_token_words(token, wc)`: Used by `passes/offsets.lua`, `passes/annotation.lua`, and other passes.
+---   2. **Pass entry** `M.run(ctx)`: Loads the authored `word_count.metadata.h` into `ctx.shared.corpus.word_counts` for downstream passes.
+---      The generated `.macs.h` files are OUTPUT artifacts and are NOT inputs to this pass;
+---      Current component counts are owned by `passes/components.lua` (which populates `corpus.word_counts` and `corpus.component_body_index`
+---      AFTER computing each current count from the just-built body + `corpus.word_counts`).
+---
+--- **Canonical contract**:
+---   * `ctx.shared.corpus.word_counts` is the count table.
+---   * `corpus.word_counts` is the sole count table. Consumers read `corpus.word_counts` directly.
+---   * `ctx.shared.components` and `ctx.shared.component_body_index` are NOT created by this pass (projections only).
+---   * No `.macs.h` recursive discovery (no `scan_dir`, no scan cache, no `_invalidate_scan_cache`).
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module-scope requires + package.path setup
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
+-- Uses `debug.getinfo` to find this file's own directory, so it works both standalone and when require'd from the orchestrator.
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class WordCounts
+--- @field [string] integer  -- macro name -> word count
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+
+--- @class PassCtx
+--- @field sources            SourceFile[]  -- all source files in the build
+--- @field metadata_path      string        -- path to word_count.metadata.h
+--- @field shared             table         -- cross-pass shared state
+--- @field shared.corpus      table         -- canonical corpus (required)
+--- @field shared.corpus.word_counts WordCounts -- canonical count table (populated by this pass)
+--- @field out_root           string        -- output root (e.g. "build/gen")
+--- @field project_root       string        -- project root (e.g. "code/")
+--- @field upstream           table<string, table>  -- per-pass upstream outputs
+--- @field flags              table         -- CLI flags
+--- @field verbose            boolean       -- if true, log diagnostic info
+
+--- @class PassResult
+--- @field outputs  table[]  -- {kind=, path=} entries describing emit files
+--- @field errors   table[]  -- {line=, msg=} entries; build-stops
+--- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module exports
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+-- ┌────────────────────────────────────────────────────────────────────┐
+-- │ Shared utility: count_token_words                                  │
+-- └────────────────────────────────────────────────────────────────────┘
+
+--- Count words emitted by a single comma-separated token inside an atom body.
+--- For most tokens (regular MIPS instructions) this returns 1.
+--- For `mac_X(...)` calls, this returns the resolved word count from `wc` (recursively if needed). For `nop2` etc., returns wc[name].
+--- For unknown macros, returns 1 and (optionally) warns.
+--- @param token string     -- a single token from split_top_level_commas
+--- @param wc    WordCounts -- the shared word-count table
+--- @return integer
+function M.count_token_words(token, wc)
+	local s = duffle.trim(token)
+	if    s == "" then return 0 end
+	local name, after = duffle.read_ident(s, 1)
+	if not name then return 1 end
+	if wc[name] then return wc[name] end
+	local paren_pos = duffle.skip_ws_and_cmt(s, after)
+	if s:sub(paren_pos, paren_pos) == "(" then
+		io.stderr:write("  warning: unknown macro '" .. name .. "', assuming 1 word\n")
+	end
+	return 1
+end
+
+-- ┌────────────────────────────────────────────────────────────────────┐
+-- │ Pass entry: M.run(ctx) — "word-counts" pass                        │
+-- └────────────────────────────────────────────────────────────────────┘
+
+--- Load the authored `word_count.metadata.h` into `ctx.shared.corpus.word_counts`.
+--- Generated `.macs.h` files are OUTPUT artifacts and are NOT scanned as inputs.
+--- Current component counts are computed and inserted by `passes/components.lua`
+--- after the components pass iterates `corpus.source_order` and writes each source's `<dir_basename>.macs.h` file.
+---
+--- Contract:
+---   * `ctx.shared.corpus` MUST exist (canonical corpus ownership).
+---   * `ctx.metadata_path` MUST be a readable file path to the authored `word_count.metadata.h`.
+---   * The pass assigns exactly one table to `corpus.word_counts`.
+---     Consumers read the corpus-owned table directly.
+---     Consumers must read `corpus.word_counts` directly.
+--- @param ctx PassCtx
+--- @return PassResult
+function M.run(ctx)
+	-- 1. Canonical-corpus ownership gate.
+	local corpus = ctx.shared and ctx.shared.corpus
+	if type(corpus) ~= "table" then
+		error("word_count_eval.run requires ctx.shared.corpus (canonical corpus). The fixture must install the corpus before running this pass.", 0)
+	end
+
+	-- 2. metadata_path gate.
+	if type(ctx.metadata_path) ~= "string" or ctx.metadata_path == "" then
+		error("word_count_eval.run requires ctx.metadata_path (path to the authored word_count.metadata.h).", 0)
+	end
+
+	-- 3. Load authored metadata. Generated .macs.h files are NOT scanned
+	--    (the pass computes their counts from the just-built bodies after disk emission; see passes/components.lua).
+	local wc = duffle.load_word_counts(ctx.metadata_path)
+
+	-- 4. Assign the count table. ONE assignment, no copy. The assignment creates no secondary alias.
+	corpus.word_counts = wc
+
+	return { outputs = {}, errors = {}, warnings = {} }
+end
+
+return M

scripts/pcsx_debug_helper/autoexec.lua

@@ -0,0 +1,51 @@
+-- autoexec.lua - pcsx_debug_helper plugin entry point.
+-- Packaged in scripts/pcsx_debug_helper.zip. Loaded by pcsx-redux via the -archive CLI flag (see scripts/launch_pcsx_debug.ps1).
+--
+-- Registers two web handlers for external CLI tools:
+--   /api/v1/lua/gte - full GTE state (32 data + 32 control regs + PC)
+--   /api/v1/lua/gp  - GP state summary (screenshot endpoint + VRAM endpoint refs)
+--
+-- The GTE handler reads COP2 regs via PCSX.getRegisters().CP2D/CP2C.
+-- The pcsx-redux gdb stub doesn't expose COP2, so this is the only way for external tools to see GTE state.
+--
+-- The GP handler is a thin pointer: 
+-- pcsx-redux's Lua API exposes only PCSX.GPU.takeScreenShot() (no GPUSTAT, no GP0/GP1 command log, no display state). For richer GP state, the existing web endpoints are the practical path:
+--   /api/v1/state/still      - PNG screenshot
+--   /api/v1/gpu/vram/raw     - VRAM raw bytes (1MB)
+--
+-- Companion: scripts/gdb/gdb_tape_atoms.gdb (covers GPRs + atom-aware stepping).
+
+local function register_handlers()
+    if not PCSX.WebServer then PCSX.WebServer = {} end
+    if not PCSX.WebServer.Handlers then PCSX.WebServer.Handlers = {} end
+
+    -- ── GTE state ──
+    PCSX.WebServer.Handlers.gte = function(req)
+        local r = PCSX.getRegisters()
+        local out = { "pc=0x" .. string.format("%x", r.pc) }
+        for i = 0, 31 do
+            out[#out + 1] = string.format("D[%d]=0x%08x C[%d]=0x%08x",
+                i, r.CP2D.r[i], i, r.CP2C.r[i])
+        end
+        return table.concat(out, "\n")
+    end
+
+		-- ── GP state (pointer to existing endpoints) ──
+		-- pcsx-redux's Lua GPU API exposes only takeScreenShot(); no GPUSTAT / GP0 / GP1 command log / display state.
+		-- We point to the existing web endpoints that DO expose those (when the emulator is actually rendering. Paused-at-BP frames won't have a fresh frame).
+    PCSX.WebServer.Handlers.gp = function(req)
+        local out = {
+            "gpu_screenshot_png=http://localhost:8080/api/v1/state/still",
+            "vram_raw=http://localhost:8080/api/v1/gpu/vram/raw (1MB VRAM)",
+            "gpustat=NOT_AVAILABLE_VIA_LUA",
+            "gp_command_log=NOT_AVAILABLE_VIA_LUA (use pcsx-redux Debug > GPU Logger)",
+            "hint_run_emulator_unpaused_for_screenshot",
+        }
+        return table.concat(out, "\n")
+    end
+end
+
+local ok, err = pcall(register_handlers)
+if ok then print("[pcsx_debug_helper] handlers registered: gte, gp")
+else       print("[pcsx_debug_helper] registration failed: " .. tostring(err))
+end

scripts/update_deps.ps1

@@ -4,25 +4,24 @@ $path_code      = join-path $path_root 'code'
 $path_scripts   = join-path $path_root 'scripts'
 $path_toolchain = join-path $path_root 'toolchain'
 
+# Halt on any error (instead of PowerShell's default `Continue`).
+$ErrorActionPreference = 'Stop'
+
 $misc = join-path $PSScriptRoot 'helpers/misc.ps1'
 . $misc
 
-# TODO(Ed): Review usage of these deps
-# I orgiinally cloned them when starting to get to the C runtime usage of the course
-# However, based on the heavy reliance of the PSX.Dev extension I might fallback; also
-# The gdb server doesn't need the full repo and were only using the src/mips 
-# which has a standalone repo (nuggets)
-# armips may not be used at all but I'm not sure...
-
 $url_armips     = 'https://github.com/Kingcom/armips.git'
 $url_pcsx_redux = 'https://github.com/grumpycoders/pcsx-redux.git'
 $url_psyq_iwyu  = 'https://github.com/johnbaumann/psyq_include_what_you_use.git'
+$url_lpeg       = 'https://github.com/roberto-ieru/LPeg.git'
 
 $path_armips     = join-path $path_toolchain 'armips'
 $path_pcsx_redux = join-path $path_toolchain 'pcsx-redux'
 $path_psyq_iwyu  = join-path $path_toolchain 'psyq_iwyu'
+$path_lpeg       = join-path $path_toolchain 'lpeg'
 
 clone-gitrepo $path_armips     $url_armips
+clone-gitrepo $path_lpeg       $url_lpeg
 clone-gitrepo $path_pcsx_redux $url_pcsx_redux
 clone-gitrepo $path_psyq_iwyu  $url_psyq_iwyu
 
@@ -37,3 +36,83 @@ pop-location
 # $path_pcsx_redux_binaries   = join-path $path_pcsx_redux_vsprojects 'x64/Release'
 
 # $psyq_obj_parser = join-path $path_pcsx_redux_binaries 'psyq-obj-parser.exe'
+
+# ════════════════════════════════════════════════════════════════════════════
+# PCSX-Redux — built via MSBuild (VS2022)
+# Requires: Visual Studio 2022 with the C++ desktop workload.
+# Output: toolchain\pcsx-redux\vsprojects\x64\Debug\pcsx-redux.exe
+# ════════════════════════════════════════════════════════════════════════════
+
+# Locate MSBuild from the VS2022 install (no hardcoded path — uses vswhere).
+$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+if (-not (Test-Path $vswhere)) {
+	write-error "vswhere not found at '$vswhere'. Install Visual Studio 2022 with the C++ desktop workload."
+	exit 1
+}
+$msbuild_exe = & $vswhere -latest -products * -requires Microsoft.Component.MSBuild -find "MSBuild\**\Bin\MSBuild.exe" 2>$null | Select-Object -First 1
+if (-not $msbuild_exe) {
+	write-error "MSBuild not found via vswhere. Install Visual Studio 2022 with the C++ desktop workload."
+	exit 1
+}
+
+$path_pcsx_sln = join-path $path_pcsx_redux 'vsprojects\pcsx-redux.sln'
+&	$msbuild_exe $path_pcsx_sln /p:Configuration=Release /p:Platform=x64 /p:PlatformToolset=v143 /m /v:minimal
+
+# Locate luajit via scoop. `luajit.exe` is on PATH via scoop's shim;
+# we use `scoop prefix` to find the install root for the include dir (needed to compile lpeg against luajit's headers).
+# If scoop or luajit is missing, fail fast with an actionable message.
+$luajit_prefix = & scoop prefix luajit 2>$null
+if (-not $luajit_prefix -or -not (Test-Path (Join-Path $luajit_prefix 'bin/luajit.exe'))) {
+	write-error "luajit not found via 'scoop prefix luajit'. Install via: scoop install luajit"
+	exit 1
+}
+
+# Discover the luajit include dir by globbing `include/luajit-*`.
+# This avoids hardcoding a specific version (e.g. `luajit-2.1`).
+$luajit_include_root = Join-Path $luajit_prefix 'include'
+$lua_inc_dir = Get-ChildItem -Path $luajit_include_root -Directory -Filter 'luajit-*' -ErrorAction SilentlyContinue |
+	Select-Object -First 1 -ExpandProperty FullName
+if (-not $lua_inc_dir) {
+	write-error "No 'luajit-*' include dir found under '$luajit_include_root'. The scoop luajit install may be broken."
+	exit 1
+}
+
+# Generate lpeg.dll by compiling the 6 source files directly.
+# `gcc` is on PATH (scoop's shim puts it there).
+# The source files: lpcap.c lpcode.c lpcset.c lpprint.c lptree.c lpvm.c
+# Link against luajit's import library (`libluajit-5.1.a`) for the Lua C API symbols (lua_*, luaL_*).
+$luajit_lib_dir = Join-Path $luajit_prefix 'lib'
+$lpeg_sources = @('lpcap.c', 'lpcode.c', 'lpcset.c', 'lpprint.c', 'lptree.c', 'lpvm.c')
+$lpeg_compile_args = @(
+	'-O2', '-shared',
+	"-I$lua_inc_dir",
+	"-L$luajit_lib_dir",
+	'-o', 'lpeg.dll'
+) + $lpeg_sources + @('-lluajit-5.1')
+push-location $path_lpeg
+&	gcc @lpeg_compile_args
+pop-location
+
+# ════════════════════════════════════════════════════════════════════════════
+# lfs (LuaFileSystem) — compiled from pcsx-redux's vendored luafilesystem source.
+# Source: toolchain/pcsx-redux/third_party/luafilesystem/src/lfs.c
+# Output: toolchain/lfs/lfs.dll
+# ════════════════════════════════════════════════════════════════════════════
+
+$path_lfs = join-path $path_toolchain 'lfs'
+verify-path $path_lfs
+$lfs_src = join-path $path_pcsx_redux 'third_party\luafilesystem\src\lfs.c'
+$lfs_dll = join-path $path_lfs 'lfs.dll'
+$lfs_dll_import = join-path $luajit_lib_dir 'libluajit-5.1.dll.a'
+& gcc -O2 -shared "-I$lua_inc_dir" -o $lfs_dll $lfs_src $lfs_dll_import
+
+# ════════════════════════════════════════════════════════════════════════════
+# OpenBIOS — built from the PCSX-Redux source tree via make + mipsel-none-elf
+# Output: toolchain\pcsx-redux\src\mips\openbios\openbios.bin
+# ════════════════════════════════════════════════════════════════════════════
+
+$path_openbios = join-path $path_pcsx_redux 'src\mips\openbios'
+push-location $path_openbios
+&	make clean
+&	make
+pop-location

scripts/word_count_eval.lua

@@ -1,246 +0,0 @@
--- word_count_eval.lua
---
--- Word-counting logic for the tape-atom metaprogram pipeline.
--- Used by:
---   - passes/components.lua (compute_component_word_count)
---   - passes/offsets.lua    (scan_atom_body)
---   - passes/annotation.lua (TAPE_WORDS <-> WORD_COUNT drift check)
---
--- This module ALSO exposes M.run(ctx) — the "word-counts" pass entry in
--- the PASSES table — which loads metadata.h + scans for existing
--- *.macs.h files into ctx.shared.word_counts.
---
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex,
--- Lua 5.3 compatible.
-
--- ════════════════════════════════════════════════════════════════════════════
--- Module-scope requires + package.path setup
--- ════════════════════════════════════════════════════════════════════════════
-
-local script_path = arg and arg[0] or "?"
-local last_sep = 0
-for i = 1, #script_path do
-	local c = script_path:sub(i, i)
-	if c == "/" or c == "\\" then last_sep = i end
-end
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
-package.path   = script_dir .. "?.lua;" .. script_dir .. "?/init.lua;" .. package.path
-package.cpath = "C:\\projects\\Pikuma\\ps1\\toolchain\\luajit-2.1\\lib\\lua\\5.1\\?.dll;" .. package.cpath
-
-local duffle = require("duffle")
-local trim              = duffle.trim
-local read_ident        = duffle.read_ident
-local skip_ws_and_cmt   = duffle.skip_ws_and_cmt
-local load_word_counts  = duffle.load_word_counts
-local split_top_level_commas = duffle.split_top_level_commas
-local is_space          = duffle.is_space
-
--- ════════════════════════════════════════════════════════════════════════════
--- Type declarations
--- ════════════════════════════════════════════════════════════════════════════
-
---- @class WordCounts
---- @field [string] integer  -- macro name -> word count
-
---- @class PassCtx
---- @field sources            SourceFile[]
---- @field metadata_path      string
---- @field shared             table
---- @field shared.word_counts WordCounts
---- @field out_root           string
---- @field project_root       string
---- @field upstream           table<string, table>
---- @field flags              table
---- @field dry_run            boolean
---- @field verbose            boolean
-
---- @class PassResult
---- @field outputs  table[]
---- @field errors   table[]
---- @field warnings table[]
-
---- @class SourceFile
---- @field path     string
---- @field text     string
---- @field dir      string
---- @field basename string
-
--- ════════════════════════════════════════════════════════════════════════════
--- Module exports
--- ════════════════════════════════════════════════════════════════════════════
-
-local M = {}
-
--- ┌────────────────────────────────────────────────────────────────────┐
--- │ Shared utility: count_token_words                                  │
--- └────────────────────────────────────────────────────────────────────┘
-
---- Count words emitted by a single comma-separated token inside an atom body.
---- For most tokens (regular MIPS instructions) this returns 1.
---- For `mac_X(...)` calls, this returns the resolved word count from `wc`
---- (recursively if needed). For `nop2` etc., returns wc[name].
---- For unknown macros, returns 1 and (optionally) warns.
----
---- PORT NOTE: taken verbatim from tape_atom.offset_gen.meta.lua:130-141
---- (`word_count_of_token`). Behavior is identical to preserve the
---- branch-offset fix from commit 98e27c2.
----
---- @param token string        -- a single token from split_top_level_commas
---- @param wc WordCounts       -- the shared word-count table
---- @return integer
-function M.count_token_words(token, wc)
-	local s = trim(token)
-	if s == "" then return 0 end
-	local name, after = read_ident(s, 1)
-	if not name then return 1 end
-	if wc[name] then return wc[name] end
-	local j = skip_ws_and_cmt(s, after)
-	if s:sub(j, j) == "(" then
-		io.stderr:write("  warning: unknown macro '" .. name .. "', assuming 1 word\n")
-	end
-	return 1
-end
-
--- ┌────────────────────────────────────────────────────────────────────┐
--- │ Shared utility: scan_dir                                           │
--- └────────────────────────────────────────────────────────────────────┘
-
---- Recursively scan a directory for files matching a glob suffix.
---- No regex per the no_regex constraint — uses plain byte matching
---- via `dir /b /s` on Windows.
----
---- PORT NOTE: taken from tape_atom.offset_gen.meta.lua:432-443
---- (`scan_dir`). Adapted: removed the hardcoded project_root derivation;
---- the caller passes `dir` explicitly.
----
---- @param dir string        -- directory to scan (absolute or relative)
---- @param suffix string     -- file pattern, e.g. "*.macs.h"
---- @return string[]
-function M.scan_dir(dir, suffix)
-	local results = {}
-	local p = io.popen('dir /b /s "' .. dir .. '\\' .. suffix .. '" 2>nul')
-	if not p then return results end
-	for raw_line in p:lines() do
-		local path = raw_line:gsub("\\", "/")
-		results[#results + 1] = path
-	end
-	p:close()
-	return results
-end
-
--- ┌────────────────────────────────────────────────────────────────────┐
--- │ Shared utility: count_body_words                                   │
--- └────────────────────────────────────────────────────────────────────┘
-
---- Count words emitted by an entire atom body (a brace-delimited block).
---- Splits by top-level commas; for each token, delegates to count_token_words.
---- Handles `atom_label(name)` / `atom_offset(tag, name)` markers (record at
---- current pos, do NOT advance pos; if the marker call bundles an instruction
---- after it, count that instruction too).
----
---- PORT NOTE: taken verbatim from tape_atom.offset_gen.meta.lua:207-239
---- (`scan_atom_body`). Behavior is identical to preserve the branch-offset
---- fix from commit 98e27c2.
----
---- @param body string         -- brace-delimited atom body (without braces)
---- @param wc WordCounts       -- the shared word-count table
---- @return integer            -- total words
-function M.count_body_words(body, wc)
-	local pos = 0
-	for _, tok in ipairs(split_top_level_commas(body)) do
-		local k    = 1
-		local tlen = #tok
-		while k <= tlen and is_space(tok:sub(k, k)) do k = k + 1 end
-		local leading_ident = read_ident(tok, k)
-		if leading_ident == "atom_label" or leading_ident == "atom_offset" then
-			-- Marker call: record at current pos, do NOT advance pos.
-			-- But the source pattern may bundle the marker with the next
-			-- instruction on a new line (no top-level comma between them).
-			-- In that case, the rest of `tok` after the marker call is
-			-- a real instruction that must still be counted.
-			local marker_end = M.find_marker_call_end(tok)
-			if marker_end > 0 and marker_end < #tok then
-				local rest = trim(tok:sub(marker_end + 1))
-				if rest ~= "" then
-					local rest_words = M.count_token_words(rest, wc)
-					pos = pos + rest_words
-				end
-			end
-		else
-			pos = pos + M.count_token_words(tok, wc)
-		end
-	end
-	return pos
-end
-
---- Find the end position (just past the closing ')') of the first
---- atom_label/atom_offset call in `tok`. Returns 0 if no such call.
---- Internal helper for count_body_words.
----
---- PORT NOTE: taken from tape_atom.offset_gen.meta.lua:181-205
---- (`find_marker_call_end`).
----
---- @param tok string
---- @return integer  -- 0 if no marker call found
-function M.find_marker_call_end(tok)
-	local i   = 1
-	local len = #tok
-	while i <= len do
-		i = skip_ws_and_cmt(tok, i)
-		if i > len then break end
-		local c = tok:sub(i, i)
-		if is_space(c) then
-			i = i + 1
-		elseif c == "/" then
-			-- comment — skip past it (delegated to duffle.skip_str_or_cmt)
-			local nx = duffle.skip_str_or_cmt(tok, i)
-			if nx > i then i = nx else i = i + 1 end
-		else
-			local ident, after = read_ident(tok, i)
-			if ident == "atom_label" or ident == "atom_offset" then
-				local j = skip_ws_and_cmt(tok, after)
-				if tok:sub(j, j) == "(" then
-					local _, end_paren = duffle.read_parens(tok, j)
-					return end_paren - 1
-				end
-				return 0
-			end
-			i = after or (i + 1)
-		end
-	end
-	return 0
-end
-
--- ┌────────────────────────────────────────────────────────────────────┐
--- │ Pass entry: M.run(ctx) — "word-counts" pass                        │
--- └────────────────────────────────────────────────────────────────────┘
-
---- Load metadata.h + scan for existing *.macs.h files into
---- ctx.shared.word_counts. Loading the .macs.h files is idempotent:
---- entries from later (current-build) .macs.h files override
---- metadata.h entries of the same name.
----
---- @param ctx PassCtx
---- @return PassResult
-function M.run(ctx)
-	local wc = {}
-
-	-- 1. Load metadata.h (the encoding-macro source of truth).
-	local meta_counts = load_word_counts(ctx.metadata_path)
-	for name, count in pairs(meta_counts) do wc[name] = count end
-
-	-- 2. Scan project_root recursively for *.macs.h files (component-macro source).
-	local macs_files = M.scan_dir(ctx.project_root, "*.macs.h")
-	for _, macs_path in ipairs(macs_files) do
-		local ok, mc = pcall(load_word_counts, macs_path)
-		if ok and type(mc) == "table" then
-			for name, count in pairs(mc) do wc[name] = count end
-		end
-	end
-
-	ctx.shared.word_counts = wc
-
-	return { outputs = {}, errors = {}, warnings = {} }
-end
-
-return M