checkpoint: atom 0-1 works for resolve look at.

Need to rewrite the ps1 lua metaprogram sometime soonish. Getting too bloated... need to consolidate code paths.

In this push codebase structure is starting to get a bit more realized. Decided todo now to match Pikuma's linking module files vods beginning to reorganize its codebase as well.
Atoms & atom components are not in their on *.atom.c files. (Not calling it tape.c as I don't really bake tapes like that outside of the unity c file so far...)

The lua metaprogram has had additional features added to it yet again to avoid hardcoding module handling and supporting multiple atom files per-module.
Either after the camera or cd-rom section I'll be most likely pausing to fully refactor the metaprogram. Possibly as a full re-write to get the loc minimal.

.gitignore

@@ -20,3 +20,4 @@ toolchain/lpeg
 
 scratch
 toolchain/libpsn00b
+scripts/pcsx_debug_helper.zip

.vscode/launch.json

@@ -142,6 +142,41 @@
 				"tbreak main",
 				"continue"
 			]
+		},
+		{
+			"name": "Debug: Hello Camera!",
+			"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_camera.dwarf-injected.elf",
+			"setupCommands": [
+				{ "text": "set mi-async off" },
+				{ "text": "set remotetimeout 0" },
+				{ "text": "set logging file build/gen/hello_camera.gdb.log" },
+				{ "text": "set logging redirect on" }
+			],
+			"autorun": [
+				"monitor reset shellhalt",
+				"load build/hello_camera.dwarf-injected.elf",
+				"source scripts/gdb/gdb_tape_atoms.gdb",
+				"tbreak main",
+				"continue"
+			]
 		}
 	]
 }

code/duffle/bios.h

@@ -0,0 +1,14 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#endif
+enum {
+	bios_init_pad_2  = 0x12,
+	bios_start_pad_2 = 0x13,
+	bios_flushcache  = 0x44,
+	bios_table_addr  = 0xA0,
+	bios_btable_addr = 0xB0,
+};
+
+enum {
+	bios_pad_buffer_size = 0x22,
+};

code/duffle/dsl.atom.h

@@ -1,5 +1,5 @@
 /*
- * atom_dsl.h
+ * dsl.atom.h
  * ============================================================================
  *
  * ATOM DSL: Annotation layer for tape atoms (lottes_tape.h).
@@ -57,7 +57,6 @@
 
 #ifdef INTELLISENSE_DIRECTIVES
 #pragma once
-// #include <stdint.h>
 #endif
 
 /* ============================================================================
@@ -76,6 +75,26 @@
  * ----------------------------------------------------------------------------*/
 #define atom_reg /* atom_reg: opt the preceding enum entry into the DWARF registry */
 
+// ----------------------------------------------------------------------------
+// atom_auto_reg(atom, sym) — per-atom auto-allocated GPR binding.
+//   enum {
+//       atom_auto_reg(cube_g4_face, R_Fwdx),                // expands to: R_Fwdx = R_Fwdx_Code /* atom_auto_reg: cube_g4_face */,
+//       atom_auto_reg(cube_g4_face, R_Eye_z) atom_type(S4), // atom_type chains after
+//   };
+// (The macro IS the entire enum entry — no separate LHS=RHS. The `atom` scope is
+//  preserved in a trailing C-comment on the RHS so the Lua scanner can recover
+//  it after preprocessing strips the macro form. R_<Sym>_Code is resolved from gen/auto_reg.h which the .c file #include's before the enum declaration.)
+#define atom_auto_reg(atom, sym) sym = sym ## _Code /* atom_auto_reg: atom */
+
+// ----------------------------------------------------------------------------
+// phase_auto_reg(phase, sym) — per-phase auto-allocated GPR binding.
+//   enum {
+//       phase_auto_reg(cube_g4, R_Temp0),     // expands to: R_Temp0 = R_Temp0_Code /* phase_auto_reg: cube_g4 */,
+//       phase_auto_reg(cube_g4, R_Temp1),
+//   };
+// (Same macro-as-enum-entry form as atom_auto_reg above; the `phase` scope is preserved in a trailing C-comment on the RHS for the Lua scanner to recover.)
+#define phase_auto_reg(phase, sym) sym = sym ## _Code /* phase_auto_reg: phase */
+
 /* ============================================================================
  *   atom_info :
  *      MipsAtom_(cube_tri) atom_info(
@@ -148,12 +167,12 @@
  *   ... body ...
  *   atom_label(bounds_chk)                   ← another anchor
  *
- *   atom_offset(culling, bounds_chk)         ← resolved by gen/.offsets.h
+ *   atom_offset(culling, bounds_chk)         ← resolved by gen/offsets.h
  *
- * The metaprogram generates gen/atom_offsets.h with one #define with the offset value per atom_offset(F, T) call.
+ * The metaprogram generates gen/offsets.h with one #define with the offset value per atom_offset(F, T) call.
  * The preprocessor then expands the 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.
+ * If gen/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.

code/duffle/dsl.h

@@ -28,8 +28,9 @@
 #define internal static // internal
 
 #define asm           __asm__
-#define align_(value) __attribute__((aligned (value)))             // for easy alignment
 
+#define A_(data)      (& data)
+#define align_(value) __attribute__((aligned (value)))             // for easy alignment
 #define align_(value) __attribute__((aligned (value)))             // for easy alignment
 #define C_(type,data) ((type)(data))                               // for enforced precedence
 #define expect_(x, y) __builtin_expect(x, y)                       // so compiler knows the common path
@@ -43,7 +44,9 @@
 
 #define R_    restrict 
 #define V_    volatile 
-// Fictional, used for intiution.
+
+#pragma region Fictional //, used for intiution
+
 #define EUB_  restrict // Execute Unit Bound:    Data is siloed in the ALU Register File. The Load/Store Unit is bypassed. (Route to Execution Unit.  Keep in registers)
 #define ISO_  restrict // Isolated Provenance:   Alternative to Exu_. Guarantees electrical memory isolation, 
                        //                        unlocking the compiler’s ability to safely pack data across multiple parallel SIMD lanes (vectorization).
@@ -67,7 +70,8 @@
 #define latch_load_anchor(ptr)       //__atomic_load_n(ptr, ooo_anchor_)
 #define latch_store_drain(ptr, val)  //__atomic_store_n(ptr, val, ooo_drain_)
 #define pulse_xchg_weld(ptr, val)    //__atomic_exchange_n(ptr, val, ooo_weld_)
-//end of: Fictional.
+
+#pragma endreigon Fictional
 
 
 // R_ (restrict) establishes an "Eigen" or "Proprius" mapping.
@@ -130,8 +134,8 @@ typedef __UINT32_TYPE__ TSet_(B4);
 #define u4_v(value) C_(U4 V_*, value)
 enum { false = 0, true  = 1, true_overflow, };
 
-#define u4_lo(value) ((value) & 0xFFFFU)
-#define u4_hi(value) ((value) >> 12)
+#define u4_lo(value) (u4_(value) & 0xFFFFU)
+#define u4_hi(value) (u4_(value) >> (S_(U2) * 8))
 
 typedef void Proc_(VoidFn) (void);
 
@@ -165,6 +169,8 @@ def_signed_ops(le, <=)
 #undef def_signed_ops
 #undef def_signed_op
 
+// Unused, we arent' doing any C-like asm since we have the asm dsl. We'll keep the non-generics if we somehow do.
+#if 0
 #define def_generic_sop(op, a, ...) _Generic((a), U1:  op ## _s1, U2: op ## _s2, U4: op ## _s4) (a, __VA_ARGS__)
 #define add_s(a,b) def_generic_sop(add,a,b)
 #define sub_s(a,b) def_generic_sop(sub,a,b)
@@ -174,6 +180,7 @@ def_signed_ops(le, <=)
 #define ge_s(a,b)  def_generic_sop(ge, a,b)
 #define le_s(a,b)  def_generic_sop(le, a,b)
 #undef def_generic_sop
+#endif
 
 #define alignas                             _Alignas
 #define alignof                             _Alignof

code/duffle/gen/duffle.macs.h

@@ -1,134 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#pragma once
-#endif
-// 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_*)
-
-#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)) \
-,	jump_reg( R_AtomJmp) \
-,	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)) \
-,	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)) \
-,	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_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)
-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,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 */ \
-,	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,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_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	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.
- * Hardcoded for Poly_G4 (9 words). For Poly_F3, use ac_insert_ot_tag_f3. */
-#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,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 */ \
-,	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,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_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
-WORD_COUNT(mac_insert_ot_tag_g4, 11)
-
-/* atom_dbg_skip */
-#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(...) \
-	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))
-WORD_COUNT(mac_gte_store_f3, 3)
-
-#define mac_format_g4_color(r0, g0, b0, r1, g1, b1, r2, g2, b2, r3, g3, b3) \
-	mac_pack_color_word(O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0) \
-,	mac_pack_color_word(O_(Poly_G4,c1), 0,               r1,g1,b1) \
-,	mac_pack_color_word(O_(Poly_G4,c2), 0,               r2,g2,b2) \
-,	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, SXY2=v2.screen). 
- * 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). */
-#define mac_gte_store_g4_p012(...) \
-	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))
-WORD_COUNT(mac_gte_store_g4_p012, 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 earlier RTPT.
- */
-#define mac_gte_store_g4_p3(...) \
-	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3))
-WORD_COUNT(mac_gte_store_g4_p3, 1)
-

code/duffle/gen/duffle.offsets.h

@@ -1,9 +0,0 @@
-// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT
-// Source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
-#pragma once
-
-#pragma region lottes_tape
-
-
-#pragma endregion lottes_tape
-

code/duffle/gen/macs.h

@@ -0,0 +1,247 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#pragma once
+#endif
+// Auto-generated by ps1_meta.lua — DO NOT EDIT
+// Directory: C:\projects\Pikuma\ps1\code\duffle/
+//   source: C:\projects\Pikuma\ps1\code\duffle\word_count.metadata.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\dsl.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\memory.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\math.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gcc_asm.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\mips.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gp.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gte.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\dsl.atom.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\bios.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\psyq.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\math.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\mips.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\gte.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\gp.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\psyq.atom.c
+// Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
+
+#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).
+//   - mac_yield() is the safe default for atom-endings: 4 words, BD-slot of jr is mandatory nop.
+//   - mac_yield_load() + mac_yield_tail():
+//     - unconditional branch: mac_yield_load fills the branch's BD-slot (replaces a nop);
+//     - mac_yield_tail runs at the branch target (does NOT re-load R_AtomJmp).
+#define mac_yield(...) \
+	load_word(R_AtomJmp, R_TapePtr, 0) \
+,	add_ui_self(         R_TapePtr, S_(MipsCode)) \
+,	jump_reg( R_AtomJmp) \
+,	nop
+WORD_COUNT(mac_yield, 4)
+
+/* atom_dbg_skip */
+#define mac_yield_load(...) \
+	load_word(R_AtomJmp, R_TapePtr, 0)
+WORD_COUNT(mac_yield_load, 1)
+
+/* atom_dbg_skip */
+#define mac_yield_tail(...) \
+	add_ui_self(R_TapePtr, S_(MipsCode)) \
+,	jump_reg(  R_AtomJmp) \
+,	nop
+WORD_COUNT(mac_yield_tail, 3)
+
+/* atom_dbg_skip */
+#define mac_load_v2s2(rs_x, rs_y, r_base, offset) \
+	load_half( rs_x, r_base, O_(V3_S2,x)) \
+,	load_half( rs_y, r_base, O_(V3_S2,y))
+WORD_COUNT(mac_load_v2s2, 2)
+
+/* atom_dbg_skip */
+#define mac_store_v2s2(rt_x, rt_y, base, offset) \
+	store_half(rt_x, base, offset + O_(V2_S2,x)) \
+,	store_half(rt_y, base, offset + O_(V2_S2,y))
+WORD_COUNT(mac_store_v2s2, 2)
+
+/* atom_dbg_skip */
+#define mac_load_v3s4(rs_x, rs_y, rs_z, r_base, offset) \
+	load_word( rs_x, r_base, O_(V3_S4,x)) \
+,	load_word( rs_y, r_base, O_(V3_S4,y)) \
+,	load_word( rs_z, r_base, O_(V3_S4,z))
+WORD_COUNT(mac_load_v3s4, 3)
+
+/* atom_dbg_skip */
+#define mac_store_v3s4(rt_x, rt_y, rt_z, base, offset) \
+	store_word(rt_x, base, offset + O_(V3_S4,x)) \
+,	store_word(rt_y, base, offset + O_(V3_S4,y)) \
+,	store_word(rt_z, base, offset + O_(V3_S4,z))
+WORD_COUNT(mac_store_v3s4, 3)
+
+/* atom_dbg_skip */
+#define mac_sub_v3s4(rds_x, rds_y, rds_z, rt_x, rt_y, rt_z) \
+	sub_s(rds_x, rds_x, rt_x) \
+,	sub_s(rds_y, rds_y, rt_y) \
+,	sub_s(rds_z, rds_z, rt_z)
+WORD_COUNT(mac_sub_v3s4, 3)
+
+/* atom_dbg_skip */
+#define mac_store_rects2(rt_x, rt_y, rt_width, rt_height, base, offset) \
+	store_half(rt_x,      base, offset + O_(Rect_S2,x)) \
+,	store_half(rt_y,      base, offset + O_(Rect_S2,y)) \
+,	store_half(rt_width,  base, offset + O_(Rect_S2,width)) \
+,	store_half(rt_height, base, offset + O_(Rect_S2,height))
+WORD_COUNT(mac_store_rects2, 4)
+
+/* atom_dbg_skip */
+#define mac_load_tri_indices(r_face_cusor, r_i0, r_i1, r_i2) \
+	load_half_u(r_i0, r_face_cusor, 0 * S_(S2)) \
+,	load_half_u(r_i1, r_face_cusor, 1 * S_(S2)) \
+,	load_half_u(r_i2, r_face_cusor, 2 * S_(S2))
+WORD_COUNT(mac_load_tri_indices, 3)
+
+/* atom_dbg_skip */
+#define mac_gte_store_f3(r_primitive_cursor) \
+	gte_sw(C2_SXY0, r_primitive_cursor, O_(Poly_F3,p0)) \
+,	gte_sw(C2_SXY1, r_primitive_cursor, O_(Poly_F3,p1)) \
+,	gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_F3,p2))
+WORD_COUNT(mac_gte_store_f3, 3)
+
+/* atom_dbg_skip */
+#define mac_gte_load_tri_verts(r_vert_base, r_v0, r_v1, r_v2) \
+	shift_lleft(R_AT, r_v0, v3s2_byteoff) \
+,	add_u_self(R_AT, r_vert_base) \
+,	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_v1, v3s2_byteoff) \
+,	add_u_self(R_AT, r_vert_base) \
+,	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_v2, v3s2_byteoff) \
+,	add_u_self(R_AT, r_vert_base) \
+,	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)
+WORD_COUNT(mac_gte_load_tri_verts, 18)
+
+/* atom_dbg_skip */
+#define mac_gte_store_g4_p012(r_primitive_cursor) \
+	gte_sw(C2_SXY0, r_primitive_cursor, O_(Poly_G4,p0)) \
+,	gte_sw(C2_SXY1, r_primitive_cursor, O_(Poly_G4,p1)) \
+,	gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_G4,p2))
+WORD_COUNT(mac_gte_store_g4_p012, 3)
+
+/* atom_dbg_skip */
+#define mac_gte_store_g4_p3(r_primitive_cursor) \
+	gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_G4,p3))
+WORD_COUNT(mac_gte_store_g4_p3, 1)
+
+/* atom_dbg_skip */
+#define mac_gte_sqr_v3(r_sx, r_sy, r_sz, r_sq_x, r_sq_y, r_sq_z) \
+	gte_mv_to_data_r(r_sx, C2_IR1) \
+,	gte_mv_to_data_r(r_sy, C2_IR2) \
+,	gte_mv_to_data_r(r_sz, C2_IR3) \
+,	nop \
+,	gte_cmdw_sqr \
+,	gte_mv_from_data_r(r_sq_x, C2_MAC1) \
+,	gte_mv_from_data_r(r_sq_y, C2_MAC2) \
+,	gte_mv_from_data_r(r_sq_z, C2_MAC3)
+WORD_COUNT(mac_gte_sqr_v3, 8)
+
+/* atom_dbg_skip */
+#define mac_gte_gpf_scale(r_sx, r_sy, r_sz, r_recip_est, r_shift, r_dx, r_dy, r_dz) \
+	gte_mv_to_data_r(r_recip_est, C2_IR0) \
+,	gte_mv_to_data_r(r_sx,        C2_IR1) \
+,	gte_mv_to_data_r(r_sy,        C2_IR2) \
+,	gte_mv_to_data_r(r_sz,        C2_IR3) \
+,	nop2 /* retire IR0..IR3 → GPF input pre-fill (matches libgte 0x80016134..0x80016138) */ \
+,	gte_cmdw_gpf \
+,	gte_mv_from_data_r(r_dx, C2_MAC1) \
+,	gte_mv_from_data_r(r_dy, C2_MAC2) \
+,	gte_mv_from_data_r(r_dz, C2_MAC3) \
+,	shift_aright_var(r_dx, r_dx, r_shift) \
+,	shift_aright_var(r_dy, r_dy, r_shift) \
+,	shift_aright_var(r_dz, r_dz, r_shift)
+WORD_COUNT(mac_gte_gpf_scale, 13)
+
+#define mac_gcmd_push(cmd, reg_transfer, reg_base, port) \
+	load_upper_i(reg_transfer, cmd >> 16) \
+,	or_i_self(   reg_transfer, cmd & 0xFFFF) \
+,	store_word(  reg_transfer, reg_base, port)
+WORD_COUNT(mac_gcmd_push, 3)
+
+/* atom_dbg_skip */
+#define mac_store_rgb8(rr, rg, rb, base, offset) \
+	store_byte(rr, base, offset + O_(RGB8,r)) \
+,	store_byte(rg, base, offset + O_(RGB8,g)) \
+,	store_byte(rb, base, offset + O_(RGB8,b))
+WORD_COUNT(mac_store_rgb8, 3)
+
+/* atom_dbg_skip */
+#define mac_pack_color_word(r_base, 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_base, (off))
+WORD_COUNT(mac_pack_color_word, 3)
+
+/* atom_dbg_skip */
+#define mac_format_f3_color(r_base, r, g, b) \
+	mac_pack_color_word(r_base, O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b)
+WORD_COUNT(mac_format_f3_color, 3)
+
+#define mac_format_g4_color(r_prim_cursor, r0, g0, b0, r1, g1, b1, r2, g2, b2, r3, g3, b3) \
+	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0) \
+,	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c1), 0,               r1,g1,b1) \
+,	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c2), 0,               r2,g2,b2) \
+,	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c3), 0,               r3,g3,b3)
+WORD_COUNT(mac_format_g4_color, 12)
+
+#define mac_insert_ot_tag(r_ot_base, r_prim_cursor, poly_size) \
+	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_ot_base)                             /* T1 = & OrderingTable[OTZ] */ \
+,	load_word(   R_AT, R_T1,          O_(PolyTag,code))       /* AT = old_ot_head */ \
+,	load_upper_i(R_V0, (poly_size/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) \
+,	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_prim_cursor, O_(PolyTag,code))       /* prim->tag = packed(prim_length, old_addr) */ \
+,	shift_lleft( R_AT, r_prim_cursor, S_(PolyTag_len_bits))   /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lright(R_AT, R_AT,          S_(PolyTag_len_bits)) \
+,	store_word(  R_AT, R_T1,          O_(PolyTag,code))       /* OrderingTable[OTZ] = PrimCursor */
+WORD_COUNT(mac_insert_ot_tag, 11)
+
+/* atom_dbg_skip */
+#define mac_pad_set_centered_axes(r_state, r_scratch) \
+	load_upper_i(r_scratch, (PadAxis_Centered_Word >> 16) & 0xFFFF) \
+,	or_i_self(   r_scratch,  PadAxis_Centered_Word        & 0xFFFF) \
+,	store_word(  r_scratch, r_state, O_(PadState,axes))
+WORD_COUNT(mac_pad_set_centered_axes, 3)
+
+/* atom_dbg_skip */
+#define mac_pad_set_id_byte(r_state, r_id, id_value) \
+	add_ui(    r_id, R_0, id_value) \
+,	store_byte(r_id, r_state, O_(PadState,id))
+WORD_COUNT(mac_pad_set_id_byte, 2)
+
+/* atom_dbg_skip */
+#define mac_pad_set_status(r_tmp, r_state, pad_status) \
+	add_ui(    r_tmp, R_0, pad_status) \
+,	store_word(r_tmp, r_state, O_(PadState,status))
+WORD_COUNT(mac_pad_set_status, 2)
+
+/* atom_dbg_skip */
+#define mac_pad_store_inverted_buttons(r_buttons, r_pad_state) \
+	nor_u(       r_buttons, r_buttons, R_0) \
+,	store_half(  r_buttons, r_pad_state, O_(PadState,   buttons))
+WORD_COUNT(mac_pad_store_inverted_buttons, 2)
+

code/duffle/gen/offsets.h

@@ -0,0 +1,65 @@
+// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT
+// Directory: C:\projects\Pikuma\ps1\code\duffle\
+//   source: C:\projects\Pikuma\ps1\code\duffle\word_count.metadata.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\dsl.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\memory.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\math.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gcc_asm.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\mips.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gp.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\gte.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\dsl.atom.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\bios.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\psyq.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\math.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\mips.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\gte.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\gp.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\pad.atom.c
+//   source: C:\projects\Pikuma\ps1\code\duffle\psyq.atom.c
+#pragma once
+
+#pragma region duffle
+
+
+// --- atom: normalize_v3s4 (63 words) ---
+
+#define _atom_offset_srav_path_aligned_done           6
+#define _atom_offset_aligned_done_srav_path           1
+
+enum {
+    atom_offset_srav_path_aligned_done = _atom_offset_srav_path_aligned_done,
+    atom_offset_aligned_done_srav_path = _atom_offset_aligned_done_srav_path,
+};
+
+// --- atom: pad_bios_snapshot (84 words) ---
+
+#define _atom_offset_snap_root_skip_disconnected      10
+#define _atom_offset_disconnected_snap_end            65
+#define _atom_offset_case_2_id_dispatch               9
+#define _atom_offset_pending_snap_end                 54
+#define _atom_offset_id_dispatch_try_analog_stick     12
+#define _atom_offset_id_dispatch_snap_end             40
+#define _atom_offset_try_analog_stick_try_analog_pad  13
+#define _atom_offset_analog_stick_snap_end            25
+#define _atom_offset_try_analog_pad_try_unsupported   12
+#define _atom_offset_analog_pad_snap_end              10
+
+enum {
+    atom_offset_snap_root_skip_disconnected = _atom_offset_snap_root_skip_disconnected,
+    atom_offset_disconnected_snap_end = _atom_offset_disconnected_snap_end,
+    atom_offset_case_2_id_dispatch = _atom_offset_case_2_id_dispatch,
+    atom_offset_pending_snap_end = _atom_offset_pending_snap_end,
+    atom_offset_id_dispatch_try_analog_stick = _atom_offset_id_dispatch_try_analog_stick,
+    atom_offset_id_dispatch_snap_end = _atom_offset_id_dispatch_snap_end,
+    atom_offset_try_analog_stick_try_analog_pad = _atom_offset_try_analog_stick_try_analog_pad,
+    atom_offset_analog_stick_snap_end = _atom_offset_analog_stick_snap_end,
+    atom_offset_try_analog_pad_try_unsupported = _atom_offset_try_analog_pad_try_unsupported,
+    atom_offset_analog_pad_snap_end = _atom_offset_analog_pad_snap_end,
+};
+
+#pragma endregion duffle
+

code/duffle/gp.atom.c

@@ -0,0 +1,60 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "dsl.h"
+#	include "gp.h"
+#	include "lottes_tape.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(gp_atom_c);
+
+#pragma region MACs (Mips Atom Components)
+
+FI_ Slice_MipsCode ac_gcmd_push(AtomBuilder_R ab, U4 cmd, U4 reg_transfer, U4 reg_base, U2 port)
+MipsAtomComp_Proc_(ac_gcmd_push, ab, {
+	load_upper_i(reg_transfer, cmd >> 16),
+	or_i_self(   reg_transfer, cmd & 0xFFFF),
+	store_word(  reg_transfer, reg_base, port),
+})
+
+FI_ Slice_MipsCode ac_store_rgb8(AtomBuilder_R ab, U1 rr, U1 rg, U1 rb, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_rgb8, ab, {
+	store_byte(rr, base, offset + O_(RGB8,r)),
+	store_byte(rg, base, offset + O_(RGB8,g)),
+	store_byte(rb, base, offset + O_(RGB8,b)),
+})
+
+FI_ Slice_MipsCode ac_pack_color_word(AtomBuilder_R ab, U4 r_base, U4 off, U4 cmd, U1 r, U1 g, U1 b)
+atom_dbg_skip MipsAtomComp_Proc_(ac_pack_color_word, ab, {
+	load_upper_i(R_AT, (cmd) << 8  | (b)),
+	or_i_self(   R_AT, ((g)  << 8) | (r)),
+	store_word(  R_AT, r_base, (off)),
+})
+
+FI_ Slice_MipsCode ac_format_f3_color(AtomBuilder_R ab, U4 r_base, U1 r, U1 g, U1 b)
+atom_dbg_skip MipsAtomComp_Proc_(ac_format_f3_color, ab, { mac_pack_color_word(r_base, O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b) })
+
+FI_ Slice_MipsCode ac_format_g4_color(AtomBuilder_R ab, U4 r_prim_cursor,
+	U1 r0, U1 g0, U1 b0,
+  U1 r1, U1 g1, U1 b1,
+  U1 r2, U1 g2, U1 b2,
+  U1 r3, U1 g3, U1 b3)
+MipsAtomComp_Proc_(ac_format_g4_color, ab, {
+	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0),
+	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c1), 0,               r1,g1,b1),
+	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c2), 0,               r2,g2,b2),
+	mac_pack_color_word(r_prim_cursor, O_(Poly_G4,c3), 0,               r3,g3,b3),
+})
+
+/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list. */
+I_ Slice_MipsCode ac_insert_ot_tag(AtomBuilder_R ab, U4 r_ot_base, U4 r_prim_cursor, U4 poly_size) MipsAtomComp_Proc_(ac_insert_ot_tag, ab, {
+	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_ot_base),                             // T1 = & OrderingTable[OTZ]
+	load_word(   R_AT, R_T1,          O_(PolyTag,code)),       // AT = old_ot_head
+	load_upper_i(R_V0, (poly_size/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits),
+	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_prim_cursor, O_(PolyTag,code)),       // prim->tag = packed(prim_length, old_addr)
+	shift_lleft( R_AT, r_prim_cursor, S_(PolyTag_len_bits)),   // AT = (prim_length << 24) | old_addr
+	shift_lright(R_AT, R_AT,          S_(PolyTag_len_bits)),
+	store_word(  R_AT, R_T1,          O_(PolyTag,code)),       // OrderingTable[OTZ] = PrimCursor
+})
+
+#pragma endregion MACs (Mips Atom Components)

code/duffle/gte.atom.c

@@ -0,0 +1,304 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+#	include "gte.h"
+#	include "gp.h"
+#	include "lottes_tape.h"	
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(gte_atom_c);
+
+#pragma region MACs (Mips Atom Components)
+
+/* Words: 3; Loads 3 S2 indices from the face array */
+FI_ Slice_MipsCode ac_load_tri_indices(AtomBuilder_R ab, U4 r_face_cusor, U4 r_i0, U4 r_i1, U4 r_i2) atom_dbg_skip MipsAtomComp_Proc_(ac_load_tri_indices, ab, {
+	load_half_u(r_i0, r_face_cusor, 0 * S_(S2)),
+	load_half_u(r_i1, r_face_cusor, 1 * S_(S2)),
+	load_half_u(r_i2, r_face_cusor, 2 * S_(S2)),
+})
+
+/* 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). */
+FI_ Slice_MipsCode ac_gte_store_f3(AtomBuilder_R ab, U4 r_primitive_cursor) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_store_f3, ab, {
+	gte_sw(C2_SXY0, r_primitive_cursor, O_(Poly_F3,p0)),
+	gte_sw(C2_SXY1, r_primitive_cursor, O_(Poly_F3,p1)),
+	gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_F3,p2)),
+})
+
+/* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
+I_ Slice_MipsCode ac_gte_load_tri_verts(AtomBuilder_R ab, U4 r_vert_base, U4 r_v0, U4 r_v1, U4 r_v2) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_load_tri_verts, ab, {
+	shift_lleft(R_AT, r_v0, v3s2_byteoff), add_u_self(R_AT, r_vert_base), 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_v1, v3s2_byteoff), add_u_self(R_AT, r_vert_base), 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_v2, v3s2_byteoff), add_u_self(R_AT, r_vert_base), 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),
+})
+
+/* 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, SXY2=v2.screen).
+ * 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). */
+FI_ Slice_MipsCode ac_gte_store_g4_p012(AtomBuilder_R ab, U4 r_primitive_cursor) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_store_g4_p012, ab, {
+	gte_sw(C2_SXY0, r_primitive_cursor, O_(Poly_G4,p0)),
+	gte_sw(C2_SXY1, r_primitive_cursor, O_(Poly_G4,p1)),
+	gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_G4,p2)),
+})
+
+/* 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 earlier RTPT.
+ */
+FI_ Slice_MipsCode ac_gte_store_g4_p3(AtomBuilder_R ab, U4 r_primitive_cursor) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_store_g4_p3, ab, { gte_sw(C2_SXY2, r_primitive_cursor, O_(Poly_G4,p3)) })
+
+/* ─── STAGE 1 of normalize: SQR + mfc2 MAC1/2/3 ───
+ * Emits squared magnitude per component (in MAC1/2/3) into caller-provided scratch regs.
+ * Stage 2 of normalize consumes these directly.
+ * Words: 8.  Clobbers: IR1/2/3, MAC1/2/3.  Uses gte_cmdw_sqr (sf=0, lm=1). */
+FI_ Slice_MipsCode ac_gte_sqr_v3(AtomBuilder_R ab, U4 r_sx, U4 r_sy, U4 r_sz, U4 r_sq_x, U4 r_sq_y, U4 r_sq_z) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_sqr_v3, ab, {
+	gte_mv_to_data_r(r_sx, C2_IR1),
+	gte_mv_to_data_r(r_sy, C2_IR2),
+	gte_mv_to_data_r(r_sz, C2_IR3),
+	nop, gte_cmdw_sqr,
+	gte_mv_from_data_r(r_sq_x, C2_MAC1),
+	gte_mv_from_data_r(r_sq_y, C2_MAC2),
+	gte_mv_from_data_r(r_sq_z, C2_MAC3),
+})
+
+/* ─── STAGE 4 of normalize: mtc2 IR0..3 + GPF + mfc2 MAC + srav finalize ───
+ * Reusable standalone — given an IR0 = 1/|v| estimate (typically from a sqrtbl lookup) and a shift count 
+ * (typically (31 - LZCR)/2), multiplies IR0*IR[i] via GPF and shifts right to produce the normalized output.
+ * Used standalone for "scale vector by scalar".
+ * Words: 11.  Clobbers: IR0..3, MAC1..3.  Uses gte_cmdw_gpf (sf=0, lm=0). */
+FI_ Slice_MipsCode ac_gte_gpf_scale(AtomBuilder_R ab, U4 r_sx, U4 r_sy, U4 r_sz, U4 r_recip_est, U4 r_shift, U4 r_dx, U4 r_dy, U4 r_dz) atom_dbg_skip MipsAtomComp_Proc_(ac_gte_gpf_scale, ab, {
+	gte_mv_to_data_r(r_recip_est, C2_IR0),
+	gte_mv_to_data_r(r_sx,        C2_IR1),
+	gte_mv_to_data_r(r_sy,        C2_IR2),
+	gte_mv_to_data_r(r_sz,        C2_IR3),
+	nop2, /* retire IR0..IR3 → GPF input pre-fill (matches libgte 0x80016134..0x80016138) */
+	gte_cmdw_gpf,
+	gte_mv_from_data_r(r_dx, C2_MAC1),
+	gte_mv_from_data_r(r_dy, C2_MAC2),
+	gte_mv_from_data_r(r_dz, C2_MAC3),
+	shift_aright_var(r_dx, r_dx, r_shift),
+	shift_aright_var(r_dy, r_dy, r_shift),
+	shift_aright_var(r_dz, r_dz, r_shift),
+})
+
+#pragma endregion MACs (Mips Atom Components)
+
+#pragma region Atom Procs
+
+/* ─── Local copy of PSYQ's sqrtbl (1/sqrt lookup table for VectorNormal). ───
+ * Source: PSYQ 4.7 libgte sqrtbl at 0x800185B4 in hello_camera.elf.
+ *   objdump -s --start-address=0x800185B4 --stop-address=0x800185F4 hello_camera.elf
+ *   → 192 entries × 16-bit signed, in 1.12 fixed-point (max value 0x1000 = 1.0).
+ *
+ * Data is identical to the libgte original (byte-for-byte verified).
+ * 
+ * ─── Per-entry semantics (decoded from libgte msc02 VectorNormal) ───
+ * Each entry is `1/sqrt(x)` in 1.12 fixed point (value / 4096).
+ * The 192 entries span 4 octaves of the input magnitude, with 48 entries per octave:
+ *   Octave 0 (entries  0- 47): mantissa in [0x8000,  0x10000)  output ~[1.000, 0.707]
+ *   Octave 1 (entries 48- 95): mantissa in [0x10000, 0x20000)  output ~[0.707, 0.500]
+ *   Octave 2 (entries 96-143): mantissa in [0x20000, 0x40000)  output ~[0.500, 0.354]
+ *   Octave 3 (entries144-191): mantissa in [0x40000, 0x80000)  output ~[0.354, 0.251]
+ * Within each octave, 8 sub-entries interpolate over the 8 fractional bits of the mantissa
+ * (the byte `(0x80 | (i mod 8))` for the lower-byte of the aligned value).
+ * Sampling the first value of each octave:
+ *   [0]   0x1000 = 1.0000                 ; 1 / sqrt(1.0000)
+ *   [48]  0x0e4f = 0.8940                 ; 1 / sqrt(1.2500)
+ *   [96]  0x0d10 = 0.8164                 ; 1 / sqrt(1.5000)
+ *   [144] 0x0c0a = 0.7520                 ; 1 / sqrt(1.7500)
+ * And representative sub-entries within octave 0 (mantissa in [0x8000, 0x8100)):
+ *   [0]   0x1000 = 1.0000                 ; 1 / sqrt(0x8000)
+ *   [1]   0x0fe0 = 0.9922                 ; 1 / sqrt(0x8100)
+ *   [2]   0x0fc1 = 0.9846                 ; 1 / sqrt(0x8200)
+ *   [3]   0x0fa3 = 0.9773                 ; 1 / sqrt(0x8300)
+ *   [4]   0x0f85 = 0.9700                 ; 1 / sqrt(0x8400)
+ *   [5]   0x0f68 = 0.9629                 ; 1 / sqrt(0x8500)
+ *   [6]   0x0f4c = 0.9561                 ; 1 / sqrt(0x8600)
+ *   [7]   0x0f30 = 0.9492                 ; 1 / sqrt(0x8700)
+ *
+ * The algorithm's `addi -64 / sll 1 / lh` selects the entry at `(aligned - 64) * 2` for the case where `aligned` has its top bit at bit 24.
+ * After the sllv/srav pair, `aligned` always lands in `[0x80, 0x100)` 
+ * (with top bit at bit 24 → after `sub $aligned - 64`, the index sits in `[0x40, 0x80) * 2 = [0x80, 0x100)` bytes = entries [64, 128) within the sqrtbl).
+ * The earlier 64 entries (octave 0) are reached when the magnitude after shifting puts the top bit below bit 24 (the `sllv` branch),
+ * and the load upper_halves of the table bracket the input range.
+ * The later 64 entries (octaves 2-3) are the `srav` branch when the magnitude's top bit is well above bit 24.
+ *
+ * 192-entry table is reproduced verbatim from libgte (verified against libpsn00b/psxgte/vector.s:100-123 — 24 rows × 8 halfwords, last entry 0x0804). */
+internal S2 const gte_normalize_sqr_tbl[192] align_(2) = {
+	0x1000, 0x0fe0, 0x0fc1, 0x0fa3, 0x0f85, 0x0f68, 0x0f4c, 0x0f30,
+	0x0f15, 0x0efb, 0x0ee1, 0x0ec7, 0x0eae, 0x0e96, 0x0e7e, 0x0e66,
+	0x0e4f, 0x0e38, 0x0e22, 0x0e0c, 0x0df7, 0x0de2, 0x0dcd, 0x0db9,
+	0x0da5, 0x0d91, 0x0d7e, 0x0d6b, 0x0d58, 0x0d45, 0x0d33, 0x0d21,
+	0x0d10, 0x0cff, 0x0cee, 0x0cdd, 0x0ccc, 0x0cbc, 0x0cac, 0x0c9c,
+	0x0c8d, 0x0c7d, 0x0c6e, 0x0c5f, 0x0c51, 0x0c42, 0x0c34, 0x0c26,
+	0x0c18, 0x0c0a, 0x0bfd, 0x0bef, 0x0be2, 0x0bd5, 0x0bc8, 0x0bbb,
+	0x0baf, 0x0ba2, 0x0b96, 0x0b8a, 0x0b7e, 0x0b72, 0x0b67, 0x0b5b,
+	0x0b50, 0x0b45, 0x0b39, 0x0b2e, 0x0b24, 0x0b19, 0x0b0e, 0x0b04,
+	0x0af9, 0x0aef, 0x0ae5, 0x0adb, 0x0ad1, 0x0ac7, 0x0abd, 0x0ab4,
+	0x0aaa, 0x0aa1, 0x0a97, 0x0a8e, 0x0a85, 0x0a7c, 0x0a73, 0x0a6a,
+	0x0a61, 0x0a59, 0x0a50, 0x0a47, 0x0a3f, 0x0a37, 0x0a2e, 0x0a26,
+	0x0a1e, 0x0a16, 0x0a0e, 0x0a06, 0x09fe, 0x09f6, 0x09ef, 0x09e7,
+	0x09e0, 0x09d8, 0x09d1, 0x09c9, 0x09c2, 0x09bb, 0x09b4, 0x09ad,
+	0x09a5, 0x099e, 0x0998, 0x0991, 0x098a, 0x0983, 0x097c, 0x0976,
+	0x096f, 0x0969, 0x0962, 0x095c, 0x0955, 0x094f, 0x0949, 0x0943,
+	0x093c, 0x0936, 0x0930, 0x092a, 0x0924, 0x091e, 0x0918, 0x0912,
+	0x090d, 0x0907, 0x0901, 0x08fb, 0x08f6, 0x08f0, 0x08eb, 0x08e5,
+	0x08e0, 0x08da, 0x08d5, 0x08cf, 0x08ca, 0x08c5, 0x08bf, 0x08ba,
+	0x08b5, 0x08b0, 0x08ab, 0x08a6, 0x08a1, 0x089c, 0x0897, 0x0892,
+	0x088d, 0x0888, 0x0883, 0x087e, 0x087a, 0x0875, 0x0870, 0x086b,
+	0x0867, 0x0862, 0x085e, 0x0859, 0x0855, 0x0850, 0x084c, 0x0847,
+	0x0843, 0x083e, 0x083a, 0x0836, 0x0831, 0x082d, 0x0829, 0x0824,
+	0x0820, 0x081c, 0x0818, 0x0814, 0x0810, 0x080c, 0x0808, 0x0804,
+};
+
+/* ─── Full normalize (all 4 stages inline) ───
+ * Generic 4-stage GTE normalize (SQR → sum+LZCR → align+sqrtbl → GPF+srav).
+ *
+ * Parameterized by caller-provided scratch base + src/dst offsets.
+ * The caller passes r_src_offset and r_dst_offset as compile-time constants
+ * (typically derived from O_ macros in the caller's struct schema, e.g., `O_(CallerBundleScratch, fwd)`).
+ *
+ * This design lets any caller (with a scratch base + struct schema) use `normalize_v3s4_proc` 
+ * without putting magic offsets in the C-side bundle helper — the offsets come from O_ macros at the call site.
+ *
+ * Body uses 9 GPRs (r_src_ptr..r_branch_tmp):
+ *   r_src_ptr, r_dst_ptr : src/dst pointers (computed from r_scratch + caller offsets)
+ *   r_tmp                : src.x PRESERVED across stages 1-2 (NOT clobbered by mfc2 MAC2) → fed to IR1 in stage 4
+ *   r_mac1_scratch       : MAC1 result scratch (also holds aligned |v|² in stage 3)
+ *   r_mac2_scratch       : MAC2 result scratch → result.x after stage 4 sra
+ *   r_recip_est          : src.y PRESERVED across stages 1-2 → fed to IR2 in stage 4 → result.y
+ *   r_lzcr               : |v|² sum (stage 2) → shift count (stage 3) → 1/|v| (stage 4 IR0)
+ *   r_shift              : shift count SAVED in stage 3 → consumed by stage 4 srav
+ *   r_branch_tmp         : src.z PRESERVED across stages 1-2 → fed to IR3 in stage 4 → result.z (also sqrtbl base addr)
+ *
+ * Atom_labels are srav_path / aligned_done 
+ * (NOT namespaced — they're internal to this proc; 
+ * the metaprogram's per-atom-name enum emission handles any collision across different atoms/files that share the same labels).
+ *
+ * Pool cost: 11 GPRs (well within the 9-10 caller-trash GPR budget when r_scratch is a wave-context carrier).
+ *
+ * Direct port of PSYQ libgte msc02.rel.text VectorNormal disassembly (0x800160a0..0x8001615c).
+ * Words: ~59 (matches libgte 0x800160a0..0x8001615c at +/- 0-2 words for BD-slot reshuffling).
+ * Sqrtbl: hardcoded to 0x800185B4 (libgte msc02.rel.data). Note: swapped to local.
+ * Pipeline: clobbers IR0..3, MAC1..3, LZCS, LZCR.
+ */
+/* MipsAtom_Proc_ wrapper: declares the static MipsCode[] body, then calls atombuilder_unroll(ab, ...) to copy the encoded instructions into the caller's MipsAtomBuilder arena.  */
+I_ MipsAtom* normalize_v3s4_proc(AtomArena_R aa,	U4 r_scratch /* GPR code: scratch base carrier (e.g., R_T4 = R_ResolveScratch) */
+	,	U4 r_src_offset, U4 r_dst_offset     /* GPR codes: PARAMETERIZED offsets (caller passes O_ macros) */
+	,	U4 r_src_ptr, U4 r_dst_ptr, U4 r_tmp /* GPR codes: 3 scratch regs (src/dst computed + tmp) */
+	,	U4 r_mac1_scratch, U4 r_mac2_scratch /* GPR codes: 2 more: MAC1/MAC2 scratch */
+	,	U4 r_recip_est                       /* GPR code: |v|² sum + shift-input + sqrtbl[index] */
+	,	U4 r_lzcr, U4 r_shift                /* GPR codes: lzcr + final srav amount */
+	,	U4 r_branch_tmp                      /* GPR code: scratch (shift count, branch target, lookup addr) */
+)
+MipsAtom_Proc_(normalize_v3s4, aa, {
+	add_si(r_src_ptr, r_scratch, r_src_offset),     /* r_src_ptr = &src */
+	add_si(r_dst_ptr, r_scratch, r_dst_offset),     /* r_dst_ptr = &dst */
+	nop,
+
+	/* Load src.x/y/z from r_src_ptr (caller-determined address) into r_tmp/r_recip_est/r_branch_tmp.
+	 * r_tmp holds src.x throughout stages 1-2 — r_mac2_scratch is clobbered to MAC2 in stage 1.5 (line below). */
+	load_word(r_tmp,          r_src_ptr, O_(V3_S4,x)),
+	load_word(r_recip_est,    r_src_ptr, O_(V3_S4,y)),
+	load_word(r_branch_tmp,   r_src_ptr, O_(V3_S4,z)),
+	nop, /* load-delay */
+
+	/* Stage 1: mtc2 src → IR1/2/3, SQR fires. */
+	gte_mv_to_data_r(r_tmp,        C2_IR1),
+	gte_mv_to_data_r(r_recip_est,  C2_IR2),
+	gte_mv_to_data_r(r_branch_tmp, C2_IR3),
+	nop, gte_cmdw_sqr,
+
+	/* Stage 2: mfc2 MAC1/2/3, sum, mtc2 LZCS. */
+	gte_mv_from_data_r(r_mac1_scratch, C2_MAC1),
+	gte_mv_from_data_r(r_mac2_scratch, C2_MAC2),
+	gte_mv_from_data_r(r_lzcr,         C2_MAC3),
+	nop,
+	add_u(r_lzcr, r_lzcr, r_mac2_scratch),
+	add_u(r_lzcr, r_lzcr, r_mac1_scratch),
+	gte_mv_to_data_r(r_lzcr, C2_LZCS),
+	nop2,
+	gte_mv_from_data_r(r_shift, C2_LZCR),
+	nop,
+
+	/* Stage 3: compute srav amount (r_lzcr) + align |v|² to bit 24.
+	 * IMPORTANT: the sllv/srav below writes the aligned |v|² to r_mac1_scratch (NOT r_lzcr),
+	 * so r_lzcr retains the shift count all the way to the start of stage 4.
+	 */
+	and_i(   r_shift, r_shift, -2),
+	or_u(r_mac1_scratch, r_lzcr, 0),                            /* FIX B: save sum before clobbering r_lzcr with shift count */
+	li_s(    r_lzcr,           31),
+	sub_s(   r_lzcr, r_lzcr, r_shift),
+	shift_aright(r_lzcr, r_lzcr, 1),
+	/* r_branch_tmp = LZCR - 24 (overwrites r_branch_tmp; src.z no longer needed after SQR) */
+	add_si(  r_branch_tmp, r_shift, -24),
+	branch_lt_zero(r_branch_tmp, atom_offset(aligned_done, srav_path)), nop,    /* FIX A: bltz → srav_path (LZCR<24 path) */
+	jump_rel(atom_offset(srav_path, aligned_done)),                              /* FIX A: b → aligned_done (LZCR>=24 path) */
+	shift_lleft_var(r_mac1_scratch, r_mac1_scratch, r_branch_tmp),              /* FIX B: src=sum (r_mac1_scratch), dst=same */
+	atom_label(srav_path)
+	li_s(    r_branch_tmp, 24),
+	sub_s(   r_branch_tmp, r_branch_tmp, r_shift),
+	shift_aright_var(r_mac1_scratch, r_mac1_scratch, r_branch_tmp),             /* FIX B: src=sum (r_mac1_scratch), dst=same */
+	atom_label(aligned_done)
+	/* Save the shift count to r_shift before the next 5 instructions overwrite r_lzcr
+	 * (the sqrtbl lookup loads 1/|v| into r_lzcr, which becomes IR0 in stage 4). */
+	or_u(r_shift, r_lzcr, 0),                                    /* r_shift ← shift count (preserved through stage 4) */
+	/* r_mac1_scratch holds |v|² aligned (top bit at bit 7). */
+	add_si(     r_mac1_scratch, r_mac1_scratch, -64),
+	shift_lleft(r_mac1_scratch, r_mac1_scratch, 1),
+	load_upper_i(r_branch_tmp, u4_hi(& gte_normalize_sqr_tbl)),
+	or_i_self(   r_branch_tmp, u4_lo(& gte_normalize_sqr_tbl)),
+	add_u(r_branch_tmp, r_branch_tmp, r_mac1_scratch),
+	load_half(r_lzcr,   r_branch_tmp, 0), nop,                  /* r_lzcr = sqrtbl[aligned-64] = 1/|v| (IR0 in stage 4) */
+
+	/* FIX bug C: r_branch_tmp held the sqrtbl base+index, NOT src.z. Reload src.z from scratch now that r_branch_tmp is free. */
+	load_word(r_branch_tmp, r_src_ptr, O_(V3_S4,z)), nop,        /* r_branch_tmp = src.z (for IR3 in stage 4) */
+
+	/* Stage 4: GPF + srav finalize (r_shift = shift count, r_lzcr = 1/|v|). */
+	gte_mv_to_data_r(r_lzcr,         C2_IR0),
+	gte_mv_to_data_r(r_tmp,          C2_IR1),                    /* IR1 = src.x (preserved in r_tmp — r_mac2_scratch was clobbered to MAC2 in stage 1.5) */
+	gte_mv_to_data_r(r_recip_est,    C2_IR2),
+	gte_mv_to_data_r(r_branch_tmp,   C2_IR3),                    /* IR3 = src.z (reloaded) */
+	nop2, gte_cmdw_gpf,
+	gte_mv_from_data_r(r_mac2_scratch, C2_MAC1),
+	gte_mv_from_data_r(r_recip_est,    C2_MAC2),
+	gte_mv_from_data_r(r_branch_tmp,   C2_MAC3),
+	shift_aright_var(r_mac2_scratch, r_mac2_scratch, r_shift),   /* sra by r_shift = (31-LZCR)/2 (saved before sqrtbl lookup) */
+	shift_aright_var(r_recip_est,    r_recip_est,    r_shift),
+	shift_aright_var(r_branch_tmp,   r_branch_tmp,   r_shift),
+
+	/* Store result.x/y/z to r_dst_ptr (caller-determined dst address). */
+	store_word(r_mac2_scratch, r_dst_ptr, O_(V3_S4,x)),
+	store_word(r_recip_est,    r_dst_ptr, O_(V3_S4,y)),
+	store_word(r_branch_tmp,   r_dst_ptr, O_(V3_S4,z)),
+
+	mac_yield()
+})
+
+#pragma endregion Atom Procs
+
+#pragma region Baked Atoms
+
+typedef Struct_(Binds_SetGteMT3S2S4) {
+	MT3_S2S4* transform;
+};
+internal MipsAtom_(set_gte_mt3s2s4) atom_info(
+		atom_bind(Binds_SetGteMT3S2S4)
+	,	atom_reads(R_TapePtr)
+){
+	/* Pop matrix address from tape into R_T3 ($11) */
+	load_word(R_T3, R_TapePtr, O_(Binds_SetGteMT3S2S4,transform)),
+	add_ui_self(    R_TapePtr, S_(Binds_SetGteMT3S2S4)),
+	/* Load 3x3 Rotation + 3x1 Translation from R_T3 into GTE CONTROL Regs (ctc2) */
+	load_word(R_T0, R_T3, 0),  load_word(R_T1, R_T3,  4),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_RT11), gte_mv_to_ctrl_r(R_T1, gte_cr_RT12),
+	load_word(R_T0, R_T3, 8),  load_word(R_T1, R_T3, 12), load_word(R_T2, R_T3, 16),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_RT13), gte_mv_to_ctrl_r(R_T1, gte_cr_RT21), gte_mv_to_ctrl_r(R_T2, gte_cr_RT22),
+	load_word(R_T0, R_T3, 20), load_word(R_T1, R_T3, 24), load_word(R_T2, R_T3, 28),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_TRX),  gte_mv_to_ctrl_r(R_T1, gte_cr_TRY),  gte_mv_to_ctrl_r(R_T2, gte_cr_TRZ),
+	mac_yield()
+};
+
+#pragma endregion Baked Atoms

code/duffle/gte.h

@@ -161,6 +161,8 @@ enum {
 	gte_cmd_nclip     = 0x06, /* Normal Clipping (Backface culling) */
 	gte_cmd_op        = 0x0C, /* Outer Product */
 	gte_cmd_mvmva     = 0x12, /* Matrix Vector Multiply & Add (Custom math) */
+	gte_cmd_sqr       = 0x28, /* Square vector — MAC[i] = IR[i]²; IR[i] ← MAC[i] saturated */
+	gte_cmd_gpf       = 0x3D, /* General-purpose Interpolation — MAC[i] = IR0 * IR[i]  */
 
 /* --- GTE Command Bit-Field Layout ---
  * A GTE command word (sent to COP2 with RS=1) is laid out as:
@@ -171,8 +173,7 @@ 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. 
+ * Shifts/masks below are the *bit positions* and *bit widths* of each configurable field, used by the ENC_GTE_CMD encoder. 
  * Mirrors the OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
  */
 
@@ -182,6 +183,12 @@ enum {
 	gte_shift_cv  = 13,  gte_width_cv  = 2,  gte_mask_cv = 0x3,
 	gte_shift_lm  = 10,  gte_width_lm  = 1,  gte_mask_lm  = 0x1,
 	gte_shift_cmd =  0,  gte_width_cmd = 6,  gte_mask_cmd = 0x3F,
+
+	/* Fake command number (bits 24-20) — IGNORED by the GTE hardware per PSX-SPX `geometrytransformationenginegte.md` line 48.
+	 * libgte's compiler emits non-zero values in this field as a disassembly signature. */
+	gte_shift_fake_cmd = 20,
+	gte_width_fake_cmd = 5,
+	gte_mask_fake_cmd  = 0x1F,
 };
 
 /* --- GTE Control Register Indices (for ctc2/cfc2) ---
@@ -243,10 +250,10 @@ enum { _C2_OPS_ = 0
  *   bit 1 (0x02): register class — 0 = data,  1 = control
  *   bit 2 (0x04): direction      — 0 = read,  1 = write
  *
- * The values 0x00 (sub_mfc2) and 0x04 (sub_mtc2) are the same 5-bit numbers as the general MIPS `cop_mf` / `cop_mt` defined in mips.h
+ * The values 0x00 (sub_mfc2) and 0x04 (sub_mtc2) are the same 5-bit numbers as general MIPS `cop_mf` / `cop_mt` defined in mips.h
  * (which target the data register file on any coprocessor).
  * They are re-aliased here so the four-way table reads like the spec mnemonics (MFC2 / CFC2 / MTC2 / CTC2)
- * and so the encoding lives next to its only consumer (this header).
+ * and so the encoding is next to its only consumer (this header).
  *
  * Vendor mnemonic aliases (gte_mfc2 / gte_mtc2 / gte_cfc2 / gte_ctc2) live in gte_vendor_sym.h. */
 enum { _C2_TX_SUBS_ = 0
@@ -309,13 +316,13 @@ enum { _C2_TX_SUBS_ = 0
 
 /* GTE Command Format
  * Opcode is always MIPS_OP_COP2, RS is always 1 (CO).
- * The lower 25 bits are the GTE-specific command payload.
+ * Lower 25 bits are GTE-specific command payload.
  *
- * The granular `enc_gte_<field>(x)` macros below mirror the `enc_op`/`enc_rs` pattern in mips.h:
+ * The `enc_gte_<field>(x)` macros below mirror the `enc_op`/`enc_rs` pattern in mips.h:
  * Each one self-masks and shifts its own field, so a caller can build up a GTE command piece by piece
  * (handy for state-driven MVMVA emitters that vary one field at a time).
  *
- * `ENC_GTE_CMD` is the all-in-one convenience for emitting a full command word in one go.
+ * `ENC_GTE_CMD` is an all-in-one convenience for emitting a full command word.
  * It just ORs the per-field encoders together. */
 #define gte_cmd_base (enc_op(op_cop2) | (1 << 25))
 
@@ -325,7 +332,8 @@ enum { _C2_TX_SUBS_ = 0
 #define enc_gte_v(v)            (((v)   & gte_mask_v       ) << gte_shift_v  )
 #define enc_gte_cv(cv)          (((cv)  & gte_mask_cv      ) << gte_shift_cv )
 #define enc_gte_lm(lm)          (((lm)  & gte_mask_lm      ) << gte_shift_lm )
-#define enc_gte_cmd(cmd) (((cmd) & gte_mask_cmd) << gte_shift_cmd)
+#define enc_gte_cmd(cmd)        (((cmd) & gte_mask_cmd     ) << gte_shift_cmd )
+#define enc_gte_fake_cmd(x)     (((x)   & gte_mask_fake_cmd) << gte_shift_fake_cmd)
 
 /* Composite: all six GTE fields + the COP2/CO base. */
 #define enc_gte_cmdw(sf, mx, v, cv, lm, cmd) ( \
@@ -363,11 +371,11 @@ enum { _C2_TX_SUBS_ = 0
  *  (the perspective divide happens regardless of `sf`).
  *
  *  If we emit a strictly-spec-compliant word (`sf=0`, reserved bits clear),
- *  PCSX-Redux's GTE checks those bits more strictly than the silicon does and RTPT silently no-ops — 
- *  the floor's screen coordinates come out as raw projection-of-rotation (Z never divided),
+ *  PCSX-Redux's GTE checks those bits more strictly than the silicon does and RTPT silently no-ops.
+ *  The floor's screen coordinates come out as raw projection-of-rotation (Z never divided), 
  *  `nclip` ends up wrong, and the triangle is culled.
  *
- *  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.
+ *  So for RTPS and RTPT we OR-in the `0x28` "PsyQ compat" pattern to match the working bit pattern.
  *  NCLIP / OP / MVMVA stay spec-clean — their reserved bits really are zero in the original PsyQ source.
  * --------------------------------------------------------------------------
  */
@@ -378,11 +386,45 @@ enum { _C2_TX_SUBS_ = 0
 #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_wedge         gte_cmdw_op      /* "wedge product"  -- geometric-algebra terminology.
+	* RGA(Lengyel): the GTE OP is a 3D signed-16-bit D x IR cross, not a generic RGA exterior product.
+	* The wedge alias is the 3D complement interpretation of the same 3 scalars (MAC1..MAC3). */
 #define gte_cmdw_mvmva  (gte_cmd_base | enc_gte_cmd(gte_cmd_mvmva))
 
+/* SQR / GPF cosmetic-bits compat helpers.
+ * Each command's `_compat` macro ORs in the `fake_cmd` field value libgte happens to emit.
+ * The hardware ignores these bits (per PSX-SPX line 48). */
+#define gte_cmdw_sqr_fake_sig  enc_gte_fake_cmd(0x0A)
+#define gte_cmdw_gpf_fake_sig  enc_gte_fake_cmd(0x19)
+
+/* SQR — Square Vector.
+ * PSX-SPX `geometrytransformationenginegte.md` §"SQR":
+ *   [MAC1,MAC2,MAC3] = [IR1*IR1, IR2*IR2, IR3*IR3] SHR (sf*12)
+ *   [IR1,IR2,IR3]    = [MAC1,MAC2,MAC3] (saturated to 0x7FFF when lm=1)
+ * Sourced verbatim from libgte msc02 VectorNormal disassembly at 0x800160b0:
+ *   0x4AA00428 = gte_cmd_base | gte_cmdw_sqr_compat | enc_gte_lm(1) | enc_gte_cmd(0x28)
+ *   bit 19     sf=0
+ *   bit 10     lm=1
+ *   bits 5-0   cmd=0x28=SQR
+ *   bits 24-20 = 0x0A (libgte "nonsense SDK command number" signature) */
+#define gte_cmdw_sqr   (gte_cmd_base | enc_gte_cmd(gte_cmd_sqr) | enc_gte_lm(1) | gte_cmdw_sqr_fake_sig)
+
+/* GPF — General-purpose Interpolation.
+ * PSX-SPX `geometrytransformationenginegte.md` §"GPF":
+ *   [MAC1,MAC2,MAC3] = (([IR1,IR2,IR3] * IR0) + [MAC1,MAC2,MAC3]) SAR (sf*12)
+ *   [IR1,IR2,IR3]    = [MAC1,MAC2,MAC3]
+ * Sourced verbatim from libgte msc02 VectorNormal disassembly at 0x8001613c:
+ *   0x4B90003D = gte_cmd_base | gte_cmdw_gpf_compat | enc_gte_cmd(0x3D)
+ *   bit 19     sf=0
+ *   bit 10     lm=0
+ *   bits 5-0   cmd=0x3D=GPF
+ *   bits 24-20 = 0x19 (libgte "nonsense SDK command number" signature) */
+#define gte_cmdw_gpf   (gte_cmd_base | enc_gte_cmd(gte_cmd_gpf) | gte_cmdw_gpf_fake_sig)
+
 #define gte_cmdw_rotate_translate_perspective_single gte_cmdw_rtps
 #define gte_cmdw_rotate_translate_perspective_triple gte_cmdw_rtpt
+/* RGA(Lengyel): RTPS/RTPT consume the matrix expansion of a rigid transformation (rotation matrix + translation vector) loaded into the RT/TR control registers.
+ * For unitized points the same result equals the motor antiproduct; the GTE executes the LA form, not a symbolic antiproduct. */
 
 /* PsyQ compatibility bits for AVSZ3 (Bits 20, 22, 24 must be set) */
 #define gte_cmdw_psyq_avsz3_compat (0x15 << 20)
@@ -433,7 +475,6 @@ enum {
 #define gte_lw_v2_z(base)   enc_gte_lw(gte_in_v2_z,  (base), GTE_Z_Offset)
 
 /* gte_load_vN(r_ptr, base) — placeholder-punned lwc2 loaders
- *
  * Emits `.word` constants encoding `lwc2 $N, off(<base>)` for the chosen 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).
  *

code/duffle/lottes_tape.h

@@ -1,36 +1,70 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+
 #	include "dsl.h"
 #	include "gcc_asm.h"
 # include "mips.h"
 # include "gte.h"
 # include "memory.h"
-#	include "atom_dsl.h"
-#	include "gen/duffle.macs.h"
-#	include "gen/duffle.offsets.h"
+#	include "dsl.atom.h"
 #endif
 
-typedef U4 const MipsCode; // Underlying type to mips asm words.
-typedef Slice_(MipsCode);
-
-typedef U4 const MipsAtom; // Underlying type to an array of mips asm words that must terminate with an ac_yield.
-#define MipsAtom_(sym) MipsCode sym [] align_(4) =
-
-// 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) =
-
-// Used for components with value-args (e.g., ac_format_f3_color).
-//   FI_ Slice_MipsCode ac_X(args) MipsAtomComp_Proc_(ac_X, { body })
-// expands to:
-//   FI_ Slice_MipsCode 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) are included manually by the unity build.
-
-/* Register aliases */
+#pragma region Tape Drive
+/* -----------------------------------------------------------------------------------------------------------
+ *  TAPE DRIVE ABI
+ * -----------------------------------------------------------------------------------------------------------
+ * Note(Ed): One of the main purposes of this codebase is to help me learn this, 
+ * as such the information below may not* be entirely realized or finalized conceptually.
+ * -----------------------------------------------------------------------------------------------------------
+ * This ABI and its associated legos were directly inspired by researching the work of 
+ * Timothy Lottes and Onat Türkçüoğlu; along with many others. It's the simplest bootstrap of a 
+ * directly executed chain of assemby arrays (Atoms) that terminate with a yield sequence to the next atom.
+ * These eventually lead to a terminal atom for the tape which is defined below as "tape_exit".
+ * 
+ * This behaves as one of the simplest runtime harnesses ontop of a host-enviornment's execution engine 
+ * to author and compose programs with. From here various conventions can be further applied. 
+ * To make things easier  to understand it may be better to focus on what this ABI does not have. 
+ * It does not have have any branching within the tape but relative branches within atoms or between atoms.
+ * Branching nearly is always downstream. Atuomatic stack usage is non-existent.
+ * Push/Pop, FIFO, or Arena/Bump data structures are used by atoms explicitly.
+ * In it's current form with the C11 macro DSL, the user also has fullfill manual register allocation per atom.
+ * 
+ * One of the remarkable things about utilizing this ABI is its essentially interopable with CPUs, GPUs, FPGA, 
+ * or, basically anything from the 5th generation consoles and onward.
+ * The ABI directly reflects how all computational hardware must be architected in order to execute 
+ * digital logic effectively on current era tech.
+ * On the PS1 we don't have access to a few features like multi-threading, speculative execution, or L3 cache;
+ * but, we can set the foundation for legoing whats required for eventually expanding this ABI's paradigm 
+ * and core atoms to take those newer hardware features into account. For example, you can easily expand 
+ * this to support wave-based execution model on a PS2 or PS3. Not having a stack or 
+ * automatic register allocation means the user cannott ignore excessive argument shuffle across workload or
+ * waves and thier phases. Crossing ABI boundaries to other runtimes that do has obviouss penalties.
+ * 
+ * Learning data-oreinted code becomes a natural progression. Your not fighting a stack-based procedural 
+ * paradigm that wants to argument shuffle. There is no ambiguity due to the lack of constraints, for example,
+ * on how the user may "call" a procedure in traditional random dispatch runtimes. The user does have to
+ * hammer down "rules" or patterns for massaging the compiler to dissolve those call frames; just to get 
+ * the asesmbly into its desired form. The form is obvious, and once the user gets to author these compoonents
+ * it becomes a game of tetris.
+ * 
+ * Another feature is this ABI is very compatible with bootstrapping and developing simple toolchains built off
+ * of bit-packed annotated command streams the user can directly author, maintatain, and immediately execute.
+ * That being like a color forth, or maybe something more familar like an immediate mode library 
+ * for various systems such as GUIs. This can make the tetris less of a chore with some helpful policy
+ * generation for allocation of registers, helping to choose resuable components, designing DSL on the fly, etc.
+ * -----------------------------------------------------------------------------------------------------------
+ * TODO(Ed): We need pretty ascii diagrams and proper guides, articles, etc.
+ * -----------------------------------------------------------------------------------------------------------
+ * For now this ideation has just started functioning. I'm abusing C11 & a lua metaprogram to help establish 
+ * a hybrid toolchain to ideate on a traditional text-based authoring UX for this paradigm.
+ * If pcsx-redux provides viable hot-reload and persistent data storage beyond save-states
+ * (just copying ram to filesystem), I can author a color forth to mess around with.
+ * With either an editor in-emulator or on the actual machine itself. Assembly is tedius,
+ * but I think this codebase most likely has a pretty ergonomic flavor worst case...
+ * */
+/* Register Allocation Info */
 enum {
 	R_AtomJmp  = R_T8 atom_reg,  /* debug-visible; tape yield handshake scratch */
 	R_TapePtr  = R_T9 atom_reg,  /* The Instruction Stream Pointer */
@@ -59,28 +93,60 @@ enum {
 	R_TScratch6  = R_T6,
 	R_TScratch7  = R_T7,
 	R_TScratch8 =  R_T8,
-	R_TScratch10 = R_V0,
-	R_TScratch11 = R_V1,
+	R_TScratch10 = R_V0, // Tend to be used with gte DMAs
+	R_TScratch11 = R_V1, // Tend to be used with gte DMAs
 	// Note(Ed): We can technically clobber these, but don't unless we hit a bottleneck.
-	// R_TScratch12 = R_A0,
-	// R_TScratch13 = R_A1,
-	// R_TScratch14 = R_A3,
-	// TODO(Ed): Review S0-S7, they are technically avaialble, we just have to snapshot them at the ABI boundary.
-	// TODO(Ed): This is technically a waste of cycles for most work? so maybe only do this for expensive atoms on-demand or atom phases.
-// TODO(Ed): Sort out the other available registers... (Not sure how much is left avail)
+	// A 0-2
+	// S 0-7
 };
 
-#pragma region Tape Drive
-/* ---------------------------------------------------------------------------
- *  TAPE DRIVE ABI & REGISTER ALIASES (the enum moved earlier; see below)
- * ---------------------------------------------------------------------------*/
-typedef Slice_(MipsAtom); typedef Slice_MipsAtom Tape;
+typedef U4 const MipsCode; // Underlying type to mips asm words.
+typedef Slice_(MipsCode);
+
+typedef U4 const MipsAtom; // Underlying type to an array of mips asm words that must terminate with an ac_yield.
+#define MipsAtom_(sym) MipsCode sym [] align_(4) =
+
+// Used for atoms with value-args
+//   FI_ void ac_X(args) MipsAtomComp_Proc_(ac_X, { body })
+// expands to:
+//   FI_ void ac_X(args) { MipsCode ac_X[] align_(4) = { body }; return ac_X; }
+#define MipsAtom_Proc_(sym, aa, ...) { MipsCode sym [] align_(4) = __VA_ARGS__; return atomarena_push(aa, slice_from_array(MipsCode, sym)); }
+
+// 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) =
+
+// Used for components with value-args (mandatory `ab` (atom-builder) arg).
+//   FI_ void ac_X(MipsAtomBuilder_R ab, args) MipsAtomComp_Proc_(ac_X, ab, { body })
+// expands to:
+//   FI_ void ac_X(MipsAtomBuilder_R ab, args) {
+//       MipsCode ac_X[] align_(4) = { body };
+//       atombuilder_unroll(ab, slice_from_array(MipsCode, ac_X));
+//   }
+// The body must NOT include mac_yield() (the parent atom yields).
+// Inline-only callers (the generated `mac_<name>` aliases) skip this arg via metaprogram filtering;
+// escape callers (ac_<name> invoked as a function) pass a long-lived builder.
+#define MipsAtomComp_Proc_(sym, ab, ...) { MipsCode sym [] align_(4) = __VA_ARGS__; atombuilder_push(ab, slice_from_array(MipsCode, sym)); }
+
+/* Line-table anchor: gcc only adds a file to the .debug_line file table when the contains line-numbered content.
+	Files containing only atoms and atom components.
+   Place `ATOM_FILE_LINE_MARKER();` once at file scope in any `.atom.c` that defines atoms.
+	 The macro expands to a file-scope `internal U4 const` declaration keeps the file in the line table.
+	 The constant is in `.rodata` and unreferenced; the linker may eliminate it.
+	 The two-level concat + `__LINE__` suffix makes the identifier unique per call site
+	 (the identifier embeds the source line, so duplicates across `#include`d files don't collide). */
+#define ATOM_FILE_DEBUGGER_LINE_MARKER(file_name) internal U4 const tmpl(atom_file_debugger_line_marker,file_name) = 0
+
+ typedef Slice_(MipsAtom); typedef Slice_MipsAtom Tape;
 
 /* The 'Exit' Atom */
 atom_dbg_skip MipsAtom_(tape_exit) { jump_reg(rret_addr), nop };
 
-//TODO(Ed): Do we backup R_S0-7 here? Have it in a heavier tape run as a opt-in? Same with V0-1 and A0-3?
-/* Generalized Tape Engine Runner */
+// TODO(Ed): When we have a substantial workload/throughput, profile each of these to see impact at ABI boundaries.
+
+/* Tape Runner (Default) */
 FI_ void tape_run(Tape tape) { register U4* tape_ptr rgcc(R_TapePtr) = u4_r(tape.ptr); asm volatile(
 	asm_words(
 		  load_word(  R_AtomJmp, R_TapePtr, 0) /* Bootstrap the first jump */
@@ -91,29 +157,50 @@ FI_ void tape_run(Tape tape) { register U4* tape_ptr rgcc(R_TapePtr) = u4_r(tape
 	asm_rpins, r_use(tape_ptr)
 	asm_clobber: 
 		rlit(R_AT),
-		rlit(R_V0), rlit(R_V1),
+		rlit(R_V0), rlit(R_V1), // We clobber these for GTE ACs (that don't expose register selection, might expose them in the future...)
 		rlit(R_T0), rlit(R_T1), rlit(R_T2), rlit(R_T3), rlit(R_T4),
 		rlit(R_T5), rlit(R_T6), rlit(R_T7), rlit(R_T8),
 		clb_mem_drain 
 ); }
 
+/* Tape Runner (Static and Arg Clobbers) */
+FI_ void tape_run_a02_s07(Tape tape) { register U4* tape_ptr rgcc(R_TapePtr) = u4_r(tape.ptr); asm volatile(
+	asm_words(
+		  load_word(  R_AtomJmp, R_TapePtr, 0) /* Bootstrap the first jump */
+		, add_ui_self(R_TapePtr, S_(MipsAtom)) /* Advance tape */
+		, call_reg(   R_AtomJmp)               /* jalr $t9 */
+		, nop                                  /* Branch delay slot */
+	)
+	asm_rpins, r_use(tape_ptr)
+	asm_clobber: 
+		rlit(R_AT),
+		rlit(R_V0), rlit(R_V1), rlit(R_A0), rlit(R_A1), rlit(R_A2),
+		rlit(R_T0), rlit(R_T1), rlit(R_T2), rlit(R_T3), rlit(R_T4),
+		rlit(R_T5), rlit(R_T6), rlit(R_T7), rlit(R_T8),
+		rlit(R_S0), rlit(R_S1), rlit(R_S2), rlit(R_S3), rlit(R_S4),
+		rlit(R_S5), rlit(R_S6), rlit(R_S7),
+		clb_mem_drain 
+); }
+
+// Procedural authoring of tapes:
 typedef Relative_(FArena) Struct_(TapeBuilder) { U4 ptr; U4 capacity; U4 used; };
 FI_ void        tb_init(TapeBuilder* tb, FArena* arena) { tb->ptr = arena->start; tb->used = 0; }
 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 }; }
+FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ u4_(mem.ptr), mem.len, 0 }; }  /* capacity in elements (matches used units) */
 
-FI_ void tb_emit(TapeBuilder* tb, MipsCode* atom) { u4_r(tb->ptr)[tb->used] = u4_(atom); ++ tb->used; }
+FI_ void tb_emit(TapeBuilder* tb, MipsAtom* 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; }
 #define tb_emit_(atom)        tb_emit(& tb, atom)
 #define tb_data_(field, data) tb_data(& tb, u4_(data))
 
+FI_ void tb_emit_bundle(TapeBuilder_R tb, Slice_MipsAtom atoms) { mem_copy(u4_(tb->ptr), u4_(atoms.ptr), S_slice(atoms)); tb->used += atoms.len; }
+
 FI_ Tape tb_end  (TapeBuilder* tb) { tb_emit(tb,tape_exit); return (Tape){ C_(U4*,tb->ptr), tb->used }; }
 FI_ Tape tb_slice(TapeBuilder  tb) {                        return (Tape){ C_(U4*,tb.ptr),  tb.used }; }
 #define tb_scope(tb)     for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,tape_exit))
 
 FI_ void tb_scope_run_end(TapeBuilder* tb) { tb_emit(tb,tape_exit); tape_run(tb_slice(tb[0])); }
 #define tb_scope_run(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_scope_run_end(tb))
-
 #pragma endregion Tape Drive
 
 #pragma region Macro Mips Atom Components
@@ -123,197 +210,77 @@ FI_ void tb_scope_run_end(TapeBuilder* tb) { tb_emit(tb,tape_exit); tape_run(tb_
  * ---------------------------------------------------------------------------*/
 
 // The 'Yield' sequence for Tape Atoms (mac_yield).
+//   - mac_yield() is the safe default for atom-endings: 4 words, BD-slot of jr is mandatory nop.
+//   - mac_yield_load() + mac_yield_tail():
+//     - unconditional branch: mac_yield_load fills the branch's BD-slot (replaces a nop);
+//     - mac_yield_tail runs at the branch target (does NOT re-load R_AtomJmp).
+
 atom_dbg_skip MipsAtomComp_(ac_yield) {
 	load_word(R_AtomJmp, R_TapePtr, 0),
 	add_ui_self(         R_TapePtr, S_(MipsCode)),
 	jump_reg( R_AtomJmp), nop,
 };
 
-enum {
-	R_PrimCursor = R_T7 atom_reg atom_type(U4*),    /* VRAM output cursor (primitive buffer) */
-	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 atom_reg atom_type(V3_S2*), /* Base address of the vertex array */
-	R_OtBase     = R_T6 atom_reg atom_type(U4*),    /* Base address of the Ordering Table */
-#define R_PrimCursor_Code  R_T7_Code
-#define R_FaceCursor_Code  R_T4_Code
-#define R_VertBase_Code    R_T5_Code
-#define R_OtBase_Code      R_T6_Code
+atom_dbg_skip MipsAtomComp_(ac_yield_load) {
+	load_word(R_AtomJmp, R_TapePtr, 0),
 };
 
-/* Words: 3; Loads 3 S2 indices from the face array */
-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)),
+atom_dbg_skip MipsAtomComp_(ac_yield_tail) {
+	add_ui_self(R_TapePtr, S_(MipsCode)),
+	jump_reg(  R_AtomJmp), nop,
 };
-
-/* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
-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),
-};
-
-/* 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. */
-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,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
-	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,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_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
-};
-
-/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
- * Hardcoded for Poly_G4 (9 words). For Poly_F3, use 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,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
-	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,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_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	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. */
-FI_ Slice_MipsCode ac_pack_color_word(U4 off, U4 cmd, U1 r, U1 g, U1 b)
-atom_dbg_skip MipsAtomComp_Proc_(ac_pack_color_word, {
-	load_upper_i(R_AT, (cmd) << 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). */
-FI_ Slice_MipsCode ac_format_f3_color(U1 r, U1 g, U1 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). */
-atom_dbg_skip MipsAtomComp_(ac_gte_store_f3) {
-	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)),
-};
-
-/* Words: 12; Emits the four (code|color) words of a Poly_G4.
- * Args: rN,gN,bN are 8-bit RGB byte values for each of the 4 vertices. */
-FI_ Slice_MipsCode ac_format_g4_color(
-	U1 r0, U1 g0, U1 b0,
-  U1 r1, U1 g1, U1 b1,
-  U1 r2, U1 g2, U1 b2,
-  U1 r3, U1 g3, U1 b3)
-MipsAtomComp_Proc_(ac_format_g4_color, {
-	mac_pack_color_word(O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0),
-	mac_pack_color_word(O_(Poly_G4,c1), 0,               r1,g1,b1),
-	mac_pack_color_word(O_(Poly_G4,c2), 0,               r2,g2,b2),
-	mac_pack_color_word(O_(Poly_G4,c3), 0,               r3,g3,b3),
-})
-
-/* 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, SXY2=v2.screen). 
- * 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). */
-atom_dbg_skip MipsAtomComp_(ac_gte_store_g4_p012) {
-	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)),
-};
-
-/* 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 earlier RTPT.
- */
-atom_dbg_skip MipsAtomComp_(ac_gte_store_g4_p3) { gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3)) };
-
 #pragma endregion Macro Atom Components
 
-#pragma region Mips Atom Builder
-// This allows for runtime procedural authoring of mips atoms.
+#pragma region Atom Builder
+// This helps with runtime procedural authoring of mips atoms.
 
 typedef Struct_(FMipsAtom512) { U4 data[512]; U4 used; };
 
 // FArena Related
-typedef Relative_(FArena) Struct_(MipsAtomBuilder) { U4 start; U4 capacity; U4 used; };
-// Whatever the builder is writting to should most likely coresspond
-// to something that can fit within instruction cache?
+typedef Relative_(FArena) Struct_(AtomBuilder) { U4 start; U4 capacity; U4 used; };
 
-FI_ void atombuilder_unroll(MipsAtomBuilder_R ab, Slice_MipsCode_R code) {
-	assert(ab->capacity - ab->used - code->len);
-	mem_copy(ab->start, u4_(code->ptr), code->len);
-	mem_bump(ab->start, ab->capacity, & ab->used, code->len);
+// Usual way to resolve an atom after the bulder is done.
+#define atom_from_atombuilder(ab) C_(MipsAtom*, (ab).start)
+
+FI_ void atombuilder_push(AtomBuilder_R ab, Slice_MipsCode code) {
+	assert(ab->capacity - ab->used - code.len);
+	U4 dest = ab->start + ab->used * S_(MipsCode);
+	mem_copy(dest, u4_(code.ptr), S_slice(code));
+	mem_bump(ab->start, ab->capacity, & ab->used, code.len);
 }
-#define atombuilder_unroll_mac(ab, mac) atombuilder_unroll(ab, slice_arg_from_array(Slice_MipsCode, mac))
+#define atombuilder_push_mac(ab, mac) atombuilder_push(ab, slice_arg_from_array(Slice_MipsCode, mac))
 
-// When done authoring, utilize this to cap-off the atom
-FI_ void atombuilder_end(MipsAtomBuilder_R ab) {
-	mem_copy(ab->start, u4_(ac_yield), S_(ac_yield));
-	mem_bump(ab->start, ab->capacity, & ab->used, S_(ac_yield));
-}
-
-#define mipsatom_from_builder(ab) (Slice_MipsCode){ab.start, ab.used}
+// When done authoring, utilize this to cap-off the atom (if not utilizing a MipsAtom_Proc).
+FI_ void atombuilder_end(AtomBuilder_R ab) { atombuilder_push(ab, slice_from_array(MipsCode, ac_yield)); }
 
+FI_ void tb_emit_atombuilder(TapeBuilder_R tb, AtomBuilder_R ab) { tb_emit(tb, atom_from_atombuilder(ab[0])); }
 #pragma endregion Mips Atom Builder
 
+#pragma region Atom Arena
+typedef Relative_(FArena) Struct_(AtomArena) { U4 start; U4 capacity; U4 used; };
+
+#define atomarena_unused_start(ab) ((ab).start + (ab).used * S_(MipsCode))
+FI_ void atomarena_init(AtomArena_R arena, Slice mem) {  assert(arena != nullptr);
+	arena->start    = u4_(mem.ptr);
+	arena->capacity = mem.len;
+	arena->used     = 0;
+}
+FI_ AtomArena atomarena_make(Slice mem) { AtomArena a; atomarena_init(& a, mem); return a; }
+FI_ MipsAtom* atomarena_push(AtomArena_R aa, Slice_MipsCode code) {
+	assert(aa->capacity - aa->used - code.len);
+	U4 dest = atomarena_unused_start(aa[0]);
+	mem_copy(dest, u4_(code.ptr), S_slice(code));
+	mem_bump(aa->start, aa->capacity, & aa->used, code.len);
+	return C_(MipsAtom*, dest);
+}
+FI_ void atomarena_reset(AtomArena_R aa) { aa->used = 0; }
+#pragma region Atom Arena
+
+#pragma region Mips Atom Procs
+
+#pragma endregion Mips Atom Procs
+
 #pragma region Baked Mips Atoms
 // These atoms are resolved at compile time and are (usually) statically linked readonly data.
 
-enum {
-	bios_flushcache = 0x44,
-	bios_table_addr = 0xA0,
-};
-
-/* Flushes the Instruction Cache (PSX A-function 0x44 via BIOS stub at 0xA0).
- * Sequence (per MIPS ABI; arguments in arg registers, RA pushed to stack):
- *   1. sp -= 8;  sw $ra, 4($sp)        ; save RA
- *   2. $a0 = bios_flushcache (arg0)
- *   3. $t0 = bios_table_addr           ; t0 = &BIOS A-function table
- *   4. jalr $t0, $ra                   ; call BIOS(flushcache)
- *      nop                             ; branch delay slot
- *   5. lw $ra, 4($sp);  jr $ra         ; restore & return
- *   6. sp += 8
- */
-internal MipsAtom_(mips_flush_icache) {
-	add_ui(rstack_ptr, rstack_ptr, -MipsStackAlignment), // sp -= 8
-	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), nop,                   // jalr  $t0, $ra, 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) 
-	mac_yield(),
-};
-
-typedef Struct_(Binds_SetGteWorld) {
-	M3_S2* transform;
-};
-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)),
-	/* Load 3x3 Rotation + 3x1 Translation from R_T3 into GTE CONTROL Regs (ctc2) */
-	load_word(R_T0, R_T3, 0),  load_word(R_T1, R_T3,  4),
-	gte_mv_to_ctrl_r(R_T0, gte_cr_RT11), gte_mv_to_ctrl_r(R_T1, gte_cr_RT12),
-	load_word(R_T0, R_T3, 8),  load_word(R_T1, R_T3, 12), load_word(R_T2, R_T3, 16),
-	gte_mv_to_ctrl_r(R_T0, gte_cr_RT13), gte_mv_to_ctrl_r(R_T1, gte_cr_RT21), gte_mv_to_ctrl_r(R_T2, gte_cr_RT22),
-	load_word(R_T0, R_T3, 20), load_word(R_T1, R_T3, 24), load_word(R_T2, R_T3, 28),
-	gte_mv_to_ctrl_r(R_T0, gte_cr_TRX),  gte_mv_to_ctrl_r(R_T1, gte_cr_TRY),  gte_mv_to_ctrl_r(R_T2, gte_cr_TRZ),
-	mac_yield()
-};
-
 #pragma endregion Baked Mips Atoms

code/duffle/math.atom.c

@@ -0,0 +1,47 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+#	include "math.h"
+#	include "lottes_tape.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(math_atom_c);
+
+#pragma region MACs (Mips Atom Component)
+
+FI_ Slice_MipsCode ac_load_v2s2(AtomBuilder_R ab, U4 rs_x, U4 rs_y, U4 r_base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_load_v2s2, ab, {
+	load_half( rs_x, r_base, O_(V3_S2,x)),
+	load_half( rs_y, r_base, O_(V3_S2,y)),
+})
+
+FI_ Slice_MipsCode ac_store_v2s2(AtomBuilder_R ab, U4 rt_x, U4 rt_y, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_v2s2, ab, {
+	store_half(rt_x, base, offset + O_(V2_S2,x)),
+	store_half(rt_y, base, offset + O_(V2_S2,y)),
+})
+
+FI_ Slice_MipsCode ac_load_v3s4(AtomBuilder_R ab, U4 rs_x, U4 rs_y, U4 rs_z, U4 r_base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_load_v3s4, ab, {
+	load_word( rs_x, r_base, O_(V3_S4,x)),
+	load_word( rs_y, r_base, O_(V3_S4,y)),
+	load_word( rs_z, r_base, O_(V3_S4,z)),
+})
+
+FI_ Slice_MipsCode ac_store_v3s4(AtomBuilder_R ab, U4 rt_x, U4 rt_y, U4 rt_z, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_v3s4, ab, {
+	store_word(rt_x, base, offset + O_(V3_S4,x)),
+	store_word(rt_y, base, offset + O_(V3_S4,y)),
+	store_word(rt_z, base, offset + O_(V3_S4,z)),
+})
+
+FI_ Slice_MipsCode ac_sub_v3s4(AtomBuilder_R ab, U4 rds_x, U4 rds_y, U4 rds_z, U4 rt_x,  U4 rt_y,  U4 rt_z) atom_dbg_skip MipsAtomComp_Proc_(ac_sub_v3s4, ab, {
+	sub_s(rds_x, rds_x, rt_x),
+	sub_s(rds_y, rds_y, rt_y),
+	sub_s(rds_z, rds_z, rt_z),
+})
+
+FI_ Slice_MipsCode ac_store_rects2(AtomBuilder_R ab, U4 rt_x, U4 rt_y, U4 rt_width, U4 rt_height, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_rects2, ab, {
+	store_half(rt_x,      base, offset + O_(Rect_S2,x)),
+	store_half(rt_y,      base, offset + O_(Rect_S2,y)),
+	store_half(rt_width,  base, offset + O_(Rect_S2,width)),
+	store_half(rt_height, base, offset + O_(Rect_S2,height)),
+})
+
+#pragma endregion MACs (Mips Atom Component)

code/duffle/math.h

@@ -7,6 +7,18 @@
 #define max(A, B)       (((A) > (B)) ? (A) : (B))
 #define clamp_bot(X, B) max(X, B)
 
+/* Convention
+<Type> ## <Width> _ <Component Type> ## <Component Width>
+For types with compound data (Ex: Rotation Matrix & Translation):
+<TypeA> ## <TypeB> ## <Width> _ <ComponentTypeA> ## <ComponentWidthA> ## <ComponentTypeB> ## <ComponentWidthB>
+
+A: Array
+V: Vector
+R: Range
+M: Matrix
+T: Translation
+*/
+
 enum { 
 	v3s2_byteoff = 3, // log2(8), used with shift_left_logical op for index via byte offset.
 };
@@ -26,23 +38,38 @@ typedef Struct_(Extent2_S4) { S4 width; S4 height; };
 typedef Struct_(V2_U1)      { U1 x; U1 y; };
 typedef Struct_(V2_S2)      { S2 x; S2 y; };
 typedef Struct_(V2_S4)      { S4 x; S4 y; };
-typedef Struct_(V3_S2)      { S2 x; S2 y; S2 z; S2 pad; };
-typedef Struct_(V3_S4)      { S4 x; S4 y; S4 z; S4 pad; };
+typedef Struct_(V3_S2)      { S2 x; S2 y; S2 z; S2 pad; }; // PSY-Q: SVECTOR
+typedef Struct_(V3_S4)      { S4 x; S4 y; S4 z; S4 pad; }; // PSY-Q: VECTOR. RGA(Lengyel): Euclidean vector or direction. A zero-weight RGA point is stored as a V3_S4 with the implicit weight dropped.
 typedef Struct_(V4_S2)      { S2 x; S2 y; S2 z; S2 w; };
 typedef Struct_(V4_S4)      { S4 x; S4 y; S4 z; S4 w; };
 
-typedef Struct_(R2_S2)      { V2_S2 p0; V2_S2 p1; };
-typedef Struct_(R2_S4)      { V2_S4 p0; V2_S4 p1; };
+// typedef Struct_(P3_S4)      { S4 x; S4 y; S4 z; S4 w1; }; // RGA(Lengyel): Affine point with implicit weight one. Storage alias of V3_S4. Use P3_S4 when the value is a point.
+typedef V3_S4 P3_S4;
+
+typedef Struct_(R2_S2)      { V2_S2 p0; V2_S2 p1; }; // Range-2 Signed 2-Byte (16-bit)
+typedef Struct_(R2_S4)      { V2_S4 p0; V2_S4 p1; }; // Range-2 Signed 4-Byte (32-bit)
 
 typedef Struct_(Rect_S2)    { S2 x; S2 y; S2 width; S2 height; };
 typedef Struct_(Rect_S4)    { S4 x; S4 y; S4 width; S4 height; };
 
-typedef Struct_(M3_S2) { A3x3_S2 m; A3_S4 t; };
+typedef Struct_(MT3_S2S4)   { A3x3_S2 m; A3_S4 t; }; // PSY-Q: MATRIX. RGA(Lengyel): Matrix expansion of a rigid transformation. GTE utilizes this representation; corresponding motor not constructed here.
 
+/* RGA(Lengyel) reserved names (deferred):
+ *   P4_S4  - future flat point with explicit weight (Lengyel/TML FlatPoint3D analog).
+ *   B3_S4  - future 3D bivector (callers store a Complement(Wedge(...)) as a V3_S4).
+ *   Mo8_S4 - future motor. Not introduced until a course operation actually needs composition, interpolation, or inversion. */
+
+typedef Array_(V2_U1, 2);
 typedef Array_(V2_S2, 2);
 typedef Array_(V2_S2, 3);
 typedef Array_(V2_S2, 4);
 
+enum {
+	fp_one = (1 << 12),
+};
+
+#define v3s4_fp_one() v3s4(fp_one, fp_one, fp_one)
+
 #define v2s2(x,y)     (V2_S2){x,y}
 #define v3s2(x,y,z)   (V3_S2){x,y,z,0}
 #define v3s4(x,y,z)   (V3_S4){x,y,z,0}
@@ -61,10 +88,28 @@ FI_ void add_a3s4_fp(A3_S4_R out_a, A3_S4 b) {
 	(out_a[0])[2] += b[2] >> 1;
 }
 
-FI_ void add_v3s4(V3_S4_R out_a, V3_S4 b) { 
-	add_a3s4(pcast(A3_S4_R, out_a), pcast(A3_S4, b)); 
+FI_ void sub_a3s4(A3_S4_R out_a, A3_S4 b) {
+	(out_a[0])[0] -= b[0];
+	(out_a[0])[1] -= b[1];
+	(out_a[0])[2] -= b[2];
 }
 
-FI_ void add_v3s4_fp(V3_S4_R out_a, V3_S4 b) { 
-	add_a3s4_fp(pcast(A3_S4_R, out_a), pcast(A3_S4, b)); 
+FI_ void sub_a3s4_fp(A3_S4_R out_a, A3_S4 b) {
+	(out_a[0])[0] -= b[0] >> 1;
+	(out_a[0])[1] -= b[1] >> 1;
+	(out_a[0])[2] -= b[2] >> 1;
 }
+
+FI_ void mul_a3s4(A3_S4_R out_a, A3_S4 b) {
+	(out_a[0])[0] *= b[0];
+	(out_a[0])[1] *= b[1];
+	(out_a[0])[2] *= b[2];
+}
+
+FI_ void add_v3s4   (V3_S4_R out_a, V3_S4 b) {  add_a3s4   (pcast(A3_S4_R, out_a), pcast(A3_S4, b));  }
+FI_ void add_v3s4_fp(V3_S4_R out_a, V3_S4 b) {  add_a3s4_fp(pcast(A3_S4_R, out_a), pcast(A3_S4, b));  }
+
+FI_ void sub_v3s4   (V3_S4_R out_a, V3_S4 b) {  sub_a3s4   (pcast(A3_S4_R, out_a), pcast(A3_S4, b));  }
+FI_ void sub_v3s4_fp(V3_S4_R out_a, V3_S4 b) {  sub_a3s4_fp(pcast(A3_S4_R, out_a), pcast(A3_S4, b));  }
+
+FI_ void mul_v3s4   (V3_S4_R out_a, V3_S4 b) {  mul_a3s4   (pcast(A3_S4_R, out_a), pcast(A3_S4, b));  }

code/duffle/memory.h

@@ -58,13 +58,13 @@ typedef Struct_(Str8)        { UTF8* ptr; U4 len; };
 typedef Struct_(Slice_Str8)  { Str8* ptr; U4 len; };
 #define slit(string_literal) (Str8){ (UTF8*) string_literal, S_(string_literal) - 1 }
 
-typedef Struct_(Slice) { U4 ptr, len; }; // Untyped Slice
-FI_ Slice slice_ut_(U4 ptr, U4 len) { return (Slice){ptr, len}; }
+typedef Struct_(Slice) { B1* ptr; U4 len; }; // Untyped Slice (byte-addressable; .len in elements)
+FI_ Slice slice_ut_(U4 ptr, U4 len) { return (Slice){(B1*)ptr, len}; }
 
 #define Slice_(type)       Struct_(tmpl(Slice,type)) { type* ptr; U4 len; }
 typedef Slice_(B1);
 #define slice_assert(s)    do { assert((s).ptr != 0); assert((s).len > 0); } while(0)
-#define slice_end(slice)   ((slice).ptr + (slice).len)
+#define slice_end(slice)   ((slice).ptr + S_slice(slice) / S_(B1))  /* byte-ptr arithmetic; .len is in elements per slice convention */
 #define S_slice(s)         ((s).len * S_((s).ptr[0]))
 
 #define slice_ut(ptr,len)  slice_ut_(u4_(ptr),     u4_(len))
@@ -73,22 +73,23 @@ typedef Slice_(B1);
 
 #define slice_iter(container, iter)     (T_((container).ptr) iter = (container).ptr; iter != slice_end(container); ++ iter)
 #define slice_arg_from_array(type, ...) & (tmpl(Slice,type)) { .ptr = array_decl(type,__VA_ARGS__), .len = array_len( array_decl(type,__VA_ARGS__)) }
-#define slice_from_array(type, array)     (tmpl(Slice,type)) { .ptr = array, .len = S_(array) }
+#define slice_from_array(type, array)     (tmpl(Slice,type)) { .ptr = array, .len = S_(array) / S_(type) }
 
-FI_ void slice_zero_(Slice s) { slice_assert(s); mem_zero(s.ptr, s.len); }
+FI_ void slice_zero_(Slice s) { slice_assert(s); mem_zero(u4_(s.ptr), s.len); }
 #define  slice_zero(s)        slice_zero_(slice_to_ut(s))
 
 FI_ void slice_copy_(Slice dest, Slice src) {
-	assert(dest.len >= src.len);
+	assert(S_slice(dest) >= S_slice(src));
 	slice_assert(dest);
 	slice_assert(src);
-	mem_copy(dest.ptr, src.ptr, src.len);
+	mem_copy(u4_(dest.ptr), u4_(src.ptr), S_slice(src));
 }
 #define slice_copy(dest, src) do {  \
 	static_assert(T_same(dest, src)); \
 	slice_copy_(slice_to_ut(dest), slice_to_ut(src)); \
 } while(0)
 
+typedef Slice_(U1);
 typedef Slice_(U4);
 
 #pragma endregion Slice
@@ -98,7 +99,7 @@ typedef Slice_(U4);
 typedef Opt_(farena)    { U4 alignment, type_width; };
 typedef Struct_(FArena) { U4 start, capacity, used; };
 FI_ void farena_init(FArena_R arena, Slice mem) {  assert(arena != nullptr);
-	arena->start    = mem.ptr;
+	arena->start    = u4_(mem.ptr);
 	arena->capacity = mem.len;
 	arena->used     = 0;
 }
@@ -109,7 +110,7 @@ I_  Slice  farena_push(FArena_R arena, U4 amount, Opt_farena o) {
 	U4 to_commit = align_pow2(desired, o.alignment ?  o.alignment : MEM_ALIGNMENT_DEFAULT);
 	U4 ptr       = arena->start + arena->used;
 	mem_bump(arena->start, arena->capacity, & arena->used, to_commit);
-	return (Slice){ ptr, to_commit };
+	return (Slice){ (B1*)ptr, to_commit };
 }
 FI_ void farena_reset (FArena_R arena) { arena->used = 0; }
 FI_ void farena_rewind(FArena_R arena, U4 save_point) {
@@ -117,6 +118,7 @@ FI_ void farena_rewind(FArena_R arena, U4 save_point) {
 	arena->used -= save_point - arena->start;
 }
 FI_ U4 farena_save(FArena arena)  { return arena.used; }
+FI_ U4 farena_unused_start(FArena arena) { return arena.start + arena.used; }
 #define farena_push_(arena, amount, ...)                                          farena_push((arena), (amount), opt_(farena, __VA_ARGS__))
 #define farena_push_type(arena, type, ...)                              C_(type*, farena_push((arena), 1,        opt_(farena, .type_width=S_(type), __VA_ARGS__)).ptr)
 #define farena_push_array(arena, type, amount, ...) (tmpl(Slice,type)){ C_(type*, farena_push((arena), (amount), opt_(farena, .type_width=S_(type), __VA_ARGS__)).ptr), (amount) }

code/duffle/mips.atom.c

@@ -0,0 +1,34 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+#	include "bios.h"
+#	include "lottes_tape.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(mips_atom_c);
+
+#pragma region Baked Atoms
+
+/* Flushes the Instruction Cache (PSX A-function 0x44 via BIOS stub at 0xA0).
+ * Sequence (per MIPS ABI; arguments in arg registers, RA pushed to stack):
+ *   1. sp -= 8;  sw $ra, 4($sp)        ; save RA
+ *   2. $a0 = bios_flushcache (arg0)
+ *   3. $t0 = bios_table_addr           ; t0 = &BIOS A-function table
+ *   4. jalr $t0, $ra                   ; call BIOS(flushcache)
+ *      nop                             ; branch delay slot
+ *   5. lw $ra, 4($sp);  jr $ra         ; restore & return
+ *   6. sp += 8
+ */
+internal MipsAtom_(mips_flush_icache) {
+	add_ui(rstack_ptr, rstack_ptr, -MipsStackAlignment), // sp -= 8
+	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), nop,                   // jalr  $t0, $ra, 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) 
+	mac_yield(),
+};
+
+#pragma endregion Baked Atoms

code/duffle/mips.h

@@ -348,6 +348,12 @@ enum { _BitOffsets = 0
 #define shift_lright(rd, rt, shamt) enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_srl)
 #define shift_aright(rd, rt, shamt) enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_sra)
 
+/* Shift Variable — register-shift forms.
+ * shift_lleft_var(rd, rt, rs)  → sllv rd, rt, rs   (shamt in low 5 bits of rs)
+ * shift_aright_var(rd, rt, rs) → srav rd, rt, rs */
+#define shift_lleft_var(rd, rt, rs)  enc_r(op_special, (rs), (rt), (rd), 0, fc_sllv)
+#define shift_aright_var(rd, rt, rs) enc_r(op_special, (rs), (rt), (rd), 0, fc_srav)
+
 #define shift_lleft_self(rd_rt, shamt) enc_r(op_special, R_0, (rd_rt), (rd_rt), (shamt), fc_sll)
 
 #define mask_upper(rd, rt, shamt) shift_lleft(rd, rt, shamt), shift_lright(rd, rt, shamt)
@@ -362,10 +368,26 @@ enum { _BitOffsets = 0
 /* call_reg rs — jump-and-link to register-held address; link in $ra. */
 #define call_reg(rs)               jump_link((rs), R_RA)
 
-/* j target — absolute jump within the current 256MB region. */
+/* j target — absolute jump within the current 256MB region.
+ * WARNING: `jump(off)` CANNOT BE USED for within-atom jumps in the current pipeline.
+ * The MIPS j opcode encodes `(target_addr >> 2)` in its 26-bit immediate field; an  ABSOLUTE byte address, not a relative word offset.
+ * The metaprogram computes `off` as a relative word offset (`target_word_idx - branch_word_idx - 1`), which the assembler/linker does NOT resolve.
+ * `jump(off)` is only safe when the BUILD PIPELINE owns the absolute position of the emitted code — i.e. when: s
+ *   - the build emits a symbol-relative `.word` expression that the linker resolvess via `R_MIPS_26`, OR
+ *   - the code is hand-assembled with explicit absolute targets, OR a custom post-build patcher resolves the 26-bit field.
+ * TODO(Ed): Review this.. technically we can resolve aboslute jumps on baked atoms? (Even proedurally generated ones...)
+ */
 #define jump(off)                  enc_i(op_j,     R_0, R_0, (off))
 
-/* call_addr off — jump-and-link to immediate address. */
+/* jump_rel off — unconditional relative jump (the within-atom-safe `jump`).
+ * MIPS I R3000A has no "branch always" opcode. The idiom for an unconditional relative jump is `beq $0, $0, off`. */
+#define jump_rel(off)              branch_equal(R_0, R_0, (off))
+
+/* call_addr off — jump-and-link to immediate address.
+ * Same WARNING as `jump(off)` above: the jal opcode also encodes an absolute 26-bit target.
+ * For within-atom calls, the current pipeline has no equivalent always-taken call-and-link idiom.
+ * Workaround: `branch_link` (always-taken branch + explicit `la $ra, next_word_addr; jr $ra`), or just use `call_reg($tmp)` after loading the target into a register.
+ */
 #define call_addr(off)             enc_i(op_jal,   R_0, R_0, (off))
 
 /* --- Store family (mirrors the load family) --- */
@@ -379,13 +401,7 @@ enum { _BitOffsets = 0
  * sub_s / sub_u  → sub / subu
  * 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 _Generic-based signed integer-arithmetic helpers for U1/U2/U4.
- * Those live in a different conceptual layer (generic arithmetic on DSL 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
+ */
 #define add_s(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_add)
 #define add_u(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_addu)
 #define sub_s(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_sub)
@@ -440,6 +456,9 @@ enum { _BitOffsets = 0
 #define nop  shift_lleft(rdiscard, rdiscard, 0)
 #define nop2 nop, nop
 
+// li_s — load signed 16-bit immediate into GPR (addiu rt, $0, imm — sign-extends).
+#define li_s(rt, imm)  add_ui((rt), R_0, (imm))
+
 #define load_imm_1w(rt, imm)    add_ui((rt),  R_0, (imm))
 #define load_imm_1w_s0(rt, imm) add_si((rt)), R_0, (imm))
 

code/duffle/pad.atom.c

@@ -0,0 +1,195 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#		include "gen/macs.h"
+#		include "gen/offsets.h"
+#	include "mips.h"
+#	include "dsl.atom.h"
+#	include "lottes_tape.h"
+#	include "pad.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(pad_atom_c);
+
+#pragma region MACs (Mips Atom Components)
+
+FI_ Slice_MipsCode ac_pad_set_centered_axes(AtomBuilder_R ab, U4 r_state, U4 r_scratch) atom_dbg_skip MipsAtomComp_Proc_(ac_pad_set_centered_axes, ab, {
+    load_upper_i(r_scratch, (PadAxis_Centered_Word >> 16) & 0xFFFF),
+    or_i_self(   r_scratch,  PadAxis_Centered_Word        & 0xFFFF),
+    store_word(  r_scratch, r_state, O_(PadState,axes)),
+})
+
+FI_ Slice_MipsCode ac_pad_set_id_byte(AtomBuilder_R ab, U1 r_state, U1 r_id, U1 id_value) atom_dbg_skip MipsAtomComp_Proc_(ac_pad_set_id_byte, ab, {
+    add_ui(    r_id, R_0, id_value),
+    store_byte(r_id, r_state, O_(PadState,id)),
+})
+
+FI_ Slice_MipsCode ac_pad_set_status(AtomBuilder_R ab, U4 r_tmp, U1 r_state, U4 pad_status) atom_dbg_skip MipsAtomComp_Proc_(ac_pad_set_status, ab, {
+    add_ui(    r_tmp, R_0, pad_status),
+    store_word(r_tmp, r_state, O_(PadState,status)),
+})
+
+/* Invert r_buttons (active-low → active-high) and store to PadState.buttons.
+ * r_buttons must already be loaded (the caller is responsible for filling the load-delay slot of
+ * the preceding load_half_u with an instruction that doesn't read r_buttons). */
+FI_ Slice_MipsCode ac_pad_store_inverted_buttons(AtomBuilder_R ab, U1 r_buttons, U1 r_pad_state) atom_dbg_skip MipsAtomComp_Proc_(ac_pad_store_inverted_buttons, ab, {
+    nor_u(       r_buttons, r_buttons, R_0),
+    store_half(  r_buttons, r_pad_state, O_(PadState,   buttons)),
+})
+
+#pragma endregion MACs (Mips Atom Components)
+
+#pragma region Baked Atoms
+
+/* ----- pad_bios_snapshot -----
+ * Per-frame snapshot of one BIOS pad buffer into PadState.
+ * Decoder (branch ladder on raw[0] status + raw[1] id):
+ *   1. raw[0] == 0xFF         -> Disconnected (buttons=0, axes=0x80)
+ *   2. raw[0]==0 && raw[1]==0 -> Pending      (buttons=0, axes=0x80)
+ *   3. raw[1] == 0x41         -> Digital      (buttons normalized; axes=0x80)
+ *   4. raw[1] == 0x53         -> AnalogStick  (buttons normalized; axes from raw[4..7])
+ *   5. raw[1] in 0x7x         -> AnalogPad    (buttons normalized; axes from raw[4..7])
+ *   6. else                   -> Unsupported  (buttons=0, axes=0x80)
+ *
+ * Buttons normalization: byte_swap16((~raw_buttons) & 0xFFFF).
+ *   raw_buttons    = load_half_u(raw, 2) = raw[2] | (raw[3] << 8).
+ *   byte_swap16(x) = (x >> 8) | (x << 8); nor(x, R_0) = ~x. store_half truncates to 16 bits so the upper-16 mask is implicit in the store.
+ *
+ * Register use (atom-local; no wave-context touched):
+ *   R_T0 = raw base      (kept throughout; axes loads read raw[4..7] from R_T0)
+ *   R_T1 = state base    (kept throughout; all stores go through R_T1)
+ *   R_T2 = raw[0] status (alive across the disc/pending/id dispatch, then dead)
+ *   R_T3 = raw[1] id     (alive across the id dispatch, then dead)
+ *   R_T4 = scratch       (shifts, compares, immediate loads, store values)
+ *   R_T5 = scratch       (parallel lui+ori for the 0x80808080 axes constant + byte-swap target)
+ */
+enum {
+	R_PadRaw    = R_T0 atom_reg atom_type(U1),
+	R_PadState  = R_T1 atom_reg atom_type(PadState*),
+	R_RawStatus = R_T2 atom_reg,
+	R_RawId     = R_T3 atom_reg,
+};
+typedef Struct_(Binds_PadBiosSnapshot) {
+    PadBiosRaw* raw;
+    PadState*   state;
+};
+internal MipsAtom_(pad_bios_snapshot) atom_info(atom_bind(Binds_PadBiosSnapshot)
+, atom_reads( R_PadRaw, R_PadState, R_RawStatus, R_RawId)
+, atom_writes(R_PadRaw, R_PadState, R_RawStatus, R_RawId)
+) {
+	/* === Bind consumption: T0 = raw, T1 = state, advance R_TapePtr by 8. */
+	load_word(R_PadRaw,   R_TapePtr, O_(Binds_PadBiosSnapshot,raw)),
+	load_word(R_PadState, R_TapePtr, O_(Binds_PadBiosSnapshot,state)),
+	add_ui_self(          R_TapePtr, S_(Binds_PadBiosSnapshot)),
+
+	/* === Read raw[0] (status) + raw[1] (id) */
+	load_byte_u(R_RawStatus, R_PadRaw, O_(PadBiosRaw,status)),
+	load_byte_u(R_RawId,     R_PadRaw, O_(PadBiosRaw,id)),
+
+atom_label(snap_root) /* === Case 1: Disconnected (status == 0xFF). */
+	add_ui(R_T4, R_0, PadRawStatus_Timeout), branch_ne(R_RawStatus, R_T4, atom_offset(snap_root, skip_disconnected)),
+	/* BD-slot: pre-compute PadStatus_Disconnected. Branch reads R_T4=0xFF in EX before this WB completes.
+	 * If branch NOT taken (fall through to pending/id_dispatch), R_T4 is overwritten by the next case body's add_ui — harmless. */
+
+atom_label(disconnected) /* === Disconnected body. */
+	mac_pad_set_status(R_T4,  R_PadState, PadStatus_Disconnected),
+	store_half(        R_0,   R_PadState, O_(PadState,buttons)),
+	mac_pad_set_centered_axes(R_PadState, R_T4),
+	mac_pad_set_id_byte(R_PadState, R_RawId, PadRawStatus_Timeout),
+	jump_rel(atom_offset(disconnected, snap_end)),
+		/* BD-slot: load next atom's entry point (replaces the nop).
+		 * Always jumps to snap_end, where mac_yield_tail() transfers control to R_AtomJmp without re-loading it. */
+		mac_yield_load(),
+atom_label(skip_disconnected)
+
+	/* === Case 2: Pending (status == 0 && id == 0)
+	 * Combined check: if (status | id) != 0 then skip to id_dispatch. Falls through to the Pending case only when both are zero. */
+	or_u_self(R_RawStatus, R_RawId), branch_ne(R_RawStatus, R_0, atom_offset(case_2, id_dispatch)),
+	/* BD-slot: pre-compute PadStatus_Pending. Branch reads R_RawStatus in EX before this WB completes.
+	 * If branch NOT taken (fall through to id_dispatch), R_T4 is overwritten by the digital/analog body add_ui - harmless. */
+
+atom_label(pending) /* === Pending body (status=0, id=0 — pre-IRQ-empty buffer). */
+	mac_pad_set_status(R_T4,  R_PadState, PadStatus_Pending),
+	store_half(        R_0,   R_PadState, O_(PadState,buttons)),
+	mac_pad_set_centered_axes(R_PadState, R_T4),
+	store_byte(R_RawId, R_PadState, O_(PadState,id)),
+	jump_rel(atom_offset(pending, snap_end)),
+		mac_yield_load(),
+
+atom_label(id_dispatch) /* === Case 3-6: ID dispatch */
+	add_ui(R_T4, R_0, PadRawId_Digital), branch_ne(R_RawId, R_T4, atom_offset(id_dispatch, try_analog_stick)),
+	/* BD-slot: pre-compute PadStatus_Digital. Branch reads R_RawId in EX before this WB completes.
+	 * If branch NOT taken (fall through to try_analog_stick), R_T4 is overwritten by the analog body add_ui. */
+
+	/* === Digital body (status, buttons normalize, axes=0x80, id, branch.
+	 * R_T5 holds the 0x80808080 axes constant (loaded into the load-delay slot of the buttons-load).
+	 * R_T5 is then "dead" — only consumed at the analog_pad range check downstream. */
+	mac_pad_set_status(R_T4, R_PadState, PadStatus_Digital),
+	load_half_u(       R_T4, R_PadRaw, O_(PadBiosRaw, buttons)), /* R_T4 = raw_buttons; */
+	load_upper_i(R_T5, PadAxis_Centered_Hi), or_i_self(R_T5, PadAxis_Centered_Lo), /* fills the buttons-load's delay slot (doesn't read R_T4) */
+	mac_pad_store_inverted_buttons(R_T4, R_PadState),            /* R_T4 settled: nor + sh writes ~raw_buttons to state.buttons */
+	store_word(R_T5,    R_PadState, O_(PadState, axes)),         /* single sw writes the 4-byte axes block at offset 8 (left_x, left_y, right_x, right_y) */
+	mac_pad_set_id_byte(R_PadState, R_T4, PadRawId_Digital),
+
+	jump_rel(atom_offset(id_dispatch, snap_end)),
+		mac_yield_load(),
+
+atom_label(try_analog_stick) /* === Case 4: AnalogStick (id == 0x53)*/
+	add_ui(R_T4, R_0, PadRawId_AnalogStick), branch_ne(R_RawId, R_T4, atom_offset(try_analog_stick, try_analog_pad)),
+	/* BD-slot: pre-compute PadStatus_AnalogStick. Branch reads R_RawId in EX before this WB completes.
+	 * If branch NOT taken (fall through to try_analog_pad), R_T4 is overwritten by the analog_pad body add_ui. */
+
+atom_label(analog_stick) /* === AnalogStick body
+	* R_T5 holds left_xy (loaded into the load-delay slot of the buttons-load via the left-axis load_half_u).
+	* R_T4 holds right_xy (loaded into the load-delay slot of the left-load).
+	* R_T5 is then "dead" — reused for the id-byte value load in mac_pad_write_id_byte.
+	* The buttons invert+store happens BEFORE R_T4 is overwritten by the right_xy load. */
+	mac_pad_set_status(R_T4, R_PadState, PadStatus_AnalogStick),
+	load_half_u(       R_T4, R_PadRaw, O_(PadBiosRaw,buttons)),  /* R_T4 = raw_buttons; delay slot at the next instruction */
+	load_half_u(       R_T5, R_PadRaw, O_(PadBiosRaw,left)),     /* fills the buttons-load's delay slot (doesn't read R_T4) */
+	mac_pad_store_inverted_buttons(R_T4, R_PadState),            /* R_T4 settled: nor + sh writes ~raw_buttons to state.buttons */
+	load_half_u( R_T4,  R_PadRaw,   O_(PadBiosRaw,right)),       /* fills R_T5's load-delay slot (doesn't read R_T5); overwrites R_T4 (was buttons) with right_xy */
+	store_half(  R_T5,  R_PadState, O_(PadState,  left)),
+	store_half(  R_T4,  R_PadState, O_(PadState,  right)),
+	mac_pad_set_id_byte(R_PadState, R_T5, PadRawId_AnalogStick),
+	jump_rel(atom_offset(analog_stick, snap_end)),
+		mac_yield_load(),
+
+atom_label(try_analog_pad) /* === Case 5-6: AnalogPad (id & 0xF0 == 0x70) */
+	and_i(    R_T4, R_RawId, PadRawId_AnalogPadMask),
+	add_ui(   R_T5, R_0,     PadRawId_AnalogPadValue),
+	branch_ne(R_T4, R_T5, atom_offset(try_analog_pad, try_unsupported)),
+	/* BD-slot: pre-compute PadStatus_AnalogPad. Branch reads R_T4 in EX before this WB completes.
+	 * If branch NOT taken (fall through to try_unsupported), R_T4 is overwritten by the unsupported body add_ui. */
+
+atom_label(analog_pad) /* === AnalogPad body
+	* Same shape as AnalogStick with AnalogPad status. R_T5 holds left_xy (it's dead on this path).
+	* The id byte is raw id from the BIOS buffer (R_RawId already holds raw[1]).
+	* Buttons invert + store happens before R_T4 is overwritten by the right_xy load. */
+	mac_pad_set_status(R_T4, R_PadState, PadStatus_AnalogPad),
+	load_half_u(       R_T4, R_PadRaw, O_(PadBiosRaw,buttons)), /* R_T4 = raw_buttons; delay slot at the next instruction */
+	load_half_u(       R_T5, R_PadRaw, O_(PadBiosRaw,left)),    /* fills the buttons-load's delay slot (doesn't read R_T4) */
+	mac_pad_store_inverted_buttons(R_T4, R_PadState),           /* R_T4 settled: nor + sh writes ~raw_buttons to state.buttons */
+	load_half_u(R_T4,    R_PadRaw,   O_(PadBiosRaw,right)),     /* fills R_T5's load-delay slot (doesn't read R_T5); overwrites R_T4 with right_xy */
+	store_half( R_T5,    R_PadState, O_(PadState,  left)),
+	store_half( R_T4,    R_PadState, O_(PadState,  right)),
+	store_byte( R_RawId, R_PadState, O_(PadState,  id)),
+
+	jump_rel(atom_offset(analog_pad, snap_end)),
+		mac_yield_load(),
+
+atom_label(try_unsupported) /* === Case 7: Unsupported — fall through from the AnalogPad range-check miss. */
+	add_ui(    R_T4, R_0, PadStatus_Unsupported),
+	store_word(R_T4, R_PadState, O_(PadState,status)),
+	store_half(R_0,  R_PadState, O_(PadState,buttons)),
+	mac_pad_set_centered_axes(R_PadState, R_T4),
+	mac_pad_set_id_byte(R_PadState, R_RawId, PadUnknownId_Sentinel),
+	/* Fall through to snap_end. */
+
+atom_label(no_jump_fallthrough)
+	mac_yield_load(),
+
+atom_label(snap_end)
+	/* NOT mac_yield() — R_AtomJmp was already loaded in the BD-slot of the case-exit branch. */
+	mac_yield_tail(),
+};
+
+#pragma endregion Baked Atoms

code/duffle/pad.c

@@ -0,0 +1,78 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "dsl.h"
+#	include "gcc_asm.h"
+#	include "mips.h"
+#	include "bios.h"
+#	include "pad.h"
+#endif
+
+/* Uses ONE 8-byte frame allocated via the compiler's standard prologue.
+ * 4 wasted-arg words for B(12h) InitPAD2 are at [SP+0..15] but are not explicitly allocated.
+ * Compiler handles the MIPS O32 "wasted stack" convention for us by treating the B-call as a 4-arg call.
+ *
+ * The buffer pointers are passed as arguments so the compiler keeps them in callee-saved registers;
+ * The B(12h) asm volatile block does NOT clobber those registers (it clobbers only the volatile GPRs + B-table arg registers explicitly).
+ * The C-level writes after the call re-load the pointers from their callee-saved homes.
+ *
+ * The clobber list for both B-calls names the full BIOS destroy set documented in kernelbios.md:167-174 (R1..R15, R24..R25, R31, HI/LO).
+ * The kernel-ABI "volatile GPRs" subset is clb_mem_drain; the rest of the destroy set is enumerated explicitly here. */
+NI_ void pad_bios_init_start(PadBiosRaw* raw0, PadBiosRaw* raw1)
+{
+	/* Pin raw0 + raw1 to $a0 + $a1 via rgcc; the B(12h) call uses these directly.
+	 * The `(void)` casts mark them as unread after the call so the compiler doesn't need to move them back. */
+	register PadBiosRaw* p0 rgcc(R_A0) = raw0;
+	register PadBiosRaw* p1 rgcc(R_A1) = raw1;
+	(void)p0; (void)p1;
+
+	// TODO(Ed): Properly annotate the raw values in the inline asm instructions.
+	// Use enums.
+
+	/* B(12h) InitPAD2(raw0, 0x22, raw1, 0x22)
+	 *   $a0 = raw0 (rgcc-bound; survives the sequence below)
+	 *   $a1 = raw1 (preserved into $a2 before $a1 is overwritten)
+	 *   $a2 = raw1 (moved from $a1; survives $a1's overwrite)
+	 *   $a3 = 0x22 (immediate)
+	 *   $t1 = 0x12 (function number)
+	 *   $t2 = 0xB0 (BIOS B-table address) */
+	asm volatile(
+		asm_words(
+			or_u(    rarg_2, rarg_1, rdiscard),               /* $a2 = $a1 = raw1 */
+			add_ui(  rarg_1, rdiscard, bios_pad_buffer_size), /* $a1 = 0x22 */
+			add_ui(  rarg_3, rdiscard, bios_pad_buffer_size), /* $a3 = 0x22 */
+			add_ui(  rtmp_1, rdiscard, bios_init_pad_2),      /* $t1 = 0x12 */
+			add_ui(  rtmp_2, rdiscard, bios_btable_addr),     /* $t2 = 0xB0 */
+			call_reg(rtmp_2),                                 /* jalr $t2, $ra */
+			nop                                               /* BD slot */
+		)
+		asm_rpins, r_use(p0), r_use(p1)
+		asm_clobber: 
+			rlit(R_AT), 
+			rlit(R_V0), rlit(R_V1), 
+			rlit(R_T0), rlit(R_T1), rlit(R_T2), rlit(R_T3), rlit(R_T4),
+			rlit(R_T5), rlit(R_T6), rlit(R_T7), rlit(R_T8), rlit(R_T9),
+			rlit(R_RA),
+			clb_mem_drain
+	);
+
+	/* The C-level writes re-load the pointers via the parameter names and write 0xFF to each 
+	 * buffer's status byte to mark the initial-state hazard documented in kernelbios.md:1621-1624. */
+	u1_v(raw0)[0] = 0xFF;
+	u1_v(raw1)[0] = 0xFF;
+
+	/* B(13h) StartPAD2() — no args. The BIOS preserves $sp. */
+	asm volatile(
+		asm_words(
+			add_ui(  rtmp_1, rdiscard, bios_start_pad_2), /* $t1 = 0x13 */
+			add_ui(  rtmp_2, rdiscard, bios_btable_addr), /* $t2 = 0xB0 (re-load) */
+			call_reg(rtmp_2),                             /* jalr $t2, $ra */
+			nop                                           /* BD slot */
+		)
+		asm_clobber:
+			rlit(R_AT),
+			rlit(R_V0), rlit(R_V1),
+			rlit(R_T0), rlit(R_T1), rlit(R_T2), rlit(R_T3), rlit(R_T4),
+			rlit(R_T5), rlit(R_T6), rlit(R_T7), rlit(R_T8), rlit(R_T9),
+			rlit(R_RA),
+			clb_mem_drain
+	);
+}

code/duffle/pad.h

@@ -1,12 +1,14 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
 #	include "dsl.h"
+#	include "math.h"
 #endif
 
 /* PSX button bit positions — 1:1 with PSX-SPX docs at docs/psx-spx/docs/controllersandmemorycards.md:405-421.
  * Wire is active-low (0 = pressed).
- * The decoder atom computes buttons = (~raw_buttons) & 0xFFFF; the active-low-to-active-high inversion is applied bit-by-bit. */
-enum {
+ * The decoder atom computes buttons = (~raw_buttons) & 0xFFFF; 
+ * active-low-to-active-high inversion is applied bit-by-bit. */
+typedef Enum_(U2, PadBtns) {
 	Bit_(Pad_Select,    0),
 	Bit_(Pad_L3,        1),
 	Bit_(Pad_R3,        2),
@@ -32,18 +34,22 @@ enum {
 	Pad1 = 1 << PadId_Offset,
 };
 
-#define pad0_(btn_id) (btn_id << Pad0)
-#define pad1_(btn_id) (btn_id << Pad1)
-
-/* ============================================================
+/* =============================================================================
  * BIOS pad-buffer subsystem: docs/psx-spx/docs/kernelbios.md (B(12h) + B(13h))
- * ============================================================ */
+ * ============================================================================= */
 
 enum {
 	PAD_BIOS_RAW_SIZE = 0x22,
 };
+// BIOS pad buffer layout (docs/psx-spx/docs/kernelbios.md (InitPAD2 returns 0x22 = 34 bytes per port)).
+// Bytes 0..7 are the named snapshot region; bytes 8..33 are reserved (the BIOS writes the buffer raw; we only read bytes 0..7 via O_(PadBiosRaw, ...)).
 typedef Struct_(PadBiosRaw) {
-	U1 bytes[PAD_BIOS_RAW_SIZE];
+	U1    status;  /* offset 0   (PadRawStatus_Ok / PadRawStatus_Timeout) */
+	U1    id;      /* offset 1   (PadRawId_Digital / PadRawId_AnalogStick / 0x7x AnalogPad) */
+	U2    buttons; /* offset 2-3 (active-low 16-bit button map) */
+	V2_U1 right;   /* offset 4-5 (right stick x, y) */
+	V2_U1 left;    /* offset 6-7 (left  stick x, y) */
+	U1    reserved[PAD_BIOS_RAW_SIZE - 8]; /* offset 8..33 */
 };
 
 typedef Enum_(U4, PadStatus) {
@@ -56,18 +62,54 @@ typedef Enum_(U4, PadStatus) {
 	PadStatus_Invalid,
 };
 
-/* PadState — per-port normalized runtime state.
- * Field order is chosen so that the 4 axes (left_x, left_y, right_x, right_y)
- * form a contiguous 4-byte block at offset 8, allowing a single `store_word` to clear-or-write all 4 axes in one MIPS instruction.
- * The struct size stays 12 bytes (unchanged from the prior order,
- * which left the C compiler to insert 1 byte of trailing pad to reach the 4-byte struct alignment). */
-typedef Struct_(PadState) {
-	PadStatus status;  /* offset 0,  size 4 (U4) */
-	U2        buttons; /* offset 4,  size 2 */
-	U1        id;      /* offset 6,  size 1 */
-	U1        pad;     /* offset 7,  size 1 — explicit pad to align the axes block */
-	U1        left_x;  /* offset 8,  size 1 — store_word target (4-byte aligned) */
-	U1        left_y;  /* offset 9,  size 1 */
-	U1        right_x; /* offset 10, size 1 */
-	U1        right_y; /* offset 11, size 1 */
+/* Distinct from the game-facing PadStatus enum: PadRawStatus_Ok and PadRawStatus_Timeout are raw BIOS values;
+ * PadStatus_* are game-facing post-decode states. PadUnknownId_Sentinel is written by the decoder 
+ * when the controller id does not match any known controller type.
+ * PadAxisCentered_Word: Four-byte 0x80 pattern used to clear / center 
+ * four byte axes at PadState.left_x through PadState.right_y. */
+typedef Enum_(U1, PadRawStatus) {
+	PadRawStatus_Ok      = 0x00,
+	PadRawStatus_Timeout = 0xFF,
 };
+typedef Enum_(U1, PadRawId) {
+	PadRawId_Digital           = 0x41,
+	PadRawId_AnalogStick       = 0x53,
+	PadRawId_AnalogPadMask     = 0xF0,
+	PadRawId_AnalogPadValue    = 0x70,
+};
+typedef Enum_(U1, PadUnknownId) {
+	PadUnknownId_Sentinel      = 0xFF,
+};
+typedef Enum_(U4, PadAxisCentered) {
+	PadAxis_Centered_Hi   = 0x8080,
+	PadAxis_Centered_Lo   = 0x8080,
+	PadAxis_Centered_Word = 0x80808080U,
+};
+typedef Enum_(U1, PadDeadZone) {
+	PadDeadZone_LowBound  = 0x70,  /* left_x <  LowBound  → active;  delta = 0x80 - left_x > 0 (rightward pull) */
+	PadDeadZone_Center    = 0x80,  /* analog rest position; left_x == Center → delta = 0 (no rotation) */
+	PadDeadZone_HighBound = 0x90,  /* left_x >  HighBound → active;  delta = 0x80 - left_x < 0 (leftward pull) */
+};
+
+
+typedef Struct_(PadAxes) {
+	V2_U1  left;  /* offset 8-9 */
+	V2_U1  right; /* offset 10-11 */
+};
+// Field order is chosen so that the 4 axes (left_x, left_y, right_x, right_y)
+// form a contiguous 4-byte block at offset 8, allowing a single `store_word` to clear-or-write all 4 axes in one MIPS instruction.
+typedef Struct_(PadState) {
+	PadStatus status;   /* offset 0,    (U4) */
+	PadBtns   buttons;  /* offset 4,    */
+	U1        id;       /* offset 6,    */
+	byte_pad(1);        /* offset 7,  explicit pad to align the axes block */
+	union {
+		A2_V2_U1 axes;    /* offset 8-11 store_target (4-byte aligned)*/
+		struct {
+			V2_U1  left;    /* offset 8-9 */
+			V2_U1  right;   /* offset 10-11 */
+		};
+	};
+};
+
+internal void pad_bios_init_start(PadBiosRaw* raw0, PadBiosRaw* raw1);

code/duffle/psyq.atom.c

@@ -0,0 +1,7 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+#	include "psyq.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(pysq_atom_c);

code/duffle/psyq.h

@@ -1,8 +1,8 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
-#	include "duffle/dsl.h"
-#	include "duffle/math.h"
-#	include "duffle/gp.h"
+#	include "dsl.h"
+#	include "math.h"
+#	include "gp.h"
 #endif
 
 typedef Struct_(DrawEnv_Packed) { U4 tag; U4 code[15]; };
@@ -64,9 +64,9 @@ typedef Struct_(Tile) {
 	Linear Algebra
 */
 
-M3_S2* m3s2_rotation   (V3_S2* vec, M3_S2* mat) asm("RotMatrix");
-M3_S2* m3s2_translation(M3_S2* mat, V3_S4* vec) asm("TransMatrix");
-M3_S2* m3s2_scale      (M3_S2* mat, V3_S4* vec) asm("ScaleMatrix");
+MT3_S2S4* mt3s2s4_rotation   (V3_S2*    vec, MT3_S2S4* mat) asm("RotMatrix");
+MT3_S2S4* mt3s2s4_translation(MT3_S2S4* mat, V3_S4*    vec) asm("TransMatrix");
+MT3_S2S4* mt3s2s4_scale      (MT3_S2S4* mat, V3_S4*    vec) asm("ScaleMatrix");
 
 // Rotation, Translation, Perspective
 
@@ -99,5 +99,23 @@ FI_ S4 rtp_avg_nclip_a4_v3s2(
 	);
 }
 
-void gte_matrix_set_rotation   (M3_S2* mat) asm("SetRotMatrix");
-void gte_matrix_set_translation(M3_S2* mat) asm("SetTransMatrix");
+void gte_matrix_set_rotation   (MT3_S2S4* mat) asm("SetRotMatrix");
+void gte_matrix_set_translation(MT3_S2S4* mat) asm("SetTransMatrix");
+
+// Einheit, Metrication to unit vector. "Normalization", not Orthogonal "Normal, Normalis". Directionalization.
+// RGA(Lengyel): Normalize the bulk of a zero-weight direction. This is not finite-point unitization (which forces w=1).
+S4 normalize_v3s4(V3_S4* v0, V3_S4* v1) asm("VectorNormal");
+
+// RGA(Lengyel): Apply the matrix expansion of a rigid transformation.
+// Motor antiproduct is equivalent for unitized points; LA form is what GTE consumes.
+V3_S4* mul_m3s2_v3s4(MT3_S2S4* m, V3_S4* v, V3_S4* result) asm("ApplyMatrixLV");
+
+// RGA(Lengyel): Store the full translation column. The motor translator would store half this displacement in m.xyz.
+MT3_S2S4* trans_m3s2(MT3_S2S4* m, V3_S4* off) asm("TransMatrix");
+
+MT3_S2S4* gte_comp_coord_m3s2(MT3_S2S4* m0, MT3_S2S4* m1, MT3_S2S4* result) asm("CompMatrixLV");
+
+// RGA(Lengyel): Complement(Wedge(a,b)), i.e. the Euclidean 3D complement of the exterior product, stored as a V3_S4.
+// The underlying GTE OP is a specialized signed-16-bit D x IR command; the wedge interpretation is a 3D dual of the same 3 scalars.
+void cross_v3s4(V3_S4* v0, V3_S4* v1, V3_S4* result) asm("OuterProduct12");
+

code/duffle/word_count.metadata.h

@@ -6,7 +6,7 @@
 // One line per macro that appears in your atom sources.
 //
 // This file is encoding-macros-only. 
-// The auto-generated component macros (mac_X) live in duffle/gen/<dir>.macs.h (included separately by the unity build).
+// The auto-generated component macros (mac_X) live in the source directory's own gen/macs.h (per-directory aggregation; included separately by the unity build).
 // The unity build should include THIS file and the .macs.h file in the same TU, with both wrapped 
 // (or the include guard order handled) to avoid WORD_COUNT redeclaration.
 //
@@ -15,6 +15,8 @@
 #define WORD_COUNT(name, count)  enum { words_##name = (count) };
 
 WORD_COUNT(nop,                              1)
+WORD_COUNT(atom_label,                        0)
+WORD_COUNT(atom_offset,                       0)
 WORD_COUNT(load_upper_i,                     1)
 WORD_COUNT(jump_reg,                         1)
 WORD_COUNT(jump_link,                        1)
@@ -54,6 +56,15 @@ WORD_COUNT(gte_sw,                           1)
 WORD_COUNT(gte_cmdw_rtpt,                    1)
 WORD_COUNT(gte_cmdw_nclip,                   1)
 WORD_COUNT(gte_avg_sort_z3,                  1)
+WORD_COUNT(gte_cmdw_sqr,                     1)
+WORD_COUNT(gte_cmdw_gpf,                     1)
+WORD_COUNT(shift_lleft_var,                  1)
+WORD_COUNT(shift_aright_var,                 1)
+WORD_COUNT(li_s,                             1)
+WORD_COUNT(and_i,                            1)
+WORD_COUNT(add_si,                           1)
+WORD_COUNT(branch_lt_zero,                   1)
+WORD_COUNT(sub_s,                            1)
 WORD_COUNT(sub_u,                            1)
 WORD_COUNT(nop2,                             2)
 

code/hello_camera/gen/auto_reg.h

@@ -0,0 +1,13 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#pragma once
+#endif
+// Auto-generated by ps1_meta.lua (passes/auto_reg.lua) — DO NOT EDIT
+// Directory: C:\projects\Pikuma\ps1\code\hello_camera
+//   source: C:/projects/Pikuma/ps1/code/hello_camera/hello_camera.c
+//   source: C:/projects/Pikuma/ps1/code/hello_camera/hello_camera.h
+//   source: C:/projects/Pikuma/ps1/code/hello_camera/hello_camera.atom.c
+// Per-phase register allocations resolved by the lua pass.
+// R_<Sym>_Code = <chosen GPR's _Code constant> for every marker in this directory.
+
+#define R_GpTmp_Code R_V0_Code
+

code/hello_camera/gen/macs.h

@@ -2,53 +2,23 @@
 #pragma once
 #endif
 // Auto-generated by ps1_meta.lua — DO NOT EDIT
-// Source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.tape.c
+// Directory: C:\projects\Pikuma\ps1\code\hello_camera/
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.c
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.h
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.atom.c
 // Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
 
 #ifndef WORD_COUNT
 #define WORD_COUNT(name, count)  enum { words_##name = (count) };
 #endif
 
-/* atom_dbg_skip */
-#define mac_load_v2s2(rs_x, rs_y, r_base, offset) \
-	load_half( rs_x, r_base, O_(V3_S2,x)) \
-,	load_half( rs_y, r_base, O_(V3_S2,y))
-WORD_COUNT(mac_load_v2s2, 2)
-
-/* atom_dbg_skip */
-#define mac_store_v2s2(rt_x, rt_y, base, offset) \
-	store_half(rt_x, base, offset + O_(V2_S2,x)) \
-,	store_half(rt_y, base, offset + O_(V2_S2,y))
-WORD_COUNT(mac_store_v2s2, 2)
-
-/* atom_dbg_skip */
-#define mac_store_rects2(rt_x, rt_y, rt_width, rt_height, base, offset) \
-	store_half(rt_x,      base, offset + O_(Rect_S2,x)) \
-,	store_half(rt_y,      base, offset + O_(Rect_S2,y)) \
-,	store_half(rt_width,  base, offset + O_(Rect_S2,width)) \
-,	store_half(rt_height, base, offset + O_(Rect_S2,height))
-WORD_COUNT(mac_store_rects2, 4)
-
-/* atom_dbg_skip */
-#define mac_store_rgb8(rr, rg, rb, base, offset) \
-	store_byte(rr, base, offset + O_(DrawEnv,initial_bg_color.r)) \
-,	store_byte(rg, base, offset + O_(DrawEnv,initial_bg_color.g)) \
-,	store_byte(rb, base, offset + O_(DrawEnv,initial_bg_color.b))
-WORD_COUNT(mac_store_rgb8, 3)
-
-#define mac_gcmd_push(cmd, reg_transfer, reg_base, port) \
-	load_upper_i(reg_transfer, cmd >> 16) \
-,	or_i_self(   reg_transfer, cmd & 0xFFFF) \
-,	store_word(  reg_transfer, reg_base, port)
-WORD_COUNT(mac_gcmd_push, 3)
-
 #define mac_put_disp_env(reg_transfer, reg_base, port) \
 	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port) \
 ,	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port) \
 ,	mac_gcmd_push(gp0_word_set_mask_bit(),                 reg_transfer, reg_base, port) \
 ,	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port) \
 ,	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port)
-WORD_COUNT(mac_put_disp_env, 15)
+WORD_COUNT(mac_put_disp_env, 5)
 
 #define mac_put_draw_env(reg_transfer, reg_base, port) \
 	mac_gcmd_push(gp0_dr_env_tag,                            reg_transfer, reg_base, port) /* tag (length=15 << 24, addr=0) — packet header for the DR_ENV sequence. The GPU needs this to recognize the next 15 words as a DR_ENV packet and trigger the isbg auto-clear. */ \
@@ -67,5 +37,5 @@ WORD_COUNT(mac_put_disp_env, 15)
 ,	mac_gcmd_push(gp0_word_set_texture_window(), reg_transfer, reg_base, port)	/* code[13..14]  Padding (NOP) — completes the 16-word packet. */ \
 ,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port) \
 ,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port)
-WORD_COUNT(mac_put_draw_env, 48)
+WORD_COUNT(mac_put_draw_env, 16)
 

code/hello_camera/gen/offsets.h

@@ -0,0 +1,68 @@
+// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT
+// Directory: C:\projects\Pikuma\ps1\code\hello_camera\
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.c
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.h
+//   source: C:\projects\Pikuma\ps1\code\hello_camera\hello_camera.atom.c
+#pragma once
+
+#pragma region hello_camera
+
+
+// --- atom: pad_input_cube_rotation (60 words) ---
+
+#define _atom_offset_dpad_left_exit_dpad_left         6
+#define _atom_offset_dpad_right_exit_dpad_right       6
+#define _atom_offset_dead_zone_low_check_dead_low_active  8
+#define _atom_offset_dead_zone_high_check_dead_high_active  15
+#define _atom_offset_dead_zone_skip_exit_stick        24
+#define _atom_offset_end_low_exit_stick               12
+
+enum {
+    atom_offset_dpad_left_exit_dpad_left = _atom_offset_dpad_left_exit_dpad_left,
+    atom_offset_dpad_right_exit_dpad_right = _atom_offset_dpad_right_exit_dpad_right,
+    atom_offset_dead_zone_low_check_dead_low_active = _atom_offset_dead_zone_low_check_dead_low_active,
+    atom_offset_dead_zone_high_check_dead_high_active = _atom_offset_dead_zone_high_check_dead_high_active,
+    atom_offset_dead_zone_skip_exit_stick = _atom_offset_dead_zone_skip_exit_stick,
+    atom_offset_end_low_exit_stick = _atom_offset_end_low_exit_stick,
+};
+
+// --- atom: pad_input_cam (40 words) ---
+
+#define _atom_offset_left_x_exit_left_x               3
+#define _atom_offset_right_x_exit_right_x             3
+#define _atom_offset_up_y_exit_up_y                   3
+#define _atom_offset_down_y_exit_down_y               3
+#define _atom_offset_cross_z_exit_cross_z             3
+#define _atom_offset_circle_z_exit_circle_z           3
+
+enum {
+    atom_offset_left_x_exit_left_x = _atom_offset_left_x_exit_left_x,
+    atom_offset_right_x_exit_right_x = _atom_offset_right_x_exit_right_x,
+    atom_offset_up_y_exit_up_y = _atom_offset_up_y_exit_up_y,
+    atom_offset_down_y_exit_down_y = _atom_offset_down_y_exit_down_y,
+    atom_offset_cross_z_exit_cross_z = _atom_offset_cross_z_exit_cross_z,
+    atom_offset_circle_z_exit_circle_z = _atom_offset_circle_z_exit_circle_z,
+};
+
+// --- atom: cube_g4_face (76 words) ---
+
+#define _atom_offset_cull_cube_g4_face_exit           41
+#define _atom_offset_bounds_chk_cube_g4_face_exit     24
+
+enum {
+    atom_offset_cull_cube_g4_face_exit = _atom_offset_cull_cube_g4_face_exit,
+    atom_offset_bounds_chk_cube_g4_face_exit = _atom_offset_bounds_chk_cube_g4_face_exit,
+};
+
+// --- atom: floor_f3_face (58 words) ---
+
+#define _atom_offset_culling_floor_f3_face_exit       25
+#define _atom_offset_bounds_chk_floor_f3_face_exit    16
+
+enum {
+    atom_offset_culling_floor_f3_face_exit = _atom_offset_culling_floor_f3_face_exit,
+    atom_offset_bounds_chk_floor_f3_face_exit = _atom_offset_bounds_chk_floor_f3_face_exit,
+};
+
+#pragma endregion hello_camera
+

code/hello_camera/hello_camera.atom.c

@@ -0,0 +1,917 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#		include "duffle/gen/macs.h"
+#		include "duffle/gen/offsets.h"
+#	include "duffle/dsl.atom.h"
+#	include "duffle/lottes_tape.h"
+#	include "duffle/mips.h"
+#	include "duffle/gte.h"
+#	include "duffle/gp.h"
+#	include "duffle/pad.h"
+#	include "duffle/word_count.metadata.h"
+#	include "duffle/psyq.h"
+#	include "duffle/math.atom.c"
+#	include "duffle/mips.atom.c"
+#	include "duffle/gte.atom.c"
+#	include "duffle/gp.atom.c"
+#	include "duffle/psyq.atom.c"
+#		include "gen/offsets.h"
+#		include "gen/macs.h"
+#		include "gen/auto_reg.h"
+#	include "hello_camera.h"
+#endif
+
+ATOM_FILE_DEBUGGER_LINE_MARKER(hello_joypad_atom_c);
+
+#pragma region MACs (Mips Atom components)
+
+FI_ Slice_MipsCode ac_put_disp_env(AtomBuilder_R ab, U4 reg_transfer, U4 reg_base, U2 port)
+MipsAtomComp_Proc_(ac_put_disp_env, ab, {
+	// Emits 5 GP0 commands for buffer 0 (display_area = (0,0,320,240)).
+	// Sequence per libpsyx PutDispEnv: DrawArea TL → DrawArea BR → Mask → DrawArea TL → DrawArea BR
+	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_set_mask_bit(),                 reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port),
+})
+
+FI_ Slice_MipsCode ac_put_draw_env(AtomBuilder_R ab, U4 reg_transfer, U4 reg_base, U2 port)
+MipsAtomComp_Proc_(ac_put_draw_env, ab, {
+	/*
+	* ORIGIN: each code word corresponds to the EXACT value libpsyx's PutDrawEnv function would compute for the same DrawEnv settings.
+	* References:
+	*   - libpsyx source: `toolchain/psyq-4_7/lib/libgpu.a` (binary, function `PutDrawEnv`)
+	*   - PSX-SPX doc:     https://problemkaputt.de/psx-spx.htm#gputdrawingcommands
+	*   - PSYQ SDK:        `setdrawenv` / `makelongdr_env` source
+	*   - NOCASH PSX spec: §"GP0(E1h) Draw Mode setting" through §"DR_ENV"
+	*
+	* The 16-word format is documented in the PSYQ SDK manual and on NOCASH's PSX-spec.txt. The libpsyx reference is at:
+	*   ./toolchain/psyq-4_7/lib/libgpu.a
+	*   (binary; the PutDrawEnv implementation builds the 16-word DR_ENV from the user's DRAWENV struct and emits it via GP0 GPU commands.)
+	*
+	* Word indices (libpsyx PutDrawEnv / SetDrawEnv order):
+	*   tag          = (length << 24) | addr                — 16-word packet (1 tag + 15 code)
+	*   code[0]      = DrawMode (dfe=1, dtd=0, tpage=0)     — must come first per libpsyx
+	*   code[1]      = TextureWindow (tw=(0,0))             — bare-cmd word; GPU uses current state
+	*   code[2]      = DrawArea top-left (clip.x=0, clip.y=240)
+	*   code[3]      = DrawArea bottom-right (clip.x+w=320, clip.y+h=480)
+	*   code[4]      = DrawOffset (ofs=(0,0))               — bare-cmd word
+	*   code[5]      = Mask (dtd=0, dfe=1, isbg=1)          — 0xE6 cmd + isbg bit
+	*   code[6]      = Initial-bg-color (isbg=1, r=7, g=7, b=7)
+	*   code[7]      = DrawMode (isbg=1, tpage=0)           — re-asserts DrawMode with isbg
+	*   code[8..10]  = padding (NOP)                        — 3 words to fill the packet
+	*   code[11..12] = TextureWindow bottom-right           — defaults to (0,0,0,0)
+	*   code[13..14] = padding (NOP)                        — completes the 16-word packet
+	*/
+	mac_gcmd_push(gp0_dr_env_tag,                            reg_transfer, reg_base, port), /* tag (length=15 << 24, addr=0) — packet header for the DR_ENV sequence. The GPU needs this to recognize the next 15 words as a DR_ENV packet and trigger the isbg auto-clear. */
+	mac_gcmd_push(gp0_word_draw_mode_drawing_allowed,        reg_transfer, reg_base, port), /* code[0]  DrawMode (dfe=1, dtd=0, tpage=0) */
+	mac_gcmd_push(gp0_word_set_texture_window(),             reg_transfer, reg_base, port), /* code[1]  TextureWindow (tw=(0,0)) */
+	mac_gcmd_push(enc_gp0_draw_area_tl_word(0, ScreenRes_Y), reg_transfer, reg_base, port), /* code[2]  DrawArea top-left (clip.x=0, clip.y=ScreenRes_Y=240) */
+	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240,   reg_transfer, reg_base, port), /* code[3]  DrawArea bottom-right (clip.x+w=320, clip.y+h=480) */
+
+	mac_gcmd_push(gp0_word_set_draw_offset(),               reg_transfer, reg_base, port), /* code[4]  DrawOffset (ofs=(0,0)) — bare-cmd word; the GPU uses the current state machine. */
+	mac_gcmd_push(gp0_word_dr_env_mask(),                   reg_transfer, reg_base, port), /* code[5]  Mask (dtd=0, dfe=1, isbg=1) — 0xE6 cmd + isbg bit. */
+	mac_gcmd_push(gp0_word_dr_env_bg_color_cmd(1, 7, 7, 7), reg_transfer, reg_base, port), /* code[6]  Initial-bg-color + auto-clear (isbg=1, r=7, g=7, b=7). */
+	mac_gcmd_push(gp0_word_dr_env_draw_mode(1),             reg_transfer, reg_base, port), /* code[7]  Re-assert DrawMode with isbg=1 (isbg-flag set; the 0xE1 cmd byte plus isbg only). */
+
+	/* code[8..10]  Padding (NOP — GPU discards; the DR_ENV requires 16 words total). */
+	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port),
+
+	/* code[11..12]  TextureWindow bottom-right (tw.x+tw.w=0, tw.y+tw.h=0) — libpsyx emits twice. */
+	mac_gcmd_push(gp0_word_set_texture_window(), reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_set_texture_window(), reg_transfer, reg_base, port),
+
+	/* code[13..14]  Padding (NOP) — completes the 16-word packet. */
+	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port),
+	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port),
+})
+
+#pragma endregion MACs
+
+#pragma region Atom Procs
+// Modular Atoms
+
+/* Scratchpad layout for the resolve_look_at bundle.
+ * The chain atoms communicate entirely via the wave-context GPR carrier R_ResolveScratch (R_T4) + hardcoded offsets into smem.scratchpad
+ * (PS1 hardware scratchpad at 0x1F800000).
+ *
+ * Atom 0 (input_and_sub) STAGES the C-side inputs (eye, up_in) into the scratchpad;
+ * AT THE SAME TIME it computes fwd = target - eye and stores it at scratch+0.
+ * Atoms 1-6 then read/write specific scratchpad offsets internally using
+ * `r_scratch + hardcoded_offset` — no tape-data pointers are passed between atoms.
+ *   +0   fwd   (atom 0 writes; atom  1 reads)
+ *   +16  uz    (atom 1 writes; atoms 2 + 4 read)
+ *   +32  right (atom 2 writes; atom  3 reads)
+ *   +48  ux    (atom 3 writes; atoms 4 + 6 read)
+ *   +64  up    (atom 4 writes; atom  5 reads)
+ *   +80  uy    (atom 5 writes; atom  6 reads)
+ *   +96  eye   (atom 0 stages from C-side pointer; atom 6 reads)
+ *   +128 up_in (atom 0 stages from C-side pointer; atom 2 reads)
+ */
+
+// enum {
+// 	R_LookAt    = R_T0 atom_reg atom_type(MT3_S2S4*),
+// 	R_CamEye    = R_T1 atom_reg atom_type(P3_S4*),
+// 	R_CamTarget = R_T2 atom_reg atom_type(P3_S4*),
+// 	R_WorldUp   = R_T3 atom_reg atom_type(V3_S4*),
+// };
+
+enum {
+	/* Wave-context GPR carrier for the resolve_look_at bundle: the scratch base.
+	* Set by atom 0 (popped from tape), read by atoms 1-6 (used as pointer base). */
+	R_ResolveScratch = R_T4 atom_reg atom_type(U4*),
+};
+typedef Struct_(Binds_ResolveLookAt) {
+	MT3_S2S4* look_at;
+	P3_S4*    eye;
+	P3_S4*    target;
+	V3_S4*    up_in;
+};
+
+/* ─── ResolveLookAtScratch — offset schema for the resolve_look_at bundle's
+ * scratchpad slots (PS1 hardware scratchpad at 0x1F800000).
+ *
+ * Each slot is 16 bytes: V3_S4 is already 16 bytes (4 × S4 = x/y/z/pad).
+ * The struct fields are contiguous — slot i starts at offset i*16.
+ * Used by the assembly via O_(ResolveLookAtScratch, fld.x/y/z) which resolves to a compile-time byte offset.
+ * NOT a runtime struct — the struct is purely a schema for offsets; the assembly uses `r_scratch + O_(...)` to compute slot addresses at runtime.
+ *
+ * Slot producers/consumers (referenced by the resolve_look_at chain atoms):
+ *   +0    fwd    0 writes (target - eye);     atom  1 (normalize) reads
+ *   +16   uz     1 writes (normalize fwd);    atoms 2 + 4 read (cross operands)
+ *   +32   right  2 writes (cross uz x up_in); atom  3 (normalize) reads
+ *   +48   ux     3 writes (normalize right);  atoms 4 + 6 read
+ *   +64   up     4 writes (cross uz x ux);    atom  5 (normalize) reads
+ *   +80   uy     5 writes (normalize up);     atom  6 reads
+ *   +96   eye    0 stages (C-side input);     atom  6 reads (translation column)
+ *   +112  target reserved (currently written nowhere — kept for symmetry w/ eye)
+ *   +128  up_in  0 stages (C-side input); atom 2 reads (cross operand)
+ *
+ * Fields use P3_S4 (point) for eye/target (RGA: affine point, implicit weight 1);
+ * V3_S4 (vector) for fwd/uz/right/ux/up/uy/up_in (RGA: Euclidean vector).
+ * P3_S4 is a storage alias of V3_S4 (see math.h comment: "Storage alias of V3_S4.
+ * Use P3_S4 when the value is a point.") — both are 16 bytes.
+ */
+typedef Struct_(ResolveLookAtScratch) {
+	V3_S4 fwd;       /* offset  +0  (16 bytes — 4 S4 fields incl. internal pad) */
+	V3_S4 uz;        /* offset +16 (16 bytes) */
+	V3_S4 right;     /* offset +32 (16 bytes) */
+	V3_S4 ux;        /* offset +48 (16 bytes) */
+	V3_S4 up;        /* offset +64 (16 bytes) */
+	V3_S4 uy;        /* offset +80 (16 bytes) */
+	P3_S4 eye;       /* offset +96 (16 bytes; storage alias of V3_S4) */
+	P3_S4 target;    /* offset +112 (16 bytes; storage alias of V3_S4) */
+	V3_S4 up_in;     /* offset +128 (16 bytes) */
+};
+
+/* ─── resolve_look_at bundle chain atoms ────────────────────────────
+ * 4 unique atom procs in the resolve_look_at bundle (4 chain atoms + 3 calls to generic normalize_v3s4_proc).
+ * All 4 chain atoms are runtime-built MipsAtom_Proc_ atoms: each function declares a static MipsCode[] body, 
+ * then calls atombuilder_unroll() to append it to the caller's MipsAtomBuilder arena. resolve_look_at_init() 
+ * uses this pattern to pre-build the bundle into the static arena (smem.resolve_look_at_arena).
+ *
+ * Atom roster:
+ *	0: resolve_look_at__input_and_sub              (chain atom)
+ *	1: normalize_v3s4_proc (gte.atom.c)            (generic normalize; called for fwd→uz)
+ *	2: resolve_look_at__cross_uz_up_in_to_right    (chain atom)
+ *	3: normalize_v3s4_proc (gte.atom.c)            (generic normalize; called for right→ux)
+ *	4: resolve_look_at__cross_uz_ux_to_up          (chain atom)
+ *	5: normalize_v3s4_proc (gte.atom.c)            (generic normalize; called for up→uy)
+ *	6: resolve_look_at__populate_and_translate     (chain atom)
+ *
+ * The generic normalize_v3s4_proc is a parameterized 4-stage GTE normalize (SQR → mfc2 → LZCS → GPF → srav);
+ * it accepts scratch base + offset args so any caller (with a scratch base + struct schema) can use it.
+ */
+
+typedef Struct_(Binds_ResolveLookAtSub) {
+	U4 target;  /* U4 (C-side P3_S4* — read by atom 0 directly; NOT a scratchpad address) */
+	U4 eye;     /* U4 (C-side P3_S4* — read by atom 0 directly; staged into scratchpad by atom 0) */
+	U4 up_in;   /* U4 (C-side V3_S4* — read by atom 0 directly; staged into scratchpad by atom 0) */
+	U4 scratchpad;
+};
+
+/* Atom 0 in the bundle: input_and_sub. Stages C-side inputs into the scratchpad and computes fwd = target - eye.
+ * Inputs (C-side pointers popped from the tape):
+ *   r_target_ptr : P3_S4* (C-side struct; atom 0 reads target.x/y/z directly)
+ *   r_eye_ptr    : P3_S4* (C-side struct; staged into scratchpad at +96/+100/+104)
+ *   r_up_in_ptr  : V3_S4* (C-side struct; staged into scratchpad at +128/+132/+136)
+ *   r_scratch    : R_ResolveScratch (R_T4) — scratch base, read by atoms 1-6
+ * 
+ * Bind-pop layout:
+ *   Binds_ResolveLookAtSub
+ * Staging work:
+ *   * Stage eye.x/y/z   → scratch (for atom 6's translation column)
+ *   * Stage up_in.x/y/z → scratch (for atom 2's outer-product operand)
+ *   * Compute fwd = target - eye, store fwd.x/y/z → scratch+0/+4/+8 (for atom 1)
+ *
+ * GPR codes (assigned by resolve_look_at_init):
+ *   r_target_ptr : R_T0
+ *   r_eye_ptr    : R_T1
+ *   r_up_in_ptr  : R_T2
+ *   r_scratch    : R_T4 (R_ResolveScratch; wave-context carrier)
+ *   r_tmp0       : R_T3 (stage eye/up_in + load eye.y)
+ *   r_tmp1       : R_T5 (stage eye/up_in + load eye.z)
+ *   r_tmp2       : R_T6 (stage eye/up_in + load target.x)
+ *   r_tmp3       : R_T7 (stage eye/up_in + load target.y)
+ *   R_AT         : hardcoded (load eye.y / eye.z / target.z)
+ *   R_V0         : hardcoded (load eye.z / target.z)
+ *
+ * Pool cost: 8 GPRs + R_T4 (carrier) + R_AT + R_V0 (hardcoded) = 11 GPRs.
+ */
+I_ MipsAtom* resolve_look_at__input_and_sub_proc(AtomArena_R aa,	U4 r_scratch
+	,	U4 r_target_ptr,U4 r_eye_ptr, U4 r_up_in_ptr
+	,	U4 r_tmp0,      U4 r_tmp1,    U4 r_tmp2, U4 r_tmp3
+) MipsAtom_Proc_(resolve_look_at__input_and_sub, aa, {
+	/* Pop the 3 C-side pointers + scratch_base from the tape. */
+	load_word(r_target_ptr, R_TapePtr, O_(Binds_ResolveLookAtSub,target)),
+	load_word(r_eye_ptr,    R_TapePtr, O_(Binds_ResolveLookAtSub,eye)),
+	load_word(r_up_in_ptr,  R_TapePtr, O_(Binds_ResolveLookAtSub,up_in)),
+	load_word(r_scratch,    R_TapePtr, O_(Binds_ResolveLookAtSub,scratchpad)),
+	add_ui_self(            R_TapePtr, S_(Binds_ResolveLookAtSub)),
+
+	/* Stage eye.x/y/z into the scratchpad (atom 6 reads these for the translation
+	 * column). Reuse r_tmp0/r_tmp1/r_tmp2. Offsets via O_(ResolveLookAtScratch,*). */
+	load_word(r_tmp0, r_eye_ptr, O_(P3_S4,x)),
+	load_word(r_tmp1, r_eye_ptr, O_(P3_S4,y)),
+	load_word(r_tmp2, r_eye_ptr, O_(P3_S4,z)),
+	nop, /* load-delay */
+	store_word(r_tmp0, r_scratch, O_(ResolveLookAtScratch,eye.x)),
+	store_word(r_tmp1, r_scratch, O_(ResolveLookAtScratch,eye.y)),
+	store_word(r_tmp2, r_scratch, O_(ResolveLookAtScratch,eye.z)),
+
+	/* Stage up_in.x/y/z into the scratchpad (atom 2 reads these for the outer
+	 * product with uz). Reuse r_tmp0/r_tmp1/r_tmp2. */
+	load_word(r_tmp0, r_up_in_ptr, O_(V3_S4,x)),
+	load_word(r_tmp1, r_up_in_ptr, O_(V3_S4,y)),
+	load_word(r_tmp2, r_up_in_ptr, O_(V3_S4,z)),
+	nop, /* load-delay */
+	store_word(r_tmp0, r_scratch, O_(ResolveLookAtScratch,up_in.x)),
+	store_word(r_tmp1, r_scratch, O_(ResolveLookAtScratch,up_in.y)),
+	store_word(r_tmp2, r_scratch, O_(ResolveLookAtScratch,up_in.z)),
+
+	/* Compute fwd = target - eye. */
+	load_word(r_tmp0, r_target_ptr, O_(P3_S4,x)),
+	load_word(r_tmp1, r_target_ptr, O_(P3_S4,y)),
+	load_word(r_tmp2, r_target_ptr, O_(P3_S4,z)),
+	load_word(r_tmp3, r_eye_ptr,    O_(P3_S4,x)),
+	load_word(R_AT,   r_eye_ptr,    O_(P3_S4,y)),
+	load_word(R_V0,   r_eye_ptr,    O_(P3_S4,z)),
+	nop, /* load-delay */
+	sub_u(r_tmp0, r_tmp0, r_tmp3),
+	sub_u(r_tmp1, r_tmp1, R_AT),
+	sub_u(r_tmp2, r_tmp2, R_V0),
+
+	/* Store fwd.x/y/z (atom 1 reads these as the normalize src). */
+	store_word(r_tmp0, r_scratch, O_(ResolveLookAtScratch,fwd.x)),
+	store_word(r_tmp1, r_scratch, O_(ResolveLookAtScratch,fwd.y)),
+	store_word(r_tmp2, r_scratch, O_(ResolveLookAtScratch,fwd.z)),
+
+	mac_yield()
+})
+
+/* Atoms 2 + 4 in the bundle: out = a × b (GTE outer product on IR/D vectors).
+ * No bind pop — the three operand pointers (a, b, out) are derived in-body from r_scratch + hardcoded_offset.
+ * Each atom has its own variant because the offsets are baked into the body and each atom uses unique GPRs.
+ *
+ * GTE register layout (per PSX-SPX + duffle gte.h):
+ *   IR1/2/3  = a.x/y/z    (mtc2)
+ *   VXY0     = b.x        (mtc2)
+ *   VZ0      = b.y        (mtc2)
+ *   VXY1     = b.z        (mtc2)
+ *   OP       = outer product
+ *   MAC1/2/3 = out.x/y/z  (mfc2)
+ *
+ * Pool cost: r_scratch (R_T4 carrier) + 7 body GPRs + R_AT + R_V0 (hardcoded) = 10 GPRs.
+ */
+
+/* Atom 2: cross uz × up_in → right. */
+I_ MipsAtom* resolve_look_at__cross_uz_up_in_to_right_proc(AtomArena_R aa, U4 r_scratch
+	,	U4 r_a, U4 r_b, U4 r_c /* load a.x/y/z; result out.x/y/z */
+	,	U4 r_d                 /* load b.x */
+	,	U4 r_f, U4 r_g, U4 r_h /* r_f = &right (out ptr), r_g = &uz, r_h = &up_in */
+) MipsAtom_Proc_(resolve_look_at__cross_uz_up_in_to_right, aa, {
+	/* Compute the three scratch pointers from r_scratch. */
+	add_si(r_g, r_scratch, O_(ResolveLookAtScratch,uz)),    /* r_g = &uz */
+	add_si(r_h, r_scratch, O_(ResolveLookAtScratch,up_in)), /* r_h = &up_in */
+	add_si(r_f, r_scratch, O_(ResolveLookAtScratch,right)), /* r_f = &right (out) */
+	nop,
+
+	/* Load a (uz).x/y/z into r_a/r_b/r_c. */
+	load_word(r_a, r_g, O_(V3_S4,x)),
+	load_word(r_b, r_g, O_(V3_S4,y)),
+	load_word(r_c, r_g, O_(V3_S4,z)),
+	nop,
+
+	/* Load b (up_in).x/y/z into r_d + R_AT/R_V0 
+	(hardcoded; reusing the body's last two loads is fine because the load-delay slot is the nop after the third load, 
+	and mtc2 below doesn't read these regs). */
+	load_word(r_d,  r_h, O_(V3_S4,x)),
+	load_word(R_AT, r_h, O_(V3_S4,y)),
+	load_word(R_V0, r_h, O_(V3_S4,z)),
+	nop,
+
+	/* mtc2 a → IR1/2/3, b → D1/2/3 (VXY0/VZ0/VXY1). */
+	gte_mv_to_data_r(r_a,  C2_IR1),
+	gte_mv_to_data_r(r_b,  C2_IR2),
+	gte_mv_to_data_r(r_c,  C2_IR3),
+	gte_mv_to_data_r(r_d,  C2_VXY0),   /* D1 = b.x */
+	gte_mv_to_data_r(R_AT, C2_VZ0),    /* D2 = b.y */
+	gte_mv_to_data_r(R_V0, C2_VXY1),   /* D3 = b.z */
+	nop2,  /* MTC2 retirement (CPU→COP2 2-slot delay) */
+
+	gte_cmdw_outer_product,  /* OP fires; MAC1/2/3 = a × b */
+
+	/* mfc2 MAC1/2/3 → r_a/r_b/r_c (out.x/y/z). */
+	gte_mv_from_data_r(r_a, C2_MAC1),
+	gte_mv_from_data_r(r_b, C2_MAC2),
+	gte_mv_from_data_r(r_c, C2_MAC3),
+	nop,  /* MFC2 retirement */
+
+	/* Store out.x/y/z to r_f (out ptr = scratch+32). */
+	store_word(r_a, r_f, O_(V3_S4,x)),
+	store_word(r_b, r_f, O_(V3_S4,y)),
+	store_word(r_c, r_f, O_(V3_S4,z)),
+
+	mac_yield()
+})
+
+/* Atom 4: cross uz × ux → up. */
+I_ MipsAtom* resolve_look_at__cross_uz_ux_to_up_proc(AtomArena_R aa,	U4 r_scratch
+	,	U4 r_a, U4 r_b, U4 r_c                  /* load a.x/y/z; result out.x/y/z */
+	,	U4 r_d                                  /* load b.x */
+	,	U4 r_f, U4 r_g, U4 r_h                  /* r_f = &up (out ptr), r_g = &uz, r_h = &ux */
+) MipsAtom_Proc_(resolve_look_at__cross_uz_ux_to_up, aa, {
+	/* Compute the three scratch pointers from r_scratch. */
+	add_si(r_g, r_scratch, O_(ResolveLookAtScratch,uz)),       /* r_g = &uz */
+	add_si(r_h, r_scratch, O_(ResolveLookAtScratch,ux)),       /* r_h = &ux */
+	add_si(r_f, r_scratch, O_(ResolveLookAtScratch,up)),       /* r_f = &up (out) */
+	nop,
+
+	/* Load a (uz).x/y/z into r_a/r_b/r_c. */
+	load_word(r_a, r_g, O_(V3_S4,x)),
+	load_word(r_b, r_g, O_(V3_S4,y)),
+	load_word(r_c, r_g, O_(V3_S4,z)),
+	nop,
+
+	/* Load b (ux).x/y/z into r_d + R_AT/R_V0. */
+	load_word(r_d,  r_h, O_(V3_S4,x)),
+	load_word(R_AT, r_h, O_(V3_S4,y)),
+	load_word(R_V0, r_h, O_(V3_S4,z)),
+	nop,
+
+	/* mtc2 a → IR1/2/3, b → D1/2/3 (VXY0/VZ0/VXY1). */
+	gte_mv_to_data_r(r_a,  C2_IR1),
+	gte_mv_to_data_r(r_b,  C2_IR2),
+	gte_mv_to_data_r(r_c,  C2_IR3),
+	gte_mv_to_data_r(r_d,  C2_VXY0),
+	gte_mv_to_data_r(R_AT, C2_VZ0),
+	gte_mv_to_data_r(R_V0, C2_VXY1),
+	nop2,
+
+	gte_cmdw_outer_product,
+	gte_mv_from_data_r(r_a, C2_MAC1),
+	gte_mv_from_data_r(r_b, C2_MAC2),
+	gte_mv_from_data_r(r_c, C2_MAC3),
+	nop,
+	store_word(r_a, r_f, O_(V3_S4,x)),
+	store_word(r_b, r_f, O_(V3_S4,y)),
+	store_word(r_c, r_f, O_(V3_S4,z)),
+
+	mac_yield()
+})
+
+typedef Struct_(Binds_ResolveLookAtPopAndTrans) {
+	U4 look_at;  /* U4 (MT3_S2S4* — destination matrix address) */
+};
+/* Atom 6 in the bundle: write look_at->m[][] from ux/uy/uz, then compute the translation column t[] = R * (-eye).
+ *
+ * GPR codes (assigned by resolve_look_at_init):
+ *   r_look_at   : MT3_S2S4* (popped from tape; output matrix destination)
+ *   r_pux       : pointer to ux   (offset O_(ResolveLookAtScratch,ux))
+ *   r_puy       : pointer to uy   (offset O_(ResolveLookAtScratch,uy))
+ *   r_puz       : pointer to uz   (offset O_(ResolveLookAtScratch,uz))
+ *   r_peye      : pointer to eye  (offset O_(ResolveLookAtScratch,eye))
+ *   r_tmp0/1/2  : atom-local scratch (load + MVMVA + store temps)
+ *
+ * 4 pointer regs (r_pux/r_puy/r_puz/r_peye) are DEDICATED — they hold the scratch addresses for the entire body.
+ * They are computed in-body via `add_si(r_px, r_scratch, O_(ResolveLookAtScratch, field))` so no tape-data pointer is needed.
+ *
+ * Struct layout (per duffle/math.h):
+ *   MT3_S2S4 { A3x3_S2 m; A3_S4 t; }  →  m[][] is S2 packed (9 × 2 = 18 bytes at offset 0) 
+ *                                        t[0/1/2] is S4     (3 × 4 = 12 bytes at offset 18)
+ *
+ * Translation column: GTE MVMVA with the world rotation matrix pre-set
+ * (helper emits set_gte_world before the bundle, per the bundle design).
+ * MVMVA computes R * pos (with cv=0/mx=0/sf=0/v=0); MAC1/2/3 = R * (-eye).
+ * Pool cost: r_look_at (1) + r_scratch (R_T4 carrier) + 4 ptr regs + 3 tmp regs = 9 GPRs.
+ */
+I_ MipsAtom* resolve_look_at__populate_and_translate_proc(AtomArena_R aa
+	,	U4 r_look_at
+	,	U4 r_scratch
+	,	U4 r_pux, U4 r_puy, U4 r_puz, U4 r_peye    /* 4 dedicated pointer regs */
+	,	U4 r_tmp0, U4 r_tmp1, U4 r_tmp2             /* 3 atom-local scratch regs */
+) MipsAtom_Proc_(resolve_look_at__populate_and_translate, aa, {
+	/* Pop look_at* (the matrix output) — advance R_TapePtr by 4 bytes. */
+	load_word(r_look_at, R_TapePtr, O_(Binds_ResolveLookAtPopAndTrans,look_at)),
+	add_ui_self(         R_TapePtr, S_(Binds_ResolveLookAtPopAndTrans)),
+
+	/* Compute the 4 scratch pointers in their dedicated GPRs. */
+	add_si(r_pux,  r_scratch, O_(ResolveLookAtScratch,ux)),       /* r_pux  = &ux  */
+	add_si(r_puy,  r_scratch, O_(ResolveLookAtScratch,uy)),       /* r_puy  = &uy  */
+	add_si(r_puz,  r_scratch, O_(ResolveLookAtScratch,uz)),       /* r_puz  = &uz  */
+	add_si(r_peye, r_scratch, O_(ResolveLookAtScratch,eye)),      /* r_peye = &eye */
+	nop,
+
+	/* ── m[0] = (S2)ux ── */
+	load_word(r_tmp0, r_pux, O_(V3_S4,x)),
+	load_word(r_tmp1, r_pux, O_(V3_S4,y)),
+	load_word(r_tmp2, r_pux, O_(V3_S4,z)),
+	nop,
+	store_half(r_tmp0, r_look_at, O_(MT3_S2S4,m[0][0])),
+	store_half(r_tmp1, r_look_at, O_(MT3_S2S4,m[0][1])),
+	store_half(r_tmp2, r_look_at, O_(MT3_S2S4,m[0][2])),
+
+	/* ── m[1] = (S2)uy ── */
+	load_word(r_tmp0, r_puy, O_(V3_S4,x)),
+	load_word(r_tmp1, r_puy, O_(V3_S4,y)),
+	load_word(r_tmp2, r_puy, O_(V3_S4,z)),
+	nop,
+	store_half(r_tmp0, r_look_at, O_(MT3_S2S4,m[1][0])),
+	store_half(r_tmp1, r_look_at, O_(MT3_S2S4,m[1][1])),
+	store_half(r_tmp2, r_look_at, O_(MT3_S2S4,m[1][2])),
+
+	/* ── m[2] = (S2)uz ── */
+	load_word(r_tmp0, r_puz, O_(V3_S4,x)),
+	load_word(r_tmp1, r_puz, O_(V3_S4,y)),
+	load_word(r_tmp2, r_puz, O_(V3_S4,z)),
+	nop,
+	store_half(r_tmp0, r_look_at, O_(MT3_S2S4,m[2][0])),
+	store_half(r_tmp1, r_look_at, O_(MT3_S2S4,m[2][1])),
+	store_half(r_tmp2, r_look_at, O_(MT3_S2S4,m[2][2])),
+
+	/* ── Translation column t[i] = R * (-eye) ─────────────────────────────
+	 * pos = -eye: load eye.x/y/z from r_peye, negate via sub_u from R_0. */
+	load_word(r_tmp0, r_peye, O_(P3_S4,x)),
+	load_word(r_tmp1, r_peye, O_(P3_S4,y)),
+	load_word(r_tmp2, r_peye, O_(P3_S4,z)),
+	nop,
+	sub_u(r_tmp0, R_0, r_tmp0),  /* pos.x = -eye.x */
+	sub_u(r_tmp1, R_0, r_tmp1),
+	sub_u(r_tmp2, R_0, r_tmp2),
+
+	/* mtc2 IR1/2/3 = pos (for MVMVA — input vector registers). */
+	gte_mv_to_data_r(r_tmp0, C2_IR1),
+	gte_mv_to_data_r(r_tmp1, C2_IR2),
+	gte_mv_to_data_r(r_tmp2, C2_IR3),
+	nop2,
+
+	/* MVMVA: MAC1/2/3 = R * IR with cv=0 (no TR vector), mx=0 (rotation matrix), sf=0 (no shift), v=0 (V0 = IR1/2/3, no far-plane clipping).
+	 * The pre-set rotation matrix is the one set by the preceding set_gte_world atom.
+	 * gte_cmdw_mvmva is parameterless and defaults to cv=0/mx=0/sf=0/v=0. */
+	gte_cmdw_mvmva,
+	nop,  /* GTE interlock */
+
+	/* mfc2 MAC1/2/3 → r_tmp0/r_tmp1/r_tmp2 (sign-extended into 32-bit GPRs).
+	 * MAC1/2/3 hold R*v with no TR add and no perspective divide — exactly the 3 distinct world-space translation values we need for t[0..2]. */
+	gte_mv_from_data_r(r_tmp0, C2_MAC1),
+	gte_mv_from_data_r(r_tmp1, C2_MAC2),
+	gte_mv_from_data_r(r_tmp2, C2_MAC3),
+	nop,
+	store_word(r_tmp0, r_look_at, O_(MT3_S2S4,t[0])),
+	store_word(r_tmp1, r_look_at, O_(MT3_S2S4,t[1])),
+	store_word(r_tmp2, r_look_at, O_(MT3_S2S4,t[2])),
+
+	mac_yield()
+})
+
+#pragma endregion Atom Procs
+
+#pragma region Baked Atoms
+
+enum {
+	R_ScreenX   = R_T5 atom_reg atom_type(U2),
+	R_ScreenY   = R_T6 atom_reg atom_type(U2),
+	R_ScreenBuf = R_T7 atom_reg, /* Caller-pinned: & smem.screen_buf */
+#define R_ScreenBuf_Code R_T7_Code
+};
+//screen_env_init. Mirrors the libpsyx's SetDefDispEnv + SetDefDrawEnv + the manual enable_auto_clear / initial_bg_color writes.
+internal MipsAtom_(screen_env_init) atom_info(atom_phase(screen_init)
+,	atom_reads(R_T0, R_ScreenX, R_ScreenY, R_ScreenBuf)
+, atom_writes(R_T0, R_ScreenX, R_ScreenY)
+) {
+	/* display[0] = (0, 0, 320, 240); rest of struct zeroed. */
+	add_ui(R_ScreenX, R_0, ScreenRes_X), add_ui(R_ScreenY, R_0, ScreenRes_Y),
+	mac_store_v2s2(R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DisplayEnv,display_area.width) + OA_(DoubleBuffer,display,0)),
+	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,display_area) + OA_(DoubleBuffer,display,0)),
+	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,screen)       + OA_(DoubleBuffer,display,0)),
+	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,vinterlace)   + OA_(DoubleBuffer,display,0)),
+
+	/* display[1] = (0, 240, 320, 240); rest of struct zeroed. */
+	mac_store_rects2(R_0, R_ScreenY, R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DisplayEnv,display_area) + OA_(DoubleBuffer,display,1)),
+	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,screen)     + OA_(DoubleBuffer,display,1)),
+	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,vinterlace) + OA_(DoubleBuffer,display,1)),
+
+	mac_store_rects2(R_0, R_ScreenY, R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DrawEnv,clip_area)         + OA_(DoubleBuffer,draw,0)), /* draw[0].clip_area = (0, 240, 320, 240). C11's SetDefDrawEnv writes clip.y = y_arg. */
+	mac_store_v2s2(  R_0, R_ScreenY,                       R_ScreenBuf, O_(DrawEnv,drawing_offset[0]) + OA_(DoubleBuffer,draw,0)), /* draw[0].drawing_offset[0] = (0, 240); C11 passes y_arg as ofs. */
+
+	mac_store_v2s2(R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DrawEnv,clip_area.width) + OA_(DoubleBuffer,draw,1)),
+
+	/* draw[0].texture_window = (0, 0, 0, 0); two word-zeroes cover the full 8-byte tw field. */
+	store_word(R_0, R_ScreenBuf, O_(DrawEnv,texture_window.x)     + OA_(DoubleBuffer,draw,0)),
+	store_word(R_0, R_ScreenBuf, O_(DrawEnv,texture_window.width) + OA_(DoubleBuffer,draw,0)),
+
+	store_word(R_0, R_ScreenBuf, O_(DrawEnv,drawing_offset[0].x)  + OA_(DoubleBuffer,draw,1)),
+	store_word(R_0, R_ScreenBuf, O_(DrawEnv,texture_window.x)     + OA_(DoubleBuffer,draw,1)),
+	store_word(R_0, R_ScreenBuf, O_(DrawEnv,texture_window.width) + OA_(DoubleBuffer,draw,1)),
+
+	/* draw[0].texture_page = 10 (gp0_tpage_default). C11 SetDefDrawEnv at C11_only.elf:0x8001273C writes the same 0x0A. . */
+	add_ui(R_T0, R_0, gp0_tpage_default),
+	store_half(R_T0, R_ScreenBuf, O_(DrawEnv,texture_page) + OA_(DoubleBuffer,draw,0)),
+	store_half(R_T0, R_ScreenBuf, O_(DrawEnv,texture_page) + OA_(DoubleBuffer,draw,1)),
+
+	/* draw[0] control bytes: flag_dither=1, flag_draw_on_display=1 (the dfe bit per psx-spx; libpsyx sets it via `SetDefDrawEnv`'s conditional at C11_only.elf:0x80012728), enable_auto_clear=1. Each byte is named;
+	 * the previous `store_word(R_0, ..., +20)` overwrote all four with zero. */
+	add_ui(R_T0, R_0, 1),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,flag_dither)          + OA_(DoubleBuffer,draw,0)),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,flag_draw_on_display) + OA_(DoubleBuffer,draw,0)),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,enable_auto_clear)    + OA_(DoubleBuffer,draw,0)),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,flag_dither)          + OA_(DoubleBuffer,draw,1)),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,flag_draw_on_display) + OA_(DoubleBuffer,draw,1)),
+	store_byte(R_T0, R_ScreenBuf, O_(DrawEnv,enable_auto_clear)    + OA_(DoubleBuffer,draw,1)),
+
+	/* draw[0].initial_bg_color = (r=7, g=7, b=7). */
+	add_ui(R_T0, R_0, 7),
+	mac_store_rgb8(R_T0,R_T0,R_T0, R_ScreenBuf, O_(DrawEnv,initial_bg_color) + OA_(DoubleBuffer,draw,0)),
+	mac_store_rgb8(R_T0,R_T0,R_T0, R_ScreenBuf, O_(DrawEnv,initial_bg_color) + OA_(DoubleBuffer,draw,1)),
+
+	mac_yield(),
+};
+
+/* gp_screen_init's GPR setup. Tests the mixed user-pinning + auto-reg pattern:
+ *   - R_IO_BaseAddr = R_T4 (user-pinned via atom_reg; pre-existing)
+ *   - R_GP1_Offset  = R_T2 (user-pinned via atom_reg; NEW -- for GPIO_PORT1_OFFSET)
+ *   - R_ScreenX     = R_T5 (user-pinned via atom_reg; used as a transfer and GTE setup reg)
+ *   - R_GpTmp       = auto-allocated by the lua pass and used for several GPU transfers;
+ *                    the C preprocessor resolves it to the chosen free pool GPR.
+ *
+ * For gp_screen_init, the auto-reg pool exclusions are:
+ *   user_pinned (from the corpus register_alias_registry) : R_T0..R_T7 (all 8 user-pinned across hello_camera.atom.c)
+ *   body-parsed physical registers                         : aliases resolve through the registry;
+ *                                                           the body uses R_ScreenX, not raw R_T5
+ *   source_pool after both subtractions                   : {R_V0, R_V1} only
+ *   R_GpTmp gets R_V0 (the first-fit choice). Its repeated GPU-transfer use proves that the
+ *   auto-reg allocation is active while the R_ScreenX references prove the pinned alias is used.
+ *   R_TapePtr (R_T9), R_AtomJmp (R_T8), R_AT are excluded from the POOL by construction in
+ *   passes/auto_reg.lua -- see the "obvious exclusions" comment block at the top of that file.
+ */
+enum {
+	R_IO_BaseAddr = R_T4 atom_reg, /* Caller-pinned: IO_BASE_ADDR = 0x1F800000 */
+	R_GP1_Offset  = R_T2 atom_reg, /* Caller-pinned: GPIO_PORT1_OFFSET = 0x10 */
+	atom_auto_reg(gp_screen_init, R_GpTmp),  /* Auto-allocated scratch; resolved to a free pool GPR by the lua pass. C-preprocessor expands to R_GpTmp = R_GpTmp_Code with an atom_auto_reg trailing comment. */
+#define R_IO_BaseAddr_Code R_T4_Code
+#define R_GP1_Offset_Code  R_T2_Code
+};
+internal MipsAtom_(gp_screen_init) atom_info(atom_phase(screen_init), atom_reads(R_IO_BaseAddr)) {
+	store_word(R_0, R_IO_BaseAddr, GPIO_PORT1_OFFSET),                                   /* GP1(00h) Reset */
+	mac_gcmd_push(gp1_word_ResetCmdBuffer(),   R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* GP1(01h) ClearFIFO; uses pinned R_ScreenX as the transfer reg. */
+	mac_gcmd_push(gp1_word_AcknowledgeIRQ(),   R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* GP1(02h) AckIRQ; uses pinned R_ScreenX as the transfer reg. */
+	mac_gcmd_push(gp1_word_DisplayOn(),        R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* GP1(03h) Display ON; uses pinned R_ScreenX as the transfer reg. */
+	mac_gcmd_push(gp1_word_dma_to_gpu(),       R_GpTmp,   R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* GP1(04h) DMADirection=2 (CPU->GPU). libpsyx's per-frame PutDrawEnv/DrawOTag use DMA2; without this the DMA queue never drains. Uses auto-allocated R_GpTmp. */
+	mac_gcmd_push(gp1_word_StartDisplayArea(), R_GpTmp,   R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* GP1(05h) StartDisplayArea (X=0, Y=0); uses auto-allocated R_GpTmp. */
+
+	/* GP1: DisplayMode + Display Ranges. */
+	mac_gcmd_push(gp1_word_display_mode_320x240_15bit_ntsc, R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET),
+	mac_gcmd_push(gp1_word_horizontal_range_ntsc,           R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET),
+	mac_gcmd_push(gp1_word_vertical_range_ntsc,             R_ScreenX, R_IO_BaseAddr, GPIO_PORT1_OFFSET),
+
+	/* GTE: SetGeomOffset (OFX, OFY) — ScreenRes_CenterX, ScreenRes_CenterY. */
+	load_upper_i(R_ScreenX, ScreenRes_CenterX), gte_mv_to_ctrl_r(R_ScreenX, gte_cr_OFX_Code),
+	load_upper_i(R_ScreenX, ScreenRes_CenterY), gte_mv_to_ctrl_r(R_ScreenX, gte_cr_OFY_Code),
+
+	/* GTE: SetGeomScreen (H) — CR26 (per PSX-SPX / libpsyx), value is the raw projection-plane distance, NOT shifted. */
+	add_ui(R_ScreenX, R_0, ScreenZ), gte_mv_to_ctrl_r(R_ScreenX, gte_cr_H_Code),
+
+	/* GP1: DisplayEnable — bit 0 = 0 (Display ON). */
+	mac_gcmd_push(gp1_word_DisplayOn(), R_GpTmp, R_IO_BaseAddr, GPIO_PORT1_OFFSET), /* Uses auto-allocated R_GpTmp. */
+	mac_yield(),
+};
+
+typedef Struct_(Binds_PadApplyInput) {
+	PadState* state;
+	V3_S2*    cube_rot;
+	V3_S2*    floor_rot;
+};
+enum {
+	R_PadStateT5 = R_T5 atom_reg,
+	R_CubeRot    = R_T1 atom_reg,
+	R_FloorRot   = R_T2 atom_reg,
+};
+internal MipsAtom_(pad_input_cube_rotation) atom_info(atom_bind(Binds_PadApplyInput)
+, atom_reads(R_T0, R_CubeRot, R_FloorRot, R_T3, R_T4, R_PadStateT5, R_TapePtr)
+, atom_writes(     R_CubeRot, R_FloorRot)
+) {
+	/* Pop Binds from tape (state, cube_rot, floor_rot) */
+	load_word(R_PadStateT5, R_TapePtr, O_(Binds_PadApplyInput,state)),
+	load_word(R_CubeRot,    R_TapePtr, O_(Binds_PadApplyInput,cube_rot)),
+	load_word(R_FloorRot,   R_TapePtr, O_(Binds_PadApplyInput,floor_rot)),
+	add_ui_self(            R_TapePtr, S_(Binds_PadApplyInput)),
+
+	/* Load pad[0].buttons into R_T0. */
+	load_word(R_T0, R_PadStateT5, O_(PadState,buttons)), nop,
+	// Note(Ed): Potential op with delay slot?
+
+	/* D-pad Left: cube_rot.y += 30, floor_rot.y += 5.  */
+	and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(dpad_left, exit_dpad_left)),
+		load_half( R_T4, R_CubeRot,  O_(V3_S2,y)),   /* BD-slot */
+		load_half( R_T3, R_FloorRot, O_(V3_S2,y)),
+		add_si(    R_T4, R_T4, 30),
+		add_si(    R_T3, R_T3, 5),
+		store_half(R_T4, R_CubeRot,  O_(V3_S2,y)),
+		store_half(R_T3, R_FloorRot, O_(V3_S2,y)),
+	atom_label(exit_dpad_left)
+
+	/* D-pad Right: cube_rot.y -= 30, floor_rot.y -= 5. */
+	and_i(R_T3, R_T0, Pad_Right), branch_le_zero(R_T3, atom_offset(dpad_right, exit_dpad_right)),
+		load_half( R_T4, R_CubeRot,  O_(V3_S2,y)),   /* BD-slot */
+		load_half( R_T3, R_FloorRot, O_(V3_S2,y)),
+		add_si(    R_T4, R_T4, -30),
+		add_si(    R_T3, R_T3, -5),
+		store_half(R_T4, R_CubeRot,  O_(V3_S2,y)),
+		store_half(R_T3, R_FloorRot, O_(V3_S2,y)),
+	atom_label(exit_dpad_right)
+
+	/* Analog left-stick X: dead zone 0x70..0x90.
+	 * Cube delta = (0x80 - left_x) >> 2; floor delta = (0x80 - left_x) >> 5. */
+	load_byte_u(R_T3, R_PadStateT5, O_(PadState,left.x)),
+
+	/* Dead-zone check: skip analog if left_x in [0x70, 0x90] inclusive. Outside dead zone on LOW side: left_x < 0x70 (strictly).
+	 * set_lt_u(R_T4, R_T3, R_T4=0x70) → R_T4 = (left_x < 0x70) ? 1 : 0. */
+	add_ui(R_T4, R_0, PadDeadZone_HighBound), set_lt_u(R_T4, R_T3, R_T4), branch_ne(R_T4, R_0, atom_offset(dead_zone_low_check, dead_low_active)),
+	add_ui(R_T4, R_0, PadDeadZone_Center), /* BD-slot: pre-load 0x80 for dead_low_active */
+
+atom_label(dead_check_upper)
+	/* left_x >= 0x70 → check upper bound. */
+	load_byte_u(R_T3, R_PadStateT5, O_(PadState,left.x)), /* reload */
+	add_ui(     R_T4, R_0, PadDeadZone_HighBound),
+
+	/* R_T4 = (0x90 < left_x) ? 1 : 0 → (left_x > 0x90) ? 1 : 0 */
+	set_lt_u(R_T4, R_T4, R_T3), branch_ne(R_T4, R_0, atom_offset(dead_zone_high_check, dead_high_active)),
+	add_ui(  R_T4, R_0, PadDeadZone_Center), /* BD-slot: pre-load 0x80 for dead_high_active */
+	jump_rel(atom_offset(dead_zone_skip, exit_stick)),
+		mac_yield_load(),
+
+atom_label(dead_low_active)
+	/* R_T3 = left_x (from line 632 lbu; not clobbered between dead_zone_low_check branch + its BD-slot `add_ui R_T4, 0x80`).
+	 * The earlier `load_byte_u(R_T3, ...)` reload was redundant and introduced a load-use hazard on the next `sub_u`.
+	 * R_T4 = 0x80 from the BD-slot of `dead_zone_low_check`'s branch_ne. */
+	sub_u( R_T3, R_T4, R_T3), /* R_T3 = 0x80 - left_x */
+	/* delta = 0x80 - left_x (positive). */
+
+	/* R_T4 = cube_delta */
+	shift_aright(R_T4, R_T3, 2),
+	load_half(   R_T0, R_CubeRot, O_(V3_S2,y)), nop,
+	add_u(       R_T0, R_T0, R_T4),
+	store_half(  R_T0, R_CubeRot, O_(V3_S2,y)),
+	/* R_T4 = floor_delta — moved into the load-delay slot of the floor load below (fills the 1-instruction gap;
+	 * doesn't read R_T0; R_T4 settles by the subsequent add_u). */
+	load_half(   R_T0, R_FloorRot, O_(V3_S2,y)),
+	shift_aright(R_T4, R_T3, 5),
+	add_u(       R_T0, R_T0, R_T4),
+	store_half(  R_T0, R_FloorRot, O_(V3_S2,y)),
+
+	jump_rel(atom_offset(end_low, exit_stick)),
+		mac_yield_load(),
+
+atom_label(dead_high_active)
+	/* R_T3 = left_x (from line 641 lbu in dead_check_upper; not clobbered between dead_zone_high_check branch + its BD-slot `add_ui R_T4, 0x80`).
+	 * The earlier `load_byte_u(R_T3, ...)` reload was redundant and introduced a load-use hazard on the next `sub_u`.
+	 * R_T4 = 0x80 from the BD-slot of `dead_zone_high_check`'s branch_ne. */
+	sub_u( R_T3, R_T4, R_T3),
+	/* delta = 0x80 - left_x (signed negative). */
+
+	shift_aright(R_T4, R_T3, 2),                      /* R_T4 = cube_delta (signed) */
+	load_half(   R_T0, R_CubeRot, O_(V3_S2,y)), nop,
+	add_u(       R_T0, R_T0, R_T4),
+	store_half(  R_T0, R_CubeRot, O_(V3_S2,y)),
+
+	/* R_T4 = floor_delta (signed) — moved into the load-delay slot of the floor load below. */
+	load_half(   R_T0, R_FloorRot, O_(V3_S2,y)),
+	shift_aright(R_T4, R_T3, 5),
+	add_u(       R_T0, R_T0, R_T4),
+	store_half(  R_T0, R_FloorRot, O_(V3_S2,y)),
+
+atom_label(no_jump_fallthrough)
+	mac_yield_load(),
+
+atom_label(exit_stick)
+	/* NOT mac_yield() — R_AtomJmp was already loaded in the BD-slot of the dead-zone/exit branch. */
+	mac_yield_tail(),
+};
+
+enum {
+	R_Cam         = R_T4 atom_reg,
+	R_CamPadState = R_T5 atom_reg,
+};
+typedef Struct_(Binds_PadInputCam) {
+	PadState* state;
+	Camera*   cam;
+};
+internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
+, atom_reads( R_Cam, R_CamPadState, R_TapePtr)
+, atom_writes(R_Cam)
+) {
+	/* Bind pop: state → R_CamPadState (R_T5), cam → R_Cam (R_T4), advance R_TapePtr by 8. */
+	load_word(R_CamPadState, R_TapePtr, O_(Binds_PadInputCam,state)),
+	load_word(R_Cam,         R_TapePtr, O_(Binds_PadInputCam,cam)),
+	add_ui_self(             R_TapePtr, S_(Binds_PadInputCam)),
+
+	/* Load pad[0].buttons into R_T0; nop fills the load-delay slot. */
+	load_word(R_T0, R_CamPadState, O_(PadState,buttons)),
+	load_word(R_T1, R_Cam, O_(Camera,pos.x)), // BD-Slot.
+
+	// D-pad Left → cam.pos.x -= 50.  and_i fulfills BD-slot for load on R_Cam.
+	and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(left_x, exit_left_x)), mac_yield_load(),
+		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.x)),
+atom_label(exit_left_x)
+	/* D-pad Right → cam.pos.x += 50. Reuses R_T1 from Left. */
+	and_i(R_T3, R_T0, Pad_Right), branch_le_zero(R_T3, atom_offset(right_x, exit_right_x)), nop,
+		add_si(R_T1, R_T1,  50), store_word(R_T1, R_Cam, O_(Camera,pos.x)),
+atom_label(exit_right_x)
+
+	/* D-pad Up → cam.pos.y -= 50. Load pos.y BEFORE the andi. */
+	load_word(R_T1, R_Cam, O_(Camera,pos.y)),
+	and_i(R_T3, R_T0, Pad_Up), branch_le_zero(R_T3, atom_offset(up_y, exit_up_y)), nop,
+		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.y)),
+atom_label(exit_up_y)
+	/* D-pad Down → cam.pos.y += 50. Reuses R_T1 from Up. */
+	and_i(R_T3, R_T0, Pad_Down), branch_le_zero(R_T3, atom_offset(down_y, exit_down_y)), nop,
+		add_si(R_T1, R_T1,  50), store_word(R_T1, R_Cam, O_(Camera,pos.y)),
+atom_label(exit_down_y)
+
+	/* D-pad Cross → cam.pos.z -= 50. Load pos.z BEFORE the andi. */
+	load_word(R_T1, R_Cam, O_(Camera,pos.z)),
+	and_i(R_T3, R_T0, Pad_Cross), branch_le_zero(R_T3, atom_offset(cross_z, exit_cross_z)), nop,
+		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.z)),
+atom_label(exit_cross_z)
+	/* D-pad Circle → cam.pos.z += 50. Reuses R_T1 from Cross. */
+	and_i(R_T3, R_T0, Pad_Circle), branch_le_zero(R_T3, atom_offset(circle_z, exit_circle_z)), nop,
+		add_si(R_T1, R_T1,  50), store_word(R_T1, R_Cam, O_(Camera,pos.z)),
+atom_label(exit_circle_z)
+
+	mac_yield_tail(),
+};
+
+enum {
+	R_PrimCursor = R_T7 atom_reg atom_type(U4*),    /* Output cursor (primitive buffer) */
+	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 atom_reg atom_type(V3_S2*), /* Base address of the vertex array */
+	R_OtBase     = R_T6 atom_reg atom_type(U4*),    /* Base address of the Ordering Table */
+#define R_PrimCursor_Code  R_T7_Code
+#define R_FaceCursor_Code  R_T4_Code
+#define R_VertBase_Code    R_T5_Code
+#define R_OtBase_Code      R_T6_Code
+};
+typedef Struct_(Binds_CubeTri) {
+	U4     PrimCursor;
+	V4_S2* FaceCursor;
+	V3_S2* VertBase;
+	U4*    OtBase;
+};
+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, R_TapePtr)
+){
+	/* 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)),
+	mac_yield()
+};
+
+// cube_g4_face — Draw one cube face (Gouraud-shaded quad) via the GTE tape pipeline
+internal
+MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
+		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)),
+
+	mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2),
+	nop2, gte_cmdw_rotate_translate_perspective_triple, // required cpu -> gte delay slot
+	gte_cmdw_nclip,
+
+	gte_mv_from_data_r(R_T0, C2_MAC0), nop,
+	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)),
+		/* BD-slot: Write the prim tag (R_0=0; overwrites the legacy tag word in the prim_buffer).
+		 * If branch IS taken (face culled), the body is skipped and this 0-tag is stranded —
+		 * harmless because the OT entry that points to this prim is created later. */
+		store_word(R_0, R_PrimCursor, O_(Poly_G4, tag)),
+		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),
+
+		mac_gte_store_g4_p012(R_PrimCursor),
+		gte_cmdw_rotate_translate_perspective_single,
+		mac_gte_store_g4_p3(R_PrimCursor),
+
+		gte_cmdw_avg_sort_z4,
+		gte_mv_from_data_r(R_T1, C2_OTZ),
+		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,
+			mac_insert_ot_tag(R_OtBase, R_PrimCursor, S_(Poly_G4)),
+			mac_format_g4_color(R_PrimCursor,
+				/* c0 magenta */ 0xFF, 0x00, 0xFF,
+				/* c1 yellow  */ 0xFF, 0xFF, 0x00,
+				/* c2 cyan    */ 0x00, 0xFF, 0xFF,
+				/* c3 green   */ 0x00, 0xFF, 0x00),
+		// end: branch(bounds_chk)
+// end: branch(cull)
+
+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 */
+	mac_yield()
+};
+
+typedef Struct_(Binds_FloorTri) {
+	U4     PrimCursor;
+	V3_S2* FaceCursor;
+	V3_S2* VertBase;
+	U4*    OtBase;
+};
+internal
+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, R_TapePtr)
+){
+	/* 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)),
+	load_word(R_VertBase,   R_TapePtr, O_(Binds_FloorTri,VertBase)),
+	load_word(R_OtBase,     R_TapePtr, O_(Binds_FloorTri,OtBase)),
+	add_ui_self(            R_TapePtr, S_(Binds_FloorTri)),
+	mac_yield()
+};
+
+// atom_dbg_skip
+internal
+MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
+	, atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+	, atom_writes(R_PrimCursor, R_FaceCursor)
+) {
+	mac_load_tri_indices(R_FaceCursor, R_T0, R_T1, R_T2),
+	mac_gte_load_tri_verts(R_VertBase,   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) */
+	gte_mv_from_data_r(R_T0, C2_MAC0),
+	nop, branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop, // required gte -> cpu load-delay slot.
+		/* Format Primitive */
+		mac_gte_store_f3(R_PrimCursor),
+
+		/* Calculate Depth */
+		gte_avg_sort_z3,
+		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),
+		branch_equal(R_AT, R_0,  atom_offset(bounds_chk, floor_f3_face_exit)), nop,
+			mac_format_f3_color(R_PrimCursor, 0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
+			mac_insert_ot_tag(R_OtBase, R_PrimCursor, S_(Poly_F3)),   /* Insert into Ordering Table Linked List */
+			add_ui_self(R_PrimCursor, S_(Poly_F3)), /* Advance Prim Cursor (5 words) */
+				// Note(Ed): No bounds checking, should be checked before atom runs.
+		// end: branch(bounds_chk)
+	// end: branch(culling)
+
+/* Advance Input Cursor & Yield (Both branch targets land here) */
+atom_label(floor_f3_face_exit)
+	add_ui_self(R_FaceCursor, S_(S2) * 4),  /* Advance Face Cursor (4 * S2 = 8 bytes) */
+	mac_yield()
+};
+
+typedef Struct_(Binds_SyncPrimitiveArena) { U4 used; U4 cursor; };
+internal MipsAtom_(sync_primitive_arena) atom_info(atom_bind(Binds_SyncPrimitiveArena)
+	, atom_reads( R_TapePtr, R_PrimCursor)
+	, atom_writes(R_TapePtr)
+){
+	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)),
+	/* Calculate byte offset and store directly back to RAM */
+	sub_u(     R_T0, R_PrimCursor, R_T0), // R_T0    = R_PrimCursor - binds.cursor
+	store_word(R_T0, R_AT, 0),            // R_AT[0] = R_T0
+	mac_yield()
+};
+
+#pragma endregion Baked Atoms

code/hello_camera/hello_camera.c

@@ -0,0 +1,528 @@
+#pragma region Vendors
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+// #include "libgpu.h"
+// #include "libetc.h"
+// #include "libgte.h"
+#pragma endregion Vendors
+
+#pragma region Duffle Headers
+#	include "duffle/gen/macs.h"
+#	include "duffle/gen/offsets.h"
+
+#include "duffle/word_count.metadata.h"
+
+#include "duffle/dsl.h"
+#include "duffle/memory.h"
+#include "duffle/math.h"
+
+#include "duffle/gcc_asm.h"
+#include "duffle/mips.h"
+#include "duffle/gp.h"
+#include "duffle/gte.h"
+#include "duffle/pad.h"
+
+#include "duffle/dsl.atom.h"
+#include "duffle/lottes_tape.h"
+
+#include "duffle/bios.h"
+#include "duffle/psyq.h"
+#pragma endregion Duffle Headers
+
+#pragma region Duffle TUs
+#include "duffle/pad.c"
+#include "duffle/math.atom.c"
+#include "duffle/mips.atom.c"
+#include "duffle/gte.atom.c"
+#include "duffle/gp.atom.c"
+#include "duffle/pad.atom.c"
+#include "duffle/psyq.atom.c"
+#pragma endregion Duffle TUs
+
+#pragma region Hello Camera Headers
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
+#	include "gen/auto_reg.h"
+
+#include "hello_camera.h"
+#pragma endregion Hello Camera Headers
+
+#pragma region Hello Joypad TUs
+#include "hello_camera.atom.c"
+#pragma endregion Hello Joypad TUs
+
+enum {
+	Scratchpad_Loc = 0x1F800000,
+};
+#define C_scratch(type) C_(type, Scratchpad_Loc)
+
+enum {
+	Scratchpad_Len           = 1024,
+	MemTape_Len              = 512,
+	ResolveLookAtArena_Words = 512,
+};
+typedef Struct_(SMemory) {
+	PrimitiveArena          primitives;
+	A2_OrderingTable_Buffer ordering_tbl;
+	DoubleBuffer            screen_buf;
+	S4                      active_buf_id;
+
+	U4 MemTape[MemTape_Len];
+
+	MT3_S2S4 tform_world;
+	MT3_S2S4 tform_view;
+
+	Camera cam;
+
+	Ent_Cube  cube;
+	Ent_Floor floor;
+
+	PadBiosRaw pad_raw[2];
+	PadState   pad[2];
+
+	// TODO(Ed): We don't need this we can just cast at any point an address to a desired view of scratchpad, we have the address.
+	U4_V scratchpad; // d-cache
+
+	U4        resolve_look_at_mem[ResolveLookAtArena_Words];
+	MipsAtom* resolve_look_at_atom_addrs[7];
+};
+global SMemory smem;
+extern SMemory smem;
+
+#define pad0_btn_(btn) btn & smem.pad[0].buttons
+#define pad1_btn_(btn) btn & smem.pad[1].buttons
+
+I_ B1* prim__alloc(U4 type_width, Str8 type_name) {
+	gknown PrimitiveArena* pa  = & smem.primitives;
+	gknown B1*             buf = (B1*) r_(smem.primitives.buf)[smem.active_buf_id];
+	assert(pa->used + type_width < PrimitiveBuff_Len);
+	B1* next  = buf + pa->used;
+	pa->used += type_width;
+	return next;
+}
+#define prim_alloc(type) (type*)prim__alloc(S_(type), slit( stringify(type)))
+
+void
+resolve_look_at_c11(MT3_S2S4* look_at, P3_S4* eye, P3_S4* target, V3_S4* up_in) {
+// RGA(Lengyel): Build matrix expansion of a rigid transformation. Corresponding motor is not constructed; we write the LA form for GTE.
+// Preconditions: eye != target, up_in not collinear with (target - eye).
+	V3_S4 right, up, forward;
+	V3_S4 ux, uy, uz;
+	V3_S4 pos, off;
+
+	forward = target[0]; sub_v3s4(& forward, eye[0]); // RGA(Lengyel): Affine point - point = zero-weight direction.
+	normalize_v3s4(& forward, & uz);                  // RGA(Lengyel): Normalize the direction bulk. Not finite-point unitization.
+
+	cross_v3s4(& uz,   up_in, & right); normalize_v3s4(& right, & ux); // RGA(Lengyel): Complement(Wedge(forward, up_in)) -> right axis.
+	cross_v3s4(& uz, & ux,    & up);    normalize_v3s4(& up,    & uy); // RGA(Lengyel): Complement(Wedge(forward, right)) -> up axis.
+
+	// RGA(Lengyel): matrix expansion of the world-to-camera rotation (basis rows).
+	look_at->m[0][0] = ux.x; look_at->m[0][1] = ux.y; look_at->m[0][2] = ux.z;
+	look_at->m[1][0] = uy.x; look_at->m[1][1] = uy.y; look_at->m[1][2] = uy.z;
+	look_at->m[2][0] = uz.x; look_at->m[2][1] = uz.y; look_at->m[2][2] = uz.z;
+
+	pos = eye[0]; mul_v3s4(& pos, v3s4(-1,-1,-1)); // RGA(Lengyel): -eye in world coordinates (spatial bulk only; implicit weight is dropped).
+
+	// RGA(Lengyel): R * (-eye) is the full matrix translation column. 
+	// Motor translator would store half this displacement in m.xyz; GTE consumes full column.
+	mul_m3s2_v3s4(look_at, & pos, & off);
+	trans_m3s2(   look_at,        & off);
+}
+
+/* Pre-build all 7 chain atoms of the resolve_look_at bundle into the static arena.
+ * Called ONCE from main() before the frame loop.
+ * After this returns, the smem.resolve_look_at_atom_addrs[] array contains valid MIPS atom pointers
+ * for the frame-time bundle helper to emit via tb_emit(tb, captured_addr).
+ *
+ * 4 unique procs in hello_camera.atom.c (chain atoms 0, 2, 4, 6); atoms 1, 3, 5
+ * share the GENERIC normalize_v3s4_proc from gte.atom.c (called 3x with different
+ * O_(ResolveLookAtScratch,...) offsets):
+ * 	0: resolve_look_at__input_and_sub_proc
+ * 	1: normalize_v3s4_proc                  (fwd → uz; offsets 0, 16)
+ * 	2: resolve_look_at__cross_uz_up_in_to_right_proc
+ * 	3: normalize_v3s4_proc                  (right → ux; offsets 32, 48)
+ * 	4: resolve_look_at__cross_uz_ux_to_up_proc
+ * 	5: normalize_v3s4_proc                  (up → uy; offsets 64, 80)
+ * 	6: resolve_look_at__populate_and_translate_proc
+ *
+ * Task 12.16 promotion: the bundle-specific resolve_look_at__chain_normalize_proc
+ * has been promoted to the generic normalize_v3s4_proc (gte.atom.c), which now
+ * takes r_scratch + r_src_offset + r_dst_offset as U4 parameters. The 3 callers
+ * pass O_(ResolveLookAtScratch,...) macros as offset args. The metaprogram emits
+ * one set of `atom_offset__normalize_v3s4__srav_path__aligned_done` defs
+ * (namespaced by atom name) in duffle/gen/offsets.h, shared by all 3 callers.
+ *
+ * GPR pool per atom: 10 free GPRs (R_T0..R_T3 + R_T5..R_T7 + R_V0 + R_V1 + R_AT).
+ * R_T4 is reserved as the wave-context carrier (R_ResolveScratch).
+ */
+internal void resolve_look_at_init(void) {
+	/* Wrap the static arena in a MipsAtomBuilder. */
+	AtomArena ab = atomarena_make(slice_ut_arr(smem.resolve_look_at_mem));
+
+	/* Atom 0: resolve_look_at__input_and_sub — stages eye/up_in into scratchpad,
+	 * computes fwd = target - eye; binds R_ResolveScratch (R_T4) as the wave-context carrier for atoms 1-6.
+	 * The body hardcodes R_AT and R_V0 as eye.y/eye.z temps (the existing sub_u(eye.x, eye.y, eye.z) chain from the prior Task 12.7 design). */
+	smem.resolve_look_at_atom_addrs[0] = resolve_look_at__input_and_sub_proc(& ab, R_ResolveScratch,
+		R_T0,  /* r_target_ptr (popped from tape) */
+		R_T1,  /* r_eye_ptr    (popped from tape) */
+		R_T2,  /* r_up_in_ptr  (popped from tape) */
+		R_T3, R_T5, R_T6,  R_T7); /* r_tmp<0-3> */
+
+	/* Atom 1: normalize_v3s4_proc
+	 * The proc takes r_src_offset + r_dst_offset as U4 PARAMETERS — we pass the O_(...) macros here (evaluating to numeric literals 0 and 16).
+	 * Body is identical across the 3 call sites (atoms 1, 3, 5); only the offset args differ.
+	 * GPR pool: r_scratch (R_T4 carrier) + 9 body GPRs = 10.
+	 *   r_src_ptr      (R_T0) : src ptr
+	 *   r_dst_ptr      (R_T1) : dst ptr
+	 *   r_tmp          (R_T2) : src.x PRESERVED (NOT clobbered by mfc2 MAC2) → fed to IR1 in stage 4
+	 *   r_mac1_scratch (R_T3) : MAC1 scratch + aligned |v|² in stage 3
+	 *   r_mac2_scratch (R_T5) : MAC2 scratch → result.x after stage 4 sra
+	 *   r_recip_est    (R_T6) : src.y → result.y
+	 *   r_lzcr         (R_T7) : |v|² accumulator + shift count + 1/|v| (overwritten across stages 2-4)
+	 *   r_shift        (R_V0) : shift count (saved in stage 3) → sra amount in stage 4
+	 *   r_branch_tmp   (R_V1) : src.z → result.z (reused after stage 1)
+	 */
+	ab.start = ab.start + ab.used;
+	smem.resolve_look_at_atom_addrs[1] = normalize_v3s4_proc(& ab, R_ResolveScratch,
+		O_(ResolveLookAtScratch, fwd),          /* r_src_offset = 0 */
+		O_(ResolveLookAtScratch, uz),           /* r_dst_offset = 16 */
+		R_T0, R_T1, R_T2,                       /* r_src_ptr, r_dst_ptr, r_tmp */
+		R_T3,                                   /* r_mac1_scratch */
+		R_T5,                                   /* r_mac2_scratch */
+		R_T6,                                   /* r_recip_est */
+		R_T7,                                   /* r_lzcr */
+		R_V0,                                   /* r_shift */
+		R_V1);                                  /* r_branch_tmp */
+
+	/* Atom 2: resolve_look_at__cross_uz_up_in_to_right
+	 * out=scratch+32 (HARDCODED in body). GPR pool: r_scratch + 7 body + R_AT + R_V0 = 10. */
+	smem.resolve_look_at_atom_addrs[2] = resolve_look_at__cross_uz_up_in_to_right_proc(& ab, R_ResolveScratch,
+		R_T0, R_T1, R_T2, /* r_a, r_b, r_c (a.x/y/z → out.x/y/z) */
+		R_T3,             /* r_d (b.x) */
+		R_T5,             /* r_f (out ptr = scratch+32) */
+		R_T6,             /* r_g (a ptr = scratch+16) */
+		R_T7);            /* r_h (b ptr = scratch+128) */
+
+	/* Atom 3: normalize_v3s4_proc. */
+	smem.resolve_look_at_atom_addrs[3] = normalize_v3s4_proc(& ab, R_ResolveScratch,
+		O_(ResolveLookAtScratch, right), /* r_src_offset = 32 */
+		O_(ResolveLookAtScratch, ux),    /* r_dst_offset = 48 */
+		R_T0, R_T1, R_T2,
+		R_T3,
+		R_T5,
+		R_T6,
+		R_T7,
+		R_V0,
+		R_V1);
+
+	/* Atom 4: resolve_look_at__cross_uz_ux_to_up — a=scratch+16, b=scratch+48, out=scratch+64 (HARDCODED). */
+	smem.resolve_look_at_atom_addrs[4] = resolve_look_at__cross_uz_ux_to_up_proc(& ab, R_ResolveScratch,
+		R_T0, R_T1, R_T2,
+		R_T3,
+		R_T5,  /* r_f (out ptr = scratch+64) */
+		R_T6,  /* r_g (a ptr = scratch+16) */
+		R_T7); /* r_h (b ptr = scratch+48) */
+
+	/* Atom 5: normalize_v3s4_proc (generic, from gte.atom.c) — src=scratch+64=up, dst=scratch+80=uy. */
+	smem.resolve_look_at_atom_addrs[5] = normalize_v3s4_proc(& ab, R_ResolveScratch,
+		O_(ResolveLookAtScratch, up), /* r_src_offset = 64 */
+		O_(ResolveLookAtScratch, uy), /* r_dst_offset = 80 */
+		R_T0, R_T1, R_T2,
+		R_T3,
+		R_T5,
+		R_T6,
+		R_T7,
+		R_V0,
+		R_V1);
+
+	/* Atom 6: resolve_look_at__populate_and_translate — write look_at->m[][] from ux/uy/uz (computed from r_scratch+offset internally),
+	then compute translation column t[] = R * (-eye). GPR pool: r_look_at + r_scratch + 4 ptr regs + 3 tmp regs = 9. */
+	smem.resolve_look_at_atom_addrs[6] = resolve_look_at__populate_and_translate_proc(& ab,
+		R_T0,                    /* r_look_at (popped from tape; MT3_S2S4*) */
+		R_ResolveScratch,        /* r_scratch (wave-context carrier) */
+		R_T1, R_T3, R_T5, R_T7,  /* r_pux, r_puy, r_puz, r_peye */
+		R_T2, R_T6, R_V0);       /* r_tmp0, r_tmp1, r_tmp2 */
+
+	/* Sanity check: arena didn't overflow. */
+	assert(ab.used <= ResolveLookAtArena_Words);
+}
+
+/* Emit the resolve_look_at bundle into the tape. Called once per frame from update().
+ * The 7 chain atoms are pre-built at init time (resolve_look_at_init) and referenced by address via smem.resolve_look_at_atom_addrs[].
+ * Per-frame work: 7 tb_emit (atom pointer emissions) + 5 tb_data (C-side pointers for atom 0 + look_at for atom 6).
+ *
+ * Binds_ contract (the field-name labels are for human readability):
+ *   Atom 0  input_and_sub              target(4) eye(4) up_in(4) scratch_base(4) = 4 words
+ *   Atoms 1-5                           (no tape data — atom uses r_scratch + offset internally)
+ *   Atom 6  populate_and_translate     look_at(4)                                = 1 word
+ *                                       ----
+ *                                       5 tb_data words total per frame.
+ */
+I_ void resolve_look_at(
+		TapeBuilder_R tb
+	,	MT3_S2S4* look_at
+	,	P3_S4*    eye
+	,	P3_S4*    target
+	,	V3_S4*    up_in
+){
+	// tb_emit_bundle(tb, slice_from_array(MipsAtom, smem.resolve_look_at_atom_addrs));
+
+	/* Atom 0: input_and_sub — stages eye/up_in into scratchpad + computes fwd.  */
+	tb_emit(tb, smem.resolve_look_at_atom_addrs[0]); {
+		tb_data(tb, u4_(target));              /* Binds_ResolveLookAtSub.target  (C-side P3_S4*) */
+		tb_data(tb, u4_(eye));                 /* Binds_ResolveLookAtSub.eye     (C-side P3_S4*) */
+		tb_data(tb, u4_(up_in));               /* Binds_ResolveLookAtSub.up_in   (C-side V3_S4*) */
+		tb_data(tb, u4_(smem.scratchpad));     /* Binds_ResolveLookAtScratch.scratch_base */
+	}
+
+	/* Atoms 1-5: disabled (atom 1 verification below) */
+	tb_emit(tb, smem.resolve_look_at_atom_addrs[1]); { }
+	// tb_emit(tb, smem.resolve_look_at_atom_addrs[2]); { }
+	// tb_emit(tb, smem.resolve_look_at_atom_addrs[3]); { }
+	// tb_emit(tb, smem.resolve_look_at_atom_addrs[4]); { }
+	// tb_emit(tb, smem.resolve_look_at_atom_addrs[5]); { }
+
+	// /* Atom 6: populate_and_translate — only output pointer is the matrix destination. */
+	// tb_emit(tb, smem.resolve_look_at_atom_addrs[6]); {
+	// 	tb_data(tb, u4_(look_at)); /* Binds_ResolveLookAtPopAndTrans.look_at (MT3_S2S4*) */
+	// }
+}
+
+FI_ void camera_look_at_c11(Camera* c, P3_S4* target, V3_S4* up_in) { resolve_look_at_c11(& c->look_at, & c->pos, target, up_in); }
+
+GCC_OPTIMIZATION_DISABLE
+void update(PrimitiveArena* pa, U4* ordering_buf) 
+{
+	TapeBuilder tb = tb_make(slice_ut_arr(smem.MemTape));
+
+	// Pad Input
+	{
+		tb.used = 0; tb_scope_run(& tb) {
+			// Grab latest state from bios.
+			tb_emit_(pad_bios_snapshot);
+				tb_data_(raw,   & smem.pad_raw[0]);
+				tb_data_(state, & smem.pad[0]);
+			tb_emit_(pad_bios_snapshot);
+				tb_data_(raw,   & smem.pad_raw[1]);
+				tb_data_(state, & smem.pad[1]);
+
+			tb_emit_(pad_input_cam);
+				tb_data_(state, & smem.pad[0]);
+				tb_data_(cam, & smem.cam);
+
+			// tb_emit_(pad_input_cube_rotation);
+			// 	tb_data_(state,     & smem.pad[0]);
+			// 	tb_data_(cube_rot,  & smem.cube.rot);
+			// 	tb_data_(floor_rot, & smem.floor.rot);
+		}
+	}
+
+	orderingtbl_clear_reverse(ordering_buf, OrderingTbl_Len);
+
+	// Update the position based on acceleration and velocity
+	gknown V3_S4_R pos = & smem.cube.pos;
+	gknown V3_S4_R vel = & smem.cube.vel;
+	gknown V3_S4_R acc = & smem.cube.accel;
+	add_v3s4(vel, acc[0]);
+	add_v3s4_fp(pos, vel[0]);
+	// vel->x += acc->x;
+	// vel->y += acc->y;
+	// vel->z += acc->z;
+	// pos->x += vel->x;
+	// pos->y += vel->y;
+	// pos->z += vel->z;
+
+	if (pos->y + 150 > smem.floor.pos.y) vel->y *= -1;
+
+	// Prep
+	S4 nclip = 0;
+	S4 orderingtbl_z = 0;
+	A2_S2 p;    //???
+	S4 flag; //????
+
+	if (0) {
+		camera_look_at_c11(& smem.cam, & smem.cube.pos, & v3s4(0, -fp_one, 0));
+	}
+	if (1)
+	{
+		tb.used = 0; tb_scope_run(& tb) {
+			resolve_look_at(& tb, & smem.cam.look_at, & smem.cam.pos, & smem.cube.pos, & v3s4(0, -fp_one, 0));
+		}
+		V3_S4 right, up, forward;
+		V3_S4 ux, uy, uz;
+		V3_S4 pos, off;
+
+		ResolveLookAtScratch_V scratch = C_scratch(ResolveLookAtScratch_V);
+
+		// Atom 0: Works (tape emits fwd to scratch+0; C-side reads it back)
+		forward = scratch->fwd;
+
+		// C-side normalize fallback (atom 1 disabled)
+		// normalize_v3s4(& forward, & uz);
+		uz = scratch->uz;  /* tape-side: enable after verifying atom 1 fix */
+
+		cross_v3s4(& uz,   & v3s4(0, -fp_one, 0), & right); normalize_v3s4(& right, & ux);
+		cross_v3s4(& uz, & ux,    & up);                    normalize_v3s4(& up,    & uy);
+
+		smem.cam.look_at.m[0][0] = ux.x; smem.cam.look_at.m[0][1] = ux.y; smem.cam.look_at.m[0][2] = ux.z;
+		smem.cam.look_at.m[1][0] = uy.x; smem.cam.look_at.m[1][1] = uy.y; smem.cam.look_at.m[1][2] = uy.z;
+		smem.cam.look_at.m[2][0] = uz.x; smem.cam.look_at.m[2][1] = uz.y; smem.cam.look_at.m[2][2] = uz.z;
+
+		pos = smem.cam.pos; mul_v3s4(& pos, v3s4(-1,-1,-1)); // RGA(Lengyel): -eye in world coordinates (spatial bulk only; implicit weight is dropped).
+
+		mul_m3s2_v3s4(& smem.cam.look_at, & pos, & off);
+		trans_m3s2(   & smem.cam.look_at,        & off);
+	}
+
+	// Draw cube
+	if (1)
+	{
+		mt3s2s4_rotation   (& smem.cube.rot,    & smem.tform_world);
+		mt3s2s4_translation(& smem.tform_world, & smem.cube.pos);
+		mt3s2s4_scale      (& smem.tform_world, & smem.cube.scale);
+
+		// Combine world and look_at matrix.
+		gte_comp_coord_m3s2(& smem.cam.look_at, & smem.tform_world, & smem.tform_view);
+		gte_matrix_set_rotation   (& smem.tform_view);
+		gte_matrix_set_translation(& smem.tform_view);
+
+		// gte_matrix_set_rotation   (& smem.tform_world);
+		// gte_matrix_set_translation(& smem.tform_world);
+
+		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
+		U4 prim_cursor = prim_base + pa->used;
+
+		tb.used = 0; tb_scope(& tb) {
+			tb_emit(& tb, rbind_cube_g4_face);
+				tb_data(& tb, prim_cursor);
+				tb_data(& tb, u4_(smem.cube.faces));
+				tb_data(& tb, u4_(smem.cube.verts));
+				tb_data(& tb, 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, cube_g4_face);
+			}
+
+			tb_emit(& tb, sync_primitive_arena);
+				tb_data(& tb, u4_(& pa->used));
+				tb_data(& tb, prim_base);
+		}
+		tape_run_a02_s07(tb_slice(tb));// Fire off the tape (bigger-clobber variant).
+
+		// smem.cube.rot.y += 30;
+	}
+	// Draw floor
+	if (1)
+	{
+		mt3s2s4_rotation   (& smem.floor.rot,   & smem.tform_world);
+		mt3s2s4_translation(& smem.tform_world, & smem.floor.pos);
+		mt3s2s4_scale      (& smem.tform_world, & smem.floor.scale);
+
+		// Combine world and look_at matrix.
+		gte_comp_coord_m3s2(& smem.cam.look_at, & smem.tform_world, & smem.tform_view);
+
+		gte_matrix_set_rotation   (& smem.tform_view);
+		gte_matrix_set_translation(& smem.tform_view);
+
+		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?
+		// The tape atoms in-flight should not need to care.
+
+		// Prepare the tape. (Push protocol to tape)
+		tb.used = 0; tb_scope(& tb) {
+			// tb_emit(& tb, set_gte_mt3s2s4);
+			// 	tb_data(& tb, u4_(& smem.tform_view));
+
+			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, floor_f3_face);
+			}
+			// After floor_f3_face iterations complete, the primitive arena's used counter needs updating.
+			tb_emit(& tb, sync_primitive_arena);
+				tb_data(& tb, u4_(& pa->used));
+				tb_data(& tb, prim_base);
+		}
+		tape_run_a02_s07(tb_slice(tb));// Fire off the tape (bigger-clobber variant).
+
+		// C-side state (pa->used) has already been updated by the tape!
+		// smem.floor.rot.y += 5;
+	}
+}
+GCC_OPTIMIZATION_ENABLE
+
+void render(void) {
+}
+
+void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_buf, PrimitiveArena* pa) {
+	draw_sync(0);
+	vsync(0);
+	displayenv_put(& r_(screen_buf->display)[active_buf_id[0] ]);
+	drawenv_put   (& r_(screen_buf->draw)   [active_buf_id[0] ]);
+	{
+		draw_orderingtbl(ordering_buf + OrderingTbl_Len - 1);
+		pa->used = 0;
+	}
+	active_buf_id[0] = ! active_buf_id[0]; // Swap current buffer
+}
+
+GCC_OPTIMIZATION_DISABLE
+int main(void)
+{
+	smem = (SMemory){0};
+	// TODO(Ed): remove this field we don't need it in smem.
+	smem.scratchpad = C_(U4_V, Scratchpad_Loc);
+	// smem.primitives.used = 0;
+	// smem.active_buf_id   = 0;
+	smem.cam.pos = v3s4(500, -1000, -1500);
+	/*Persistent Entity Setup*/{
+		ent_cube128_init(& smem.cube.verts, & smem.cube.faces); {
+			Ent_Cube* cube = & smem.cube;
+			cube->rot    = v3s2(0, 0, 0);
+			cube->scale  = v3s4_fp_one();
+			cube->accel  = v3s4(0, 1, 0);
+			cube->pos    = v3s4(0, -400, 1800);
+		}
+		ent_floor_init(& smem.floor.verts, & smem.floor.faces); {
+			Ent_Floor* floor = & smem.floor;
+			floor->rot   = v3s2(0, 0, 0);
+			floor->pos   = v3s4(0, 450, 1800);
+			floor->scale = v3s4_fp_one();
+		}
+	}
+	TapeBuilder tb = tb_make(slice_ut_arr(smem.MemTape)); {
+		reset_graph(0);
+		/* Direct BIOS: poll both ports during VBlank. */
+		pad_bios_init_start(& smem.pad_raw[0], & smem.pad_raw[1]);
+
+		/* Pre-build the resolve_look_at bundle atoms into the static arena. */
+		resolve_look_at_init();
+
+		/* Pinned registers for the GPU init atom. */
+		register U4*           io_base_addr rgcc(R_IO_BaseAddr) = u4_r(IO_BASE_ADDR);
+		register DoubleBuffer* screen_buf   rgcc(R_ScreenBuf)   = & smem.screen_buf;
+		tb.used = 0; tb_scope_run(& tb) {
+			tb_emit(& tb, screen_env_init);
+			tb_emit(& tb, gp_screen_init);
+		}
+	}
+	while (1) {
+		gknown S4* active_buf_id  = & smem.active_buf_id;
+		gknown U4* ordering_buf   = r_(smem.ordering_tbl)[active_buf_id[0]];
+		gknown PrimitiveArena* pa = & smem.primitives;
+		update(pa, ordering_buf);
+		render();
+		gp_display_frame(& smem.screen_buf, active_buf_id, ordering_buf, pa);
+	};
+	return 0;
+}
+GCC_OPTIMIZATION_ENABLE
+

code/hello_camera/hello_camera.h

@@ -0,0 +1,102 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "duffle/dsl.h"
+#	include "duffle/math.h"
+#	include "duffle/gp.h"
+#	include "duffle/pad.h"
+#endif
+
+enum {
+	// PrimitiveBuff_Len = 4096,
+	// OrderingTbl_Len   = 2048,
+	PrimitiveBuff_Len = 131072,
+	OrderingTbl_Len   = 8192,
+};
+
+enum {
+	ScreenRes_X = 320,
+	ScreenRes_Y = 240,
+	ScreenZ     = 320,
+	ScreenRes_CenterX = (ScreenRes_X >> 1),
+	ScreenRes_CenterY = (ScreenRes_Y >> 1),
+};
+
+typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
+typedef Array_(OrderingTable_Buffer, 2);
+
+typedef B1 PrimitiveBuffer[PrimitiveBuff_Len];
+typedef Array_(PrimitiveBuffer, 2);
+typedef Struct_(PrimitiveArena) {
+	A2_PrimitiveBuffer buf;
+	U4                 used;
+};
+
+#define Cube_num_verts 8
+typedef Array_(V3_S2, Cube_num_verts);
+#define Cube_num_faces 6
+typedef Array_(V4_S2, Cube_num_faces);
+I_ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
+	LP_ A8_V3_S2 baked_verts = (A8_V3_S2) {
+		{ -128, -128, -128 },
+		{  128, -128, -128 },
+		{  128, -128,  128 },
+		{ -128, -128,  128 },
+		{ -128,  128, -128 },
+		{  128,  128, -128 },
+		{  128,  128,  128 },
+		{ -128,  128,  128 }
+	};
+	LP_ A6_V4_S2 baked_faces = (A6_V4_S2) {
+		{ 3, 2, 0, 1 },
+		{ 0, 1, 4, 5 },
+		{ 4, 5, 7, 6 },
+		{ 1, 2, 5, 6 },
+		{ 2, 3, 6, 7 },
+		{ 3, 0, 7, 4 },
+	};
+	mem_copy(u4_(verts), u4_(& baked_verts), S_(A8_V3_S2) );
+	mem_copy(u4_(faces), u4_(& baked_faces), S_(A6_V4_S2) );
+	return;
+}
+typedef Struct_(Ent_Cube) {
+	V3_S4 accel;
+	V3_S4 vel;
+	V3_S4 pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	V3_S4 scale;
+	V3_S2 rot;
+	A8_V3_S2 verts;
+	A6_V4_S2 faces;
+};
+
+#define Floor_num_verts 4
+typedef Array_(V3_S2, Floor_num_verts);
+#define Floor_num_faces 2
+typedef Array_(V3_S2, Floor_num_faces);
+I_ void ent_floor_init(A4_V3_S2* verts, A2_V3_S2* faces) {
+	LP_ A4_V3_S2 baked_verts = (A4_V3_S2) {
+		{ -900, 0, -900 },
+		{ -900, 0,  900 },
+		{  900, 0, -900 },
+		{  900, 0,  900 },
+	};
+	LP_ A2_V3_S2 baked_faces = (A2_V3_S2) {
+		{ 0, 1, 2 },
+		{ 1, 3, 2 },
+	};
+	mem_copy(u4_(verts), u4_(& baked_verts), S_(A4_V3_S2));
+	mem_copy(u4_(faces), u4_(& baked_faces), S_(A2_V3_S2));
+};
+typedef Struct_(Ent_Floor) {
+	V3_S4 accel;
+	V3_S4 pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	V3_S4 scale;
+	V3_S2 rot;
+	A4_V3_S2 verts;
+	A2_V3_S2 faces;
+};
+
+typedef Struct_(Camera) {
+	P3_S4    pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	V3_S2    rot;
+	MT3_S2S4 look_at;
+};

code/hello_gte/hello_gte.c

@@ -14,13 +14,13 @@
 #include "duffle/gp.h"
 #include "duffle/gte.h"
 
-#	include "duffle/gen/duffle.macs.h"
-#	include "duffle/gen/duffle.offsets.h"
+#	include "duffle/gen/macs.h"
+#	include "duffle/gen/offsets.h"
 #include "duffle/atom_dsl.h"
 #include "duffle/lottes_tape.h"
 #include "duffle/word_count.metadata.h"
 
-#	include "gen/hello_gte.offsets.h"
+#	include "gen/offsets.h"
 #include "hello_gte.h"
 
 #include "hello_gte.tape.c"

code/hello_gte/hello_gte.tape.c

@@ -1,10 +1,10 @@
 #ifdef INTELLISENSE_DIRECTIVES
-#	include "duffle/gen/duffle.macs.h"
-#	include "duffle/gen/duffle.offsets.h"
+#	include "duffle/gen/macs.h"
+#	include "duffle/gen/offsets.h"
 #	include "duffle/atom_dsl.h"
 #	include "duffle/lottes_tape.h"
 #	include "duffle/word_count.metadata.h"
-#	include "gen/hello_gte.offsets.h"
+#	include "gen/offsets.h"
 #	include "hello_gte.h"
 #endif
 
@@ -125,9 +125,9 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 
 		gte_cmdw_avg_sort_z4,
 		gte_mv_from_data_r(R_T1, C2_OTZ),
+
 		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,
 			mac_insert_ot_tag_g4(),
 			mac_format_g4_color(
@@ -184,7 +184,7 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 		/* Calculate Depth */
 		gte_avg_sort_z3,
 		gte_mv_from_data_r(R_T1, C2_OTZ),
-		/* Bounds Check OTZ < 2048 (Branch forward to skip insertion) */
+		/* Bounds Check OTZ < OrderingTbl_Len (Branch forward to skip insertion) */
 		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, floor_f3_face_exit)), nop,

code/hello_joypad/gen/macs.h

@@ -0,0 +1,41 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#pragma once
+#endif
+// Auto-generated by ps1_meta.lua — DO NOT EDIT
+// Directory: C:\projects\Pikuma\ps1\code\hello_joypad/
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.c
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.h
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.atom.c
+// Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
+
+#ifndef WORD_COUNT
+#define WORD_COUNT(name, count)  enum { words_##name = (count) };
+#endif
+
+#define mac_put_disp_env(reg_transfer, reg_base, port) \
+	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_set_mask_bit(),                 reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port)
+WORD_COUNT(mac_put_disp_env, 5)
+
+#define mac_put_draw_env(reg_transfer, reg_base, port) \
+	mac_gcmd_push(gp0_dr_env_tag,                            reg_transfer, reg_base, port) /* tag (length=15 << 24, addr=0) — packet header for the DR_ENV sequence. The GPU needs this to recognize the next 15 words as a DR_ENV packet and trigger the isbg auto-clear. */ \
+,	mac_gcmd_push(gp0_word_draw_mode_drawing_allowed,        reg_transfer, reg_base, port) /* code[0]  DrawMode (dfe=1, dtd=0, tpage=0) */ \
+,	mac_gcmd_push(gp0_word_set_texture_window(),             reg_transfer, reg_base, port) /* code[1]  TextureWindow (tw=(0,0)) */ \
+,	mac_gcmd_push(enc_gp0_draw_area_tl_word(0, ScreenRes_Y), reg_transfer, reg_base, port) /* code[2]  DrawArea top-left (clip.x=0, clip.y=ScreenRes_Y=240) */ \
+,	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240,   reg_transfer, reg_base, port) /* code[3]  DrawArea bottom-right (clip.x+w=320, clip.y+h=480) */ \
+,	mac_gcmd_push(gp0_word_set_draw_offset(),               reg_transfer, reg_base, port) /* code[4]  DrawOffset (ofs=(0,0)) — bare-cmd word; the GPU uses the current state machine. */ \
+,	mac_gcmd_push(gp0_word_dr_env_mask(),                   reg_transfer, reg_base, port) /* code[5]  Mask (dtd=0, dfe=1, isbg=1) — 0xE6 cmd + isbg bit. */ \
+,	mac_gcmd_push(gp0_word_dr_env_bg_color_cmd(1, 7, 7, 7), reg_transfer, reg_base, port) /* code[6]  Initial-bg-color + auto-clear (isbg=1, r=7, g=7, b=7). */ \
+,	mac_gcmd_push(gp0_word_dr_env_draw_mode(1),             reg_transfer, reg_base, port) /* code[7]  Re-assert DrawMode with isbg=1 (isbg-flag set; the 0xE1 cmd byte plus isbg only). */	/* code[8..10]  Padding (NOP — GPU discards; the DR_ENV requires 16 words total). */ \
+,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port)	/* code[11..12]  TextureWindow bottom-right (tw.x+tw.w=0, tw.y+tw.h=0) — libpsyx emits twice. */ \
+,	mac_gcmd_push(gp0_word_set_texture_window(), reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_set_texture_window(), reg_transfer, reg_base, port)	/* code[13..14]  Padding (NOP) — completes the 16-word packet. */ \
+,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port) \
+,	mac_gcmd_push(gp0_word_nop(), reg_transfer, reg_base, port)
+WORD_COUNT(mac_put_draw_env, 16)
+

code/hello_joypad/gen/offsets.h

@@ -1,13 +1,16 @@
 // Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT
-// Source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.tape.c
+// Directory: C:\projects\Pikuma\ps1\code\hello_joypad\
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.c
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.h
+//   source: C:\projects\Pikuma\ps1\code\hello_joypad\hello_joypad.atom.c
 #pragma once
 
-#pragma region hello_joypad.tape
+#pragma region hello_joypad
 
 
-// --- atom: cube_g4_face (77 words) ---
+// --- atom: cube_g4_face (76 words) ---
 
-#define _atom_offset_cull_cube_g4_face_exit           42
+#define _atom_offset_cull_cube_g4_face_exit           41
 #define _atom_offset_bounds_chk_cube_g4_face_exit     24
 
 enum {
@@ -28,15 +31,15 @@ enum {
 // --- atom: pad_bios_snapshot (78 words) ---
 
 #define _atom_offset_snap_root_skip_disconnected      8
-#define _atom_offset_disconnected_snap_end            60
+#define _atom_offset_disconnected_snap_end            61
 #define _atom_offset_case_2_id_dispatch               8
-#define _atom_offset_pending_snap_end                 50
+#define _atom_offset_pending_snap_end                 51
 #define _atom_offset_id_dispatch_try_analog_stick     11
-#define _atom_offset_id_dispatch_snap_end             37
+#define _atom_offset_id_dispatch_snap_end             38
 #define _atom_offset_try_analog_stick_try_analog_pad  12
-#define _atom_offset_analog_stick_snap_end            23
+#define _atom_offset_analog_stick_snap_end            24
 #define _atom_offset_try_analog_pad_try_unsupported   11
-#define _atom_offset_analog_pad_snap_end              9
+#define _atom_offset_analog_pad_snap_end              10
 
 enum {
     atom_offset_snap_root_skip_disconnected = _atom_offset_snap_root_skip_disconnected,
@@ -57,8 +60,8 @@ enum {
 #define _atom_offset_dpad_right_exit_dpad_right       6
 #define _atom_offset_dead_zone_low_check_dead_low_active  8
 #define _atom_offset_dead_zone_high_check_dead_high_active  15
-#define _atom_offset_dead_zone_skip_exit_stick        23
-#define _atom_offset_end_low_exit_stick               11
+#define _atom_offset_dead_zone_skip_exit_stick        24
+#define _atom_offset_end_low_exit_stick               12
 
 enum {
     atom_offset_dpad_left_exit_dpad_left = _atom_offset_dpad_left_exit_dpad_left,
@@ -69,5 +72,5 @@ enum {
     atom_offset_end_low_exit_stick = _atom_offset_end_low_exit_stick,
 };
 
-#pragma endregion hello_joypad.tape
+#pragma endregion hello_joypad
 

code/hello_joypad/hello_joypad.atom.c

@@ -1,53 +1,31 @@
 #ifdef INTELLISENSE_DIRECTIVES
-#	include "duffle/gen/duffle.macs.h"
-#	include "duffle/gen/duffle.offsets.h"
-#	include "duffle/atom_dsl.h"
+#	pragma once
+#		include "duffle/gen/macs.h"
+#		include "duffle/gen/offsets.h"
+#	include "duffle/dsl.atom.h"
 #	include "duffle/lottes_tape.h"
 #	include "duffle/mips.h"
 #	include "duffle/gte.h"
 #	include "duffle/gp.h"
 #	include "duffle/pad.h"
 #	include "duffle/word_count.metadata.h"
-#	include "psyq.h"
-#	include "gen/hello_joypad.offsets.h"
-#	include "gen/hello_joypad.macs.h"
+#	include "duffle/psyq.h"
+#	include "duffle/math.atom.c"
+#	include "duffle/mips.atom.c"
+#	include "duffle/gte.atom.c"
+#	include "duffle/gp.atom.c"
+#	include "duffle/psyq.atom.c"
+#		include "gen/offsets.h"
+#		include "gen/macs.h"
 #	include "hello_joypad.h"
 #endif
 
+ATOM_FILE_DEBUGGER_LINE_MARKER(hello_joypad_atom_c);
+
 #pragma region MACs (Mips Atom components)
 
-FI_ Slice_MipsCode ac_load_v2s2(U4 rs_x, U4 rs_y, U4 r_base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_load_v2s2, {
-	load_half( rs_x, r_base, O_(V3_S2,x)),
-	load_half( rs_y, r_base, O_(V3_S2,y)),
-})
-
-FI_ Slice_MipsCode ac_store_v2s2(U4 rt_x, U4 rt_y, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_v2s2, {
-	store_half(rt_x, base, offset + O_(V2_S2,x)),
-	store_half(rt_y, base, offset + O_(V2_S2,y)),
-})
-
-FI_ Slice_MipsCode ac_store_rects2(U4 rt_x, U4 rt_y, U4 rt_width, U4 rt_height, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_rects2, {
-	store_half(rt_x,      base, offset + O_(Rect_S2,x)),
-	store_half(rt_y,      base, offset + O_(Rect_S2,y)),
-	store_half(rt_width,  base, offset + O_(Rect_S2,width)),
-	store_half(rt_height, base, offset + O_(Rect_S2,height)),
-})
-
-FI_ Slice_MipsCode ac_store_rgb8(U1 rr, U1 rg, U1 rb, U4 base, U4 offset) atom_dbg_skip MipsAtomComp_Proc_(ac_store_rgb8, {
-	store_byte(rr, base, offset + O_(DrawEnv,initial_bg_color.r)),
-	store_byte(rg, base, offset + O_(DrawEnv,initial_bg_color.g)),
-	store_byte(rb, base, offset + O_(DrawEnv,initial_bg_color.b)),	
-})
-
-FI_ Slice_MipsCode ac_gcmd_push(U4 cmd, U4 reg_transfer, U4 reg_base, U2 port)
-MipsAtomComp_Proc_(ac_gcmd_push, {
-	load_upper_i(reg_transfer, cmd >> 16),
-	or_i_self(   reg_transfer, cmd & 0xFFFF),
-	store_word(  reg_transfer, reg_base, port),
-})
-
-FI_ Slice_MipsCode ac_put_disp_env(U4 reg_transfer, U4 reg_base, U2 port)
-MipsAtomComp_Proc_(ac_put_disp_env, {
+FI_ Slice_MipsCode ac_put_disp_env(MipsAtomBuilder_R ab, U4 reg_transfer, U4 reg_base, U2 port)
+MipsAtomComp_Proc_(ac_put_disp_env, ab, {
 	// Emits 5 GP0 commands for buffer 0 (display_area = (0,0,320,240)).
 	// Sequence per libpsyx PutDispEnv: DrawArea TL → DrawArea BR → Mask → DrawArea TL → DrawArea BR
 	mac_gcmd_push(gp0_word_draw_area_top_left_origin,      reg_transfer, reg_base, port),
@@ -57,8 +35,8 @@ MipsAtomComp_Proc_(ac_put_disp_env, {
 	mac_gcmd_push(gp0_word_draw_area_bottom_right_320x240, reg_transfer, reg_base, port),
 })
 
-FI_ Slice_MipsCode ac_put_draw_env(U4 reg_transfer, U4 reg_base, U2 port)
-MipsAtomComp_Proc_(ac_put_draw_env, {
+FI_ Slice_MipsCode ac_put_draw_env(MipsAtomBuilder_R ab, U4 reg_transfer, U4 reg_base, U2 port)
+MipsAtomComp_Proc_(ac_put_draw_env, ab, {
 	/*
 	* ORIGIN: each code word corresponds to the EXACT value libpsyx's PutDrawEnv function would compute for the same DrawEnv settings.
 	* References:
@@ -114,68 +92,6 @@ MipsAtomComp_Proc_(ac_put_draw_env, {
 
 #pragma region Baked Atoms
 
-/* DIAGNOSTIC 1: Pure tape loop test */
-internal MipsAtom_(diag_yield) { mac_yield() };
-
-/* DIAGNOSTIC 2: Pure memory test (No GTE). Draws a fixed cyan triangle. */
-internal MipsAtom_(diag_color) {
-	store_word(  R_0, R_T7, 0), 
-	load_upper_i(R_AT, gp0_cmd_poly_f3 << 8 | 0xFF), /* High: MipsCode Poly_F3(0x20) + Color B:FF */
-	or_i_self(   R_AT, 0xFF00),                      /* Low:  Color G:FF, R:00 (Cyan) */
-	store_word(  R_AT, R_T7, 4),
-	
-	/* Fake coordinates - Swapped winding order to prevent GPU culling! */
-	load_upper_i(R_AT, 0x0010), or_i_self(R_AT, 0x0010), store_word(R_AT, R_T7, 8),  /* (16, 16) */
-	load_upper_i(R_AT, 0x0050), or_i_self(R_AT, 0x0010), store_word(R_AT, R_T7, 12), /* (80, 16) */
-	load_upper_i(R_AT, 0x0010), or_i_self(R_AT, 0x0050), store_word(R_AT, R_T7, 16), /* (16, 80) */
-
-	add_ui(          R_T1, R_0,  10),
-	shift_lleft_self(R_T1,       S_(U4)/2), 
-	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),
-	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)),         
-	or_u_self(  R_AT, R_V0),          
-	store_word( R_AT, R_T1, 0),       
-
-	add_ui(R_T7, R_T7, 20),          
-
-	mac_yield()
-};
-
-/* DIAGNOSTIC 3: Pure GTE test (No Memory Writes) */
-internal MipsAtom_(diag_gte) {
-	/* Load 3 indices */
-	load_half_u(R_T0, R_T4, 0),
-	load_half_u(R_T1, R_T4, 2),
-	load_half_u(R_T2, R_T4, 4),
-
-	/* Load Vertices into GTE */
-	shift_lleft( R_AT, R_T0, 3), add_u(    R_AT, R_AT, R_T5),
-	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-	gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
-
-	shift_lleft( R_AT, R_T1, 3), add_u(R_AT, R_AT, R_T5),
-	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-	gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
-
-	shift_lleft(R_AT, R_T2, 3), add_u(R_AT, R_AT, R_T5),
-	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-	gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
-
-	/* Run Math */
-	nop2, gte_cmdw_rtpt,
-	nop2, gte_cmdw_nclip,
-	nop2,
-
-	/* Advance Face Cursor and Yield */
-	add_ui(R_T4, R_T4, 8),
-
-	mac_yield()
-};
-
 enum {
 	R_ScreenX   = R_T5 atom_reg atom_type(U2),
 	R_ScreenY   = R_T6 atom_reg atom_type(U2),
@@ -200,7 +116,7 @@ internal MipsAtom_(screen_env_init) atom_info(atom_phase(screen_init)
 	store_word(R_0, R_ScreenBuf, O_(DisplayEnv,vinterlace) + OA_(DoubleBuffer,display,1)),
 
 	mac_store_rects2(R_0, R_ScreenY, R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DrawEnv,clip_area)         + OA_(DoubleBuffer,draw,0)), /* draw[0].clip_area = (0, 240, 320, 240). C11's SetDefDrawEnv writes clip.y = y_arg. */
-	mac_store_v2s2(  R_0, R_ScreenY,                       R_ScreenBuf, O_(DrawEnv,drawing_offset[0]) + OA_(DoubleBuffer,draw,0)), /* draw[0].drawing_offset[0] = (0, 240); C11 passes y_arg as ofs. */
+	mac_store_v2s2(R_0, R_ScreenY,                       R_ScreenBuf, O_(DrawEnv,drawing_offset[0]) + OA_(DoubleBuffer,draw,0)), /* draw[0].drawing_offset[0] = (0, 240); C11 passes y_arg as ofs. */
 
 	mac_store_v2s2(R_ScreenX, R_ScreenY, R_ScreenBuf, O_(DrawEnv,clip_area.width) + OA_(DoubleBuffer,draw,1)),
 
@@ -264,6 +180,17 @@ internal MipsAtom_(gp_screen_init) atom_info(atom_phase(screen_init), atom_reads
 	mac_yield(),
 };
 
+enum {
+	R_PrimCursor = R_T7 atom_reg atom_type(U4*),    /* VRAM output cursor (primitive buffer) */
+	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 atom_reg atom_type(V3_S2*), /* Base address of the vertex array */
+	R_OtBase     = R_T6 atom_reg atom_type(U4*),    /* Base address of the Ordering Table */
+#define R_PrimCursor_Code  R_T7_Code
+#define R_FaceCursor_Code  R_T4_Code
+#define R_VertBase_Code    R_T5_Code
+#define R_OtBase_Code      R_T6_Code
+};
+
 typedef Struct_(Binds_CubeTri) {
 	U4     PrimCursor;
 	V4_S2* FaceCursor;
@@ -294,20 +221,23 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
 	load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)),
 
-	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
+	mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2),
 	nop2, gte_cmdw_rotate_translate_perspective_triple, // required cpu -> gte delay slot
 	gte_cmdw_nclip,
 
 	gte_mv_from_data_r(R_T0, C2_MAC0), nop,
-	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)), nop,
+	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)),
+		/* BD-slot: write the prim tag (R_0=0; overwrites the legacy tag word in the prim_buffer).
+		 * If branch IS taken (face culled), the body is skipped and this 0-tag is stranded —
+		 * harmless because the OT entry that points to this prim is created later, only on the body path. */
 		store_word(R_0, R_PrimCursor, O_(Poly_G4, tag)),
 		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),
 
-		mac_gte_store_g4_p012(),
+		mac_gte_store_g4_p012(R_PrimCursor),
 		gte_cmdw_rotate_translate_perspective_single,
-		mac_gte_store_g4_p3(),
+		mac_gte_store_g4_p3(R_PrimCursor),
 
 		gte_cmdw_avg_sort_z4,
 		gte_mv_from_data_r(R_T1, C2_OTZ),
@@ -315,8 +245,8 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 		set_lt_u(    R_AT, R_T1, R_AT),
 
 		branch_equal(R_AT, R_0,  atom_offset(bounds_chk, cube_g4_face_exit)), nop,
-			mac_insert_ot_tag_g4(),
-			mac_format_g4_color(
+			mac_insert_ot_tag_g4(R_OtBase, R_PrimCursor),
+			mac_format_g4_color(R_PrimCursor,
 				/* c0 magenta */ 0xFF, 0x00, 0xFF,
 				/* c1 yellow  */ 0xFF, 0xFF, 0x00,
 				/* c2 cyan    */ 0x00, 0xFF, 0xFF,
@@ -356,8 +286,8 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 	, atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
 	, atom_writes(R_PrimCursor, R_FaceCursor)
 ) {
-	mac_load_tri_indices(  R_T0, R_T1, R_T2),
-	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
+	mac_load_tri_indices(R_FaceCursor, R_T0, R_T1, R_T2),
+	mac_gte_load_tri_verts(R_VertBase,   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,
 
@@ -365,7 +295,7 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 	gte_mv_from_data_r(R_T0, C2_MAC0),
 	nop, branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop, // required gte -> cpu load-delay slot.
 		/* Format Primitive */
-		mac_gte_store_f3(),
+		mac_gte_store_f3(R_PrimCursor),
 
 		/* Calculate Depth */
 		gte_avg_sort_z3,
@@ -374,8 +304,8 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 		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, floor_f3_face_exit)), nop,
-			mac_format_f3_color(0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
-			mac_insert_ot_tag_f3(),                 /* Insert into Ordering Table Linked List */
+			mac_format_f3_color(R_PrimCursor, 0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
+			mac_insert_ot_tag_f3(R_OtBase, R_PrimCursor),         /* Insert into Ordering Table Linked List */
 			add_ui_self(R_PrimCursor, S_(Poly_F3)), /* Advance Prim Cursor (5 words) */
 				// Note(Ed): No bounds checking, should be checked before atom runs.
 		// end: branch(bounds_chk)
@@ -459,9 +389,11 @@ atom_label(disconnected) /* === Disconnected body. */
 	load_upper_i(R_T4, 0x8080), or_i_self(R_T4, 0x8080),
 	store_word(  R_T4,    R_PadState, O_(PadState,left_x)),
 	store_byte(  R_RawId, R_PadState, O_(PadState,id)),
-	branch_equal(R_0, R_0, atom_offset(disconnected, snap_end)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(disconnected, snap_end)), nop,
+	jump_rel(atom_offset(disconnected, snap_end)),
+		/* BD-slot: load next atom's entry point (replaces the nop).
+		 * The unconditional branch always jumps to snap_end, where mac_yield_tail()
+		 * transfers control to R_AtomJmp without re-loading it. */
+		mac_yield_load(),
 atom_label(skip_disconnected)
 
 	/* === Case 2: Pending (status == 0 && id == 0)
@@ -479,9 +411,8 @@ atom_label(pending) /* === Pending body */
 	load_upper_i(R_T4, 0x8080), or_i_self(R_T4, 0x8080),
 	store_word(  R_T4,    R_PadState, O_(PadState,left_x)),
 	store_byte(  R_RawId, R_PadState, O_(PadState,id)),
-	branch_equal(R_0, R_0, atom_offset(pending, snap_end)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(pending, snap_end)), nop,
+	jump_rel(atom_offset(pending, snap_end)),
+		mac_yield_load(),
 
 atom_label(id_dispatch) /* === Case 3-6: ID dispatch */
 	add_ui(R_T4, R_0, 0x41), branch_ne(R_RawId, R_T4, atom_offset(id_dispatch, try_analog_stick)),
@@ -503,9 +434,8 @@ atom_label(id_dispatch) /* === Case 3-6: ID dispatch */
 	add_ui(      R_T4, R_0, 0x41),
 	store_byte(  R_T4, R_PadState, O_(PadState,id)),
 
-	branch_equal(R_0, R_0, atom_offset(id_dispatch, snap_end)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(id_dispatch, snap_end)), nop,
+	jump_rel(atom_offset(id_dispatch, snap_end)),
+		mac_yield_load(),
 
 atom_label(try_analog_stick) /* === Case 4: AnalogStick (id == 0x53)*/
 	add_ui(R_T4, R_0, 0x53), branch_ne(R_RawId, R_T4, atom_offset(try_analog_stick, try_analog_pad)),
@@ -526,9 +456,8 @@ atom_label(analog_stick) /* === AnalogStick body
 	store_half(  R_T4, R_PadState, O_(PadState,right_x)),
 	add_ui(      R_T5, R_0, 0x53),                        /* R_T5 = id value (clobbers left_xy, already stored) */
 	store_byte(  R_T5, R_PadState, O_(PadState,id)),
-	branch_equal(R_0, R_0, atom_offset(analog_stick, snap_end)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(analog_stick, snap_end)), nop,
+	jump_rel(atom_offset(analog_stick, snap_end)),
+		mac_yield_load(),
 
 atom_label(try_analog_pad) /* === Case 5-6: AnalogPad (id & 0xF0 == 0x70) */
 	and_i(    R_T4, R_RawId, 0xF0),
@@ -550,9 +479,8 @@ atom_label(analog_pad) /* === AnalogPad body
 	store_half( R_T4, R_PadState, O_(PadState,right_x)),
 	store_byte( R_RawId, R_PadState, O_(PadState,id)),
 
-	branch_equal(R_0, R_0, atom_offset(analog_pad, snap_end)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(analog_pad, snap_end)), nop,
+	jump_rel(atom_offset(analog_pad, snap_end)),
+		mac_yield_load(),
 
 atom_label(try_unsupported) /* === Case 7: Unsupported — fall through from the AnalogPad range-check miss. */
 	add_ui(    R_T4, R_0, PadStatus_Unsupported),
@@ -565,8 +493,12 @@ atom_label(try_unsupported) /* === Case 7: Unsupported — fall through from the
 	store_byte(  R_T4, R_PadState, O_(PadState,id)),
 	/* Fall through to snap_end. */
 
+atom_label(no_jump_fallthrough)
+	mac_yield_load(),
+
 atom_label(snap_end)
-	mac_yield(),
+	/* NOT mac_yield() — R_AtomJmp was already loaded in the BD-slot of the case-exit branch. */
+	mac_yield_tail(),
 };
 
 /* ----- pad_apply_input -----
@@ -650,10 +582,8 @@ atom_label(dead_check_upper)
 	/* R_T4 = (0x90 < left_x) ? 1 : 0 → (left_x > 0x90) ? 1 : 0 */
 	set_lt_u(R_T4, R_T4, R_T3), branch_ne(R_T4, R_0, atom_offset(dead_zone_high_check, dead_high_active)),
 	add_ui(  R_T4, R_0, 0x80), /* BD-slot: pre-load 0x80 for dead_high_active */
-	branch_equal(R_0, R_0, atom_offset(dead_zone_skip, exit_stick)), nop,
-	/* Fall-through = left_x in [0x70, 0x90] (dead zone); skip analog entirely. */
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(dead_zone_skip, exit_stick)), nop,
+	jump_rel(atom_offset(dead_zone_skip, exit_stick)),
+		mac_yield_load(),
 
 atom_label(dead_low_active)
 	/* R_T3 = left_x (from line 632 lbu; not clobbered between dead_zone_low_check branch + its BD-slot `add_ui R_T4, 0x80`).
@@ -675,9 +605,8 @@ atom_label(dead_low_active)
 	add_u(       R_T0, R_T0, R_T4),
 	store_half(  R_T0, R_FloorRot, O_(V3_S2,y)),
 
-	branch_equal(R_0, R_0, atom_offset(end_low, exit_stick)), nop,
-	// TODO(Ed): Lua metaprogram: Support jump instruction here..
-	// jump(atom_offset(end_low, exit_stick)), nop,
+	jump_rel(atom_offset(end_low, exit_stick)),
+		mac_yield_load(),
 
 atom_label(dead_high_active)
 	/* R_T3 = left_x (from line 641 lbu in dead_check_upper; not clobbered between dead_zone_high_check branch + its BD-slot `add_ui R_T4, 0x80`).
@@ -698,8 +627,12 @@ atom_label(dead_high_active)
 	add_u(       R_T0, R_T0, R_T4),
 	store_half(  R_T0, R_FloorRot, O_(V3_S2,y)),
 
+atom_label(no_jump_fallthrough)
+	mac_yield_load(),
+
 atom_label(exit_stick)
-	mac_yield(),
+	/* NOT mac_yield() — R_AtomJmp was already loaded in the BD-slot of the dead-zone/exit branch. */
+	mac_yield_tail(),
 };
 
 #pragma endregion Baked Atoms

code/hello_joypad/hello_joypad.c

@@ -1,9 +1,17 @@
+#pragma region Vendors
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 // #include "libgpu.h"
 // #include "libetc.h"
 // #include "libgte.h"
+#pragma endregion Vendors
+
+#pragma region Duffle Headers
+#	include "duffle/gen/macs.h"
+#	include "duffle/gen/offsets.h"
+
+#include "duffle/word_count.metadata.h"
 
 #include "duffle/dsl.h"
 #include "duffle/memory.h"
@@ -15,109 +23,43 @@
 #include "duffle/gte.h"
 #include "duffle/pad.h"
 
-#	include "duffle/gen/duffle.macs.h"
-#	include "duffle/gen/duffle.offsets.h"
-#include "duffle/atom_dsl.h"
+#include "duffle/dsl.atom.h"
 #include "duffle/lottes_tape.h"
-#include "duffle/word_count.metadata.h"
 
-#include "psyq.h"
+#include "duffle/psyq.h"
+#pragma endregion Duffle Headers
+
+#pragma region Duffle TUs
+#include "duffle/math.atom.c"
+#include "duffle/mips.atom.c"
+#include "duffle/gte.atom.c"
+#include "duffle/gp.atom.c"
+#include "duffle/psyq.atom.c"
+#pragma endregion Duffle TUs
+
+#pragma region Joypade Headers
+#	include "gen/macs.h"
+#	include "gen/offsets.h"
 
-#	include "gen/hello_joypad.macs.h"
-#	include "gen/hello_joypad.offsets.h"
 #include "hello_joypad.h"
+#pragma region Joypad Headers
 
-#include "psyq.c"
-#include "hello_joypad.tape.c"
-
-
-typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
-typedef Array_(OrderingTable_Buffer, 2);
-
-typedef B1 PrimitiveBuffer[PrimitiveBuff_Len];
-typedef Array_(PrimitiveBuffer, 2);
-typedef Struct_(PrimitiveArena) {
-	A2_PrimitiveBuffer buf;
-	U4                 used;
-};
-
-#define Cube_num_verts 8
-typedef Array_(V3_S2, Cube_num_verts);
-#define Cube_num_faces 6
-typedef Array_(V4_S2, Cube_num_faces);
-I_ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
-	LP_ A8_V3_S2 baked_verts = (A8_V3_S2) {
-		{ -128, -128, -128 },
-		{  128, -128, -128 },
-		{  128, -128,  128 },
-		{ -128, -128,  128 },
-		{ -128,  128, -128 },
-		{  128,  128, -128 },
-		{  128,  128,  128 },
-		{ -128,  128,  128 }
-	};
-	LP_ A6_V4_S2 baked_faces = (A6_V4_S2) {
-		{ 3, 2, 0, 1 },
-		{ 0, 1, 4, 5 },
-		{ 4, 5, 7, 6 },
-		{ 1, 2, 5, 6 },
-		{ 2, 3, 6, 7 },
-		{ 3, 0, 7, 4 },
-	};
-	mem_copy(u4_(verts), u4_(& baked_verts), S_(A8_V3_S2) );
-	mem_copy(u4_(faces), u4_(& baked_faces), S_(A6_V4_S2) );
-	return;
-}
-typedef Struct_(Ent_Cube) {
-	V3_S4 accel;
-	V3_S4 vel;
-	V3_S4 pos;
-	V3_S4 scale;
-	V3_S2 rot;
-	A8_V3_S2 verts;
-	A6_V4_S2 faces;
-};
-
-#define Floor_num_verts 4
-typedef Array_(V3_S2, Floor_num_verts);
-#define Floor_num_faces 2
-typedef Array_(V3_S2, Floor_num_faces);
-I_ void ent_floor_init(A4_V3_S2* verts, A2_V3_S2* faces) {
-	LP_ A4_V3_S2 baked_verts = (A4_V3_S2) {
-		{ -900, 0, -900 },
-		{ -900, 0,  900 },
-		{  900, 0, -900 },
-		{  900, 0,  900 },
-	};
-	LP_ A2_V3_S2 baked_faces = (A2_V3_S2) {
-		{ 0, 1, 2 },
-		{ 1, 3, 2 },
-	};
-	mem_copy(u4_(verts), u4_(& baked_verts), S_(A4_V3_S2));
-	mem_copy(u4_(faces), u4_(& baked_faces), S_(A2_V3_S2));
-};
-typedef Struct_(Ent_Floor) {
-	V3_S4 accel;
-	V3_S4 pos;
-	V3_S4 scale;
-	V3_S2 rot;
-	A4_V3_S2 verts;
-	A2_V3_S2 faces;
-};
-
+#pragma region Hello Joypad TUs
+#include "hello_joypad.atom.c"
+#pragma endregion Hello Joypad TUs
 
 enum { 
 	Scratchpad_Len = 1024, 
 	MemTape_Len    = 512,
 };
 typedef Struct_(SMemory) {
-	U4 MemTape[MemTape_Len];
-
-	DoubleBuffer            screen_buf;
-	A2_OrderingTable_Buffer ordering_tbl;
 	PrimitiveArena          primitives;
+	A2_OrderingTable_Buffer ordering_tbl;
+	DoubleBuffer            screen_buf;
 	S4                      active_buf_id;
 
+	U4 MemTape[MemTape_Len];
+
 	M3_S2 tform_world;
 
 	Ent_Cube  cube;
@@ -212,50 +154,6 @@ NI_ void pad_bios_init_start(PadBiosRaw* raw0, PadBiosRaw* raw1)
 	);
 }
 
-void gp_screen_init_c11(DoubleBuffer* screen_buf, S4* active_buf_id)
-{
-	reset_graph(0);
-
-	// Set the current initial buffer
-	active_buf_id[0] = 0;
-
-	// Just setting env data, not interacting with console hw.
-	// First buffer area
-	displayenv_init(& r_(screen_buf->display)[0], 0, 0,           ScreenRes_X, ScreenRes_Y);
-	drawenv_init   (& r_(screen_buf->draw   )[0], 0, ScreenRes_Y, ScreenRes_X, ScreenRes_Y);
-	// Second buffer area
-	displayenv_init(& r_(screen_buf->display)[1], 0, ScreenRes_Y, ScreenRes_X, ScreenRes_Y);
-	drawenv_init   (& r_(screen_buf->draw   )[1], 0, 0,           ScreenRes_X, ScreenRes_Y);
-	// Set the back/drawing buffer
-	screen_buf->draw[0].enable_auto_clear = true;
-	screen_buf->draw[1].enable_auto_clear = true;
-	// Set the background clear color
-	screen_buf->draw[0].initial_bg_color = rgb8( .r = 7, .g = 7,  .b = 7 );
-	screen_buf->draw[1].initial_bg_color = rgb8( .r = 7, .g = 7,  .b = 7 );
-	// screen_buf->draw[1].initial_bg_color = rgb8( .r = 47, .g = 13, .b = 0 );
-	displayenv_put(& r_(screen_buf->display)[ active_buf_id[0] ]);
-	drawenv_put   (& r_(screen_buf->draw   )[ active_buf_id[0] ]);
-
-	// Initialize and setup the GTE geometry offsets
-	geom_init();
-	geom_set_offset(ScreenRes_CenterX, ScreenRes_CenterY);
-	geom_set_screen(ScreenZ);
-
-	set_display_enabled(1); // gp_DisplayEnabled
-}
-
-void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_buf, PrimitiveArena* pa) {
-	draw_sync(0);
-	vsync(0);
-	displayenv_put(& r_(screen_buf->display)[active_buf_id[0] ]);
-	drawenv_put   (& r_(screen_buf->draw)   [active_buf_id[0] ]);
-	{
-		draw_orderingtbl(ordering_buf + OrderingTbl_Len - 1);
-		pa->used = 0;
-	}
-	active_buf_id[0] = ! active_buf_id[0]; // Swap current buffer
-}
-
 GCC_OPTIMIZATION_DISABLE
 void update(PrimitiveArena* pa, U4* ordering_buf) 
 {
@@ -478,28 +376,25 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		// C-side state (pa->used) has already been updated by the tape!
 		// smem.floor.rot.y += 5;
 	}
-	// --- TAPE DIAGNOSTICS ---
-	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++) {
-				// tb_emit(& tb, code_diag_yield);
-				// tb_emit(& tb, code_diag_color);
-				// tb_emit(& tb, code_diag_gte); 
-			}
-		}
-		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];
-	}
 }
 GCC_OPTIMIZATION_ENABLE
 
 void render(void) {
 }
 
+void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_buf, PrimitiveArena* pa) {
+	draw_sync(0);
+	vsync(0);
+	displayenv_put(& r_(screen_buf->display)[active_buf_id[0] ]);
+	drawenv_put   (& r_(screen_buf->draw)   [active_buf_id[0] ]);
+	{
+		draw_orderingtbl(ordering_buf + OrderingTbl_Len - 1);
+		pa->used = 0;
+	}
+	active_buf_id[0] = ! active_buf_id[0]; // Swap current buffer
+}
+
+GCC_OPTIMIZATION_DISABLE
 int main(void)
 {
 	smem = (SMemory){0};
@@ -543,3 +438,4 @@ int main(void)
 	};
 	return 0;
 }
+GCC_OPTIMIZATION_ENABLE

code/hello_joypad/hello_joypad.h

@@ -7,8 +7,10 @@
 #endif
 
 enum {
-	PrimitiveBuff_Len = 4096,
-	OrderingTbl_Len   = 2048
+	// PrimitiveBuff_Len = 4096,
+	// OrderingTbl_Len   = 2048,
+	PrimitiveBuff_Len = 131072,
+	OrderingTbl_Len   = 8192,
 };
 
 enum {
@@ -24,3 +26,77 @@ enum {
 };
 
 #define v3s4_fp_one() v3s4(fp_one, fp_one, fp_one)
+
+typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
+typedef Array_(OrderingTable_Buffer, 2);
+
+typedef B1 PrimitiveBuffer[PrimitiveBuff_Len];
+typedef Array_(PrimitiveBuffer, 2);
+typedef Struct_(PrimitiveArena) {
+	A2_PrimitiveBuffer buf;
+	U4                 used;
+};
+
+#define Cube_num_verts 8
+typedef Array_(V3_S2, Cube_num_verts);
+#define Cube_num_faces 6
+typedef Array_(V4_S2, Cube_num_faces);
+I_ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
+	LP_ A8_V3_S2 baked_verts = (A8_V3_S2) {
+		{ -128, -128, -128 },
+		{  128, -128, -128 },
+		{  128, -128,  128 },
+		{ -128, -128,  128 },
+		{ -128,  128, -128 },
+		{  128,  128, -128 },
+		{  128,  128,  128 },
+		{ -128,  128,  128 }
+	};
+	LP_ A6_V4_S2 baked_faces = (A6_V4_S2) {
+		{ 3, 2, 0, 1 },
+		{ 0, 1, 4, 5 },
+		{ 4, 5, 7, 6 },
+		{ 1, 2, 5, 6 },
+		{ 2, 3, 6, 7 },
+		{ 3, 0, 7, 4 },
+	};
+	mem_copy(u4_(verts), u4_(& baked_verts), S_(A8_V3_S2) );
+	mem_copy(u4_(faces), u4_(& baked_faces), S_(A6_V4_S2) );
+	return;
+}
+typedef Struct_(Ent_Cube) {
+	V3_S4 accel;
+	V3_S4 vel;
+	V3_S4 pos;
+	V3_S4 scale;
+	V3_S2 rot;
+	A8_V3_S2 verts;
+	A6_V4_S2 faces;
+};
+
+#define Floor_num_verts 4
+typedef Array_(V3_S2, Floor_num_verts);
+#define Floor_num_faces 2
+typedef Array_(V3_S2, Floor_num_faces);
+I_ void ent_floor_init(A4_V3_S2* verts, A2_V3_S2* faces) {
+	LP_ A4_V3_S2 baked_verts = (A4_V3_S2) {
+		{ -900, 0, -900 },
+		{ -900, 0,  900 },
+		{  900, 0, -900 },
+		{  900, 0,  900 },
+	};
+	LP_ A2_V3_S2 baked_faces = (A2_V3_S2) {
+		{ 0, 1, 2 },
+		{ 1, 3, 2 },
+	};
+	mem_copy(u4_(verts), u4_(& baked_verts), S_(A4_V3_S2));
+	mem_copy(u4_(faces), u4_(& baked_faces), S_(A2_V3_S2));
+};
+typedef Struct_(Ent_Floor) {
+	V3_S4 accel;
+	V3_S4 pos;
+	V3_S4 scale;
+	V3_S2 rot;
+	A4_V3_S2 verts;
+	A2_V3_S2 faces;
+};

code/hello_joypad/psyq.c

@@ -1,3 +0,0 @@
-#ifdef INTELLISENSE_DIRECTIVES
-#	include "psyq.h"
-#endif

code/hello_joypad/sio.tape.c

@@ -24,8 +24,8 @@
  * Emits 9 instructions (status/buttons/axes/attempt stores plus the
  * two-instruction zero-extended buttons load).
  */
-FI_ Slice_MipsCode ac_pad_sio_write_pad_state(U4 status_val, U4 state_ptr_reg, U4 scratch_reg)
-MipsAtomComp_Proc_(ac_pad_sio_write_pad_state, {
+FI_ Slice_MipsCode ac_pad_sio_write_pad_state(MipsAtomBuilder_R ab, U4 status_val, U4 state_ptr_reg, U4 scratch_reg)
+MipsAtomComp_Proc_(ac_pad_sio_write_pad_state, ab, {
 	add_ui(scratch_reg, R_0, status_val),
 	store_word(scratch_reg, state_ptr_reg, O_(PadState,status)),
 	/* FIX 2026-08-02: buttons = 0x0000FFFF = "no buttons pressed" in

scripts/build_psyq.ps1

@@ -180,12 +180,9 @@ function link-modules { param([string[]]$link_modules, [string]  $elf, [string[]
 	$link_args += ($f_link_pass_through_prefix + $f_link_mapfile + $map)
 
 	$link_args += ($f_link_pass_through_prefix + $f_link_start_group)
-	# raw_sio_pad_poll_20260802 — Task 5.1c surgical library-list trim.
-	# The 16 removed entries (c2, card, cd, comb, ds, gs, gun, hmd, math,
-	# mcrd, mcx, press, sio, snd, spu, tap) had LOAD lines in the map but
-	# ZERO .o files pulled in — they were unused. The 5 kept libraries
-	# (api, c, etc, gpu, gte) are required by the C-side calls in
-	# hello_joypad.c (reset_graph, draw_sync, vsync, etc.).
+	# 16 removed entries (c2, card, cd, comb, ds, gs, gun, hmd, math, mcrd, mcx, press, sio, snd, spu, tap)
+	# had LOAD lines in the map but ZERO .o files pulled in — they were unused.
+	# 5 kept libraries (api, c, etc, gpu, gte) are required by the C-side calls in hello_joypad.c (reset_graph, draw_sync, vsync, etc.).
 	$libraries = @(
 		"api",
 		"c",
@@ -227,9 +224,7 @@ function ps1-meta { param(
 		[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.
+	# `--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) {
@@ -265,6 +260,73 @@ function ps1-meta { param(
 	}
 }
 
+function inject-dwarf { param(
+	[string]$elf,
+	[string]$path_gen
+)
+	$base_name               = [System.IO.Path]::GetFileNameWithoutExtension($elf)
+	$path_dwarf_line_bin     = join-path $path_gen  "$base_name.dwarf_line.bin"
+	$path_dwarf_aranges_bin  = join-path $path_gen  "$base_name.dwarf_aranges.bin"
+	$path_dwarf_rnglists_bin = join-path $path_gen  "$base_name.dwarf_rnglists.bin"
+	$path_dwarf_info_bin     = join-path $path_gen  "$base_name.dwarf_info.bin"
+	$path_dwarf_abbrev_bin   = join-path $path_gen  "$base_name.dwarf_abbrev.bin"
+	$path_dwarf_str_bin      = join-path $path_gen  "$base_name.dwarf_str.bin"
+	$path_dwarf_loc_bin      = join-path $path_gen  "$base_name.dwarf_loc.bin"
+	$path_dwarf_loclists_bin = join-path $path_gen  "$base_name.dwarf_loclists.bin"
+	$path_inject_elf         = join-path $path_build "$base_name.dwarf-injected.elf"
+
+	if (-not (Test-Path $path_dwarf_line_bin))     { return }
+	if (-not (Test-Path $path_dwarf_aranges_bin))  { return }
+	if (-not (Test-Path $path_dwarf_rnglists_bin)) { return }
+
+	Write-Host "[build] DWARF-injecting $elf -> $path_inject_elf"
+	Copy-Item -LiteralPath $elf -Destination $path_inject_elf -Force
+
+	# Objcopy call 1: 3x --update-section for the PC-mapping tables (line, aranges, rnglists).
+	$objcopy_args_dwarf_pc = @(
+		"--update-section=.debug_line=$path_dwarf_line_bin",
+		"--update-section=.debug_aranges=$path_dwarf_aranges_bin",
+		"--update-section=.debug_rnglists=$path_dwarf_rnglists_bin"
+	)
+	& $Objcopy @objcopy_args_dwarf_pc $path_inject_elf 2>&1 | Out-Null
+	if ($LASTEXITCODE -ne 0) {
+		Write-Warning "[build] objcopy dwarf-pc splice failed (exit $LASTEXITCODE); removing $path_inject_elf"
+		Remove-Item -LiteralPath $path_inject_elf -ErrorAction SilentlyContinue
+		return
+	}
+
+	# Objcopy call 2: 3x --update-section + 2x --add-section for the debug-data tables (info, abbrev, str, loc, loclists).
+	$objcopy_args_dwarf_info = @(
+		"--update-section=.debug_info=$path_dwarf_info_bin",
+		"--update-section=.debug_abbrev=$path_dwarf_abbrev_bin",
+		"--update-section=.debug_str=$path_dwarf_str_bin",
+		"--add-section=.debug_loc=$path_dwarf_loc_bin",
+		"--add-section=.debug_loclists=$path_dwarf_loclists_bin"
+	)
+	& $Objcopy @objcopy_args_dwarf_info $path_inject_elf 2>&1 | Out-Null
+	if ($LASTEXITCODE -ne 0) {
+		Write-Warning "[build] objcopy dwarf-info splice failed (exit $LASTEXITCODE); removing $path_inject_elf"
+		Remove-Item -LiteralPath $path_inject_elf -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" `
+		$path_inject_elf 2>&1 | Out-Null
+	if ($LASTEXITCODE -ne 0) {
+		Write-Warning "[build] atom-section flag update failed (exit $LASTEXITCODE); removing $path_inject_elf"
+		Remove-Item -LiteralPath $path_inject_elf -ErrorAction SilentlyContinue
+	}
+	else {
+		Write-Host "[build] DWARF-injected ELF: $path_inject_elf"
+	}
+}
+# inject-dwarf
+
 function build-hello_psyqo {
 	$includes += @()
 
@@ -391,61 +453,7 @@ function build-hello_gte {
 	# 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"
-		}
-	}
+	inject-dwarf $elf $path_build_gen
 }
 # build-hello_gte
 
@@ -496,63 +504,59 @@ function build-hello_joypad {
 	# 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_joypad.dwarf_line.bin'
-	$dwarfArangesBin  = join-path $path_build_gen 'hello_joypad.dwarf_aranges.bin'
-	$dwarfRnglistsBin = join-path $path_build_gen 'hello_joypad.dwarf_rnglists.bin'
-	$injectElf        = join-path $path_build 'hello_joypad.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_joypad.dwarf_info.bin'
-		$dwarfAbbrevBin   = join-path $path_build_gen 'hello_joypad.dwarf_abbrev.bin'
-		$dwarfStrBin      = join-path $path_build_gen 'hello_joypad.dwarf_str.bin'
-		$dwarfLocBin      = join-path $path_build_gen 'hello_joypad.dwarf_loc.bin'
-		$dwarfLoclistsBin = join-path $path_build_gen 'hello_joypad.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"
-		}
-	}
+	inject-dwarf $elf $path_build_gen
 }
-build-hello_joypad
+# build-hello_joypad
+
+function build-hello_camera {
+	$includes += @()
+
+	$path_module        = join-path $path_code   'hello_camera'
+	$path_duffle        = join-path $path_code   'duffle'
+	$path_atom_metadata = join-path $path_duffle 'word_count.metadata.h'
+	$path_build_gen     = join-path $path_build  'gen'
+
+	$src_c = join-path $path_module 'hello_camera.c'
+	ps1-meta -unity_root $src_c -metadata $path_atom_metadata -out_root $path_build_gen -passes @('--pre-link')
+
+	$assemble_args = @()
+	$assemble_args += $f_debug
+	$assemble_args += $f_optimize_none
+	$assemble_args += ($f_include + $path_code)
+
+	$src_asm_crt    = join-path $path_nugget_common 'crt0/crt0.s'
+	$module_asm_crt = join-path $path_build         'crt0.o'
+	assemble-unit $src_asm_crt $module_asm_crt $includes $assemble_args
+
+	$module_c = join-path $path_build  'hello_camera_c.o'
+
+	$compile_args = @()
+	$compile_args += $f_debug
+	$compile_args += $f_optimize_none
+	# $compile_args += $f_optimize_intrinsics
+	# $compile_args += $f_optimize_size
+	# $compile_args += $f_optimize_debug
+	$compile_args += ($f_include + $path_code)
+	compile-unit $src_c $module_c $includes $compile_args
+
+	$elf = join-path $path_build 'hello_camera.elf'
+	$exe = join-path $path_build 'hello_camera.ps-exe'
+
+	$link_args = @()
+	$link_args += $f_debug
+	# $link_args += $f_optimize_size
+	$link_modules = @(
+		$module_asm_crt,
+		$module_c
+	)
+	link-modules $link_modules $elf $link_args
+	make-binary $elf $exe
+
+	ps1-meta -unity_root $src_c -metadata $path_atom_metadata -out_root $path_build_gen -passes @('--post-link') ` -extra_args @('--elf', $elf)
+
+	inject-dwarf $elf $path_build_gen
+}
+build-hello_camera
 
 # NO idea if this works yet...
 function Send-ToEmulator { param( [string]$exePath )

scripts/duffle.lua

@@ -1,18 +1,12 @@
 --- duffle.lua — shared primitives + domain tables for the tape-atom metaprograms.
----
---- One ownership statement, then the rest is signal:
----   * **Character classification** (`is_space`, `is_alpha`, `is_alnum`, `is_digit`, plus the byte-fast `_byte` variants).
----   * **String / path primitives** (`trim`, `dirname`, `basename_no_ext`, `normalize_path`, `canonical_path_key`, `find_byte`).
----   * **I/O primitives** (`read_file`, `write_file`, `ensure_dir`).
----   * **Corpus resolution** (`parse_direct_quoted_includes`, `resolve_source_corpus`).
----   * **C-language scanner** (`skip_ws_and_cmt`, `skip_str_or_cmt`, `read_ident`, `read_parens`, `read_braces`, `read_brackets`,
----     `read_balanced`, `scan_to_char`, `split_top_level_commas`).
----   * **Word-count loader** (`load_word_counts` for `WORD_COUNT(...)` metadata files).
----   * **Line lookup** (`LineIndex` returns an O(log N) `line_of(pos)` closure for source-mapping).
----   * **Domain tables** (`TAPE_ATOM_MACROS`, `GTE_PIPELINE_LATENCY`, `GP0_CMD_SIZE`, `GP0_CMD_BY_SHAPE`,
----     `GP0_MACRO_CONTRIB`, `INSTRUCTION_LATENCY`).
----
---- **Conventions**: tabs (1/level), EmmyLua annotations, no regex.
+---   * Character classification: `is_space`, `is_alpha`, `is_alnum`, `is_digit`, plus the byte-fast `_byte` variants.
+---   * String / path primitives: `trim`, `dirname`, `basename_no_ext`, `normalize_path`, `canonical_path_key`, `find_byte`.
+---   * I/O primitives:           `read_file`, `write_file`, `ensure_dir`.
+---   * Corpus resolution:        `parse_direct_quoted_includes`, `resolve_source_corpus`.
+---   * C-language scanner:       `skip_ws_and_cmt`, `skip_str_or_cmt`, `read_ident`, `read_parens`, `read_braces`, `read_brackets`, `read_balanced`, `scan_to_char`, `split_top_level_commas`.
+---   * Word-count loader:        `load_word_counts` for `WORD_COUNT(...)` metadata files.
+---   * Line lookup:              `LineIndex` returns an O(log N) `line_of(pos)` closure for source-mapping.
+---   * Domain tables:            `TAPE_ATOM_MACROS`, `GTE_PIPELINE_LATENCY`, `GP0_CMD_SIZE`, `GP0_CMD_BY_SHAPE`, `INSTRUCTION_LATENCY`.
 
 local M = {}
 
@@ -24,7 +18,7 @@ local lfs = require("lfs")
 -- Cross-file type aliases
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @alias Path        string   -- absolute or CWD-relative file path
+--- @alias Path        string   -- Absolute or CWD-relative file path
 --- @alias LineNum     integer  -- 1-indexed source line number
 --- @alias ByteOff     integer  -- 0-indexed byte offset within a source string
 --- @alias MacroName   string   -- lower_snake_case macro identifier (e.g. "mac_yield")
@@ -32,10 +26,10 @@ local lfs = require("lfs")
 --- @alias Severity    string   -- "error" | "warning" | "info"
 
 --- @class SourceFile
---- @field path     Path      -- 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
+--- @field path     Path      -- Absolute path to the source file
+--- @field text     string    -- Full source text
+--- @field dir      string    -- Directory containing the source
+--- @field basename string    -- Filename without extension
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- ASCII byte constants
@@ -73,20 +67,12 @@ local BYTE_DIGIT_9 = 0x39       -- '9'
 -- ════════════════════════════════════════════════════════════════════════════
 -- Section -1: Bootstrap (path-setup at module load)
 -- ════════════════════════════════════════════════════════════════════════════
---
--- Path setup runs through `scripts/duffle_paths.lua`, which derives the repo root from `debug.getinfo(1, "S").source`
--- (no subprocess, ~0ms) and then calls `require("duffle")`.
--- Entry and pass scripts load `duffle_paths.lua` first; a `find_repo_root` / `setup_package_path` defined here was dead code in practice.
--- `git rev-parse` costs ~100-180ms per subprocess spawn on Windows; `debug.getinfo` is <1ms, so we keep only the fast path.
---
--- To load `duffle.lua` outside `duffle_paths.lua`, set `package.path` manually before `require`.
--- See `docs/guide_metaprogram_ssdl.md` §"I/O primitives" for the pattern.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Section 0: LPeg patterns (compiled once at module load)
 -- ════════════════════════════════════════════════════════════════════════════
 --
--- LPeg is a required dependency (PEG library, no regex). It's loaded via `package.cpath` — `duffle_paths.lua` wires the path to `toolchain/lpeg/lpeg.dll`.
+-- LPeg is a required dependency (PEG library). It's loaded via `package.cpath` — `duffle_paths.lua` wires the path to `toolchain/lpeg/lpeg.dll`.
 -- LPeg handles the high-level scanner; the byte-by-byte helpers in Section 1 handle classification primitives that LPeg's CPython-level cost would dominate.
 --
 -- If the require fails, fail loud with an actionable message. The build script (`update_deps.ps1`) builds lpeg.dll into `toolchain/lpeg/`; run it when the dll is missing.
@@ -108,24 +94,18 @@ local lpeg_alnum_pat  = alpha_pat + digit_pat
 local lpeg_alpha_pat = alpha_pat
 local lpeg_ident_pat = lpeg.C(alpha_pat * lpeg_alnum_pat^0)
 
--- String literal: "..." with backslash escapes.
-local lpeg_str_pat = P('"') * (P(1) - S('"\\') + P('\\') * P(1))^0 * P('"')
--- Char literal: '...' with backslash escapes.
-local lpeg_chr_pat = P("'") * (P(1) - S("'\\") + P('\\') * P(1))^0 * P("'")
--- Line comment: // ... to end-of-line.
-local lpeg_line_cmt_pat = P("//") * (P(1) - S("\n"))^0
--- Block comment: /* ... */ (no nesting per C standard).
-local lpeg_block_cmt_pat = P("/*") * (P(1) - P("*/"))^0 * P("*/")
--- String or comment (any of the four forms).
-local lpeg_str_or_cmt_pat = lpeg_str_pat + lpeg_chr_pat + lpeg_line_cmt_pat + lpeg_block_cmt_pat
+local lpeg_str_pat        = P('"') * (P(1) - S('"\\') + P('\\') * P(1))^0 * P('"') -- String literal: "..." with backslash escapes.
+local lpeg_chr_pat        = P("'") * (P(1) - S("'\\") + P('\\') * P(1))^0 * P("'") -- Char literal: '...' with backslash escapes.
+local lpeg_line_cmt_pat   = P("//") * (P(1) - S("\n"))^0                           -- Line comment: // ... to end-of-line.
+local lpeg_block_cmt_pat  = P("/*") * (P(1) - P("*/"))^0 * P("*/")                 -- Block comment: /* ... */ (no nesting per C standard).
+local lpeg_str_or_cmt_pat = lpeg_str_pat + lpeg_chr_pat + lpeg_line_cmt_pat + lpeg_block_cmt_pat -- String or comment (any of the four forms).
 
 -- Whitespace + comment skipper: zero+ (whitespace run | string | comment).
 local ws_pat              = S(" \t\n\r\v\f")
 local lpeg_ws_and_cmt_pat = (ws_pat + lpeg_str_or_cmt_pat)^0
 
 -- Generic "skip until target, but step over balanced groups" matcher.
--- Used by scan_to_char for non-ident / non-bracket chars.
--- We accept any single char except the target.
+-- Used by scan_to_char for non-ident / non-bracket chars. We accept any single char except the target.
 -- The balanced-group stepping is handled by the caller (via read_balanced).
 local lpeg_scan_to_target_pat = function(target) return (P(1) - P(target))^0  end
 
@@ -148,12 +128,10 @@ end
 
 -- Single digit.
 function M.is_digit_byte(b) return b and b >= BYTE_DIGIT_0 and b <= BYTE_DIGIT_9 end
-
 -- Letter OR digit OR underscore.
 function M.is_alnum_byte(b) return M.is_alpha_byte(b) or M.is_digit_byte(b) end
 
--- String-based wrappers (kept for callers that already have a single-char string;
--- the byte versions are what the hot loops should call).
+-- String-based wrappers (kept for callers that already have a single-char string; the byte versions are what the hot loops should call).
 function M.is_space(c)
 	if type(c) == "number" then return M.is_space_byte(c) end
 	return c == " "  or c == "\t" or c == "\n" or c == "\r" or c == "\v" or c == "\f"
@@ -309,7 +287,7 @@ local function absolute_normalized_path(path)
 end
 
 --- Return the normalized absolute, Windows-case-folded comparison key for a path.
---- -Ordinary relative paths resolve against the process cwd. Drive-relative paths are rejected because LuaFileSystem does not expose Windows per-drive current directories.
+--- Ordinary relative paths resolve against the process cwd. Drive-relative paths are rejected because LuaFileSystem does not expose Windows per-drive current directories.
 --- @param path Path
 --- @return string
 function M.canonical_path_key(path)
@@ -537,8 +515,7 @@ local function splice_c_lines(source)
 		local splice_len = nil
 		if byte == BYTE_BACKSLASH and source:byte(pos + 1) == BYTE_NEWLINE then
 			splice_len = 2
-		elseif byte == BYTE_BACKSLASH and source:byte(pos + 1) == BYTE_CR
-			and source:byte(pos + 2) == BYTE_NEWLINE then
+		elseif byte == BYTE_BACKSLASH and source:byte(pos + 1) == BYTE_CR and source:byte(pos + 2) == BYTE_NEWLINE then
 			splice_len = 3
 		end
 
@@ -603,7 +580,7 @@ function M.parse_direct_quoted_includes(source_text)
 				pos = after
 			end
 		elseif byte == BYTE_DQUOTE or byte == BYTE_SQUOTE then
-			-- enter+leave the string literal in one skip; literal bodies cannot contain a directive regardless of what they look like.
+			-- enter + leave the string literal in one skip; literal bodies cannot contain a directive regardless of what they look like.
 			line_leading = false
 			local after  = M.skip_str_or_cmt(logical_text, pos)
 			pos          = (after > pos) and after or (pos + 1)
@@ -810,7 +787,6 @@ function M.resolve_source_corpus(options)
 end
 
 -- Split a brace-body into top-level comma-separated tokens. Honors nested parens/braces/brackets and skips strings/comments.
---
 -- Splits at top-level NEWLINES and SEMICOLONS too, AND emits a token break after a top-level comment/string.
 -- Pure-comment / pure-string chunks contribute 0 words.
 function M.split_top_level_commas(body)
@@ -846,7 +822,7 @@ function M.split_top_level_commas(body)
 				if has_real_content(chunk) then
 					tokens[#tokens + 1] = chunk
 				elseif #tokens > 0 then
-					-- Pure comment/string chunk at top level.
+					-- comment/string chunk at top level.
 					-- Append it to the LAST token so emit-context callers (components.lua build_component_lines) can convert
 					-- `// trailing comment` to `/* */` and emit it with the macro body.
 					-- count_token_words only inspects the leading ident, so a trailing comment does not affect the count.
@@ -920,8 +896,7 @@ function M.tokenize_body(body)
 		while scan <= len do
 			local c = body:byte(scan)
 			-- Terminator bytes (delimit a token at the top level): ',' = 0x2C, '\n' = 0x0A, ';' = 0x3B.
-			-- These also appear as separators between argument lists inside the parens/braces/brackets,
-			-- so we stop the scan when we hit any of them.
+			-- These also appear as separators between argument lists inside the parens/braces/brackets, so we stop the scan when we hit any of them.
 			if     c == BYTE_COMMA   then break end
 			if     c == BYTE_NEWLINE then break end
 			if     c == BYTE_SEMI    then break end
@@ -1077,6 +1052,8 @@ M.GTE_COMMAND_ALIASES = {
 	-- gte_avg_sort_z3 / gte_avg_sort_z4 are the duffle-side aliases for AVSZ3/4.
 	["gte_avg_sort_z3"]                              = "gte_cmdw_avsz3",
 	["gte_avg_sort_z4"]                              = "gte_cmdw_avsz4",
+	["gte_cmdw_sqr"]                                 = "gte_cmdw_sqr",
+	["gte_cmdw_gpf"]                                 = "gte_cmdw_gpf",
 }
 
 -- GTE command input-set table.
@@ -1088,18 +1065,18 @@ M.GTE_COMMAND_ALIASES = {
 --   * "Store delays are counted in numbers of clock cycles (not in numbers of opcodes).
 --    For 3 cycle delay, one must usually insert 3 cached opcodes (or one uncached opcode)."
 --
--- Per PSX-SPX `docs/psx-spx/docs/gtepipelinetimings.md` (the per-instruction input-latch measurement, which is the same
--- phenomenon modeled from the command side), the values are:
---   rtps:  every data register, every control register (RT/TR/OFX/OFY/H/DQA/DQB)
---   rtpt:  same superset (rtpt reads V0..V2, the RT matrix, the TR vector, OFX/OFY, H, DQA, DQB)
---   nclip: SXY0, SXY1, SXY2 (no RT/TR/OFX inputs)
+-- Per PSX-SPX `docs/psx-spx/docs/gtepipelinetimings.md` (the per-instruction input-latch measurement, which is the same phenomenon modeled from the command side), 
+-- the values are:
+--   rtps:  every data register, every control register (RT / TR / OFX / OFY / H / DQA / DQB)
+--   rtpt:  same superset (rtpt reads V0..V2, the RT matrix, the TR vector, OFX / OFY, H, DQA, DQB)
+--   nclip: SXY0, SXY1, SXY2 (no RT / TR / OFX inputs)
 --   mvmva: variable (depends on the chosen mx / v / cv selector); treated conservatively as the union of all RT + TR + BK + IR columns
 --          (the data inputs the command can read).
 --   op:    IR1, IR2, IR3 (cross-product output, atomic; consumers treat as fan-out only)
---   avsz3/avsz4: SZ0..SZ3 + ZSF3/ZSF4
+--   avsz3 / avsz4: SZ0..SZ3 + ZSF3/ZSF4
 --
 -- We model the data-register + control-register superset. Every relevant input is in this set per PSX-SPX `gtepipelinetimings.md`;
--- the per-input latching values there describe the same number's command-side view
+-- The per-input latching values there describe the same number's command-side view
 -- (a recent mtc2/ctc2 to that register must retire the same number of cycles before the command issues).
 -- Anything outside this set is safe to clobber immediately after a prior command.
 M.GTE_COMMAND_INPUTS = {
@@ -1133,7 +1110,7 @@ M.GTE_COMMAND_INPUTS = {
 		"gte_cr_OFX",   "gte_cr_OFY",   "gte_cr_H",
 		"gte_cr_DQA",   "gte_cr_DQB",
 	},
-	-- NCLIP: reads SXY0/SXY1/SXY2 only (per PSX-SPX gtepipelinetimings.md §12.6).
+	-- NCLIP: reads SXY0 / SXY1 / SXY2 only (per PSX-SPX gtepipelinetimings.md §12.6).
 	["gte_cmdw_nclip"] = {
 		"C2_SXY0", "C2_SXY1", "C2_SXY2",
 	},
@@ -1160,10 +1137,17 @@ M.GTE_COMMAND_INPUTS = {
 		"C2_SZ0", "C2_SZ1", "C2_SZ2", "C2_SZ3",
 		"gte_cr_ZSF4",
 	},
+	-- SQR: reads IR1..IR3 (per PSX-SPX gte.md SQR section; libgte disassembly 0x800160b0).
+	["gte_cmdw_sqr"] = {
+		"C2_IR1", "C2_IR2", "C2_IR3",
+	},
+	-- GPF: reads IR0 + IR1..IR3 (per PSX-SPX gte.md GPF section; libgte disassembly 0x8001613c).
+	["gte_cmdw_gpf"] = {
+		"C2_IR0", "C2_IR1", "C2_IR2", "C2_IR3",
+	},
 }
 
 -- GTE command output-set + semantic role table.
---
 -- For each command, the set of C2 data registers the command writes as outputs, paired with the SEMANTIC ROLE of each output.
 -- The semantic role is the basis for the `_post_<cmd>` contract validation.
 -- The contract says "after <cmd>, the latest screen-XY is C2_SXY2" (C2_SXY0 is wrong; the FIFO side effects leave SXY0 as an older FIFO entry, never the newest).
@@ -1220,19 +1204,35 @@ M.GTE_COMMAND_OUTPUTS = {
 	["gte_cmdw_avsz4"] = {
 		{ register = "C2_OTZ", role = "otz" },
 	},
-	-- OP (outer product): writes IR1/IR2/IR3 (color-conversion fan-out).
+	-- OP (outer product): writes IR1 / IR2 / IR3 (color-conversion fan-out).
 	["gte_cmdw_op"] = {
 		{ register = "C2_IR1", role = "latest_color" },
 		{ register = "C2_IR2", role = "latest_color" },
 		{ register = "C2_IR3", role = "latest_color" },
 	},
 	-- MVMVA: same shape as OP from the role perspective; the single
-	-- MAC result is written to C2_IR1/IR2/IR3.
+	-- MAC result is written to C2_IR1 / IR2 / IR3.
 	["gte_cmdw_mvmva"] = {
 		{ register = "C2_IR1", role = "latest_color" },
 		{ register = "C2_IR2", role = "latest_color" },
 		{ register = "C2_IR3", role = "latest_color" },
 	},
+	["gte_cmdw_sqr"] = {
+		{ register = "C2_MAC1", role = "mac_result" },
+		{ register = "C2_MAC2", role = "mac_result" },
+		{ register = "C2_MAC3", role = "mac_result" },
+		{ register = "C2_IR1",  role = "latest_color" },
+		{ register = "C2_IR2",  role = "latest_color" },
+		{ register = "C2_IR3",  role = "latest_color" },
+	},
+	["gte_cmdw_gpf"] = {
+		{ register = "C2_MAC1", role = "mac_result" },
+		{ register = "C2_MAC2", role = "mac_result" },
+		{ register = "C2_MAC3", role = "mac_result" },
+		{ register = "C2_IR1",  role = "latest_color" },
+		{ register = "C2_IR2",  role = "latest_color" },
+		{ register = "C2_IR3",  role = "latest_color" },
+	},
 }
 
 -- GTE command/post-command latch-window table.
@@ -1241,17 +1241,16 @@ M.GTE_COMMAND_OUTPUTS = {
 -- A subsequent MTC2/CTC2 overwrite of one of those outputs before the latch window expires is a hazard:
 -- the latched value in the pipeline gets overwritten by the CPU before the pipeline consumes it.
 --
--- This relation is the command -> register direction (the command is the producer; MTC2/CTC2 is the consumer).
--- It is the inverse of the MTC2 -> command input propagation (register -> command direction), which is staged by the
--- producer step of `analyze_hardware_relations`.
+-- This relation is the command -> register direction (the command is the producer; MTC2 / CTC2 is the consumer).
+-- It is the inverse of the MTC2 -> command input propagation (register -> command direction), which is staged by the producer step of `analyze_hardware_relations`.
 --
--- The schema mirrors the producer-side relations (`direction`, `evidence`, `violation_kind`); `required` counts the
--- emitted words strictly between the command's last output word and the overwrite.
+-- The schema mirrors the producer-side relations (`direction`, `evidence`, `violation_kind`); 
+-- `required` counts the emitted words strictly between the command's last output word and the overwrite.
 -- `required = 0` permits the immediately following overwrite; `required = 4` requires four intervening words.
 --
 -- Per PSX-SPX `gtepipelinetimings.md` the per-command input latching measurements are the same numbers inverted.
--- They describe when a recent MTC2/CTC2 must retire before the command issues; this table describes when a recent
--- command's outputs latch into the pipeline before a later MTC2/CTC2 overwrites them.
+-- They describe when a recent MTC2 / CTC2 must retire before the command issues. 
+-- This table describes when a recent command's outputs latch into the pipeline before a later MTC2/CTC2 overwrites them.
 --
 -- Consumers:
 --   * passes/static_analysis.lua::analyze_hardware_relations (stages post-command latch relations in `pending` after a GTE command).
@@ -1266,9 +1265,7 @@ M.GTE_COMMAND_LATCH_WINDOWS = {
 		{ register = "C2_OTZ",  required = 4 },
 		{ register = "C2_IR0",  required = 4 },
 	},
-	-- RTPT: same latching as RTPS (the LAST projection in SXY2 is the
-	-- newest one; the earlier SXY0 / SXY1 entries are part of the
-	-- batched triple).
+	-- RTPT: same latching as RTPS (the LAST projection in SXY2 is the newest one; the earlier SXY0 / SXY1 entries are part of the batched triple).
 	["gte_cmdw_rtpt"] = {
 		{ register = "C2_SXY0", required = 4 },
 		{ register = "C2_SXY1", required = 4 },
@@ -1287,7 +1284,7 @@ M.GTE_COMMAND_LATCH_WINDOWS = {
 	["gte_cmdw_avsz4"] = {
 		{ register = "C2_OTZ", required = 4 },
 	},
-	-- OP / MVMVA: IR1/IR2/IR3 latch for 4 emitted words.
+	-- OP / MVMVA: IR1 / IR2 / IR3 latch for 4 emitted words.
 	["gte_cmdw_op"] = {
 		{ register = "C2_IR1", required = 4 },
 		{ register = "C2_IR2", required = 4 },
@@ -1298,25 +1295,38 @@ M.GTE_COMMAND_LATCH_WINDOWS = {
 		{ register = "C2_IR2", required = 4 },
 		{ register = "C2_IR3", required = 4 },
 	},
+	["gte_cmdw_sqr"] = {
+		{ register = "C2_MAC1", required = 4 },
+		{ register = "C2_MAC2", required = 4 },
+		{ register = "C2_MAC3", required = 4 },
+		{ register = "C2_IR1",  required = 4 },
+		{ register = "C2_IR2",  required = 4 },
+		{ register = "C2_IR3",  required = 4 },
+	},
+	["gte_cmdw_gpf"] = {
+		{ register = "C2_MAC1", required = 4 },
+		{ register = "C2_MAC2", required = 4 },
+		{ register = "C2_MAC3", required = 4 },
+		{ register = "C2_IR1",  required = 4 },
+		{ register = "C2_IR2",  required = 4 },
+		{ register = "C2_IR3",  required = 4 },
+	},
 }
 
--- GTE component result contracts were removed: the `_post_<cmd>` naming convention was a soft convention
--- (the user did not want it formalized via static-analysis enforcement). A proper `atom_info` directive for ordering semantics is a future TODO.
-
 -- Operand-class table for the COP2->GPR load-delay check.
---
 -- Maps each emitting-token ident to the set of GPR operand positions it reads.
 -- Covers the current encoder vocabulary (`code/duffle/mips.h` + `code/duffle/gte.h`); add rows here as new encoders land.
 --
 -- Semantics:
 --   * A "GPR operand position" is the textual slot in the macro's argument list, 1-based; e.g. `load_word(rt, base, off)` has
 --     positional operands 1 (rt), 2 (base), 3 (off). The table reads operands 1 + 2 + 3 to find what GPRs the macro touches.
---   * The check tracks one entry per destination GPR per MFC2/CFC2 event.
+--   * The check tracks one entry per destination GPR per MFC2 / CFC2 event.
 --     A subsequent event counts as a "use" iff any of its read operand positions reference that destination GPR's ident (e.g. `R_T0`).
 --   * Branch delay slots are out of scope (MIPS control-flow; tracked separately).
 M.OPERAND_READ_POSITIONS = {
 	-- CPU ALU with one or two GPR operands. Reads every GPR operand.
 	["add_ui"]                 = {1, 2},
+	["li_s"]                   = {1, 2},  -- rt (write), imm16 (immediate)
 	["add_ui_self"]            = {1},
 	["add_si"]                 = {1, 2},
 	["add_u"]                  = {1, 2, 3},
@@ -1386,6 +1396,8 @@ M.OPERAND_READ_POSITIONS = {
 	["gte_mv_to_ctrl_r"]       = {},
 	["gte_lw"]                 = {},
 	["gte_sw"]                 = {},
+	["shift_lleft_var"]        = {1, 2, 3},  -- rd, rt, rs (variable shift amount)
+	["shift_aright_var"]       = {1, 2, 3},
 }
 
 -- GP0 packet sizes (total words including the 1-word tag) per GP0 cmd byte.
@@ -1430,34 +1442,7 @@ M.GP0_CMD_BY_SHAPE = {
 	["g4"]  = 0x38, ["gt4"] = 0x3C,
 }
 
--- TODO(Ed): REMOVE THIS HARDCODE, THIS SHOULD BE RESOLVED AUTOMATICALLY
--- Per-macro prim-buffer contribution: how many 32-bit words each macro writes to the primitive being built in main RAM.
--- (This counts RAM-side prim-buffer words, not .text instruction words.)
--- The sum across `mac_format_X_color` + `mac_gte_store_X_post_*` + `mac_insert_ot_tag_X` calls in an atom body must equal
--- `GP0_CMD_SIZE[GP0_CMD_BY_SHAPE[shape]]`.
-M.GP0_MACRO_CONTRIB = {
-	["mac_format_f3_color"]      = 1,
-	["mac_format_g3_color"]      = 3,
-	["mac_format_g4_color"]      = 4,
-	["mac_gte_store_f3"]         = 3,
-	["mac_gte_store_g3"]         = 3,
-	["mac_gte_store_g4_p012"]    = 3,
-	["mac_gte_store_g4_p3"]      = 1,
-	["mac_insert_ot_tag_f3"]     = 1,
-	["mac_insert_ot_tag_g4"]     = 1,
-}
-
--- Per-macro cycle cost (best-case, no stalls). Used by the static-analysis pass to emit per-atom cycle budgets.
--- The counts cover the expanded instruction sequence the macro emits (not just the surface token in source).
--- Worked example — `mac_pack_color_word(off, cmd, r, g, b)` expands to:
---     load_upper_i(R_AT, (cmd << 8) | b)        -- 1 cycle
---     or_i_self(R_AT, (g << 8) | r)             -- 1 cycle
---     store_word(R_AT, R_PrimCursor, off)       -- 1 cycle
---                                                = 3 cycles total
---
--- `mac_yield` emits a control-transfer sequence (load_word, add_ui_self, jump_reg, nop). The atom body's cycle budget excludes
--- the yield's cost (we model it as 0); the runtime cost lands in the next atom's prologue.
---
+-- Per-instruction cycle cost (best-case, no stalls). Used by the static-analysis pass to emit per-atom cycle budgets.
 -- GTE command values are the GTE instruction's intrinsic cycles — the latency after any pre-cmd `nop2` has retired.
 -- When the source emits `nop2, gte_cmdw_X`, the nops' cycles are added separately (1+1) plus the gte_cmdw_X value here:
 --   rtpt  = 23 + 2 nops = 25 total cycles  (PSX-SPX says 23 cycles for the cmd itself; the nops are pre-fill)
@@ -1471,8 +1456,15 @@ M.GP0_MACRO_CONTRIB = {
 -- PSX-SPX reports the GTE intrinsic cycles as the total execution time of the command itself (rtpt=23, rtps=15, nclip=8, etc.).
 -- The pre-fill nops are a codebase convention for retiring preceding C2 writes.
 -- See `docs/psx-spx/docs/geometrytransformationenginegte.md` for per-command cycle counts and
--- `docs/psx-spx/docs/gtepipelinetimings.md` for the hardware-verified input-latch boundaries (most inputs become
--- safe to clobber after 0-4 cycles).
+-- `docs/psx-spx/docs/gtepipelinetimings.md` for the hardware-verified input-latch boundaries
+-- (most inputs become safe to clobber after 0-4 cycles).
+--
+-- Per-macro cycle costs (`mac_yield`, `mac_pack_color_word`, ...) and per-macro prim-buffer contributions
+-- (`mac_format_*_color`, `mac_gte_store_*`, `mac_insert_ot_tag_*`) are NOT hardcoded here.
+-- `passes/components.lua::compute_components_metadata` derives both from each `MipsAtomComp_(ac_X)` body in
+-- `code/duffle/lottes_tape.h`, stores the values on `corpus.components[name].cycle_cost` and
+-- `corpus.components[name].gp0_contrib`, and `passes/static_analysis.lua` reads those fields directly.
+-- The `mac_yield` cost is 0 by convention (the runtime cost lands in the next atom's prologue).
 M.INSTRUCTION_LATENCY = {
 	-- CPU ALU (single-cycle R3000A ops)
 	["nop"]                 = 1,
@@ -1487,8 +1479,10 @@ M.INSTRUCTION_LATENCY = {
 	["xor_i"]               = 1,  ["xor_u"]           = 1,
 	["nor_u"]               = 1,
 	["shift_lleft"]         = 1,  ["shift_lleft_self"]  = 1,
+	["shift_lleft_var"]     = 1,  -- sllv: 1 cycle
 	["shift_lright"]        = 1,
 	["shift_aright"]        = 1,
+	["shift_aright_var"]    = 1,  -- srav: 1 cycle
 	["mask_upper"]          = 1,
 	["mov_from_high"]       = 2,  -- mfhi: 2 cycles
 	["mov_from_low"]        = 2,  -- mflo: 2 cycles
@@ -1506,6 +1500,7 @@ M.INSTRUCTION_LATENCY = {
 	["load_half_u"]         = 1,  ["load_half"]   = 1,
 	["load_byte_u"]         = 1,  ["load_byte"]   = 1,
 	["load_upper_i"]        = 1,
+	["li_s"]                = 1,  -- aliased to add_ui(rt, R_0, imm); 1 cycle
 	-- 2-word loads (lui + ori) used for >16-bit immediates
 	["load_imm"]                = 2,
 	["load_imm_1w"]             = 1,
@@ -1517,17 +1512,19 @@ M.INSTRUCTION_LATENCY = {
 	["store_word"]          = 1,
 	["store_half"]          = 1,
 	["store_byte"]          = 1,
-	-- Branches (branch + BD slot nop = 2 cycles; the BD slot's nop is
-	-- counted as part of the branch's cost)
+	-- Branches (branch + BD slot nop = 2 cycles; the BD slot's nop is counted as part of the branch's cost)
 	["branch_equal"]        = 2,  ["branch_ne"]          = 2,
 	["branch_le_zero"]      = 2,  ["branch_lt_zero"]     = 2,
 	["branch_ge_zero"]      = 2,  ["branch_gt_zero"]     = 2,
+	-- `jump_rel(off)` is the within-atom-safe unconditional-jump alias for `branch_equal(R_0, R_0, off)` (see `code/duffle/mips.h`).
+	-- Same cost as the underlying branch (1 instruction + 1 mandatory BD-slot nop = 2 cycles).
+	["jump_rel"]            = 2,
 	-- Jumps (jump + BD slot nop = 2 cycles)
 	["jump"]                = 2,  ["jump_reg"]           = 2,
 	["jump_link"]           = 2,  ["call_reg"]           = 2,
 	["call_addr"]           = 2,
-	-- COP2 transfers (mtc2/mfc2/ctc2/cfc2 = 1 cycle + COP2 latency; the
-	-- COP2 latency is usually absorbed by subsequent nops or by the next
+	-- COP2 transfers (mtc2/mfc2/ctc2/cfc2 = 1 cycle + COP2 latency; 
+	-- The COP2 latency is usually absorbed by subsequent nops or by the next
 	-- GTE command's pre-fill nops, so we count 1)
 	["gte_mv_to_data_r"]    = 1,
 	["gte_mv_from_data_r"]  = 1,
@@ -1547,6 +1544,8 @@ M.INSTRUCTION_LATENCY = {
 	["gte_cmdw_op"]            = 6,   -- OP: 6 cycles (PSX-SPX)
 	["gte_cmdw_outer_product"] = 6,   -- alias for OP
 	["gte_cmdw_wedge"]         = 6,   -- alias for OP
+	["gte_cmdw_sqr"]           = 5,   -- SQR(sf): 5 cycles (PSX-SPX); +2 nops for pre-fill if sf=0/1
+	["gte_cmdw_gpf"]           = 5,   -- GPF(sf,lm): 5 cycles (PSX-SPX); +2 nops for pre-fill if needed
 	-- Long-form aliases (same cycle cost as their short form)
 	["gte_cmdw_rotate_translate_perspective_single"] = 15,  -- alias for rtps
 	["gte_cmdw_rotate_translate_perspective_triple"] = 23,  -- alias for rtpt
@@ -1568,22 +1567,6 @@ M.INSTRUCTION_LATENCY = {
 	["gte_load_v2"]         = 2,
 	["gte_load_v0v1v2"]     = 6,
 
-	-- TODO(Ed): REMOVE THIS HARDCODE, THIS SHOULD BE RESOLVED AUTOMATICALLY
-	-- mac_* helpers (cycle cost = sum of the expanded instructions)
-	-- mac_yield transfers control; cycle budget is 0 (the next atom absorbs the cost).
-	["mac_yield"]              = 0,
-	["mac_pack_color_word"]    = 3,  -- lui + ori + sw
-	["mac_format_f3_color"]    = 3,  -- = mac_pack_color_word
-	["mac_format_g4_color"]    = 12, -- 4 x mac_pack_color_word
-	["mac_load_tri_indices"]   = 3,  -- 3 x lhu
-	["mac_gte_load_tri_verts"] = 18, -- 3 x {sll, addu, lw, lw, mtc2, mtc2}
-	["mac_gte_store_f3"]       = 3,
-	["mac_gte_store_g3"]       = 3,
-	["mac_gte_store_g4_p012"]  = 3,
-	["mac_gte_store_g4_p3"]    = 1,
-	["mac_insert_ot_tag_f3"]   = 11,  -- 11 .word slots in the macro body
-	["mac_insert_ot_tag_g4"]   = 11,
-
 	-- Annotation markers (emit no code; pure metaprogram hints)
 	["atom_label"]          = 0,
 	["atom_offset"]         = 0,
@@ -1600,8 +1583,7 @@ M.UNKNOWN_INSTRUCTION_CYCLES = 1
 
 -- Hardware-relation policy table.
 --
--- The forward walker in `passes/static_analysis.lua::analyze_hardware_relations` reads every emitted word_event,
--- matches its `encoder` against `row.token`, and:
+-- The forward walker in `passes/static_analysis.lua::analyze_hardware_relations` reads every emitted word_event, matches its `encoder` against `row.token`, and:
 --   * stages the event as a producer in `atom.paths.forward_state`; or
 --   * matches it as a consumer against pending producers and records a hazard on `atom.paths.hazards` when the gap is below `visibility.required`.
 --
@@ -1621,8 +1603,8 @@ M.UNKNOWN_INSTRUCTION_CYCLES = 1
 --     and is reserved for future "self-retires" relations.
 --
 -- Evidence:
---   * `evidence.confidence` is one of `"exact"`, `"conservative"`, `"unknown"`. The severity comes from `violation_kind`; a hardware
---     measurement that the vendor caveats may still classify as `"conservative"` even when the underlying timing is numerically known.
+--   * `evidence.confidence` is one of `"exact"`, `"conservative"`, `"unknown"`. The severity comes from `violation_kind`;
+--     A hardware measurement that the vendor caveats may still classify as `"conservative"` even when the underlying timing is numerically known.
 --   * `evidence.source` is the upstream reference (file + line range) the row is sourced from. New rows must carry this citation.
 --
 -- Consumers:
@@ -1732,22 +1714,42 @@ M.HARDWARE_RELATIONS = {
 	},
 	-- Memory -> COP2 data register (LWC2).
 	-- The memory-side timing is not measured by the vendored GTE latch experiment, so this relation has no numeric retirement threshold.
-	-- The forward walker emits one info edge at the first command-input consumer and then clears the pending relation.
+	-- The LWC2 destination has TWO retirement regimes (per PSX-SPX):
+	--   * GTE-command consumer (`gte_cmdw_*`): the GTE pipeline LATCHES the LWC2 result, so a `gte_cmdw_*`
+	--     in the very next slot uses the latched value. Gap = 0 is allowed. (Per `docs/psx-spx/docs/gtepipelinetimings.md:271-274`.)
+	--   * Any other consumer: standard MIPS load delay applies. Gap = 1 required. (Per `docs/psx-spx/docs/cpuspecifications.md:407-419`.)
+	-- Two separate relations so the walker can dispatch by consumer type and emit different severities
+	-- (the GTE-command path is `info` because the latch is intentional; the non-GTE-consumer path is `error` because the missing nop is a real bug).
 	{
-		id             = "lwc2_unknown_visibility",
-		semantic       = "LWC2",
+		id             = "lwc2_to_gte_command",
+		semantic       = "LWC2_to_GTE",
 		token          = "gte_lw",
 		direction      = "memory_to_cop2_data",
 		reads          = { domain = "memory",    arg = 2 },
 		writes         = { domain = "cop2.data", arg = 1 },
-		visibility     = { kind = "unknown_consumer", required = nil },
+		required       = 0,  -- GTE-command consumer: gap = 0 OK (latched).
 		evidence       = {
-			confidence = "unknown",
+			confidence = "measured",
 			source     = "gtepipelinetimings.md:271-274",
 		},
 		violation_kind = "info",
 		clear_on_consumer = true,
 	},
+	{
+		id             = "lwc2_to_other_consumer",
+		semantic       = "LWC2_to_other",
+		token          = "gte_lw",
+		direction      = "memory_to_cop2_data",
+		reads          = { domain = "memory",    arg = 2 },
+		writes         = { domain = "cop2.data", arg = 1 },
+		required       = 1,  -- Non-GTE-consumer: standard MIPS load delay.
+		evidence       = {
+			confidence = "inferred",
+			source     = "cpuspecifications.md:407-419",
+		},
+		violation_kind = "error",
+		clear_on_consumer = true,
+	},
 	-- COP2 data register -> memory (SWC2). A read of C2 state, not a CPU-to-COP2 write.
 	-- The policy row stays in for direction/provenance; staging it as a later command-input producer is suppressed.
 	{
@@ -1824,6 +1826,7 @@ M.CU2_TRANSITION_POLICY = {
 M.INSTRUCTION_GPR_EFFECTS = {
 	-- CPU ALU with one or two GPR operands. Reads every GPR operand position.
 	add_ui                  = { reads = {1, 2}, writes = {1} },
+	li_s                    = { reads = {1, 2}, writes = {1} },  -- RMW: rt is both read + written
 	add_ui_self             = { reads = {1},    writes = {1} },
 	add_si                  = { reads = {1, 2}, writes = {1} },
 	add_u                   = { reads = {2, 3}, writes = {1} },
@@ -1940,6 +1943,8 @@ M.INSTRUCTION_GPR_EFFECTS = {
 	atom_writes             = { reads = {},     writes = {}  },
 	-- mac_yield transfers control to the next atom; zero GPR effects.
 	mac_yield               = { reads = {},     writes = {}  },
+	shift_lleft_var         = { reads = {2, 3}, writes = {1} },
+	shift_aright_var        = { reads = {2, 3}, writes = {1} },
 }
 
 -- Bounded GPR-value rules consumed by the same forward event walk as `INSTRUCTION_GPR_EFFECTS`.
@@ -1952,6 +1957,7 @@ M.INSTRUCTION_GPR_EFFECTS = {
 M.GPR_VALUE_RULES = {
 	load_upper_i     = { op = "load_upper_i", dest = 1,             immediate = 2, },
 	add_ui           = { op = "add_ui",       dest = 1, source = 2, immediate = 3, },
+	li_s             = { op = "add_ui",       dest = 1, source = 2, immediate = 3 },  -- R_0 + sign-ext(imm) folds into a constant
 	or_i             = { op = "or_i",         dest = 1, source = 2, immediate = 3, },
 	and_i            = { op = "and_i",        dest = 1, source = 2, immediate = 3, },
 	xor_i            = { op = "xor_i",        dest = 1, source = 2, immediate = 3, },
@@ -2079,16 +2085,17 @@ local E_MAC_PREFIX_LEN = 4
 --- Expand a body entry into the flat sequence of emitted machine-word events.
 ---
 --- Semantics (one event per emitted machine word):
----   * **Direct one-word encoders** (`load_word`, `add_ui`, `nop`, `gte_lw`, ...): one event with `ident` = leading ident, `args` = parsed top-level args.
----   * **`nop2`** (2-word pseudo-instruction): two events, both with `ident = "nop"` so the recognized "this slot is a no-op" semantic is visible to downstream analyses.
----   * **Any other N-word token** in `word_counts`: N events sharing the same `ident` + `args` so useful CPU words retire slots in the cycle budget.
----   * **Known `mac_X(...)` calls**: recursively expand the indexed component body, including nested components. Every event from the expansion carries:
+---   * Direct one-word encoders `load_word`, `add_ui`, `nop`, `gte_lw`, ...: One event with `ident` = leading ident, `args` = parsed top-level args.
+---   * `nop2` (2-word pseudo-instruction): Two events, both with `ident = "nop"` so the recognized "this slot is a no-op" semantic is visible to downstream analyses.
+---   * Any other N-word token in `word_counts`: N events sharing the same `ident` + `args` so useful CPU words retire slots in the cycle budget.
+---   * Known `mac_X(...)` calls: Recursively expand the indexed component body, including nested components. Every event from the expansion carries:
 ---     - `source` / `line` = the COMPONENT'S source path + the line of the token within the component body (i.e. "definition site").
 ---     - `call_source` / `call_line` = the ROOT atom's source path + call-site line, PRESERVED across recursion so nested events still point at the original root.
----   * **Unknown `mac_X`** (not in `component_index`): fall back to `word_counts[ident]` if present; otherwise emit one opaque event so the cycle budget accounts for the word.
----   * **Marker tokens** (`atom_label(...)` / `atom_offset(...)`): zero events (they are pure metaprogram hints, not emitted machine words).
+---   * Unknown `mac_X` (not in `component_index`): fall back to `word_counts[ident]` if present; otherwise emit one opaque event so the cycle budget accounts for the word.
+---   * Marker Tokens (`atom_label(...)` / `atom_offset(...)`): Zero events (they are pure metaprogram hints).
 ---
---- Cycle protection: a per-expansion `visiting` set tracks components currently on the expansion stack; a re-entry produces a deterministic `{kind = "cycle", ...}` error and aborts that branch (does NOT hang, does NOT recurse).
+--- Cycle protection: a per-expansion `visiting` set tracks components currently on the expansion stack;
+--- a re-entry produces a deterministic `{kind = "cycle", ...}` error and aborts that branch (does NOT hang, does NOT recurse).
 ---
 --- Pure: reads `body_entry` / `component_index` / `word_counts`. Memoization is the caller's responsibility.
 --- Callers wanting `word_events` / `word_event_errors` precomputed for many atoms should memoize them per atom.
@@ -2110,12 +2117,12 @@ local E_MAC_PREFIX_LEN = 4
 -- word_counts table is authored-metadata + current-component count table.
 
 --- @class EmissionProjection
---- @field items       table[] -- ordered stream of word|label|offset|invoke_begin|invoke_end
---- @field word_events table[] -- dense view of items where kind == "word"
---- @field markers     table[] -- dense view of items where kind == "label"|"offset"
+--- @field items       table[] -- Ordered stream of word|label|offset|invoke_begin|invoke_end
+--- @field word_events table[] -- Dense view of items where kind == "word"
+--- @field markers     table[] -- Dense view of items where kind == "label"|"offset"
 --- @field invocations InvocationRecord[] -- dense view of items where kind == "invoke_begin"|"invoke_end"
---- @field errors      table[] -- token-resolution failures surfaced without fail-loud
---- @field warnings    table[] -- opaque warnings (e.g. unknown uncounted macro)
+--- @field errors      table[] -- Token-resolution failures surfaced without fail-loud
+--- @field warnings    table[] -- Opaque warnings (e.g. unknown uncounted macro)
 
 --- @class InvocationRecord
 --- Lives at `atom.paths.invocations[*]`. Constructed once at the single invocation-construction site
@@ -2123,20 +2130,20 @@ local E_MAC_PREFIX_LEN = 4
 --- @field id              integer  -- 1-based, monotonic per-atom invocation id (0 is reserved for "no open invocation")
 --- @field parent_id       integer  -- 0 for the outermost (root) call; otherwise the id of the immediately enclosing invocation
 --- @field kind            string   -- "comp_bare" | "comp_proc" (component form that triggered the expansion)
---- @field component_name  string   -- the bare component name without the `mac_` prefix
---- @field call_text       string   -- the immediate `mac_X(...)` token text (or root call text for the outermost entry)
---- @field root_call_text  string   -- the IMMUTABLE outermost `mac_X(...)` token text for every word emitted in this call's expansion
---- @field call_path       string   -- source path of the call site (root atom source for direct calls, component source for nested expansions)
---- @field call_line       integer  -- source line of the call site
---- @field def_path        string   -- source path of the component definition
---- @field def_line        integer  -- source line of the component declaration
+--- @field component_name  string   -- Bare component name without the `mac_` prefix
+--- @field call_text       string   -- Immediate `mac_X(...)` token text (or root call text for the outermost entry)
+--- @field root_call_text  string   -- IMMUTABLE outermost `mac_X(...)` token text for every word emitted in this call's expansion
+--- @field call_path       string   -- Source path of the call site (root atom source for direct calls, component source for nested expansions)
+--- @field call_line       integer  -- Source line of the call site
+--- @field def_path        string   -- Source path of the component definition
+--- @field def_line        integer  -- Source line of the component declaration
 --- @field start_pos       integer  -- 0-based emitted-word position of the FIRST word inside this invocation (the value of `word_idx` AT `emit_invoke_begin` time, BEFORE the first word is emitted). Words emitted inside this invocation occupy `start_pos..start_pos+#body_lines-1` (inclusive, 0-based). Downstream DWARF/provenance consumers MUST read this; do NOT reconstruct it from `start_word` (which is the 1-based items index including `invoke_begin`/`invoke_end` markers).
 --- @field end_pos         integer  -- 0-based position of the LAST word inside this invocation (set by `emit_invoke_end` to `word_idx - 1` AFTER all body words are emitted).
 --- @field start_word      integer  -- 1-based items index of the `invoke_begin` item
 --- @field end_word        integer  -- 1-based items index of the `invoke_end` item (set by `emit_invoke_end`)
---- @field word_count      integer  -- number of `word` items emitted between `start_word` and `end_word` (inclusive)
+--- @field word_count      integer  -- Number of `word` items emitted between `start_word` and `end_word` (inclusive)
 --- @field debug_skip      boolean  -- `debug_skip` stamp; true iff `corpus.components[name].debug_skip` is true at construction. Always boolean (never `nil`).
---- @field errors          table[]  -- per-invocation construction errors (cycle / count_mismatch); does not include pass-level errors
+--- @field errors          table[]  -- Per-invocation construction errors (cycle / count_mismatch); does not include pass-level errors
 
 -- Internal recursive walker. The items stream holds every emitted event in order; `word_events`, `markers`,
 -- `invocations`, `errors`, `warnings` are dense views / side outputs appended alongside.
@@ -2212,10 +2219,15 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 	end
 
 	local function emit_marker(kind, name, target, line,
-		immediate_call_text, root_call_text_w)
+		immediate_call_text, root_call_text_w,
+		consuming_encoder, consuming_arg_pos)
 		local inv_ids   = open_invocation_ids_snapshot()
 		local outermost = inv_ids[1] or 0
 		-- Markers carry the open invocation stack snapshot. `call_text` / `root_call_text` belong to words, not markers — markers are zero-width and skip per-word call-site attribution.
+		-- `consuming_encoder` + `consuming_arg_pos` carry the surrounding control-transfer instruction context
+		-- (e.g. `branch_le_zero` consuming its 3rd argument, or `jump` / `call_addr` consuming their only argument).
+		-- `passes/offsets.lua` reads these to dispatch per-consuming-instruction offset encoding.
+		-- nil for top-level markers (where the marker is the entire token — no surrounding consuming instruction).
 		local it = {
 			kind                     = kind,
 			name                     = name,
@@ -2225,6 +2237,8 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 			outermost_invocation_id  = outermost,
 		}
 		if target ~= nil then it.target = target end
+		if consuming_encoder then it.consuming_encoder = consuming_encoder end
+		if consuming_arg_pos  then it.consuming_arg_pos  = consuming_arg_pos  end
 		items[#items + 1] = it
 		markers[#markers + 1] = {
 			kind              = kind,
@@ -2232,39 +2246,102 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 			line              = line,
 			word_index        = word_idx,
 			target            = target,
+			consuming_encoder = consuming_encoder,
+			consuming_arg_pos = consuming_arg_pos,
 		}
 	end
 
-	local function emit_embedded_markers(tok, tok_line)
+	-- Count top-level commas in `tok` between position `from_pos` (inclusive) and `to_pos` (exclusive).
+	-- Tracks paren depth so commas inside nested () don't count. Skips string literals + comments.
+	-- Used by `emit_embedded_markers` to compute `consuming_arg_pos` for each embedded marker.
+	local function count_top_level_commas(tok, from_pos, to_pos)
+		local depth  = 0
+		local count  = 0
+		local i      = from_pos
+		while i < to_pos do
+			local c = tok:sub(i, i)
+			if c == "'" or c == '"' then
+				local next_pos = M.skip_str_or_cmt(tok, i)
+				i = (next_pos > i) and next_pos or (i + 1)
+			elseif c == "/" and tok:sub(i + 1, i + 1) == "/" then
+				-- line comment: skip to end of line
+				local nl = tok:find("\n", i, true)
+				i = (nl and nl + 1) or (#tok + 1)
+			elseif c == "/" and tok:sub(i + 1, i + 1) == "*" then
+				-- block comment: skip to matching */
+				local close = tok:find("*/", i + 2, true)
+				i = (close and close + 2) or (#tok + 1)
+			elseif c == "(" then
+				depth = depth + 1
+				i = i + 1
+			elseif c == ")" then
+				depth = depth - 1
+				i = i + 1
+			elseif c == "," and depth == 0 then
+				count = count + 1
+				i = i + 1
+			else
+				i = i + 1
+			end
+		end
+		return count
+	end
+
+	-- Find the position of the consuming instruction's open paren (the `(` that starts the consuming instruction's argument list).
+	-- Returns nil if the token's leading text isn't an ident followed by `(` (e.g. the ident is at the start of a non-instruction token).
+	local function find_consuming_paren(tok)
+		local i = 1
+		while i <= #tok do
+			local c = tok:sub(i, i)
+			if    c == "(" then return i end
+			if not c:match("[%w_]") and c ~= " " then return nil end
+			i = i + 1
+		end
+		return nil
+	end
+
+	local function emit_embedded_markers(tok, tok_line, consuming_encoder)
+		-- When called with a non-nil `consuming_encoder`, the marker is nested inside that instruction's argument list.
+		-- We compute each marker's arg position by counting top-level commas between the consuming instruction's `(` and the marker's start.
+		local consuming_paren = nil
+		if consuming_encoder then consuming_paren = find_consuming_paren(tok) end
 		local pos = 1
 		while pos <= #tok do
-			-- trim leading whitespace and comments before each scan.
+			-- Trim leading whitespace and comments before each scan.
 			pos = M.skip_ws_and_cmt(tok, pos)
 			if pos > #tok then break end
 			local  ident, after = M.read_ident(tok, pos)
 			if not ident then
-				-- not an ident: token is a string or comment; skip or one-step.
+				-- Not an ident: token is a string or comment; skip or one-step.
 				local next_pos = M.skip_str_or_cmt(tok, pos)
 				pos = (next_pos > pos) and next_pos or (pos + 1)
 				goto continue_loop
 			end
 			if ident ~= "atom_label" and ident ~= "atom_offset" then
-				-- ordinary ident; nothing to emit, step past the ident only.
+				-- Ordinary ident; nothing to emit, step past the ident only.
 				pos = after
 				goto continue_loop
 			end
-			-- marker ident: parse the (...) arguments.
+			-- Marker ident: parse the (...) arguments.
 			local open               = M.skip_ws_and_cmt(tok, after)
 			local inner, after_paren = M.read_parens(tok, open)
 			if not inner then
-				-- (...) unreadable: fall back to non-marker behavior.
+				-- (...) Unreadable: fall back to non-marker behavior.
 				pos = after
 				goto continue_loop
 			end
-			-- commit: label takes 1 arg, offset takes 2.
+			-- Commit: label takes 1 arg, offset takes 2.
+			-- For embedded markers, propagate the consuming_encoder + the marker's arg position
+			-- (1-based) so `passes/offsets.lua` can dispatch per-consuming-instruction offset encoding.
+			-- Top-level markers (no consuming_encoder) get nil for both — the offsets pass treats
+			-- them as branch-equivalent for backward compatibility.
+			local arg_pos = nil
+			if consuming_encoder and consuming_paren then
+				arg_pos = count_top_level_commas(tok, consuming_paren + 1, pos) + 1
+			end
 			local args = split_top_level_args(inner)
-			if ident == "atom_label" then emit_marker("label",  args[1] or "", nil,           tok_line) 
-			else                          emit_marker("offset", args[1] or "", args[2] or "", tok_line)
+			if ident == "atom_label" then emit_marker("label",  args[1] or "", nil,           tok_line, nil, nil, consuming_encoder, arg_pos)
+			else                          emit_marker("offset", args[1] or "", args[2] or "", tok_line, nil, nil, consuming_encoder, arg_pos)
 			end
 			pos = after_paren
 			::continue_loop::
@@ -2276,7 +2353,6 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 		next_inv_id = next_inv_id + 1
 		-- Invocation-level debug_skip stamp: Emission pass owns `atom.paths.invocations[*].debug_skip`.
 		-- The stamp is resolved from the `corpus.components[name]` registry (passed in via `ctx_table.components` by `emission_model.run`), 
-		-- NOT from a parallel skip map, source-text re-parse, or second pass over `invocations`.
 		-- Unmarked components stamp `false` (not `nil`) so consumers can dispatch on the boolean without nil checks.
 		--
 		-- The walker has already found the component body in `ctx_table.component_index[component_name]`, so the matching entry MUST exist in `ctx_table.components[component_name]`
@@ -2347,7 +2423,6 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 	end
 
 	-- Resolve the per-token word count. If unresolved, surface ONE warning
-	-- (NOT an error; the build does not fail-loud on an uncounted opaque word)
 	-- and fall back to 1 opaque word so the cycle budget still accounts for the slot.
 	local function resolve_count(ident, tok_line)
 		local wc = ctx_table.word_counts
@@ -2371,10 +2446,10 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 	end
 
 	-- Recursive walker: walk one body entry, possibly descending into components.
-	-- `walk_parent_inv_id` is the invocation ID of the enclosing call (0 for the root call).
-	-- `walk_root_call_text` is the outermost `mac_X(...)` token text (preserved across recursion).
-	-- `walk_immediate_call_text` is the IMMEDIATE outer `mac_X(...)` token text for words emitted in this body — nil for the root atom body.
-	-- The two trackers are propagated as separate parameters so words deep inside nested expansions correctly identify both their immediate call site and the outermost call site.
+	-- walk_parent_inv_id:       Invocation ID of the enclosing call (0 for the root call).
+	-- walk_root_call_text:      Outermost `mac_X(...)` token text (preserved across recursion).
+	-- walk_immediate_call_text: IMMEDIATE outer `mac_X(...)` token text for words emitted in this body — nil for the root atom body.
+	-- Two trackers are propagated as separate parameters so words deep inside nested expansions correctly identify both their immediate call site and the outermost call site.
 	local function walk_body_entry(body_entry, walk_parent_inv_id,
 		walk_root_call_text, walk_immediate_call_text)
 		local tokens     = body_entry.body_tokens or {}
@@ -2391,8 +2466,18 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 			local _, args  = token_ident_and_args(tok)
 			local tok_line = line_of(body_off + bt.rel) or 0
 			-- embedded markers live only in non-marker tokens.
-			if ident ~= "atom_label" and ident ~= "atom_offset" then emit_embedded_markers(tok, tok_line) end
+			-- Pass `ident` as the consuming instruction so `emit_embedded_markers` can compute each marker's arg position + record the consuming_encoder for the offsets pass.
+			-- Canonicalize `jump_rel` to `branch_equal` (its preprocessor-expanded form) so the `consuming_encoder` metadata in marker records is canonical. 
+			-- `jump_rel`: unconditional jump alias from `code/duffle/mips.h`.
+			local consuming_encoder_for_markers = (ident == "jump_rel") and "branch_equal" or ident
+			if ident ~= "atom_label" and ident ~= "atom_offset" then
+				emit_embedded_markers(tok, tok_line, consuming_encoder_for_markers)
+			end
 			-- atom_label / atom_offset: terminal markers, no further descent.
+			-- Top-level markers (the marker IS the entire token) have no consuming instruction;
+			-- nil for both `consuming_encoder` and `consuming_arg_pos`.
+			-- The offsets pass treats these as branch-equivalent for backward compatibility.
+			-- TODO(Ed): Review this don't want legacy cruft here..
 			if     ident == "atom_label"  then emit_marker("label",  args[1] or "", nil,           tok_line); return
 			elseif ident == "atom_offset" then emit_marker("offset", args[1] or "", args[2] or "", tok_line); return
 			end
@@ -2402,7 +2487,7 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 				if comp then
 					local invocation_root_call_text = walk_root_call_text or tok
 					if ctx_table.visiting[bare] then
-						-- cycle: still allocate inv_id, emit zero-width begin/end, record the cycle error; do NOT recurse.
+						-- Cycle: still allocate inv_id, emit zero-width begin/end, record the cycle error; do NOT recurse.
 						local inv = emit_invoke_begin(comp.kind or "comp_bare", bare, tok, invocation_root_call_text, def_source, tok_line)
 						inv.parent_id = walk_parent_inv_id
 						inv.call_text = tok
@@ -2417,14 +2502,14 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 						emit_invoke_end(inv)
 						return
 					end
-					-- first visit: descend + count + count_mismatch-check below.
+					-- First visit: descend + count + count_mismatch-check below.
 					ctx_table.visiting[bare] = true
 					local inv = emit_invoke_begin(comp.kind or "comp_bare", bare, tok, invocation_root_call_text, def_source, tok_line)
 					inv.parent_id = walk_parent_inv_id
 					inv.call_text = tok
 					inv.def_path  = comp.source
 					inv.def_line  = comp.declaration
-					-- propagate trackers into the recursive walk:
+					-- Propagate trackers into the recursive walk:
 					--   immediate_call_text = this call's tok (the IMMEDIATE outer call for words emitted in this body)
 					--   root_call_text      = the OUTERMOST call (immutable across the recursion)
 					walk_body_entry({
@@ -2439,7 +2524,7 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 						tok)
 					ctx_table.visiting[bare] = nil
 					emit_invoke_end(inv)
-					-- count `word` items inside [start_word, end_word].
+					-- Count `word` items inside [start_word, end_word].
 					local wc_inside = 0
 					for i = inv.start_word, inv.end_word do
 						local it = items[i]
@@ -2465,8 +2550,8 @@ local function _project_emission_inner(root_body_entry, ctx_table)
 				end
 				-- mac_X NOT in component_index: fall through to opaque emit.
 			end
-			-- direct encoder, or mac_X-without-component: resolve count + emit n words.
-			-- resolve_count may emit a warning if the count is unresolved.
+			-- Direct encoder, or mac_X-without-component: resolve count + emit n words.
+			-- Resolve_count may emit a warning if the count is unresolved.
 			local n         = resolve_count(ident, tok_line)
 			local out_ident = (ident == "nop2") and "nop" or ident
 			for _ = 1, n do

scripts/duffle_paths.lua

@@ -47,8 +47,7 @@ local function find_repo_root()
 	return root
 end
 
---- Set `package.path` (for `require("duffle")` + `require("passes.X")`) and
---- `package.cpath` (for `lpeg.dll`).
+--- 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). 

scripts/elf32.lua

@@ -0,0 +1,418 @@
+-- elf32.lua — Pure-Lua ELF32 format helpers with no lfs / no lpeg dependency.
+-- The reload helper's `parse_manifest` (scripts/pcsx_debug_helper/reload.lua) 
+-- and the metaprogram's `read_elf_sections` + `read_nm` (scripts/elf_dwarf.lua)
+-- both parsed ELF32 headers from wire bytes.
+--
+-- This module contains the format constants and the byte-level walker.
+--- The metaprogram side keeps `read_u32_le` / `read_u16_le` as local forwarders; the helper side calls `E.*` directly.
+--
+-- **Adapter contract (explicit pass style):**
+-- The helper VM's `Support.File` exposes byte-read methods that require `self` (fileffi.lua:225-227),
+-- so callers wrap once in a 1-line adapter that strips `self`.
+-- The parsers here operate on the unwrapped form.
+-- Reads are flat function calls — `E.read_u8(adapter, off)`, `E.read_u32(adapter, off)`, `E.size(adapter)`.
+--   read_u8(adapter, off)   -> integer | nil
+--   read_u16(adapter, off)  -> integer | nil
+--   read_u32(adapter, off)  -> integer | nil
+--   size(adapter)           -> integer
+--
+-- **Convention:** every offset in the constants tables is a zero-based wire offset.
+-- The `+ 1` conversion happens only at the `string.byte` boundary inside the readers.
+--
+-- spec: System V ABI gABI v1.2 §"ELF Header" (Table 1) + §"Section Header Table"
+-- spec: System V ABI gABI v1.2 §"Symbol Table" (Elf32_Sym layout)
+
+local M = {}
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Little-endian readers (bit-weighted accumulator, math.floor only)
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Read a 4-byte little-endian unsigned integer from `adapter` at zero-based wire offset `off`.
+---
+--- Bit 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; byte 2 by 16; byte 3 by 24.
+---
+--- math.floor (not LuaJIT's `>>`) keeps the body portable across LuaJIT 2.0/2.1 and plain Lua 5.x. `string.byte` receives `+ 1` at the boundary.
+---
+--- **Call form:** explicit-pass. The reader receives `adapter` as the first positional argument and the offset as the second; no `self` is passed.
+--- Test fixtures declare `function(offset) ... end` and the parsers call them via dot syntax `adapter.read_u8_at(off)`.
+--- The colon form `adapter:read_u8_at(off)` would prepend the adapter table as `offset` and break the contract.
+--- @param adapter table
+--- @param off     integer  -- zero-based wire offset
+--- @return integer|nil
+function M.read_u32(adapter, off)
+	return adapter.read_u8_at(off)
+		+ adapter.read_u8_at(off + 0x01) * 0x00000100
+		+ adapter.read_u8_at(off + 0x02) * 0x00010000
+		+ adapter.read_u8_at(off + 0x03) * 0x01000000
+end
+
+--- Read a 2-byte little-endian unsigned integer from `adapter` at zero-based wire offset `off`.
+--- @param adapter table
+--- @param off integer  -- zero-based wire offset
+--- @return integer|nil
+function M.read_u16(adapter, off)
+	return adapter.read_u8_at(off)
+		+ adapter.read_u8_at(off + 0x01) * 0x00000100
+end
+
+--- Read a 1-byte unsigned integer from `adapter` at zero-based wire offset `off`.
+--- @param adapter table
+--- @param off integer  -- zero-based wire offset
+--- @return integer|nil
+function M.read_u8(adapter, off)
+	return adapter.read_u8_at(off)
+end
+
+--- Total adapter byte length.
+--- @param adapter table
+--- @return integer
+function M.size(adapter)
+	return adapter.read_size()
+end
+
+--- Forwarders kept for backward compat with scripts/elf_dwarf.lua.
+--- The metaprogram side keeps `read_u32_le` / `read_u16_le`;
+--- both layers now use the same byte-level helpers under the hood.
+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`.
+--- @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
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Format constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- ELF format constants (System V ABI gABI v1.2).
+M.ELFCLASS32  = 1    -- spec: gABI v1.2 §"ELF Header" — EI_CLASS byte
+M.ELFDATA2LSB = 1    -- spec: gABI v1.2 §"ELF Header" — EI_DATA byte
+M.EM_MIPS     = 8    -- spec: gABI v1.2 §"Machine Information" — MIPS architecture
+
+-- Section type constants (System V ABI gABI v1.2 §"Section Header Table").
+M.SHT_SYMTAB = 2     -- spec: gABI v1.2 §"Section Types" — symbol table
+M.SHT_STRTAB = 3     -- spec: gABI v1.2 §"Section Types" — string table
+M.SHT_NOBITS = 8     -- spec: gABI v1.2 §"Section Types" — no space in file
+
+-- Section flag constants (System V ABI gABI v1.2 §"Section Header Table").
+M.SHF_WRITE     = 0x1 -- spec: gABI v1.2 §"Section Attributes" — writable
+M.SHF_ALLOC     = 0x2 -- spec: gABI v1.2 §"Section Attributes" — occupies memory
+M.SHF_EXECINSTR = 0x4 -- spec: gABI v1.2 §"Section Attributes" — executable
+
+-- ---------------------------------------------------------------------------
+-- ELF32 header layout (System V ABI gABI v1.2 §"ELF Header" Table 1)
+-- ---------------------------------------------------------------------------
+-- All offsets are zero-based wire offsets. The header is 52 bytes total (header_bytes = 0x34 = 52).
+M.ELF32_HEADER = {
+	magic_offset         = 0x00,  -- 4 bytes; expected "\127ELF"
+	magic                = "\127ELF",
+	class_offset         = 0x04,  -- 1 byte;  1 = ELF32, 2 = ELF64
+	endian_offset        = 0x05,  -- 1 byte;  1 = little-endian, 2 = big-endian
+	header_bytes         = 0x34,  -- ELF32 header is 52 bytes total
+	e_entry_offset       = 0x18,  -- 4-byte LE; entry-point virtual address
+	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
+}
+
+-- ---------------------------------------------------------------------------
+-- ELF32 section-header layout (System V ABI gABI v1.2 §"Section Header Table")
+-- ---------------------------------------------------------------------------
+-- Each entry is 40 bytes (sh_entsize_bytes = 0x28 = 40);
+-- zero-based, field offsets relative to the start of the entry.
+M.ELF32_SECTION = {
+	sh_name_offset    = 0x00,  -- 4-byte LE; offset into .shstrtab
+	sh_type_offset    = 0x04,  -- 4-byte LE; section type (SHT_*)
+	sh_flags_offset   = 0x08,  -- 4-byte LE; section flags (SHF_*)
+	sh_addr_offset    = 0x0C,  -- 4-byte LE; virtual address at execution
+	sh_offset_offset  = 0x10,  -- 4-byte LE; section's file offset
+	sh_size_offset    = 0x14,  -- 4-byte LE; section's size in bytes
+	sh_link_offset    = 0x18,  -- 4-byte LE; link to a related section
+	sh_entsize_bytes  = 0x28,  -- spec: gABI v1.2 §"Section Header Table" — 40 bytes per entry
+}
+
+-- ---------------------------------------------------------------------------
+-- ELF32 symbol-table entry layout (System V ABI gABI v1.2 §"Symbol Table")
+-- ---------------------------------------------------------------------------
+-- Each entry is 16 bytes (sym_entry_bytes = 0x10 = 16);
+-- zero-based, field offsets relative to the start of the entry.
+M.ELF32_SYM = {
+	st_name          = 0x00,  -- 4-byte LE; offset into the linked string table
+	st_value         = 0x04,  -- 4-byte LE; symbol value (address / absolute)
+	st_size          = 0x08,  -- 4-byte LE; symbol size in bytes
+	st_info          = 0x0C,  -- 1 byte;  binding (high nibble) + type (low nibble)
+	sym_entry_bytes  = 0x10,  -- spec: gABI v1.2 §"Symbol Table" — 16 bytes per entry
+}
+
+-- DWARF32 initial-length terminator (DWARF4 §7.4) — kept here so the metaprogram's elf_dwarf.lua can drop its own copy of the same constant.
+M.dw_dwarf32_terminator = 0xFFFFFFFF
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Adapter validation
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Validate that `adapter` exposes the byte-read surface.
+--- Returns true on success, false + a stable error code on failure.
+--- The helper side calls this before parse_manifest to reject callers before any byte is read.
+--- @param adapter any
+--- @return boolean, string|nil
+function M.validate_adapter(adapter)
+	if type(adapter) ~= "table" then return false, "bad_file_adapter" end
+	if type(adapter.read_u8_at)  ~= "function" then return false, "bad_file_adapter" end
+	if type(adapter.read_u16_at) ~= "function" then return false, "bad_file_adapter" end
+	if type(adapter.read_u32_at) ~= "function" then return false, "bad_file_adapter" end
+	if type(adapter.read_size)   ~= "function" then return false, "bad_file_adapter" end
+	return true, nil
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- String-table reader
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Extract a NUL-terminated C string from `strtab` at zero-based offset `off`.
+--- Returns nil if `off` is out of range or the string is not NUL-terminated.
+--- @param strtab string
+--- @param off integer
+--- @return string|nil
+function M.get_str(strtab, off)
+	if off < 0 or off >= #strtab then return nil end
+	local  end_pos = strtab:find("\0", off + 1, true)
+	if not end_pos then return nil end
+	return strtab:sub(off + 1, end_pos - 1)
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Header / section / symbol walkers
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Read the ELF32 header through `adapter` and validate the magic, class, and data encoding.
+--- Returns a table on success:
+---   { e_entry, e_shoff, e_shentsize, e_shnum, e_shstrndx, error = nil }
+--- On failure returns nil + a stable error code:
+---   bad_magic, unsupported_elf_class, unsupported_elf_data, truncated_header
+--- The header's machine field is NOT validated here — callers (e.g. the helper's prime path) decide whether to require EM_MIPS before symbol reads.
+--- @param adapter table
+--- @return table|nil, string|nil
+function M.parse_elf32_headers(adapter)
+	local  ok, err = M.validate_adapter(adapter)
+	if not ok then return nil, err end
+
+	-- 4-byte magic: 0x7F 'E' 'L' 'F'.
+	-- The byte readers take the adapter explicitly.
+	-- The production `Support.File` adapter is wrapped by the caller to drop its implicit `self` so the parser shape is flat pass-style.
+	local b1 = M.read_u8(adapter, 0)
+	local b2 = M.read_u8(adapter, 1)
+	local b3 = M.read_u8(adapter, 2)
+	local b4 = M.read_u8(adapter, 3)
+	if not (b1 and b2 and b3 and b4)
+		or not (b1 == 0x7f and b2 == 0x45 and b3 == 0x4c and b4 == 0x46) then
+		return nil, "bad_magic"
+	end
+
+	local class = M.read_u8(adapter, M.ELF32_HEADER.class_offset)
+	if    class ~= M.ELFCLASS32 then
+		return nil, "unsupported_elf_class"
+	end
+
+	local data = M.read_u8(adapter, M.ELF32_HEADER.endian_offset)
+	if    data ~= M.ELFDATA2LSB then
+		return nil, "unsupported_elf_data"
+	end
+
+	local e_entry     = M.read_u32(adapter, M.ELF32_HEADER.e_entry_offset)
+	local e_shoff     = M.read_u32(adapter, M.ELF32_HEADER.e_shoff_offset)
+	local e_shentsize = M.read_u16(adapter, M.ELF32_HEADER.e_shentsize_offset)
+	local e_shnum     = M.read_u16(adapter, M.ELF32_HEADER.e_shnum_offset)
+	local e_shstrndx  = M.read_u16(adapter, M.ELF32_HEADER.e_shstrndx_offset)
+	if not (e_entry and e_shoff and e_shentsize and e_shnum and e_shstrndx) then
+		return nil, "truncated_header"
+	end
+
+	return {
+		e_entry     = e_entry,
+		e_shoff     = e_shoff,
+		e_shentsize = e_shentsize,
+		e_shnum     = e_shnum,
+		e_shstrndx  = e_shstrndx,
+		error       = nil,
+	}
+end
+
+--- Read one section-header entry from `adapter` at `sh_off`.
+--- Returns a table with the wire fields plus a (yet-unresolved) `name` field.
+--- @param adapter table
+--- @param sh_off  integer
+--- @return table|nil, string|nil  -- entry, error
+local function read_section_entry(adapter, sh_off)
+	local entry = {
+		sh_name   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_name_offset),
+		sh_type   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_type_offset),
+		sh_flags  = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_flags_offset),
+		sh_addr   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_addr_offset),
+		sh_offset = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_offset_offset),
+		sh_size   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_size_offset),
+		sh_link   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_link_offset),
+		name      = "",
+	}
+	if not (entry.sh_name and entry.sh_type and entry.sh_flags and entry.sh_addr
+		and entry.sh_offset and entry.sh_size and entry.sh_link) then
+		return nil, "truncated_section_headers"
+	end
+	return entry, nil
+end
+
+--- Walk every section header in `hdr` and return a 1-based array of entries
+--- (the section at logical index 0 is at array position 1, etc.).
+--- Each entry has the wire fields plus a resolved `name` derived from `.shstrtab`.
+--- Returns nil + a stable error code on failure: truncated_section_headers, missing_shstrtab, truncated_strtab
+--- @param adapter table
+--- @param hdr     table  -- the table returned by parse_elf32_headers
+--- @return table|nil, string|nil
+function M.walk_sections(adapter, hdr)
+	if not hdr or hdr.error then return nil, hdr and hdr.error or "truncated_section_headers" end
+
+	local file_size = M.size(adapter)
+	if hdr.e_shoff + hdr.e_shnum * hdr.e_shentsize > file_size then
+		return nil, "truncated_section_headers"
+	end
+
+	-- Read every section header first; we need .shstrtab to resolve names.
+	local sections = {}
+	for i = 0, hdr.e_shnum - 1 do
+		local sh_off = hdr.e_shoff + i * hdr.e_shentsize
+		local entry, err = read_section_entry(adapter, sh_off)
+		if not entry then return nil, err end
+		sections[i + 1] = entry
+	end
+
+	if hdr.e_shstrndx >= hdr.e_shnum then
+		return nil, "missing_shstrtab"
+	end
+
+	local  shstrtab = sections[hdr.e_shstrndx + 1]
+	if not shstrtab or shstrtab.sh_type ~= M.SHT_STRTAB then
+		return nil, "missing_shstrtab"
+	end
+	if shstrtab.sh_offset + shstrtab.sh_size > file_size then
+		return nil, "truncated_section_headers"
+	end
+	local  shstrtab_bytes = M.read_section_bytes(adapter, shstrtab)
+	if not shstrtab_bytes then return nil, "truncated_section_headers" end
+
+	for _, s in ipairs(sections) do
+		s.name = M.get_str(shstrtab_bytes, s.sh_name) or ""
+	end
+
+	return sections, nil
+end
+
+--- Read the bytes of one section. Returns a string, or nil if the adapter returns nil for any byte (out-of-bounds).
+--- The caller is responsible fors sizing the buffer (the section's sh_offset + sh_size must fit in adapter.size).
+--- @param adapter table
+--- @param section table  -- one entry from walk_sections
+--- @return string|nil
+function M.read_section_bytes(adapter, section)
+	local size = section.sh_size
+	if    size == 0 then return "" end
+	local out = {}
+	for i = 0, size - 1 do
+		local b = M.read_u8(adapter, section.sh_offset + i)
+		if    b == nil then return nil end
+		out[#out + 1] = string.char(b)
+	end
+	return table.concat(out)
+end
+
+--- Convenience: walk sections, then look up the named section, then read its bytes.
+--- Returns nil + a stable error code if the section is absent or out-of-bounds.
+--- @param adapter  table
+--- @param sections table  -- 1-based array from walk_sections
+--- @param name     string
+--- @return string|nil, string|nil
+function M.read_named_section(adapter, sections, name)
+	if not sections then return nil, "missing_section" end
+	for _, s in ipairs(sections) do
+		if   s.name == name then
+			local bytes = M.read_section_bytes(adapter, s)
+			if not bytes then return nil, "truncated_section_data" end
+			return bytes, nil
+		end
+	end
+	return nil, "missing_section"
+end
+
+--- Walk every SHT_SYMTAB section in `sections` and accumulate symbols by name.
+--- Each stored entry is `{ value = st_value, size = st_size, info = st_info, shndx = st_shndx }`.
+--- Both STB_LOCAL and STB_GLOBAL symbols are included; the live ELF stores `smem` as a local symbol.
+--- Returns nil + a stable error code on failure: missing_symtab_strtab, truncated_section_headers
+--- @param adapter  table
+--- @param sections table
+--- @return table|nil, string|nil
+function M.collect_symbols(adapter, sections)
+	if not sections then return nil, "missing_sections" end
+	local symbols = {}
+	local file_size = M.size(adapter)
+	for _, s in ipairs(sections) do
+		if s.sh_type == M.SHT_SYMTAB then
+			local  strtab = sections[s.sh_link + 1]
+			if not strtab or strtab.sh_type ~= M.SHT_STRTAB then
+				return nil, "missing_symtab_strtab"
+			end
+			if strtab.sh_offset + strtab.sh_size > file_size then
+				return nil, "truncated_section_headers"
+			end
+			local  strtab_bytes = M.read_section_bytes(adapter, strtab)
+			if not strtab_bytes then return nil, "truncated_section_headers" end
+			if s.sh_offset + s.sh_size > file_size then
+				return nil, "truncated_section_headers"
+			end
+			local  symtab_bytes = M.read_section_bytes(adapter, s)
+			if not symtab_bytes then return nil, "truncated_section_headers" end
+			local n = #symtab_bytes / M.ELF32_SYM.sym_entry_bytes
+			for j = 0, n - 1 do
+				local e = s.sh_offset + j * M.ELF32_SYM.sym_entry_bytes
+				local st_name  = M.read_u32(adapter, e + M.ELF32_SYM.st_name)
+				if    st_name then
+					local st_value = M.read_u32(adapter, e + M.ELF32_SYM.st_value)
+					local st_size  = M.read_u32(adapter, e + M.ELF32_SYM.st_size)
+					local st_info  = M.read_u8(adapter, e + M.ELF32_SYM.st_info)
+					-- st_shndx is at offset 14 (2 bytes) — derived from the layout
+					-- the metaprogram reads too. Inline the read to keep the
+					-- adapter as the only I/O surface.
+					local b1 = M.read_u8(adapter, e + 14)
+					local b2 = M.read_u8(adapter, e + 15)
+					if not (b1 and b2) then
+						return nil, "truncated_section_headers"
+					end
+					local st_shndx = b1 + b2 * 0x100
+					local name = M.get_str(strtab_bytes, st_name) or ""
+					if    name ~= "" then
+						symbols[name] = {
+							value = st_value,
+							size  = st_size,
+							info  = st_info,
+							shndx = st_shndx,
+						}
+					end
+				end
+			end
+		end
+	end
+	return symbols, nil
+end
+
+return M

scripts/elf_dwarf.lua

@@ -1,13 +1,8 @@
 --- 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
@@ -16,6 +11,11 @@
 -- lfs is wired into package.cpath by `duffle_paths.lua` (vendored under `toolchain/lfs/lfs.dll`). 
 local lfs = require("lfs")
 
+-- scripts/elf32.lua contains format-constant tables + the byte-level walker.
+-- The this file re-exports `read_u32_le` / `read_u16_le` (and the DWARF32 terminator).
+-- TODO(Ed): Remove re-export.
+local E = require("elf32")
+
 local M = {}
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -104,34 +104,16 @@ 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`).
+--- **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.
 ---
---- ELF/DWARF field offsets are expressed in hex so they map directly to the
---- zero-based byte positions in the binary file.
+--- The ELF32 header / section / sym layout tables are within scripts/elf32.lua.
+--- The metaprogram re-exports the DWARF32 initial-length terminator.
 
-
---- 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
-}
+--- spec: DWARF4 spec §7.4 — 32-bit DWARF initial-length terminator
+M.dw_dwarf32_terminator = E.dw_dwarf32_terminator
+-- TODO(Ed): Remove re-export.
 
 -- ----------------------------------------------------------------------------
 -- DWARF4 .debug_aranges (per DWARF5 spec §7.4 — Address Range Table)
@@ -192,8 +174,7 @@ M.DWARF_LINE_OPS = {
 	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 the line-program header byte sequence.
+	-- opcode_base + line_range are 1-byte header fields; hex so they map directly to the line-program header byte sequence.
 	-- line_base stays signed decimal (=-5) since 0xFB obscures the spec semantics.
 	opcode_base              = 0x0D,
 	line_base                = -5,
@@ -249,37 +230,31 @@ M.DWARF5_DEBUG_LINE = {
 --- 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).
+--- Thin forwarder: the canonical implementation lives in scripts/elf32.lua.
+--- The "second caller lifts" pattern keeps the metaprogram side fluent
+--- (`M.read_u32_le(buf, off)`) while the body is deduped.
 --- @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
+	return E.read_u32_le(buf, off)
 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.)
+--- Thin forwarder — see `M.read_u32_le` for the rationale.
 --- @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
+	return E.read_u16_le(buf, off)
 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
+-- 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
@@ -427,9 +402,9 @@ local function read_form_value(buf, str_buf, pos, form)
 		-- 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.
+		-- 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;
@@ -455,20 +430,20 @@ 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
+--- 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
@@ -577,69 +552,58 @@ function M.read_elf_sections(elf_path, section_names)
 		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")
+	local file_size
+	do
+		f:seek("end", 0)
+		file_size = f:seek("cur", 0)
+	end
+	local adapter = {
+		read_u8_at = function(offset)
+			f:seek("set", offset)
+			local b = f:read(1)
+			if not b then return nil end
+			return b:byte()
+		end,
+		read_u16_at = function(offset)
+			f:seek("set", offset)
+			local b1 = f:read(1)
+			local b2 = f:read(1)
+			if not b1 or not b2 then return nil end
+			return b1:byte() + b2:byte() * 0x100
+		end,
+		read_u32_at = function(offset)
+			f:seek("set", offset)
+			local b1 = f:read(1)
+			local b2 = f:read(1)
+			local b3 = f:read(1)
+			local b4 = f:read(1)
+			if not b1 or not b2 or not b3 or not b4 then return nil end
+			return b1:byte() + b2:byte() * 0x100
+				+ b3:byte() * 0x10000 + b4:byte() * 0x1000000
+		end,
+		read_size = function() return file_size end,
+	}
+
+	-- Delegate the header parse + section walk to E.*.
+	local hdr, hdr_err = E.parse_elf32_headers(adapter)
+	if not hdr then
+		io.stderr:write(string.format("[elf_dwarf.read_elf_sections] header parse failed: %s\n", tostring(hdr_err)))
 		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")
+	local sections, walk_err = E.walk_sections(adapter, hdr)
+	if not sections then
+		io.stderr:write(string.format("[elf_dwarf.read_elf_sections] section walk failed: %s\n", tostring(walk_err)))
 		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)
+	-- Resolve the requested sections.
+	for _, s in ipairs(sections) do
+		if wanted[s.name] then
+			local bytes = E.read_section_bytes(adapter, s)
+			if bytes then result[s.name] = bytes end
 		end
 	end
 
@@ -656,49 +620,87 @@ end
 --- - 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.
+	-- Existence check first; an empty or missing ELF returns an empty map.
+	if lfs.attributes(elf_path, "mode") ~= "file" then
 		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 }
+	local f = io.open(elf_path, "rb")
+	if not f then
+		return addrs
 	end
+
+	-- Build the file adapter for E.*.
+	local file_size
+	do
+		f:seek("end", 0)
+		file_size = f:seek("cur", 0)
 	end
+	local adapter = {
+		read_u8_at = function(offset)
+			f:seek("set", offset)
+			local b = f:read(1)
+			if not b then return nil end
+			return b:byte()
+		end,
+		read_u16_at = function(offset)
+			f:seek("set", offset)
+			local b1 = f:read(1)
+			local b2 = f:read(1)
+			if not b1 or not b2 then return nil end
+			return b1:byte() + b2:byte() * 0x100
+		end,
+		read_u32_at = function(offset)
+			f:seek("set", offset)
+			local b1 = f:read(1)
+			local b2 = f:read(1)
+			local b3 = f:read(1)
+			local b4 = f:read(1)
+			if not b1 or not b2 or not b3 or not b4 then return nil end
+			return b1:byte() + b2:byte() * 0x100
+				+ b3:byte() * 0x10000 + b4:byte() * 0x1000000
+		end,
+		read_size = function() return file_size end,
+	}
+
+	-- Delegate the header + section walk to E.*.
+	local hdr, hdr_err = E.parse_elf32_headers(adapter)
+	if not hdr then
+		io.stderr:write(string.format("[elf_dwarf.read_nm] header parse failed: %s\n", tostring(hdr_err)))
+		f:close()
+		return addrs
+	end
+
+	local sections, walk_err = E.walk_sections(adapter, hdr)
+	if not sections then
+		io.stderr:write(string.format("[elf_dwarf.read_nm] section walk failed: %s\n", tostring(walk_err)))
+		f:close()
+		return addrs
+	end
+
+	-- E.collect_symbols returns every defined symbol (no binding filter).
+	-- The metaprogram then applies its STB_LOCAL / STB_GLOBAL + size>0 filter, matching `nm`'s default (external symbols only).
+	local symbols, sym_err = E.collect_symbols(adapter, sections)
+	if not symbols then
+		io.stderr:write(string.format("[elf_dwarf.read_nm] symbol collection failed: %s\n", tostring(sym_err)))
+		f:close()
+		return addrs
+	end
+
+	f:close()
+
+	for name, entry in pairs(symbols) do
+		-- High nibble of st_info = binding (STB_LOCAL=0, STB_GLOBAL=1, STB_WEAK=2).
+		-- math.floor(/16) is portable across LuaJIT 2.0/2.1 and plain Lua 5.x.
+		local binding = math.floor(entry.info / 16)
+		if (binding == 0 or binding == 1) and entry.size > 0 then
+			addrs[name] = { entry.value, entry.size }
 		end
 	end
 
@@ -836,12 +838,11 @@ end
 ---   * The `.debug_line` section may contain MULTIPLE line-program units
 ---     File indices are 1-based, **per unit**; we concatenate all units and the index ranges from 1..N₁ in unit 1, N₁+1..N₁+N₂ in unit 2, etc.
 ---     Per-unit indices (the way gcc emits them, and the way `DW_LNS_set_file` references them in the line program)
----     are returned via the `basename_to_index` map only when the unit boundary happens to align with the metaprogram's per-atom
----     `inv.call_file` (true today for hello_joypad — the C unit is the LAST unit, and atom-side file indices fit 1-based).
+---     are returned via the `basename_to_index` map only when the unit boundary happens to align with the metaprogram's per-atom `inv.call_file`
 ---   * Per spec, the `.debug_line_str` section (DWARF5 §7.5.6) holds the strings referenced by `DW_FORM_line_strp`.
 ---     The legacy DWARF3 format embeds strings directly with null terminators. This helper handles BOTH.
----   * File entries may have multiple forms (gcc -gdwarf-5 with `DW_LNCT_directory_index`
----     emits 2 forms: path + dir_index). The helper supports:
+---   * File entries may have multiple forms (gcc -gdwarf-5 with `DW_LNCT_directory_index` emits 2 forms: path + dir_index). 
+---     The helper supports:
 ---     - DW_FORM_line_strp (DWARF5; offset into .debug_line_str)
 ---     - DW_FORM_string (DWARF4-compat; inline null-terminated in .debug_line)
 ---     - DW_FORM_udata (ULEB128)
@@ -851,12 +852,9 @@ end
 ---
 --- Behavior on failure: writes to stderr and returns nil.
 --- Helpers consumed by `passes/dwarf_injection.lua::init_file_index_lookup(elf_path)` calls this once at pass start to populate the module-level `basename_to_index` map;
---- downstream `resolve_provenance_file_index(path)` consumers
---- (which replaced the former hardcoded `ATOM_SOURCE_FILE_INDEX` + `PROVENANCE_BASENAME_TO_FILE_INDEX` table per `conductor/tracks/dwarf_file_index_lookup_20260731/`)
---- consult the map directly.
+--- downstream `resolve_provenance_file_index(path)` consumers consult the map directly.
 ---
---- @param elf_path string  -- absolute path to the post-link ELF (typically the gcc-emitted `.elf` BEFORE dwarf_injector's splice;
----                            both shapes work since the splice preserves `.debug_line`)
+--- @param elf_path string  -- absolute path to the post-link ELF (typically the gcc-emitted `.elf` BEFORE dwarf_injector's splice; both shapes work since the splice preserves `.debug_line`)
 --- @return table|nil, table|nil, table|nil
 ---   basename_to_index: { [basename] = 1-based-per-unit-file-index, ... }
 ---   basenames:         { [1-based-per-unit-file-index] = basename, ... }
@@ -894,8 +892,7 @@ function M.read_line_unit_file_table(elf_path)
 			return nil, p + M.DWARF5_DEBUG_LINE.form_data16_bytes
 		else
 			-- Unsupported form in a directory/file-table entry: best-effort skip.
-			-- We do NOT stderr-write because the crt0.s DWARF5 line unit (gcc-as emitted) uses DW_FORM_addr (0x01) for what is effectively a path entry, 
-			-- which is non-standard.
+			-- We do NOT stderr-write because the crt0.s DWARF5 line unit (gcc-as emitted) uses DW_FORM_addr (0x01) for what is effectively a path entry, which is non-standard.
 			-- The C-unit's DWARF3 paths are read via the parallel DWARF3 path and never see this error.
 			-- Callers should consult `basename_to_index` for the paths they care about and ignore this unit if it produced none.
 			return nil, p

scripts/passes/annotation.lua

@@ -22,11 +22,11 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @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
---- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- Directory containing the source
+--- @field basename string  -- Filename without extension
+--- @field scan     table   -- Pre-scanned SourceScan payload (from duffle.scan_source)
 
 --- @class PassCtx
 --- @field sources            SourceFile[]
@@ -45,28 +45,28 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --- @field warnings table[]
 
 --- @class AtomAnnotation
---- @field line    integer       -- source line of the atom_info call
---- @field macro   string        -- the macro name (always "atom_info" in the new shape)
---- @field name    string        -- the atom name
---- @field kind    string        -- always "info"
+--- @field line    integer       -- Source line of the atom_info call
+--- @field macro   string        -- Macro name (always "atom_info" in the new shape)
+--- @field name    string        -- Atom name
+--- @field kind    string        -- Always "info"
 --- @field binds   string|nil    -- Binds_X name if any
 --- @field reads   string[]      -- R_* names (read targets)
 --- @field writes  string[]      -- R_* names (write targets)
---- @field errors  string[]|nil  -- parse-time errors from scan_source (atom_info body malformed)
+--- @field errors  string[]|nil  -- Parse-time errors from scan_source (atom_info body malformed)
 
---- @class DebugSkipMarker  -- sub-shape of scan_source.lua's @class DebugSkipMarker
---- @field marker_kind    string                 -- exact marker ident read from source. Only "atom_dbg_skip" (bare) is positive.
+--- @class DebugSkipMarker  -- Sub-shape of scan_source.lua's @class DebugSkipMarker
+--- @field marker_kind    string                 -- Exact marker ident read from source. Only "atom_dbg_skip" (bare) is positive.
 --- @field marker_line    integer
---- @field args           string|nil             -- trimmed text inside the parens (nil when has_parens is false)
+--- @field args           string|nil             -- Trimmed text inside the parens (nil when has_parens is false)
 --- @field has_parens     boolean
 --- @field is_bare        boolean                -- true iff marker_kind == "atom_dbg_skip" AND has_parens == false (the only positive form)
 --- @field pending        boolean                -- true while awaiting the following declaration
---- @field superseded_by_marker_line integer|nil -- set on a marker that was bumped out of the pending slot
+--- @field superseded_by_marker_line integer|nil -- Set on a marker that was bumped out of the pending slot
 --- @field target_kind    string|nil             -- "atom" | "comp_bare" | "comp_proc" | "unrelated" once observed
 
 --- @class Finding
---- @field line integer -- source line (or 0 for pass-level)
---- @field msg  string  -- finding message
+--- @field line integer -- Source line (or 0 for pass-level)
+--- @field msg  string  -- Finding message
 
 --- @class Findings
 --- @field errors   Finding[]
@@ -74,14 +74,14 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --- @field info     Finding[]
 
 --- @class PipeCtx
---- @field atom_index     table<string, AtomAnnotation> -- name -> AtomAnnotation (only kind=="atom")
---- @field binds_index    table<string, BindsStruct>    -- name -> BindsStruct
---- @field annot_counts   table<string, integer>        -- name -> annotation count (for unique_annotation check)
---- @field types          table<string, RegTypeDefault> -- from scan_source
---- @field atom_views     table<string, AtomViewEntry>  -- from scan_source
---- @field seen_defaults  table<string, integer>        -- duplicate atom_dbg_reg_default detection
+--- @field atom_index     table<string, AtomAnnotation> -- Name -> AtomAnnotation (only kind=="atom")
+--- @field binds_index    table<string, BindsStruct>    -- Name -> BindsStruct
+--- @field annot_counts   table<string, integer>        -- Name -> annotation count (for unique_annotation check)
+--- @field types          table<string, RegTypeDefault> -- From scan_source
+--- @field atom_views     table<string, AtomViewEntry>  -- From scan_source
+--- @field seen_defaults  table<string, integer>        -- Duplicate atom_dbg_reg_default detection
 --- @field seen_field     table<string, integer>        -- Binds_* -> count of fields (set/checked by check_binds_no_duplicate_fields)
---- @field _scan          SourceScan                    -- full scan payload (typed-view sub-calls live here) 
+--- @field _scan          SourceScan                    -- Full scan payload (typed-view sub-calls live here) 
 
 --- @class AnnotatedResult
 --- @field atoms    AtomEntry[]
@@ -95,11 +95,10 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 -- ════════════════════════════════════════════════════════════════════════════
 -- Per-check functions (the CHECK_RULES table's payload)
 -- ════════════════════════════════════════════════════════════════════════════
---
 --- The dispatcher in `validate()` routes each result by convention: existence checks write errors[] and shape checks write warnings[].
 --- `macro_word_drift` writes errors[] for missing or mismatched metadata and info[] for a match.
 
---- Check: every annotated atom must have a matching MipsAtom_(name) declaration.
+--- Check: Every annotated atom must have a matching MipsAtom_(name) declaration.
 --- @param a        AtomAnnotation
 --- @param pipe_ctx PipeCtx
 --- @param findings Findings
@@ -112,8 +111,8 @@ local function check_atom_decl_exists(a, pipe_ctx, findings)
 	end
 end
 
---- Check: every atom may have AT MOST ONE annotation.
---- Post-loop: needs full-corpus `annot_counts` from pipe_ctx.
+--- Check:     Every atom may have AT MOST ONE annotation.
+--- Post-loop: Needs full-corpus `annot_counts` from pipe_ctx.
 --- @param pipe_ctx PipeCtx
 --- @param findings Findings
 local function check_unique_annotation(pipe_ctx, findings)
@@ -146,7 +145,7 @@ end
 --- Check: TAPE_WORDS(mac_X, N) ↔ WORD_COUNT(mac_X, N) drift.
 --- Three outcomes: missing (error), mismatch (error), match (info).
 --- @param m  MacroEntry
---- @param wc table<string, integer> -- the shared word-count table (from ctx.shared.word_counts)
+--- @param wc table<string, integer> -- Shared word-count table (from ctx.shared.word_counts)
 --- @param findings Findings
 local function check_macro_word_drift(m, wc, findings)
 	local  declared = wc[m.name]
@@ -304,7 +303,7 @@ local function check_binds_no_duplicate_fields(_src, pipe_ctx, findings)
 	end
 end
 
--- Check: debug-skip markers must satisfy shape + placement constraints.
+-- Check: Debug-skip markers must satisfy shape + placement constraints.
 --- Walks the priority list once; each marker produces at most one error, so one source defect yields one finding.
 --- Priority order (first defect wins):
 ---   1. marker_kind ~= "atom_dbg_skip" -> legacy/renamed spelling (use `atom_dbg_skip`)
@@ -315,12 +314,11 @@ end
 ---   6. unsupported target_kind     -> marker precedes an unrelated declaration
 --- Valid markers stamp `debug_skip` on whole-atom, bare-component, and proc-component declaration records in scan_source.lua.
 --- @param marker DebugSkipMarker
---- @param _pipe_ctx PipeCtx     -- unused today; kept for plex-shape consistency with per_annot
+--- @param _pipe_ctx PipeCtx     -- Unused; kept for consistency with per_annot // TODO(Ed): Remove?
 --- @param findings Findings
 local function check_skip_marker(marker, _pipe_ctx, findings)
 	local kind = marker.marker_kind
 	local line = marker.marker_line
-
 	-- Left `scan.debug_skip_markers` with production records for `atom_dbg_skip` only; other identifiers take the walker's unrelated branch.
 
 	if marker.has_parens then
@@ -371,8 +369,6 @@ local function check_skip_marker(marker, _pipe_ctx, findings)
 end
 
 --- Warn when a source references an unregistered alias.
----
---- R_TapePtr, R_AtomJmp, R_PrimCursor, R_FaceCursor, R_VertBase, and R_OtBase opt in through `#define atom_reg` in lottes_tape.h.
 --- When a source uses an unregistered R_X, this check emits one pass-level info entry for that source and directs C-ABI register names to explicit alias registration.
 --- @param _src     SourceFile
 --- @param pipe_ctx PipeCtx
@@ -426,8 +422,7 @@ local CHECK_RULES = {
 -- ════════════════════════════════════════════════════════════════════════════
 -- Validation
 -- ════════════════════════════════════════════════════════════════════════════
---
--- Pure check: read from src.scan, run validations, emit findings. The scan was done once upstream.
+-- Pure check: Read from src.scan, run validations, emit findings. The scan was done once upstream.
 
 --- Builds one pass-wide pipe_ctx from the merged `corpus.*` registries and source-ordered `corpus.atom_infos`; per-source declarations and bodies remain in `src.scan`.
 --- The module ownership contract above requires callers to construct `ctx.shared.corpus` through `build_ctx`; the error message below enforces that gate.
@@ -473,7 +468,7 @@ end
 --- Validate one source against its pre-scanned SourceScan payload + the corpus-wide pipe_ctx.
 --- @param ctx             PassCtx
 --- @param src             SourceFile
---- @param corpus_pipe_ctx PipeCtx|nil  -- built once per pass from corpus registries; nil builds the same projection here.
+--- @param corpus_pipe_ctx PipeCtx|nil  -- Built once per pass from corpus registries; nil builds the same projection here.
 --- @return AnnotatedResult
 local function validate(ctx, src, corpus_pipe_ctx)
 	corpus_pipe_ctx = corpus_pipe_ctx or build_corpus_pipe_ctx(ctx)
@@ -503,14 +498,8 @@ local function validate(ctx, src, corpus_pipe_ctx)
 	end
 
 	-- Build a per-source pipe_ctx: shared lookups come from `corpus_pipe_ctx`, while declarations, bodies, types, views, defaults, and occurrences come from `src.scan`.
-	local seen_defaults = {}
-	for reg, _ in pairs(scan.types or {}) do
-		seen_defaults[reg] = (seen_defaults[reg] or 0) + 1
-	end
-	local atom_infos_list = {}
-	for _, ai in ipairs(scan.atom_infos or {}) do
-		atom_infos_list[#atom_infos_list + 1] = ai
-	end
+	local seen_defaults   = {}; for reg, _ in pairs (scan.types      or {}) do seen_defaults[reg] = (seen_defaults[reg] or 0) + 1 end
+	local atom_infos_list = {}; for _, ai  in ipairs(scan.atom_infos or {}) do atom_infos_list[#atom_infos_list + 1] = ai         end
 
 	local pipe_ctx = {
 		atom_index               = {},

scripts/passes/atoms_source_map.lua

@@ -1,8 +1,8 @@
 --- 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>`).
+--- `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.
@@ -28,7 +28,6 @@
 ---   ...
 ---   ENDATOM
 ---   ```
----
 --- Marker records are zero-width in `atom.paths.items`, so they emit no WORD rows in the dense word view.
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -95,8 +94,8 @@ 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).
+--- 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
@@ -105,20 +104,17 @@ 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)
+			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)
+			lines[#lines + 1] = string.format("WORD %d  CALL %s:%d  RAW", entry.pos, rel_path, entry.line)
 		end
 	end
 
@@ -248,9 +244,10 @@ local function build_atom_table(ctx)
 	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.
+--- 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.
@@ -395,8 +392,7 @@ local function append_gdb_commands(lines, matched)
 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.
+--- 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

scripts/passes/auto_reg.lua

@@ -0,0 +1,355 @@
+--- passes/auto_reg.lua — Per-phase automatic GPR allocator + gen/auto_reg.h emitter.
+---
+--- Reads the per-source + corpus-level `atom_auto_regs` + `phase_auto_regs` registries populated by `passes/scan_source.lua`.
+--- Runs a deterministic first-fit allocator in the `R_T0..R_T7 + R_V0..R_V1` pool (10 physical GPRs).
+--- Emits one `#define R_<Sym>_Code R_Tn_Code` per marker into per-directory `gen/auto_reg.h`.
+---
+--- User-pinned GPRs : The corpus's `register_alias_registry` is consulted to exclude GPRs the user has pinned via 
+--- `atom_reg` + `_Code` defs (e.g. carriers like `R_ResolveScratch = R_T4 atom_reg`). 
+--- These GPRs are unavailable to EVERY atom's source pool.
+--- Carriers are preserved across atoms by context discipline and must never be reallocated.
+--- Per-atom body parsing also catches alias references (R_<Alias>) and hardcoded R_Tn references,
+--- so the user can write either `R_T4` or `R_ResolveScratch` in an atom body and the pass will
+--- exclude R_T4 from that atom's pool.
+---
+--- Conflict detection: If the user hardcodes `R_Tn` in an atom body that shares a phase with an auto-reg that picked `R_Tn`,
+--- emit `phase_register_clash` as an info finding (no build stop).
+--- Should be unreachable after the user-pinning + body-parsing fix above; kept as a defensive safety net.
+---
+--- Pool exhaustion: If a phase declares more `R_<Sym>` mappings than the 10-register pool can hold,
+--- emit `phase_register_pool_exhausted` as a build-stopping error.
+
+--- @class AutoRegResult
+--- @field outputs  table[]  -- {kind=, path=} entries
+--- @field errors   table[]  -- {line=, msg=}  entries (build-stops)
+--- @field warnings table[]  -- {line=, msg=}  entries (build-continues)
+
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+--- ════════════════════════════════════════════════════════════════════════════
+--- THE GPR ALLOCATION POOL — what is allocatable, and (more importantly) WHY
+--- ════════════════════════════════════════════════════════════════════════════
+---
+--- The auto-reg pass picks physical GPRs for `atom_auto_reg(...)` / `phase_auto_reg(...)` markers.
+--- It allocates from a FIXED 10-register pool.
+--- This comment block makes the inclusion AND exclusion criteria obvious so a reader doesn't have 
+--- to grep lottes_tape.h + mips.h to understand the design.
+---
+--- ── WHAT'S IN THE POOL (10 GPRs, all caller-trash per the O32 ABI) ────────
+---     R_T0..R_T7  (GPR codes 8..15), R_V0..R_V1 (GPR codes 2..3)  
+---      The workhorse of every atom body. The uesr should be aware of atom allocation across atoms they chain. 
+---      If they have a collision it means either they didn't saturate the register file optimally for a phase,
+---      or the may have made the workload to large for the run.
+---
+--- ── WHAT'S NOT IN THE POOL — and WHY (the "obvious exclusions") ────────────
+---   R_T9  (GPR code 25)  — R_TapePtr, the tape instruction stream pointer.
+---     Owned by the tape runtime (in tape_run / tape_run_a02_s07).
+---     `rgcc(R_TapePtr)` register-variable ties the C compiler's view to $t9 across the whole tape_run.
+---     The auto-reg pass MUST NOT clobber this; doing so would desync the C-side tape pointer from the
+---     hardware pointer and crash on the next tape_run.
+---
+---   R_T8  (GPR code 24)  — R_AtomJmp, the atom-jump register used by the 4-word yield handshake.
+---     Every `mac_yield()` / `mac_yield_tail` does `load_word R_AtomJmp, R_TapePtr, 0` then
+---     `jump_reg R_AtomJmp`. The auto-reg pass MUST NOT clobber this either, or the atom dispatcher breaks.
+---     Owned by the tape runtime, same family as R_TapePtr.
+---
+---   R_AT  (GPR code 1)   — Assembler temporary. Reserved by the MIPS O32 ABI for pseudoinstruction expansion
+---     (lottes_tape.h:86, mips.h:93). The ISA's psuedo instructions use it as a scratch temporary.
+---
+---   R_A0..A3 (codes 4..7)   — Function arguments. Used in tape_run_a02_s07, see below.
+---   R_S0..S7 (codes 16..23) — Callee-saved. Preserved across C-ABI calls by convention.
+---     The `tape_run_a02_s07` variant clobbers them deliberately, but the default `tape_run` does NOT.
+---     Kept out of POOL to preserve the conservative default.
+---     Add them in a separate "big clobber" pool if/when needed.
+---
+---   R_K0/K1       (codes 26..27) — Kernel / interrupt handler reserves. Never touched by user code; OS-internal.
+---   R_GP/SP/FP/RA (codes 28..31) — Stack frame + return-address. Owned by the C compiler; never allocatable.
+---   R_0           (code 0)       — Hardwired zero. Cannot be written.
+---
+local POOL = {
+    "R_T0", "R_T1", "R_T2", "R_T3",
+    "R_T4", "R_T5", "R_T6", "R_T7",
+    "R_V0", "R_V1",
+}
+
+-- Map from integer MIPS GPR code (the `code` field on AliasEntry) to the physical GPR ident in POOL.
+-- The standard MIPS O32 ABI register numbering matches mips.h's R_*_Code #defines (mips.h).
+-- Only the POOL entries matter for auto_reg — non-pool aliases
+-- (R_AT=1, R_A0..A3=4..7, R_T8=24, R_T9=25, R_K0/K1=26..27, R_GP/SP/FP/RA=28..31) 
+-- are deliberately omitted — see the comment block above for the WHY of each exclusion.
+local INT_CODE_TO_POOL_GPR = {
+    [2]  = "R_V0", [3]  = "R_V1",
+    [8]  = "R_T0", [9]  = "R_T1", [10] = "R_T2", [11] = "R_T3",
+    [12] = "R_T4", [13] = "R_T5", [14] = "R_T6", [15] = "R_T7",
+}
+
+-- Stable sort for deterministic allocation order.
+local function stable_sort_keys(tbl)
+    local keys = {}
+    for k in pairs(tbl) do keys[#keys + 1] = k end
+    table.sort(keys)
+    return keys
+end
+
+-- Allocate one phase's auto-reg mappings.
+-- Returns (allocated_map, errors). On pool exhaustion, errors is populated and the function halts.
+local function allocate_phase(phase_label, decls)
+    -- Deep-copy POOL into a fresh sequence table. The original `table.unpack and table.unpack(POOL) or { unpack(POOL) }`
+    -- idiom wraps the unpacked values in a single inner table under LuaJIT 5.1 (`table.unpack` is nil; the `or` returns one value),
+    -- which corrupts the pool into `{ {R_T0, R_T1, ...} }` — making `table.remove(pool, 1)` return the inner table on iteration.
+    local pool   = {}
+    for i = 1, #POOL do pool[i] = POOL[i] end
+    local result = {}
+    local errors = {}
+    for _, sym in ipairs(stable_sort_keys(decls)) do
+        local next_gpr = table.remove(pool, 1)
+        if not next_gpr then
+            errors[#errors + 1] = {
+                line = 0,
+                msg  = string.format("phase_register_pool_exhausted: "
+									.. "phase '%s' requested symbol '%s' but the pool has no remaining registers "
+									.. "(max 10 per phase: R_T0..R_T7 + R_V0..R_V1). Split the phase or use hardcoded GPRs."
+                  , phase_label, sym),
+            }
+            return result, errors
+        end
+        result[sym] = next_gpr
+    end
+    return result, errors
+end
+
+-- Build two projections from corpus.register_alias_registry:
+--   user_pinned   -- { [physical_gpr_ident] = true } -- GPRs unavailable to auto_reg globally (wave-context carriers, file-scope pinned aliases)
+--   alias_to_gpr  -- { [alias_ident]        = physical_gpr_ident } -- for body parsing
+-- Both projections are derived from the same set of entries: every AliasEntry in register_alias_registry has `has_atom_reg = true` 
+-- (only those entries are added to the registry; see passes/scan_source.lua parse_enum_entry).
+-- Each entry's `code` is the integer MIPS GPR number (0..31); INT_CODE_TO_POOL_GPR translates it back to the physical GPR ident.
+-- Aliases whose `code` points to a non-POOL GPR (e.g. R_S0, R_T8, R_K1) are ignored — 
+-- they don't affect the auto_reg pool, and they're already excluded from POOL above.
+local function build_user_pins(corpus)
+    local user_pinned  = {}
+    local alias_to_gpr = {}
+    if not corpus.register_alias_registry then return user_pinned, alias_to_gpr end
+    for alias_name, alias_entry in pairs(corpus.register_alias_registry) do
+        if alias_entry.has_atom_reg and alias_entry.code then
+            local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code]
+            if gpr then
+                user_pinned[gpr]         = true
+                alias_to_gpr[alias_name] = gpr
+            end
+        end
+    end
+    return user_pinned, alias_to_gpr
+end
+
+-- Find every physical GPR referenced in the atom body, via EITHER:
+--   (a) A hardcoded physical GPR ident (R_T\d+|R_V\d+|R_A\d+|R_S\d+) — the existing regex;
+--   (b) An alias ident (R_<Alias>) resolved via alias_to_gpr back to its physical GPR ident.
+-- Returns { [physical_gpr_ident] = count }. Clash-detection and source-pool-exclusion logic
+-- only needs the presence of each GPR (boolean test), but keeping count preserves the
+-- original find_hardcoded_rn shape so callers can switch without churn.
+-- The alias pattern is sorted lexicographically to keep the regex deterministic.
+local function find_used_gprs(body_text, alias_to_gpr)
+    local found = {}
+    -- (a) Hardcoded physical GPRs (R_T0..R_T7, R_V0..R_V1, R_A0..R_A3, R_S0..R_S7).
+    for gpr in body_text:gmatch("(R_T%d+|R_V%d+|R_A%d+|R_S%d+)") do
+        found[gpr] = (found[gpr] or 0) + 1
+    end
+    -- (b) Alias references (R_<Alias>) resolved to physical GPRs via the registry.
+    --      Sorted by name so the regex is byte-stable across runs.
+    if alias_to_gpr and next(alias_to_gpr) then
+        local aliases = {}
+        for alias_name in pairs(alias_to_gpr) do
+            aliases[#aliases + 1] = alias_name
+        end
+        table.sort(aliases)
+        local pattern = "(" .. table.concat(aliases, "|") .. ")"
+        for alias_name in body_text:gmatch(pattern) do
+            local gpr = alias_to_gpr[alias_name]
+            if gpr and not found[gpr] then
+                found[gpr] = 1
+            end
+        end
+    end
+    return found
+end
+
+-- Emit one gen/auto_reg.h header per directory.
+local function emit_auto_reg_h(out_dir, dir, sources, mappings)
+    if not mappings or next(mappings) == nil then return end
+    local out_path = out_dir .. "/" .. "auto_reg.h"
+    duffle.ensure_dir(out_dir)
+    local lines = {
+        "#ifdef INTELLISENSE_DIRECTIVES",
+        "#pragma once",
+        "#endif",
+        "// Auto-generated by ps1_meta.lua (passes/auto_reg.lua) — DO NOT EDIT",
+        "// Directory: " .. dir:gsub("/", "\\"),
+    }
+    for _, src in ipairs(sources) do
+        lines[#lines + 1] = "//   source: " .. src.path
+    end
+    lines[#lines + 1] = "// Per-phase register allocations resolved by the lua pass."
+    lines[#lines + 1] = "// R_<Sym>_Code = <chosen GPR's _Code constant> for every marker in this directory."
+    lines[#lines + 1] = ""
+    for _, sym in ipairs(stable_sort_keys(mappings)) do
+        local gpr         = mappings[sym]
+        local gpr_code    = gpr .. "_Code"
+        lines[#lines + 1] = "#define " .. sym .. "_Code " .. gpr_code
+    end
+    lines[#lines + 1] = ""
+    duffle.write_file_lf(out_path, table.concat(lines, "\n") .. "\n")
+    print("  -> " .. out_path)
+    return out_path
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Pass entry
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+--- @param ctx PassCtx
+--- @return AutoRegResult
+function M.run(ctx)
+    local outputs  = {}
+    local errors   = {}
+    local warnings = {}
+
+    local corpus = ctx.shared and ctx.shared.corpus
+    if type(corpus) ~= "table" then
+        error("auto_reg.run requires ctx.shared.corpus", 0)
+    end
+
+    -- 0. Build the user-pinned GPR exclusion set + alias-to-GPR resolution map.
+    --  Wave-context carriers (e.g. `R_ResolveScratch = R_T4 atom_reg` in hello_camera.atom.c)
+    --  MUST NOT be allocated to any auto-reg marker — they're preserved across atoms by the wave-context discipline.
+		--  The corpus's register_alias_registry is the source of truth for these opt-in pins.
+    --  Body references to those aliases (via alias_to_gpr) are also excluded on a per-atom basis in step 2 below.
+    local user_pinned, alias_to_gpr = build_user_pins(corpus)
+
+    -- 1. Allocate phase pools first (phase declarations take precedence over per-atom declarations).
+    local phase_allocations = {}
+    for phase_label, decls in pairs(corpus.phase_auto_regs or {}) do
+        local mapping, errs = allocate_phase(phase_label, decls)
+        for sym, gpr in pairs(mapping) do
+            phase_allocations[phase_label]      = phase_allocations[phase_label] or {}
+            phase_allocations[phase_label][sym] = gpr
+        end
+        for _, e in ipairs(errs) do
+            errors[#errors + 1] = e
+        end
+    end
+
+    -- 2. Allocate per-atom auto-regs. If the atom scope matches a phase, reuse the phase pool.
+    -- Otherwise, allocate a private pool for the atom.
+    -- The phase membership is in `corpus.atom_phases[phase_label].atoms` (an array of atom names declared via `atom_phase(<phase>)`
+		-- in the atom's `atom_info` line). Build a reverse map `atom_name -> phase_label` so the lookup is O(1) per atom scope.
+    local atom_name_to_phase = {}
+    for phase_label, entry in pairs(corpus.atom_phases or {}) do
+        for _, atom_name in ipairs(entry.atoms or {}) do
+            atom_name_to_phase[atom_name] = phase_label
+        end
+    end
+
+    local atom_allocations = {}
+    for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do
+        local phase_label = atom_name_to_phase[atom_scope]
+        -- Build the atom's source pool: start with the full POOL, subtract:
+        --   (a) every GPR already committed (phase allocations + prior atom allocations)
+        --   (b) every USER-PINNED GPR (wave-context carriers + file-scope pinned aliases)
+        --   (c) every GPR referenced in the atom's body — either hardcoded R_X or alias R_Xxx
+        --       (the latter resolved via alias_to_gpr; this catches cases where the user wrote R_ResolveScratch instead of R_T4 directly)
+        -- Atoms whose scope matches a phase share the global pool with the phase allocations;
+        -- the original `source_pool = phase_allocations[phase_label]` form used the phase
+        -- allocation MAP as a pool, but that map has no array part, so `table.remove(source_pool, 1)`
+        -- returned nil and every atom-with-phase marker errored with `phase_register_pool_exhausted`.
+        local used = {}
+        for _, m in pairs(phase_allocations) do for _, gpr in pairs(m) do used[gpr] = true end end
+        for _, m in pairs(atom_allocations)  do for _, gpr in pairs(m) do used[gpr] = true end end
+        -- (c) Body references — scan the atom body for hardcoded + alias-resolved GPRs.
+        --     Folded into `used` so the source_pool exclusion is a single check.
+        local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+        if atom and atom.body then
+            local body_used = find_used_gprs(atom.body, alias_to_gpr)
+            for gpr in pairs(body_used) do used[gpr] = true end
+        end
+        local source_pool = {}
+        for _, gpr in ipairs(POOL) do
+            -- Exclude (a) prior commitments, (b) USER-PINNED GPRs (wave-context carriers
+            -- declared via atom_reg + _Code defs, preserved across atoms globally).
+            if not used[gpr] and not user_pinned[gpr] then
+                source_pool[#source_pool + 1] = gpr
+            end
+        end
+        local result = {}
+        for _, sym in ipairs(stable_sort_keys(decls)) do
+            local next_gpr = table.remove(source_pool, 1)
+            if not next_gpr then
+                errors[#errors + 1] = {
+                    line = 0,
+                    msg  = string.format("phase_register_pool_exhausted: atom '%s' requested symbol '%s' "
+											.. "but no free registers remain in its scope pool."
+                    	, atom_scope, sym),
+                }
+            else
+                result[sym] = next_gpr
+            end
+        end
+        atom_allocations[atom_scope] = result
+    end
+
+    -- 3. Conflict-with-hardcoded detection (defensive — should be unreachable now).
+    -- The source_pool exclusion in step 2 (b) + (c) already accounts for both user-pinned GPRs
+    -- and body-referenced GPRs (hardcoded R_Tn OR alias R_<Alias>).
+		-- An auto-reg allocation that matched an existing body reference would be impossible by construction.
+		-- This warning is kept as a defensive safety net for cases the body scanner might miss
+		-- (e.g. macros that expand to register references the scanner cannot resolve).
+    -- For each resolved (scope, sym) -> R_Tn mapping, scan the atom body source for used GPRs.
+    for atom_scope, decls in pairs(atom_allocations) do
+        local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+        if atom and atom.body then
+            local used_in_body = find_used_gprs(atom.body, alias_to_gpr)
+            for sym, allocated_gpr in pairs(decls) do
+                if used_in_body[allocated_gpr] and used_in_body[allocated_gpr] > 0 then
+                    warnings[#warnings + 1] = {
+                        line  = atom.line or 0,
+                        msg   = string.format("phase_register_clash: atom '%s' has hardcoded '%s' in its body AND an auto-reg marker '%s' "
+													.. "that was allocated to '%s' (same phase). Resolve by removing the hardcoded reference or renaming the auto-reg."
+                        	, atom_scope, allocated_gpr, sym, allocated_gpr),
+                    }
+                end
+            end
+        end
+    end
+
+    -- 4. Emit per-directory gen/auto_reg.h.
+    -- For each source directory that has atom_auto_regs or phase_auto_regs entries, emit one header.
+    local sources_by_dir = corpus.sources_by_dir or {}
+    for dir, sources in pairs(sources_by_dir) do
+        local per_dir_mappings = {}
+        for _, src in ipairs(sources) do
+            -- Collect every (sym -> gpr) entry that originated from a source in this directory.
+            -- `src.scan.atom_auto_regs` is keyed by ATOM SCOPE NAME; `pairs(t)` iterates KEYS so `scope_name` here is the scope ident (e.g. "cube_g4_face").
+						-- The previous `for _, scan_atom_auto` form silently assigned the VALUE (a `{sym = sym}` table) to the variable,
+						-- which made `atom_allocations[scan_atom_auto]` a table-indexed lookup that never resolved.
+            for scope_name in pairs(src.scan and src.scan.atom_auto_regs or {}) do
+                for sym, gpr in pairs(atom_allocations[scope_name] or {}) do
+                    per_dir_mappings[sym] = gpr
+                end
+            end
+            for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do
+                for sym, gpr in pairs(phase_allocations[scope_name] or {}) do
+                    per_dir_mappings[sym] = gpr
+                end
+            end
+        end
+        local out_dir  = dir .. "/gen"
+        local out_path = emit_auto_reg_h(out_dir, dir, sources, per_dir_mappings)
+        if out_path then outputs[#outputs + 1] = { auto_reg_h = out_path } end
+    end
+    return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/components.lua

@@ -3,13 +3,15 @@
 --- Ownership: `corpus.word_counts`, `corpus.components`, and `corpus.component_body_index`.
 --- Scanner owns `declaration_comment` and `debug_skip` on each declaration record; this pass projects both forward.
 ---
---- Reads the pre-scanned SourceScan payload from `duffle.scan_source` for `MipsAtomComp_(ac_X)` and `MipsAtomComp_Proc_(ac_X, { body })` declarations,
+--- Reads the pre-scanned SourceScan payload from `duffle.scan_source` for `MipsAtomComp_(ac_X)` and `MipsAtomComp_Proc_(ac_X, { body })` declarations (kind="comp_bare" / "comp_proc"),
 --- then resolves the function-args string from the preceding `FI_ Slice_MipsCode ac_X(...)` declaration via a backward walk.
 ---
---- Emits one `<dir_basename>.macs.h` per source with `#define mac_X(sig) \` macros plus `WORD_COUNT(mac_X, N)` entries for downstream offset computation.
+--- `MipsAtom_Proc_(X, ab, { body })` declarations (kind="atom_proc") are ATOMS, not components, and are deliberately excluded —
+--- atoms get emitted via `tb_emit(tb, code_<name>)` linker symbols, not inlined as `mac_*` macros.
 ---
---- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
---- Lua 5.3 compatible.
+--- Emits one `gen/macs.h` per *immediate source directory* with `#define mac_X(sig) \` macros plus `WORD_COUNT(mac_X, N)` entries for downstream offset computation.
+--- All sources inside the same directory contribute to the same file (per-directory aggregation).
+--- The directory itself is the namespace, so the filename does not repeat the module name.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
@@ -41,29 +43,30 @@ local MAC_PREFIX_LEN  = 4
 local BYTE_NEWLINE    = 10
 local BYTE_SLASH      = 47
 
--- Source dir basename used as the output `.macs.h` filename.
+-- Output gen subdirectory + filename (per-directory aggregation; the directory name is the namespace).
 local GEN_SUBDIR      = "gen"
+local MACS_FILENAME   = "macs.h"
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- 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
---- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- Directory containing the source
+--- @field basename string  -- Filename without extension
+--- @field scan     table   -- Pre-scanned SourceScan payload (from duffle.scan_source)
 
 --- @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 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
---- @field verbose            boolean                -- log diagnostic info
+--- @field verbose            boolean                -- Log diagnostic info
 
 --- @class PassResult
 --- @field outputs  table[]  -- {kind=, path=} entries describing emit files
@@ -71,13 +74,13 @@ local GEN_SUBDIR      = "gen"
 --- @field warnings table[]  -- {line=, msg=}  entries; build-succeeds
 
 --- @class Component
---- @field name       string     -- atom name (without `ac_` prefix)
---- @field body       string     -- brace-delimited body (without the braces)
---- @field args       string|nil -- function-args string (function form only)
---- @field line       integer    -- source line of the declaration
---- @field comment    string|nil -- scanner-owned `declaration_comment`; the components pass reads it from the scanner record
---- @field kind       string     -- "comp_bare" | "comp_proc"
---- @field debug_skip boolean    -- mirror of `a.debug_skip` (scanner-owned); true iff a bare `atom_dbg_skip` marker immediately preceded the declaration
+--- @field name       string     -- Atom name (without `ac_` prefix)
+--- @field body       string     -- Brace-delimited body (without the braces)
+--- @field args       string|nil -- Function-args string (function form only)
+--- @field line       integer    -- Source line of the declaration
+--- @field comment    string|nil -- Scanner-owned `declaration_comment`; the components pass reads it from the scanner record
+--- @field kind       string     -- "comp_bare" | "comp_proc"  (atom_proc is NOT a component — see `project_components`)
+--- @field debug_skip boolean    -- Mirror of `a.debug_skip` (scanner-owned); true iff a bare `atom_dbg_skip` marker immediately preceded the declaration
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Local helpers (file I/O + path normalization)
@@ -200,7 +203,16 @@ end
 local function project_components(source, scan)
 	local out = {}
 	for _, a in ipairs(scan.atoms) do
+		-- Only `MipsAtomComp_(ac_X)` (kind="comp_bare") and `MipsAtomComp_Proc_(ac_X, ...)` (kind="comp_proc")
+		-- are COMPONENTS — they get inlined via `mac_<name>` aliases inside atom bodies.
+		-- `MipsAtom_Proc_` (kind="atom_proc") is an ATOM (ends with `mac_yield()`); it gets emitted via
+		-- `tb_emit(tb, code_<name>)` (linker symbol), NOT inlined as a macro. Including `atom_proc` here
+		-- would incorrectly emit `mac_<name>` aliases for atoms, polluting `gen/macs.h`.
+		-- See `docs/duffle_dsl_primer.md` §"mac_* aliases" for the contract.
 		if a.kind == "comp_bare" or a.kind == "comp_proc" then
+			-- Function-args lookup is meaningful for `MipsAtomComp_Proc_` components
+			-- (the macro sits inside `FI_ Slice_MipsCode ac_X(...)`); the alias expansion
+			-- discards the `ab` (atom-builder) arg the same way both forms do.
 			local args = find_function_args_for(source, a.raw_name, a.ident_pos)
 			-- Comment ownership: scan_source.lua stamps `declaration_comment` on the record by walking backward past any associated bare marker.
 			-- The pass reads `declaration_comment` directly.
@@ -231,7 +243,6 @@ end
 --
 -- Skips `//` sequences that are inside string or character literals
 -- (a rough heuristic — sufficient for component bodies which don't have those constructs).
---
 --- @param s string
 --- @return string
 local function convert_line_comments_to_block(s)
@@ -300,7 +311,9 @@ local function word_count_rec(name, comp_by_name, wc, cache)
 			local trimmed = t.tok
 			if trimmed ~= "" then
 				local lookup = strip_mac_prefix(duffle.read_ident(trimmed, 1))
-				if lookup and comp_by_name[lookup] then
+				if lookup == "atom_label" or lookup == "atom_offset" then
+					-- Pure metaprogram anchors; emit zero words.
+				elseif lookup and comp_by_name[lookup] then
 					-- It's a `mac_X(...)` call. Recurse.
 					n = n + word_count_rec(lookup, comp_by_name, wc, cache)
 				elseif lookup and wc and wc[lookup] then
@@ -339,6 +352,115 @@ local function count_all_components(components, wc)
 	return counts
 end
 
+-- ═══════════════════════════════════════════
+-- Per-component metadata derivation (replaces the hardcoded `M.GP0_MACRO_CONTRIB` + `M.INSTRUCTION_LATENCY[mac_*]` tables that previously lived in `duffle.lua`).
+--
+-- Each `MipsAtomComp_(ac_X) { body }` definition in `code/duffle/lottes_tape.h` is the canonical source.
+-- The `mac_X(...)` macros are GENERATED from these definitions by `emit_component_macros_h` for tape-side composition;
+-- the metaprogram must NEVER walk the generated variants to derive metadata.
+-- Always walk the original `MipsAtomComp_` body via `cc.body_tokens`.
+-- ═══════════════════════════════════════════
+
+--- (internal) Recursive cycle-cost derivation. Sum `latency[ident]` per emitted instruction in the component body,
+--- recursing through nested `mac_*` calls (so `mac_format_g4_color`'s cost = 4 × `mac_pack_color_word`'s cost).
+--- Special rule: `mac_yield`'s cost = 0 (per `lottes_tape.h:125-130` "the runtime cost lands in the next atom's prologue").
+--- @param name         string  -- component bare name (e.g. "yield", "pack_color_word")
+--- @param comp_by_name table<string, Component>
+--- @param latency      table<string, integer>
+--- @param cache        table<string, integer>  -- shared memoization; `-1` sentinel detects cycles
+--- @return integer
+local function cycle_cost_rec(name, comp_by_name, latency, cache)
+	if cache[name] ~= nil then return cache[name] end
+	cache[name] = -1
+	local cc = comp_by_name[name]
+	local n
+	if cc then
+		if name == "yield" then
+			-- mac_yield's cost is 0 by convention (the runtime cost lands in the next atom's prologue).
+			n = 0
+		else
+			n = 0
+			local tokens = cc.body_tokens
+			for _, t in ipairs(tokens) do
+				local trimmed = t.tok
+				if trimmed ~= "" then
+					local ident = duffle.read_ident(trimmed, 1)
+					if ident and ident:sub(1, MAC_PREFIX_LEN) == MAC_PREFIX then
+						-- Nested `mac_X(...)` call: recurse.
+						local nested = ident:sub(MAC_PREFIX_LEN + 1)
+						n = n + cycle_cost_rec(nested, comp_by_name, latency, cache)
+					else
+						-- Leaf instruction or pseudo-macro. Look up in INSTRUCTION_LATENCY; default 1.
+						n = n + (latency[ident] or 1)
+					end
+				end
+			end
+		end
+	else
+		n = 1
+	end
+	cache[name] = n
+	return n
+end
+
+--- (internal) Recursive GP0 prim-buffer contribution. Count `store_word` / `store_half` / `store_byte` 
+--- calls in the component body that target `R_PrimCursor` (these are the RAM-side prim-buffer words the macro contributes), recursing through nested `mac_*` calls.
+--- Only `R_PrimCursor`-targeting stores count. Stores targeting other registers (e.g. `R_OtBase`, heap pointers) are not prim-buffer contributions.
+--- @param name         string
+--- @param comp_by_name table<string, Component>
+--- @param cache        table<string, integer>
+--- @return integer
+local function gp0_contrib_rec(name, comp_by_name, cache)
+	if cache[name] ~= nil then return cache[name] end
+	cache[name] = -1
+	local cc = comp_by_name[name]
+	local n
+	if cc then
+		n = 0
+		local tokens = cc.body_tokens
+		for _, t in ipairs(tokens) do
+			local trimmed = t.tok
+			if    trimmed ~= "" then
+				local ident = duffle.read_ident(trimmed, 1)
+				if    ident and ident:sub(1, MAC_PREFIX_LEN) == MAC_PREFIX then
+					-- Nested `mac_X(...)` call: recurse.
+					local nested = ident:sub(MAC_PREFIX_LEN + 1)
+					n = n + gp0_contrib_rec(nested, comp_by_name, cache)
+				elseif ident == "store_word" or ident == "store_half" or ident == "store_byte" then
+					if trimmed:find("R_PrimCursor", 1, true) then
+						n = n + 1
+					end
+				end
+			end
+		end
+	else
+		n = 0
+	end
+	cache[name] = n
+	return n
+end
+
+--- Compute `cycle_cost` + `gp0_contrib` for every component in `components` in a single pass.
+--- Memoization cache is built ONCE (per source) and shared across both helpers so that
+--- a nested `mac_Y` reference inside a `mac_X` body computes its values once.
+--- @param components Component[]
+--- @param latency    table<string, integer>
+--- @return table<string, {cycle_cost=integer, gp0_contrib=integer}>
+local function compute_components_metadata(components, latency)
+	local comp_by_name = {}
+	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end
+	local cc_cache  = {}
+	local gc_cache  = {}
+	local out       = {}
+	for _, c in ipairs(components) do
+		out[c.name] = {
+			cycle_cost = cycle_cost_rec(c.name, comp_by_name, latency, cc_cache),
+			gp0_contrib = gp0_contrib_rec(c.name, comp_by_name, gc_cache),
+		}
+	end
+	return out
+end
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- Per-component emit logic
 -- ════════════════════════════════════════════════════════════════════════════
@@ -364,13 +486,26 @@ local function split_comment_lines(s)
 end
 
 --- Determine the macro signature: function-args list (function form) or variadic-ignored (bare form).
+--- For `MipsAtomComp_Proc_` components, the leading `ab` (atom-builder) arg is dropped:
+--- the generated `mac_<name>` macros are inline-expansion aliases for baked atoms; their bodies don't reference `ab`
+--- (the builder is only consumed by the procedural `atombuilder_unroll` line that `MipsAtomComp_Proc_` appends after the body).
+--- Inline callers therefore don't need to thread a builder context.
 --- @param args_str string|nil
 --- @return string
 local function signature_from_args(args_str)
 	local arg_names = extract_arg_names(args_str)
 	if    arg_names and #arg_names > 0 then
+		-- Drop the leading `ab` (atom-builder) first arg if present.
+		-- Convention: `MipsAtomComp_Proc_` components always declare `ab` as the first function-arg
+		-- (type `MipsAtomBuilder_R`), mirroring the macro signature in `lottes_tape.h`.
+		if arg_names[1] == "ab" then
+			table.remove(arg_names, 1)
+		end
+		if #arg_names > 0 then
 			return table.concat(arg_names, ", ")
 		end
+		return "..."  -- `ab` was the only arg; fall through to variadic
+	end
 	return "..."
 end
 
@@ -411,7 +546,7 @@ local function build_component_lines(c, counts)
 
 	-- Marker comment: emitted once for every skipped component.
 	-- The marker is scanner-owned (declared by `atom_dbg_skip` immediately before the declaration in the source);
-	-- the components pass projects `c.debug_skip` and emits the marker as a generated comment.
+	-- This pass projects `c.debug_skip` and emits the marker as a generated comment.
 	if c.debug_skip then
 		lines[#lines + 1] = "/* atom_dbg_skip */"
 	end
@@ -445,9 +580,15 @@ end
 
 --- Build the boilerplate header lines (the `#ifdef INTELLISENSE_DIRECTIVES` block,
 --- the `// Auto-generated` comment, the `// Source:` line, and the self-contained `WORD_COUNT` macro definition).
---- @param src SourceFile
+--- @param dir     string       -- Absolute source directory
+--- @param sources SourceFile[] -- Sources contributing to this directory (for the header comment)
 --- @return string[]
-local function header_boilerplate(src)
+local function header_boilerplate(dir, sources)
+	local source_lines = { "// Directory: " .. duffle.to_absolute_path(dir) .. "/" }
+	for _, src in ipairs(sources) do
+		source_lines[#source_lines + 1] = "//   source: " .. duffle.to_absolute_path(src.path)
+	end
+	local source_blob = table.concat(source_lines, "\n")
 	return {
 		-- #pragma once wrapped in #ifdef INTELLISENSE_DIRECTIVES, matching the convention in lottes_tape.h.
 		-- The build does manual unity includes (the user controls include order), so the pragma is only active for IDE/tooling.
@@ -455,7 +596,7 @@ local function header_boilerplate(src)
 		"#pragma once",
 		"#endif",
 		"// Auto-generated by ps1_meta.lua — DO NOT EDIT",
-		"// Source: " .. duffle.to_absolute_path(src.path),
+		source_blob,
 		"// Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)",
 		"",
 		-- Self-contained: define WORD_COUNT if not already defined.
@@ -468,30 +609,30 @@ local function header_boilerplate(src)
 	}
 end
 
---- Compute the output path for one source's `.macs.h` file.
---- The pre-rework convention uses the *directory* basename (not the source file basename)
----  e.g. `code/duffle/lottes_tape.h` produces `code/duffle/gen/duffle.macs.h`.
---- This matches what the C codebase #includes.
---- @param src SourceFile
---- @return string  -- the output directory
---- @return string  -- the full output path
-local function compute_macs_h_path(src)
-	local  out_dir  = src.dir .. "/" .. GEN_SUBDIR
-	local  out_path = out_dir .. "/" .. duffle.basename_no_ext(src.dir) .. ".macs.h"
+--- Compute the per-directory output path for `.macs.h`.
+---  e.g. any source in `code/duffle/` produces `code/duffle/gen/macs.h` regardless of source filename.
+--- The directory name is the namespace; the filename does not repeat it.
+--- @param dir string  -- Absolute source directory
+--- @return string  -- Output directory
+--- @return string  -- Full output path
+local function compute_macs_h_path(dir)
+	local  out_dir  = dir .. "/" .. GEN_SUBDIR
+	local  out_path = out_dir .. "/" .. MACS_FILENAME
 	return out_dir, out_path
 end
 
---- Emit a per-source `.macs.h` header with the `mac_X` macros + `WORD_COUNT` entries. 
+--- Emit a per-directory `.macs.h` header with the aggregated `mac_X` macros + `WORD_COUNT` entries.
 --- Writes in BINARY mode so LF line endings are preserved (the git blob is LF; Windows text-mode would emit CRLF and break the byte-identical diff).
 --- @param ctx        PassCtx
---- @param src        SourceFile
---- @param components Component[]
---- @param counts     table<string, integer>  -- precomputed word counts (from count_all_components)
---- @return string|nil  -- path to the written file (nil if no components)
-local function emit_component_macros_h(ctx, src, components, counts)
+--- @param dir        string                  -- Absolute source directory
+--- @param sources    SourceFile[]            -- Sources contributing to this directory (for the header comment)
+--- @param components Component[]             -- Aggregated components from all sources in this directory
+--- @param counts     table<string, integer>  -- Precomputed word counts (from count_all_components)
+--- @return string|nil -- Path to the written file (nil if no components)
+local function emit_component_macros_h(ctx, dir, sources, components, counts)
 	if #components == 0 then return nil end
-	local out_dir, out_path = compute_macs_h_path(src)
-	local lines             = header_boilerplate(src)
+	local out_dir, out_path = compute_macs_h_path(dir)
+	local lines             = header_boilerplate(dir, sources)
 
 	for _, c in ipairs(components) do
 		for _, l in ipairs(build_component_lines(c, counts)) do
@@ -526,26 +667,28 @@ local function update_canonical_word_counts(corpus, components, counts)
 end
 
 --- @class ComponentDef
---- @field name       string  -- bare name (without ac_/mac_ prefix)
---- @field line       integer -- definition source line (line of `MipsAtomComp_(ac_X)` / `MipsAtomComp_Proc_(ac_X, ...)`)
---- @field path       string  -- absolute source path of the definition
---- @field kind       string  -- "comp_bare" | "comp_proc"
---- @field debug_skip boolean -- mirror of the scanner-owned `a.debug_skip`; consumers read this directly
+--- @field name       string  -- Bare name (without ac_/mac_ prefix)
+--- @field line       integer -- Definition source line (line of `MipsAtomComp_(ac_X)` / `MipsAtomComp_Proc_(ac_X, ...)`)
+--- @field path       string  -- Absolute source path of the definition
+--- @field kind       string  -- "comp_bare" | "comp_proc"  (atom_proc is NOT a component)
+--- @field debug_skip boolean -- Mirror of the scanner-owned `a.debug_skip`; consumers read this directly
 
 --- (internal) Populate `corpus.components` with this source's components-by-name map.
 --- First declaration wins; later declarations of the same bare name are dropped and recorded as a collision via `corpus.collisions` (kind = "component").
---- The pass does NOT write to `ctx.shared.components` (ownership follows the canonical contract).
---- The `debug_skip` field mirrors the scanner-owned declaration record (`c.debug_skip`).
+--- The pass does NOT write to `ctx.shared.components`.
 --- No parallel skip map is built here; consumers that need the per-component skip state read `corpus.components[name].debug_skip` directly.
+--- The `cycle_cost` + `gp0_contrib` fields are populated from `metadata[c.name]` (computed by `compute_components_metadata` against the original `MipsAtomComp_` body).
 --- @param corpus     table   -- the corpus
 --- @param src        SourceFile
 --- @param components Component[]
-local function update_canonical_components(corpus, src, components)
+--- @param metadata    table<string, {cycle_cost=integer, gp0_contrib=integer}>
+local function update_canonical_components(corpus, src, components, metadata)
 	local rel_path = src.path:gsub("\\", "/")
 	for _, c in ipairs(components) do
 		-- Keyed by bare name (e.g. `yield`, `load_tri_indices`).
 		-- The atoms_source_map pass looks up components by bare name from the corpus;
 		-- `mac_` prefix lives at the call-site identifier and is stripped before lookup.
+		local m = metadata and metadata[c.name] or nil
 		if corpus.components[c.name] == nil then
 			corpus.components[c.name] = {
 				name        = c.name,
@@ -553,6 +696,8 @@ local function update_canonical_components(corpus, src, components)
 				path        = rel_path,
 				kind        = c.kind or "comp_bare",
 				debug_skip  = c.debug_skip == true,
+				cycle_cost  = m and m.cycle_cost  or nil,
+				gp0_contrib = m and m.gp0_contrib or nil,
 			}
 		else
 			-- A second declaration of the same bare name: record a typed collision so static-analysis + the report can surface it.
@@ -624,21 +769,39 @@ function M.run(ctx)
 	--   * `corpus.component_body_index[name]` — body / line_of / source index
 	-- The pass writes to the corpus only; consumers read from the corpus directly.
 
-	for _, src in ipairs(corpus.source_order) do
-		-- project_components reads from src.scan + does backward lookups on src.text
-		local components = project_components(src.text, src.scan)
-		if #components > 0 then
-			-- Compute all component word counts once per source.
-			-- Use `corpus.word_counts` so the recursive lookup sees both authored-metadata entries
-			-- (loaded by word_count_eval.run) AND same-source component entries (populated earlier in this loop by `update_canonical_word_counts`).
-			local counts = count_all_components(components, corpus.word_counts)
-			local macs_path = emit_component_macros_h(ctx, src, components, counts)
+	-- Per-directory aggregation: every source in the same directory contributes to one `gen/macs.h`.
+	-- The directory itself is the namespace. `corpus.sources_by_dir` preserves source-order within each bucket (matches `corpus.source_order`).
+	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order)
+	for dir, sources in pairs(sources_by_dir) do
+		-- Aggregate components from every source in this directory.
+		-- `project_components` returns nil for sources with no `MipsAtomComp_` declarations; we skip those.
+		local aggregated_components = {}
+		local metadata_per_source   = {}
+		for _, src in ipairs(sources) do
+			local per_source = project_components(src.text, src.scan) or {}
+			for _, c in ipairs(per_source) do
+				aggregated_components[#aggregated_components + 1] = c
+			end
+			if #per_source > 0 then
+				metadata_per_source[src] = compute_components_metadata(per_source, duffle.INSTRUCTION_LATENCY)
+			end
+		end
+		if #aggregated_components > 0 then
+			-- Compute word counts across the aggregated set. `corpus.word_counts` carries the
+			-- same-source + prior-directory entries so the recursive lookup sees both.
+			local counts    = count_all_components(aggregated_components, corpus.word_counts)
+			local macs_path = emit_component_macros_h(ctx, dir, sources, aggregated_components, counts)
 			if macs_path then
 				outputs[#outputs + 1] = { macs_h = macs_path }
-				-- Populate the projections AFTER disk emission (so the byte-identical `.macs.h` contract is preserved before any current-count mutation).
-				update_canonical_word_counts(corpus, components, counts)
-				update_canonical_components(corpus, src, components)
-				update_canonical_component_body_index(corpus, src, components, src.scan)
+				-- Populate the projections AFTER disk emission (byte-identical `.macs.h` contract).
+				update_canonical_word_counts(corpus, aggregated_components, counts)
+				for _, src in ipairs(sources) do
+					local per_source = project_components(src.text, src.scan) or {}
+					if #per_source > 0 then
+						update_canonical_components(corpus, src, per_source, metadata_per_source[src])
+						update_canonical_component_body_index(corpus, src, per_source, src.scan)
+					end
+				end
 			end
 		end
 	end

scripts/passes/dwarf_injection.lua

@@ -73,10 +73,6 @@ local DW_RLE_start_length  = DWARF5_RNGLISTS.start_length
 
 -- File-index lookup for the existing main line unit (Unit 2).
 -- Populated at pass start by `init_file_index_lookup(elf_path)` from the runtime ELF (see `elf_dwarf.read_line_unit_file_table`).
--- The hardcoded indices and the `PROVENANCE_BASENAME_TO_FILE_INDEX` table that previously lived here were retired in `conductor/tracks/dwarf_file_index_lookup_20260731/`
--- (red of the
--- `TODO(Ed): Remove this HARDCODE` from line 156); the runtime lookup reads the
--- actual gcc-emitted `.debug_line` file table instead.
 local _file_index_by_basename    = nil  -- [basename] = 1-based line-table file index
 local _file_path_by_index        = nil  -- [1-based index] = full source path (diagnostics / future consumers)
 local _default_atom_source_index = nil  -- any valid index used in opaque-row fallbacks
@@ -188,15 +184,17 @@ end
 --- Resolve an absolute provenance path to the line-unit file index used by the emitting line program.
 --- Normalizes mixed `/` and `\` separators to a basename and looks it up against the runtime-computed file table populated by `init_file_index_lookup`.
 ---
---- Fails loudly on an unknown provenance basename: adding a new component source file will produce a clear error message naming the missing basename and listing the .debug_line file table contents, 
---- so the user can either confirm the gcc include order, the unity-root, or the `.debug_line` file table contents.
---- Silent fallback would mask the new-file case by misattributing component rows to an arbitrary source file.
+--- Returns 0 (the DWARF `set_file(0)` "no file change" sentinel) when the basename is not in the file table.
+--- This is a normal occurrence: the compiler only adds a file to the `.debug_line` file table when the file has line-numbered content (i.e., code).
+--- Files containing only static-array data (e.g. `MipsAtomComp_` declarations in `gp.atom.c`, `psyq.atom.c`, `pad.atom.c` — the OT-tag inserts, etc.) produce no line numbers,
+--- so gcc omits them from the file table.
+--- The DWARF emitter then keeps the previous line-program file state instead of pointing at a file that has no entries to walk.
+--- A stderr warning is emitted per-miss so the user can audit which files the compiler dropped.
 --- @param path string  -- absolute provenance path (mixed slashes accepted)
---- @return integer  -- 1-based line-unit file index
+--- @return integer  -- 1-based line-unit file index, or 0 on miss (DWARF no-change sentinel)
 local function resolve_provenance_file_index(path)
 	if _file_index_by_basename == nil then
-		error("[dwarf_injection] resolve_provenance_file_index called before init_file_index_lookup. "
-			.. "Is M.run being entered correctly (with --elf)?")
+		error("[dwarf_injection] resolve_provenance_file_index called before init_file_index_lookup. Is M.run being entered correctly (with --elf)?")
 	end
 	if path == nil or path == "" then
 		error("[dwarf_injection] resolve_provenance_file_index: empty path")
@@ -211,13 +209,11 @@ local function resolve_provenance_file_index(path)
 	for i, p in pairs(_file_path_by_index) do
 		if p and p:gsub("\\", "/") == normalized then return i end
 	end
-	-- Build an error message listing the known basenames for fast diagnostics.
-	local known = {}
-	for k in pairs(_file_index_by_basename) do known[#known + 1] = k end
-	table.sort(known)
-	error(string.format("[dwarf_injection] resolve_provenance_file_index: unknown provenance basename '%s' (from '%s'). "
-		.. "Known basenames in the .debug_line file table (%d): %s"
-		, basename, path, #known, table.concat(known, ", ")))
+	-- File is in the corpus but gcc omitted it from the .debug_line file table (data-only content).
+	-- Return 0 = DWARF `set_file(0)` no-change sentinel so the line program keeps its prior file state.
+	io.stderr:write(string.format("[dwarf_injection] line-table miss: '%s' (basename '%s') not in .debug_line file table; "
+		.. "falling back to set_file(0)\n", path, basename))
+	return 0
 end
 
 local DW_FORM_addr           = 0x01
@@ -232,7 +228,6 @@ local DW_FORM_sec_offset     = 0x17   -- 4-byte section-relative offset (into .d
 
 -- DW_OP_reg0 + DW_OP_piece are declared above (lines 114-116) alongside the other DWARF5 §7.7.3 loclist opcodes.
 
-
 local DW_ATE_unsigned        = 0x07   -- DWARF5 §7.8.1: DW_ATE_unsigned (used for U4 base type)
 
 -- (DW_LANG_Mips_Assembler = 0x8001 was used in the, but we want this CU to look like a C TU so VSCode's Variables pane treats it as code.)
@@ -616,10 +611,8 @@ local function build_atom_sequence(atom)
 		-- NOT anc.body_lines[1] (= the line of the first WORD, which is wrong when the outer's body starts with a nested call).
 		for ai, anc in ipairs(entry_1_ancestry) do
 			assert(anc.body_lines, "missing body_lines: emitter did not run emission-model")
-			assert(anc.body_lines[1] ~= nil
-				, "dwarf_injection: body_lines[1] missing on first-word entry for inv=" .. tostring(anc.component_name))
-			assert(anc.call_path and anc.call_path ~= ""
-				, "dwarf_injection: inv.call_path is missing on invocation " .. tostring(anc.component_name) .. "; emitter did not run emission-model.")
+			assert(anc.body_lines[1] ~= nil,              "dwarf_injection: body_lines[1] missing on first-word entry for inv=" .. tostring(anc.component_name))
+			assert(anc.call_path and anc.call_path ~= "", "dwarf_injection: inv.call_path is missing on invocation "            .. tostring(anc.component_name) .. "; emitter did not run emission-model.")
 			emit_row(resolve_provenance_file_index(anc.call_path), anc.call_line,    true)
 			local is_outermost = (ai == 1)
 			if not (is_outermost and anc.debug_skip) then
@@ -644,8 +637,7 @@ local function build_atom_sequence(atom)
 			-- all OTHER ancestors emit body_lines[1] with is_stmt = not debug_skip.
 			--
 			-- This re-emits the outer ancestor's call-site + body rows at the inner's first word PC
-			-- for debugger context: source-level stepping now shows the outer body line
-			-- (not the inner body line) when stepping into the inner. PROBLEM B fix.
+			-- for debugger context: source-level stepping now shows the outer body line (not the inner body line) when stepping into the inner. PROBLEM B fix.
 			-- The body_lines[1] row references body_first_line_of[anc.id] (= the body's first content line in the parent's source), 
 			-- NOT anc.body_lines[1] (= the line of the first WORD, which is wrong when the outer's body starts with a nested call: 
 			-- gdb 12.1 picks the displayed line as the LAST row at the same PC in byte-stream order,
@@ -653,11 +645,8 @@ local function build_atom_sequence(atom)
 			local ancestry = ancestry_idx[idx]
 			for ai, anc in ipairs(ancestry) do
 				assert(anc.body_lines, "missing body_lines: emitter did not run emission-model")
-				assert(anc.body_lines[1] ~= nil
-					, string.format("missing body_lines[1] for inv=%s start_pos=%d len=%d",
-						anc.component_name, anc.start_pos, #(anc.body_lines or {})))
-				assert(anc.call_path and anc.call_path ~= ""
-					, "dwarf_injection: inv.call_path is missing on invocation " .. tostring(anc.component_name) .. "; emitter did not run emission-model.")
+				assert(anc.body_lines[1] ~= nil, string.format("missing body_lines[1] for inv=%s start_pos=%d len=%d", anc.component_name, anc.start_pos, #(anc.body_lines or {})))
+				assert(anc.call_path and anc.call_path ~= "", "dwarf_injection: inv.call_path is missing on invocation " .. tostring(anc.component_name) .. "; emitter did not run emission-model.")
 				emit_row(resolve_provenance_file_index(anc.call_path), anc.call_line, true)
 				local is_outermost = (ai == 1)
 				if not (is_outermost and anc.debug_skip) then
@@ -673,9 +662,7 @@ local function build_atom_sequence(atom)
 			-- Marked invocations emit non-statement body rows at every body word; unmarked invocations emit statement body rows.
 			assert(inv.body_lines, "missing body_lines: emitter did not run emission-model")
 			local words_into = idx - inv.start_pos
-			assert(inv.body_lines[words_into] ~= nil
-				, string.format("missing body_lines[%d] for inv=%s start_pos=%d len=%d idx=%d",
-					words_into, inv.component_name, inv.start_pos, #(inv.body_lines or {}), idx))
+			assert(inv.body_lines[words_into] ~= nil, string.format("missing body_lines[%d] for inv=%s start_pos=%d len=%d idx=%d", words_into, inv.component_name, inv.start_pos, #(inv.body_lines or {}), idx))
 			emit_row(resolve_provenance_file_index(inv.def_path), inv.body_lines[words_into], not inv.debug_skip)
 		else
 			-- RAW word: single call-site row, always a statement target (the word itself is unmarked).
@@ -716,9 +703,9 @@ end
 ---     `{comp_name, call_file, call_line, comp_file, comp_line, start_pos, end_pos, body_lines, debug_skip}`. `body_lines[k]`
 ---     is the k-th word's source line within the component body.
 ---
---- @param corpus    table -- the corpus from `ctx.shared.corpus`
+--- @param corpus table -- From `ctx.shared.corpus`
 --- @param addrs  table -- ELF symbols keyed by atom name from `elf_dwarf.read_nm`
---- @return table[]  -- list of {name, addr, size_bytes, words, entries, invocations, debug_skip?}
+--- @return table[]  -- List of {name, addr, size_bytes, words, entries, invocations, debug_skip?}
 local function build_atom_table(corpus, addrs)
 	-- Cross-ref: keep only atoms present in BOTH the nm symbol table AND `corpus.atoms_by_name`. Output is sorted by ascending addr.
 	local atoms_by_name = corpus.atoms_by_name or {}
@@ -777,9 +764,8 @@ local function build_atom_table(corpus, addrs)
 
 	local out = {}
 	-- Walk every source's atom list (which preserves source order + per-source src_path).
-	-- Cross-ref with the nm symbol table; atoms absent from `addrs` are skipped (an atom
-	-- declared in source but not emitted as a symbol is a metaprogram or atom-info bug, not
-	-- a source-correlation bug — emit_no_emit would catch it upstream).
+	-- Cross-ref with the nm symbol table; atoms absent from `addrs` are skipped
+	-- (an atom declared in source but not emitted as a symbol is a metaprogram or atom-info bug, not a source-correlation bug — emit_no_emit would catch it upstream).
 	for _, src in ipairs((corpus and corpus.source_order) or {}) do
 		local src_path = src.path or ""
 		for _, atom_rec in ipairs(((src.scan or {}).atoms) or {}) do
@@ -840,27 +826,33 @@ end
 ---   load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,FaceCursor)),
 ---   ...
 ---
+--- Also matches `load_half` / `load_half_u` / `load_byte` / `load_byte_u` (any MIPS load instruction with `(R_<reg>, R_<base>, O_(<Binds_X>, FieldName))` shape).
+--- Every field's `byte_size` + `offset` determine which load to emit; this function only records the (reg, field) pair.
+---
 --- The GPR for each `R_<reg>` is looked up in the merged register_alias_registry; aliases absent from the registry
 --- (no `atom_reg` opt-in) are silently skipped — the resulting rbind record will be incomplete and the atom will fail to bind a usable piece chain.
 --- This is intentional: silently falling back to a hardcoded GPR would mask the missing opt-in.
 ---
---- Pre-tokenized: `body_tokens` is the scan-source pass's pre-split list of top-level
---- statements (each entry is a single `load_word(...)` call or other statement).
---- @param body_tokens table[]  -- the atom's pre-tokenized body statements (from atom.body_tokens)
---- @param binds_name  string   -- expected Binds_X name (skip pairs with mismatching binds)
---- @param registries  table    -- merged registries from collect_per_source_registries
---- @return table[]             -- list of {reg = <MIPS index>, field = <field name>}
+--- Pre-tokenized: `body_tokens` is the scan-source pass's pre-split list of top-level statements (each entry is a single `load_*` call or other statement).
+--- @param body_tokens table[]  -- The atom's pre-tokenized body statements (from atom.body_tokens)
+--- @param binds_name  string   -- Expected Binds_X name (skip pairs with mismatching binds)
+--- @param registries  table    -- Merged registries from collect_per_source_registries
+--- @return table[]             -- List of {reg = <MIPS index>, field = <field name>}
 local function parse_body_load_pairs(body_tokens, binds_name, registries)
 	local pairs = {}
 	local reg_index_by_name = (registries and registries.register_alias_registry) or {}
+	-- One regex that matches any of: load_word, load_half, load_half_u, load_byte, load_byte_u, gte_lw, gte_lwc2.
+	-- The captured ident is `kind`; `inner` holds the parens body for arg parsing.
+	local load_pattern = "^(load_word|load_half|load_half_u|load_byte|load_byte_u|gte_lw|gte_lwc2)%s*%((.*)%)$"
 	for _, t in ipairs(body_tokens or {}) do
 		local tok         = duffle.trim(t.tok or "")
-		-- Match "load_word(...)" — the entire call is one body_tokens entry.
-		local inner = tok:match("^load_word%s*%((.*)%)$")
-		if inner then
+		local kind, inner = tok:match(load_pattern)
+		if kind then
 			local args = duffle.split_top_level_commas(inner)
-			-- Expected shape: (R_<reg>, R_TapePtr, O_(Binds_<X>, FieldName))
-			if #args >= 3 then
+			-- Expected shape for an rbind piece-chain load: (R_<reg>, R_TapePtr, O_(Binds_<X>, FieldName))
+			-- The second arg MUST be R_TapePtr — loads from other bases (e.g. `load_byte_u(R_RawStatus, R_PadRaw, 0)`)
+			-- are field-derivative loads that read already-bound tape values; they're NOT a new piece-chain.
+			if #args >= 3 and duffle.trim(args[2]) == "R_TapePtr" then
 				local reg_name  = duffle.trim(args[1])
 				local third_arg = duffle.trim(args[3])
 				-- Match O_(Binds_<X>, FieldName)
@@ -879,9 +871,7 @@ local function parse_body_load_pairs(body_tokens, binds_name, registries)
 end
 
 --- Collect every rbind atom + the matching Binds_X struct + (reg, field) pairs.
----
 --- Inputs come from the dep-closed `scan-source` pass (the per-source `src.scan` payload is preserved on each `corpus.source_order` entry).
----
 --- Returns:
 ---   rbind_atoms     = {[atom_name] = {binds, fields, regs, byte_size, info_line}}
 ---   rbind_structs   = {[binds_name] = {byte_size, fields, atom_names}}
@@ -890,9 +880,9 @@ end
 --- The piece chain uses (DW_OP_regN, DW_OP_piece, ULEB128(field_size)).
 ---
 --- Binds fields come from `scan.binds`; the per-source `scan.binds[i].fields` already carries the typed-field record after the scan-source generalization.
---- @param corpus     table   -- the corpus from `ctx.shared.corpus`
---- @param atom_table table[] -- the cross-ref'd atom table from build_atom_table
---- @param registries table   -- merged registries from collect_per_source_registries
+--- @param corpus     table   -- From `ctx.shared.corpus`
+--- @param atom_table table[] -- Cross-ref'd atom table from build_atom_table
+--- @param registries table   -- Merged registries from collect_per_source_registries
 --- @return table, table      -- (rbind_atoms, rbind_structs)
 local function parse_rbind_atoms(corpus, atom_table, registries)
 	registries = registries or {}
@@ -954,7 +944,7 @@ local function parse_rbind_atoms(corpus, atom_table, registries)
 						binds     = ai.binds,
 						fields    = struct.fields, -- {name, offset} from scan.binds
 						bytes     = struct.bytes,
-						regs      = pairs,         -- ordered list of {reg, field}
+						regs      = pairs,         -- Ordered list of {reg, field}
 						info_line = ai.info_line,
 					}
 					table.insert(struct.atom_names, atom_name)
@@ -981,7 +971,8 @@ end
 --- (the final unit, referenced by the main CU's DW_AT_stmt_list).
 ---
 --- This builder extends the main compilation unit.
---- A detached synthetic line unit has no DW_AT_stmt_list referencing it, so gdb ignored it (a previous experiment); byte 13 is the first special opcode, not the extended-opcode marker.
+--- A detached synthetic line unit has no DW_AT_stmt_list referencing it, so gdb ignored it (a previous experiment);
+--- byte 13 is the first special opcode, not the extended-opcode marker.
 --- The existing final unit already contains hello_gte_tape.c as file index 11 and ends with a valid end_sequence.
 --- We preserve its bytes, append independent atom sequences, and increase only that unit's DWARF32 unit_length.
 --- @param existing   string -- existing section bytes, byte-for-byte
@@ -992,9 +983,7 @@ local function build_dwarf_line_section(existing, atom_table)
 
 	-- Build the sequences.
 	local sequences = {}
-	for _, atom in ipairs(atom_table) do
-		sequences[#sequences + 1] = build_atom_sequence(atom)
-	end
+	for _, atom in ipairs(atom_table) do sequences[#sequences + 1] = build_atom_sequence(atom) end
 	local appended = table.concat(sequences)
 
 	-- Walk DWARF32 line units and retain the final unit's bounds.
@@ -1003,7 +992,7 @@ local function build_dwarf_line_section(existing, atom_table)
 	while unit_pos < #existing do
 		if unit_pos + 4 > #existing then return existing end
 		local unit_length =  elf_dwarf.read_u32_le(existing, unit_pos)
-		if    unit_length == elf_dwarf.ELF32.dw_dwarf32_terminator then return existing end
+		if    unit_length == elf_dwarf.dw_dwarf32_terminator then return existing end
 		local unit_end_excl = unit_pos + 4 + unit_length
 		if unit_end_excl > #existing then return existing end
 		last_pos, last_length, last_end = unit_pos, unit_length, unit_end_excl
@@ -1064,7 +1053,7 @@ local function build_dwarf_aranges_section(existing, atom_table)
 	while i < #existing do
 		-- Read this unit's length.
 		local ul = elf_dwarf.read_u32_le(existing, i)
-		if    ul == elf_dwarf.ELF32.dw_dwarf32_terminator then
+		if    ul == elf_dwarf.dw_dwarf32_terminator then
 			-- DWARF64 marker - not supported.
 			io.stderr:write("[dwarf_injection] WARN: .debug_aranges contains a DWARF64 marker (0xFFFFFFFF); the 64-bit extension is not supported by this metaprogram; passing through unchanged\n")
 			return existing
@@ -1528,13 +1517,12 @@ end
 ---        DW_AT_location  = piece-chain (DW_FORM_exprloc)
 ---        DW_AT_type      = ref4 → structure_type DIE
 ---
---- This function does NOT emit the final 0 byte (root terminator). build_debug_info_section splices bytes ahead of the root terminator
---- and preserves existing DIE bytes exactly.
+--- This function does NOT emit the final 0 byte (root terminator).
+--- build_debug_info_section splices bytes ahead of the root terminator and preserves existing DIE bytes exactly.
 ---
 --- ref4 basis: DW_FORM_ref4 is CU-relative (offset from the first byte of the CU header).
 --- Our inserted DIEs live in the main CU, so every ref4 = (target section offset) - main_cu_offset.
 --- Per-die section offsets are tracked via the running `next_offset` cursor (= section offset of the NEXT byte to emit).
----
 --- @param main_cu_offset integer    -- 0-based section offset of the main CU's unit_length field
 --- @param main_cu_end_excl integer  -- 0-based section offset of the first byte AFTER the main CU
 --- @param atom_table table[]        -- atoms (with atom.rbind set if rbind; atom.invocations set if mac_X(...) calls)
@@ -1654,6 +1642,8 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 	--
 	-- The table is small + explicit — the prototype principle treats the typed-view struct layout as data, not derived state.
 	local STRUCT_MEMBER_TABLE = {
+		-- TODO(Ed): This hardcoding is brittle...
+		-- TODO(Ed): Better to just have a table for the fundamental types in duffle/dsl.h, we can derive the rest via typedef parsing...
 		-- 2-element signed short vector (rare; placeholder for future use).
 		V2_S2 = { byte_size = 4, members = {
 			{ name = "x", offset = 0, byte_size = 2 },
@@ -1790,7 +1780,8 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 	emit(uleb128(ABBREV_TYPED_VIEW_POINTER))  -- DW_TAG_pointer_type (abbrev 110; NOT 9; void chain target)
 	emit(elf_dwarf.write_u32_le(ref4_of(void_chain_offset)))  -- 4-byte ref4: points at the void base_type's tag byte
 	-- type_chain_offsets["void|1"] is what step (f) of the per-RR_<R_Name> chain looks up.
-	type_chain_offsets["void|1"] = void_chain_offset  -- both the base_type offset and the pointer_type are emitted consecutively; the OUTERMOST is the pointer_type. The variable's DW_AT_type must reference the pointer_type, not the base_type. Patch below.
+	type_chain_offsets["void|1"] = void_chain_offset  -- both the base_type offset and the pointer_type are emitted consecutively; the OUTERMOST is the pointer_type.
+	-- The variable's DW_AT_type must reference the pointer_type, not the base_type. Patch below.
 	-- Capture the pointer_type's offset (the last-thing-emitted DIE start) and overwrite the lookup.
 	-- The pointer_type was emitted as: uleb(9) (1 byte) + 4-byte ref4 = 5 bytes. Its tag byte is at void_chain_offset + 8 (the base_type's 8 bytes: 1 tag + 5 name + 1 byte_size + 1 encoding).
 	local ptr_void_offset = void_chain_offset + 8
@@ -1906,6 +1897,7 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 		end
 		local atom_view = (registries.atom_views or {})[atom.name]
 		-- Build the atom-name lookup table once (cheap; O(atom_table)) so step (b) and step (d) can resolve rbind_atom names.
+		-- TODO(Ed): Bad assignment?
 		local atom_by_name = atom_by_name or (function() local m = {}; for _, a in ipairs(atom_table) do if a.name then m[a.name] = a end end; return m end)()
 		-- step (b) inputs: this atom's `atom_ctx(<rbind_atom>)` (resolved from the registries' atom_ctxs)
 		local this_ctx = registries.atom_ctxs and registries.atom_ctxs[atom.name]
@@ -1986,6 +1978,7 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 			end,
 			-- (e) enum-site atom_type(<T>) default on the registry entry.
 			function(r_name, alias_code)
+				-- TODO(Ed): Bad definition?
 				if alias and alias.default_type and alias.default_depth and alias.default_depth > 0 then
 					return type_chain_offsets[alias.default_type .. "|" .. alias.default_depth]
 				end
@@ -2098,7 +2091,6 @@ local function build_debug_str_section(existing, atom_table, registries)
 end
 
 --- Build the new .debug_info: SPLICE inserted DIEs into the MAIN CU as children.
----
 --- This implementation:
 ---   1. Builds the inserted-children bytes (base_type, struct_types, subprograms with their RR_* + bind_args children) via build_inserted_children.
 ---   2. Patches the main CU's `unit_length` field to account for the inserted bytes.
@@ -2217,7 +2209,8 @@ function M.run(ctx)
 
 	-- Read the existing DWARF sections directly (no subprocess; io.open + manual ELF32 section-header walk).
 	-- We need all 8 sections: .debug_line / .debug_aranges / .debug_rnglists get extended (additional rows appended to the existing unit),
-	-- and .debug_info / .debug_abbrev / .debug_str / .debug_loc / .debug_loclists get spliced (the main CU's unit_length is patched; no new compile unit is appended; .debug_loc/.debug_loclists may not exist in the source ELF so we add-section them on splice).
+	-- and .debug_info / .debug_abbrev / .debug_str / .debug_loc / .debug_loclists get spliced
+	-- (the main CU's unit_length is patched; no new compile unit is appended; .debug_loc/.debug_loclists may not exist in the source ELF so we add-section them on splice).
 	-- The per-section dispatch is inlined in the writers loop below.
 	local existing_sections = elf_dwarf.read_elf_sections(elf_path, {
 		".debug_line", ".debug_aranges", ".debug_rnglists",
@@ -2234,8 +2227,7 @@ function M.run(ctx)
 	-- `corpus` is the sole canonical source projection.
 	local corpus     = (ctx.shared and ctx.shared.corpus) or {}
 	local registries = collect_per_source_registries(corpus)
-	-- Read nm symbols (the ONLY disk-side input to the atom table) and join
-	-- them against `corpus.atoms_by_name` + `atom.paths` for word rows + invocation ancestry.
+	-- Read nm symbols (the ONLY disk-side input to the atom table) and join them against `corpus.atoms_by_name` + `atom.paths` for word rows + invocation ancestry.
 	-- Disk source-map/provenance text is not consulted (those are diagnostic artifacts; semantic inputs are in memory).
 	local addrs      = elf_dwarf.read_nm(ctx.flags.elf_path)
 	local atom_table = build_atom_table(corpus, addrs)

scripts/passes/emission_model.lua

@@ -41,7 +41,6 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 -- 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.
@@ -59,8 +58,7 @@ local function stamp_root_provenance(projection, atom_record, src, corpus)
 	-- `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 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      = {}
 
@@ -190,11 +188,11 @@ function M.run(ctx)
 	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.
+	-- Kind must be one of: atom | atom_proc | 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
+		if kind ~= "atom" and kind ~= "atom_proc" and kind ~= "raw_atom" and kind ~= "comp_bare" and kind ~= "comp_proc" then
 			return
 		end
 		local proj = project_atom(atom, src, corpus)
@@ -217,7 +215,7 @@ function M.run(ctx)
 	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.
+	-- Recognized kinds (atom | atom_proc | 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 {}

scripts/passes/offsets.lua

@@ -3,12 +3,19 @@
 --- Reads the pre-scanned SourceScan payload (produced once upstream by `duffle.scan_source`)
 --- for `MipsAtom_(name)` and `MipsCode code_<name>` declarations, computes the word offset
 --- 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.
+--- `gen/offsets.h` with one `#define _atom_offset_F_T = N` per branch.
+---
+--- Per-directory aggregation: every source in the same directory contributes to the same `gen/offsets.h`.
+--- The directory itself is the namespace; the filename does not repeat the module name.
+---
+--- (Task 12.16 note: atom-namespaced enum names — e.g., `atom_offset__normalize_v3s4__srav_path__aligned_done` —
+--- were considered to prevent cross-atom label collisions, but the C-side `atom_offset(F, T)` macro in
+--- `code/duffle/dsl.atom.h` doesn't know the current atom_name at expansion time, so any namespacing
+--- on the metaprogram side breaks the C build. Reverted. The C-side would need a per-atom
+--- `CURRENT_ATOM` #define (set by `MipsAtom_`/`MipsAtom_Proc_` macros) plus an updated `atom_offset`
+--- macro that uses it. That's a coordinated refactor — deferred to a future track.)
 ---
 --- The offset is `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding: branch_offset = relative_pc_in_words - 1).
----
---- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
---- Lua 5.3 compatible.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
@@ -16,8 +23,7 @@
 
 -- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
 -- 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.
+-- Uses `debug.getinfo` to find this file's own directory, so it works 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 "./"
@@ -39,17 +45,17 @@ local OFFSET_MACRO_COL = 44
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @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
---- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- Directory containing the source
+--- @field basename string  -- Filename without extension
+--- @field scan     table   -- Pre-scanned SourceScan payload (from duffle.scan_source)
 
 --- @class PassCtx
---- @field shared             table                  -- cross-pass shared state
---- @field shared.corpus      table                  -- canonical corpus projection
+--- @field shared             table -- Cross-pass shared state
+--- @field shared.corpus      table -- Corpus projection
 --- @field shared.word_counts table
---- @field out_root           string                 -- output root (e.g. "build/gen")
+--- @field out_root           string -- Output root (e.g. "build/gen")
 
 --- @class PassResult
 --- @field outputs  table[]  -- {kind=, path=} entries describing emit files
@@ -57,22 +63,24 @@ local OFFSET_MACRO_COL = 44
 --- @field warnings table[]  -- {line=, msg=}  entries; build-succeeds
 
 --- @class BranchOffset
---- @field tag         string   -- the marker tag (e.g. "F" in `atom_offset(F, T)`)
---- @field target      string   -- the target label name (e.g. "T" in `atom_offset(F, T)`)
---- @field branch_word integer  -- branch word position within the atom body
---- @field offset      integer  -- computed `target_word - branch_word - 1`
+--- @field tag               string      -- Marker tag (e.g. "F" in `atom_offset(F, T)`)
+--- @field target            string      -- Target label name (e.g. "T" in `atom_offset(F, T)`)
+--- @field branch_word       integer     -- Branch word position within the atom body
+--- @field offset            integer     -- Computed per consuming instruction (see `compute_offsets`)
+--- @field consuming_encoder string|nil  -- Instruction consuming the offset (e.g. "branch_le_zero", "jump", "call_addr")
+--- @field consuming_arg_pos integer|nil -- 1-based arg position within the consuming instruction's arg list
 
 --- @class AtomData
---- @field name        string         -- atom name
---- @field total_words integer        -- total word count of the atom body
---- @field offsets     BranchOffset[] -- per-branch offset list
+--- @field name        string         -- Atom name
+--- @field total_words integer        -- Total word count of the atom body
+--- @field offsets     BranchOffset[] -- Per-branch offset list
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Canonical marker projection
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- MARKER_PROJECTORS is the marker-kind data table.
--- The emission-model pass already records marker word positions;
+-- The emission-model pass already records marker word positions + consuming-instruction context;
 -- this pass only projects those records into the label/branch lookup shape needed by offset computation.
 local MARKER_PROJECTORS = {
 	label = function(state, marker)
@@ -83,6 +91,8 @@ local MARKER_PROJECTORS = {
 			tag                = marker.name,
 			target             = marker.target,
 			branch_word        = marker.word_index,
+			consuming_encoder  = marker.consuming_encoder,
+			consuming_arg_pos  = marker.consuming_arg_pos,
 		}
 	end,
 }
@@ -104,7 +114,18 @@ end
 -- Offset computation + header generation
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Compute branch offsets as `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding).
+--- Compute branch offsets per consuming instruction.
+--- Disposition table:
+---   `branch_*`           -> relative offset: `target_word - branch_word - 1` (MIPS branch-immediate encoding).
+---   `jump` / `call_addr` -> same value as `branch_*` (a relative word offset). 
+---     The duffle headers' `enc_i` macro truncates the value to the immediate-field width (16 bits for branches, 26 bits for jumps).
+---     For tape-atom bodies within a single module, this works for `j`/`jal` because the linker's symbol resolution produces the correct 26-bit absolute target via standard `j` relocations.
+---     For cross-module `j`/`jal` (atom body in one module, target in another), the linker emits a `R_MIPS_26` relocation against the lower 26 bits; the upper 4 bits come from the PC of the delay slot following the `j`.
+---     The metaprogram doesn't know either at compile time, so the emitted value is the relative word offset that the duffle `enc_i` macro places in the immediate field; the toolchain handles the rest.
+---   `jump_reg` / `call_reg` / `jump_link` -> ERROR. Register-form jumps have no offset field; `atom_offset` is invalid.
+---
+--- Top-level `atom_offset(F, T)` markers (where the marker is the entire token — `consuming_encoder` == nil) default to `branch_*` behavior (relative offset).
+--- This preserves backward compatibility for any top-level marker that may exist outside a control-transfer instruction.
 --- @param labels   table<string, integer>
 --- @param branches table[]
 --- @return BranchOffset[]
@@ -115,11 +136,23 @@ local function compute_offsets(labels, branches)
 		if not target then
 			error("Branch target '" .. br.target .. "' has no atom_label (at word " .. br.branch_word .. ")")
 		end
+		local consuming = br.consuming_encoder
+		local offset
+		if consuming == "jump_reg" or consuming == "call_reg" or consuming == "jump_link" then
+			-- Register-form jumps have no offset field. `atom_offset` cannot be used here.
+			error("atom_offset cannot be used with " .. consuming
+				.. " (register-form jumps have no offset field); at word " .. br.branch_word)
+		end
+		-- All other consuming instructions (including `branch_*`, `jump`, `call_addr`, and nil for top-level markers) use the same relative offset value.
+		-- The MIPS encoding differs per opcode but the duffle `enc_i` macro handles the truncation to the immediate-field width.
+		offset = target - br.branch_word - 1
 		results[#results + 1] = {
 			target             = br.target,
 			tag                = br.tag,
 			branch_word        = br.branch_word,
-			offset      = target - br.branch_word - 1,
+			offset             = offset,
+			consuming_encoder  = br.consuming_encoder,
+			consuming_arg_pos  = br.consuming_arg_pos,
 		}
 	end
 	return results
@@ -167,41 +200,45 @@ local function emit_atom_offsets(add, atom)
 	add("")
 end
 
---- Generate the per-source .offsets.h header.
---- @param source_path string
+--- Generate the per-directory .offsets.h header.
+--- @param dir          string     -- the absolute source directory
+--- @param sources      table[]    -- sources contributing to this directory (for the header comment)
 --- @param atoms_data   AtomData[]
 --- @return string
-local function generate_header(source_path, atoms_data)
-	local basename = duffle.basename_no_ext(source_path)
+local function generate_header(dir, sources, atoms_data)
+	local dir_basename = duffle.basename_no_ext(dir)
 
 	local lines = {}
 	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)
+	add("// Directory: " .. dir:gsub("/", "\\") .. "\\")
+	for _, src in ipairs(sources) do
+		add("//   source: " .. src.path:gsub("/", "\\"))
+	end
 	add("#pragma once")
 	add("")
-	add("#pragma region " .. basename)
+	add("#pragma region " .. dir_basename)
 	add("")
 	add("")
 	for _, atom in ipairs(atoms_data) do
 		emit_atom_offsets(add, atom)
 	end
-	add("#pragma endregion " .. basename)
+	add("#pragma endregion " .. dir_basename)
 	add("")
 	return table.concat(lines, "\n") .. "\n"
 end
 
 local M = {}
 
---- (internal) Process one source: render offsets from canonical atom paths.
+--- (internal) Aggregate atoms from every source in one directory, render the per-directory `offsets.h`.
 --- Returns the offsets_h path if a header was written, or nil.
 --- @param ctx     PassCtx
---- @param src SourceFile
+--- @param dir     string       -- the absolute source directory
+--- @param sources SourceFile[] -- sources in this directory
 --- @return string|nil  -- the offsets_h path
-local function process_source(ctx, src)
+local function process_directory(ctx, dir, sources)
 	local atoms_data = {}
-	local scan = src.scan or {}
 
 	local function append_atom(atom)
 		local  paths = atom and atom.paths
@@ -214,19 +251,22 @@ local function process_source(ctx, src)
 		}
 	end
 
+	for _, src in ipairs(sources) do
+		local scan = src.scan or {}
 		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
+	end
 	if #atoms_data == 0 then return nil end
 
-	local out_path = src.dir .. "/gen/" .. duffle.basename_no_ext(src.dir) .. ".offsets.h"
+	local out_path = dir .. "/gen/offsets.h"
 	duffle.ensure_dir(duffle.dirname(out_path))
-	duffle.write_file(out_path, generate_header(src.path:gsub("/", "\\"), atoms_data))
+	duffle.write_file(out_path, generate_header(dir, sources, 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.
+--- For each canonical source-directory, emits a per-directory `gen/offsets.h`
+--- containing constants for every marker recorded in atom.paths across every source in that directory.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -235,12 +275,17 @@ function M.run(ctx)
 	local warnings = {}
 
 	local corpus = ctx.shared and ctx.shared.corpus
-	if type(corpus) ~= "table" or type(corpus.source_order) ~= "table" then
-		error("offsets.run requires ctx.shared.corpus.source_order (canonical corpus).", 0)
+	if type(corpus) ~= "table" then
+		error("offsets.run requires ctx.shared.corpus", 0)
+	end
+	if type(corpus.source_order) ~= "table" then
+		error("offsets.run requires ctx.shared.corpus.source_order.", 0)
 	end
 
-	for _, src in ipairs(corpus.source_order) do
-		local out_path = process_source(ctx, src)
+	-- Per-directory aggregation: every source in the same directory contributes to one `gen/offsets.h`.
+	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order)
+	for dir, sources in pairs(sources_by_dir) do
+		local out_path = process_directory(ctx, dir, sources)
 		if out_path then
 			outputs[#outputs + 1] = { offsets_h = out_path }
 		end

scripts/passes/report.lua

@@ -1,22 +1,21 @@
---- passes/report.lua — Per-MODULE annotation report renderer +
---- project-wide summary writer.
+--- passes/report.lua — Per-MODULE annotation report renderer + project-wide summary writer.
 ---
 --- Two output files per build:
 ---   - `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 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.
+--- This pass iterates the dir projection directly and re-validates each source via `annotation.validate()` to get the detailed per-source results.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- Resolve `arg[0]` to an absolute-ish script directory so that `require("duffle")` resolves against `scripts/` regardless of CWD.
--- Bootstrap: see `ps1_meta.lua` for the rationale.
--- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
+-- Bootstrap: See `ps1_meta.lua` for the rationale.
+-- 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.
--- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
+-- 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")
@@ -59,20 +58,20 @@ local PASS_NAME = "report"
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @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
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- 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 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
+--- @field verbose            boolean              -- If true, log diagnostic info
 
 --- @class PassResult
 --- @field outputs  table[]  -- {kind=, path=} entries describing emit files
@@ -82,60 +81,60 @@ local PASS_NAME = "report"
 -- 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
+--- @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 line    integer     -- Source line
+--- @field macro   string      -- Macro name (e.g. "atom_reads")
+--- @field name    string      -- 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
+--- @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
+--- @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
+--- @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
+--- @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
+--- @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 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)
+--- @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
+--- @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
+--- @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
+--- @field results AnnotationResult[]  -- All per-source results
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Per-MODULE annotation report (aggregated across all sources in a dir)
@@ -153,9 +152,16 @@ end
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- Render the thin project-wide summary (`build/atom_meta_report.summary.md`).
---- @param all_results { module:string, atoms:integer, annots:integer, binds:integer,
----                       macros:integer, findings:integer, errors:integer,
----                       warnings:integer, info:integer }[]
+--- @param all_results { 
+--- 	module:string,
+--- 	atoms:integer, 
+--- 	annots:integer, 
+--- 	binds:integer,
+---		macros:integer,   
+---		findings:integer,
+---		errors:integer,
+--- 	warnings:integer,
+--- 	info:integer }[]
 --- @return string
 local function render_project_summary(all_results)
 	local lines = {
@@ -165,13 +171,10 @@ local function render_project_summary(all_results)
 		"| module | atoms | annots | binds | macros | findings | errors | warnings | info |",
 		"|--------|-------|--------|-------|--------|----------|--------|----------|------|",
 	}
-	local totals = { atoms = 0, annots = 0, binds = 0, macros = 0,
-		findings = 0, errors = 0, warnings = 0, info = 0 }
+	local totals = { atoms = 0, annots = 0, binds = 0, macros = 0, findings = 0, errors = 0, warnings = 0, info = 0 }
 	for _, e in ipairs(all_results) do
-		lines[#lines + 1] = string.format(
-			"| %s | %d | %d | %d | %d | %d | %d | %d | %d |",
-			e.module, e.atoms, e.annots, e.binds, e.macros,
-			e.findings, e.errors, e.warnings, e.info)
+		lines[#lines + 1] = string.format("| %s | %d | %d | %d | %d | %d | %d | %d | %d |"
+			, e.module, e.atoms, e.annots, e.binds, e.macros, e.findings, e.errors, e.warnings, e.info)
 		totals.atoms    = totals.atoms    + e.atoms
 		totals.annots   = totals.annots   + e.annots
 		totals.binds    = totals.binds    + e.binds
@@ -181,10 +184,8 @@ local function render_project_summary(all_results)
 		totals.warnings = totals.warnings + e.warnings
 		totals.info     = totals.info     + e.info
 	end
-	lines[#lines + 1] = string.format(
-		"| **TOTAL** | %d | %d | %d | %d | %d | %d | %d | %d |",
-		totals.atoms, totals.annots, totals.binds, totals.macros,
-		totals.findings, totals.errors, totals.warnings, totals.info)
+	lines[#lines + 1] = string.format("| **TOTAL** | %d | %d | %d | %d | %d | %d | %d | %d |"
+		, totals.atoms, totals.annots, totals.binds, totals.macros, totals.findings, totals.errors, totals.warnings, totals.info)
 	return table.concat(lines, "\n") .. "\n"
 end
 
@@ -326,8 +327,8 @@ local function render_module_meta_report(dir, dir_sources, annot_results, sa_res
 				local binds  = a.binds  or "—"
 				local reads  = (#a.reads  > 0 and table.concat(a.reads,  ",")) or "—"
 				local writes = (#a.writes > 0 and table.concat(a.writes, ",")) or "—"
-				add(string.format("| %s | %d | %s | %s | %s | %s |",
-					src_name, a.line, a.name, binds, reads, writes))
+				add(string.format("| %s | %d | %s | %s | %s | %s |"
+					, src_name, a.line, a.name, binds, reads, writes))
 			end
 		end
 	end

scripts/passes/scan_source.lua

@@ -2,8 +2,8 @@
 ---
 --- Single source-walk pass that produces the fat `SourceScan` payload consumed by all downstream passes. Walks each corpus source record once,
 --- extracting every construct type the metaprograms need:
----
 ---   MipsAtom_              (kind = "atom", with optional atom_info inner)
+---   MipsAtom_Proc_         (kind = "atom_proc", body inside last {})
 ---   MipsAtomComp_          (kind = "comp_bare")
 ---   MipsAtomComp_Proc_     (kind = "comp_proc", body inside last {})
 ---   atom_dbg_skip          — bare whole-atom/component debug-step marker; following declaration disambiguates
@@ -14,8 +14,6 @@
 --- The result is attached to each `src.scan` so downstream passes can read from `src.scan.atoms` / `src.scan.binds` / etc. without re-walking the source.
 --- This is the first pass in the dep graph (no deps).
 --- Every other pass that reads source structure depends on this one — see `ps1_meta.lua :: PASSES`.
----
---- **Conventions**: tabs (1/level), EmmyLua annotations, no regex, Lua 5.3 compatible
 
 -- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
 -- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
@@ -37,7 +35,7 @@ local parse_enum_int_literal
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class SourceScan
---- @field atoms             AtomEntry[]     -- MipsAtom_ + MipsAtomComp_ + MipsAtomComp_Proc_
+--- @field atoms             AtomEntry[]     -- MipsAtom_ + MipsAtom_Proc_ + MipsAtomComp_ + MipsAtomComp_Proc_
 --- @field raw_atoms         AtomEntry[]     -- MipsCode code_<name> { body } (offsets pass only)
 --- @field binds             BindsEntry[]    -- typedef Struct_(Binds_X) { fields } (fields pre-parsed)
 --- @field atom_infos        AtomInfoEntry[] -- MipsAtom_(name) atom_info(...) (sub-calls pre-parsed)
@@ -50,15 +48,15 @@ local parse_enum_int_literal
 --- @field line_of           fun(pos: integer): integer       -- shared LineIndex closure
 
 --- @class DebugSkipMarker
---- @field marker_kind    string      -- exact marker ident read from source. Only "atom_dbg_skip" (bare) is positive; any other ident reaches the unrelated fallback and is never associated with a declaration.
---- @field marker_line    integer     -- line of the marker ident start
---- @field marker_pos     integer     -- byte position of the marker ident start (the comment walker anchors here)
+--- @field marker_kind    string      -- Exact marker ident read from source. Only "atom_dbg_skip" (bare) is positive; any other ident reaches the unrelated fallback and is never associated with a declaration.
+--- @field marker_line    integer     -- Line of the marker ident start
+--- @field marker_pos     integer     -- Byte position of the marker ident start (the comment walker anchors here)
 --- @field is_bare        boolean     -- true iff marker_kind == "atom_dbg_skip" AND has_parens == false (the only positive form)
 --- @field has_parens     boolean     -- true iff a `(...)` follows the marker ident (diagnostic-only)
---- @field args           string|nil  -- trimmed args inside the `(...)` (nil when has_parens is false)
+--- @field args           string|nil  -- Trimmed args inside the `(...)` (nil when has_parens is false)
 --- @field pending        boolean     -- true while awaiting the following declaration
 --- @field superseded_by_marker_line integer|nil -- set when a newer marker bumped this one out of the pending slot
---- @field target_kind    string|nil  -- "atom" | "comp_bare" | "comp_proc" | "unrelated" once observed (nil if no declaration ever followed)
+--- @field target_kind    string|nil  -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "unrelated" once observed (nil if no declaration ever followed)
 --- @field proc_prelude   boolean|nil -- true after the marker crossed an `FI_` prelude and awaits `MipsAtomComp_Proc_`
 
 --- @class RegTypeDefault
@@ -71,15 +69,15 @@ local parse_enum_int_literal
 --- @field reg           string  -- "R_T0"
 --- @field type_name     string
 --- @field pointer_depth integer
---- @field source_line   integer -- line of the call site (callsite or enum-site)
+--- @field source_line   integer -- Line of the call site (callsite or enum-site)
 
 --- @class AtomCtxEntry
---- @field rbind_atom string  -- the rbind atom ident that this consumer should propagate types from
+--- @field rbind_atom string  -- The rbind atom ident that this consumer should propagate types from
 --- @field info_line  integer
---- @field source     string  -- absolute path of the source file
+--- @field source     string  -- Absolute path of the source file
 
 --- @class AtomPhaseGroup
---- @field atoms string[]  -- atom names tagged with this phase label (source-order)
+--- @field atoms string[]  -- Atom names tagged with this phase label (source-order)
 
 --- @class AtomViewEntry
 --- @field atom_name        string                 -- e.g. "red_cube_g4_face"
@@ -88,11 +86,11 @@ local parse_enum_int_literal
 --- @field info_line        integer                -- line of the atom_info call
 
 --- @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
---- @field scan     table   -- pre-scanned SourceScan payload (set by this pass)
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- Directory containing the source
+--- @field basename string  -- Filename without extension
+--- @field scan     table   -- Pre-scanned SourceScan payload (set by this pass)
 
 --- @class PassCtx
 --- @field sources            SourceFile[]
@@ -111,15 +109,15 @@ local parse_enum_int_literal
 
 --- @class AtomEntry
 --- @field line              integer
---- @field name              string     -- atom name (for components: without ac_ prefix)
---- @field body              string     -- brace-delimited body (without the braces)
---- @field body_off          integer    -- char offset of body[1] in source
---- @field kind              string     -- "atom" | "comp_bare" | "comp_proc" | "raw_atom"
---- @field raw_name          string     -- un-stripped name (for components: with ac_ prefix)
---- @field ident_pos         integer    -- position of the MipsAtom_/MipsAtomComp_ ident start
---- @field after_paren       integer    -- position past the closing paren
+--- @field name              string       -- Atom name (for components: without ac_ prefix)
+--- @field body              string       -- Brace-delimited body (without the braces)
+--- @field body_off          integer      -- Char offset of body[1] in source
+--- @field kind              string       -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "raw_atom"
+--- @field raw_name          string       -- Un-stripped name (for components: with ac_ prefix)
+--- @field ident_pos         integer      -- Position of the MipsAtom_/MipsAtomComp_ ident start
+--- @field after_paren       integer      -- Position past the closing paren
 --- @field debug_skip        boolean      -- true when an `atom_dbg_skip` bare marker immediately precedes this declaration (sole-owner stamp; see push_debug_skip_marker)
---- @field declaration_comment string|nil -- populated by the scanner (backward walk past the marker, captures contiguous `/* */` or `//` block)
+--- @field declaration_comment string|nil -- Populated by the scanner (backward walk past the marker, captures contiguous `/* */` or `//` block)
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Local helpers (shared by per-form parsers)
@@ -139,10 +137,10 @@ local QUALIFIER_KEYWORDS = {
 local AC_PREFIX     = "ac_"
 local AC_PREFIX_LEN = 3
 
--- Strip the "ac_" prefix from a component name.
--- Returns the input unchanged if it doesn't start with the prefix.
--- @param raw_name string
--- @return string
+--- Strip the "ac_" prefix from a component name.
+--- Returns the input unchanged if it doesn't start with the prefix.
+--- @param raw_name string
+--- @return string
 local function strip_ac_prefix(raw_name)
 	if #raw_name > AC_PREFIX_LEN and raw_name:sub(1, AC_PREFIX_LEN) == AC_PREFIX then
 		return raw_name:sub(AC_PREFIX_LEN + 1)
@@ -184,19 +182,19 @@ local function find_body_braces(source, after_paren, fallback)
 	return body, after_brace, brace + 1
 end
 
--- Walk backward from `start_pos` capturing contiguous `/* */` block(s) and
--- `//` line(s) that immediately precede it. The caller (preceding_declaration_comment)
--- supplies `start_pos` so the walker does not need to detect marker shape or prelude layout.
--- The scanner already knows the marker_pos + decl ident_pos and threads that knowledge forward.
---
--- The walker captures:
---   - Block comment close `*/` followed by walking back to `/*`.
---   - `//` line comments (the line containing the current non-ws position starts with `//`).
--- It stops at the first non-ws char that does not begin a comment block or line.
--- Empty string if no comment is adjacent.
--- @param source string
--- @param start_pos integer -- exclusive upper bound for the captured block
--- @return string
+--- Walk backward from `start_pos` capturing contiguous `/* */` block(s) and
+--- `//` line(s) that immediately precede it. The caller (preceding_declaration_comment)
+--- supplies `start_pos` so the walker does not need to detect marker shape or prelude layout.
+--- The scanner already knows the marker_pos + decl ident_pos and threads that knowledge forward.
+---
+--- The walker captures:
+---   - Block comment close `*/` followed by walking back to `/*`.
+---   - `//` line comments (the line containing the current non-ws position starts with `//`).
+--- It stops at the first non-ws char that does not begin a comment block or line.
+--- Empty string if no comment is adjacent.
+--- @param source    string
+--- @param start_pos integer -- exclusive upper bound for the captured block
+--- @return string
 local function preceding_comment_walk_backward(source, start_pos)
 	local pieces  = {}
 	local scan_pos = start_pos
@@ -249,13 +247,13 @@ local function preceding_comment_walk_backward(source, start_pos)
 	return table.concat(pieces, "\n")
 end
 
--- Resolve the start position for the declaration-comment walk.
--- When a debug-skip marker is pending, the walker must start from the position immediately before the marker ident
--- (so it walks backward past the marker text and any `FI_ MipsAtom ac_X(args)` proc-prelude layout — neither of which is visible if we start from the declaration ident_pos).
--- When no marker is pending, the walker starts from the declaration ident_pos directly.
--- @param pending_marker DebugSkipMarker|nil
--- @param ident_pos integer -- declaration ident position
--- @return integer
+--- Resolve the start position for the declaration-comment walk.
+--- When a debug-skip marker is pending, the walker must start from the position immediately before the marker ident
+--- (so it walks backward past the marker text and any `FI_ MipsAtom ac_X(args)` proc-prelude layout — neither of which is visible if we start from the declaration ident_pos).
+--- When no marker is pending, the walker starts from the declaration ident_pos directly.
+--- @param pending_marker DebugSkipMarker|nil
+--- @param ident_pos      integer -- declaration ident position
+--- @return integer
 local function comment_walk_start(pending_marker, ident_pos)
 	if pending_marker then
 		return pending_marker.marker_pos - 1
@@ -263,16 +261,16 @@ local function comment_walk_start(pending_marker, ident_pos)
 	return ident_pos - 1
 end
 
--- Attach the pending marker to the next declaration.
--- The declaration form disambiguates whole atoms from components; the resolved `debug_skip` is stamped directly on the declaration record
--- (sole-owner discipline; see push_debug_skip_marker).
---
--- A marker is POSITIVE (stamps `debug_skip = true` on the declaration) iff:
---   marker_kind == "atom_dbg_skip" AND is_bare == true
--- Any other spelling or shape (parenthesized form, legacy name) is recorded as a raw marker for annotation validation but never stamps `debug_skip`.
--- @param out SourceScan
--- @param target_kind string|nil -- "atom" | "comp_bare" | "comp_proc" | "unrelated" once observed
--- @return boolean|nil -- true iff the marker is the positive bare form
+--- Attach the pending marker to the next declaration.
+--- The declaration form disambiguates whole atoms from components; the resolved `debug_skip` is stamped directly on the declaration record
+--- (sole-owner discipline; see push_debug_skip_marker).
+---
+--- A marker is POSITIVE (stamps `debug_skip = true` on the declaration) iff:
+---   marker_kind == "atom_dbg_skip" AND is_bare == true
+--- Any other spelling or shape (parenthesized form, legacy name) is recorded as a raw marker for annotation validation but never stamps `debug_skip`.
+--- @param out         SourceScan
+--- @param target_kind string|nil -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "unrelated" once observed
+--- @return boolean|nil -- true iff the marker is the positive bare form
 local function attach_debug_skip_marker(out, target_kind)
 	local markers = out.debug_skip_markers
 	local marker  = markers[#markers]
@@ -802,6 +800,11 @@ local BYTE_x          = 0x78   -- 'x'
 local BYTE_X          = 0x58   -- 'X'
 local BYTE_OPEN_BRACE = 0x7B   -- '{'
 local BYTE_CLOSE_BRACE= 0x7D   -- '}'
+local BYTE_SLASH      = 0x2F   -- '/'
+local BYTE_STAR       = 0x2A   -- '*'
+local BYTE_SPACE      = 0x20   -- ' '
+local BYTE_TAB        = 0x09   -- '\t'
+local BYTE_CR         = 0x0D   -- '\r'
 
 -- Maximum chain depth when resolving `R_*_Code` symbol RHS references.
 -- Eight hops is enough for any production chain (R_TapePtr_Code -> R_T8_Code -> ...).
@@ -825,6 +828,44 @@ local function hex_digit_value(b)
 	return nil
 end
 
+-- Read one trailing C-comment that appears immediately after `pos` in `body`,
+-- skipping horizontal whitespace and newlines first. Used by `parse_enum_entry` to
+-- recover the `atom_auto_reg:` / `phase_auto_reg:` scope annotation embedded by
+-- the `atom_auto_reg` / `phase_auto_reg` macros' RHS expansion
+-- (`R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`).
+-- Handles both block (`/* ... */`) and line (`// ...`) forms.
+-- Returns the comment text (without delimiters), or nil if no comment is adjacent.
+local function read_trailing_cmt_after(body, pos)
+	local body_len = #body
+	while pos <= body_len do
+		local b = body:byte(pos)
+		if b == BYTE_SPACE or b == BYTE_TAB or b == BYTE_NEWLINE or b == BYTE_CR then
+			pos = pos + 1
+		elseif b == BYTE_SLASH then
+			local b2 = body:byte(pos + 1)
+			if b2 == BYTE_STAR then
+				-- Block comment /* ... */
+				local i = pos + 2
+				while i < body_len do
+					if body:byte(i) == BYTE_STAR and body:byte(i + 1) == BYTE_SLASH then
+						return body:sub(pos + 2, i - 1)
+					end
+					i = i + 1
+				end
+				return nil  -- unterminated; treat as no comment
+			elseif b2 == BYTE_SLASH then
+				-- Line comment // ... (strip the trailing newline)
+				local end_pos = duffle.find_byte(body, BYTE_NEWLINE, pos + 2) or (body_len + 1)
+				return body:sub(pos + 2, end_pos - 1)
+			end
+			return nil
+		else
+			return nil
+		end
+	end
+	return nil
+end
+
 --- Parse a decimal/negative-decimal/hex integer literal starting at byte position `start`.
 --- Returns (value, end_pos) on success, or (nil, start) on failure / no match.
 --- Accepts: 12, -1, 0, 0x10, 0X1F, -0x10.
@@ -1131,6 +1172,46 @@ local function parse_dbg_skip_marker(source, pos, ident_end, line_of, out)
 	return marker_end
 end
 
+--- Parse `atom_auto_reg(<atom>, R_<Sym>)` and `phase_auto_reg(<phase>, R_<Sym>)` markers.
+---
+--- The macros expand to `sym = sym##_Code` per their definition in dsl.atom.h.
+--- After preprocessing, the marker renders as a full enum entry of the form `R_<Sym> = R_<Sym>_Code,`.
+--- This parser detects the macro invocation site, extracts `(scope_name, sym)`, and stores it
+--- in the per-source table (atom_auto_regs or phase_auto_regs) under the scope's name.
+---
+--- @param source    string
+--- @param pos       integer
+--- @param ident_end integer
+--- @param line_of   fun(pos: integer): integer
+--- @param out       SourceScan
+--- @return integer
+local function parse_auto_reg_marker(source, pos, ident_end, line_of, out)
+	local marker_kind = source:sub(pos, ident_end - 1)  -- "atom_auto_reg" or "phase_auto_reg"
+	local scope_kind  = marker_kind == "atom_auto_reg" and "atom" or "phase"
+
+	local inner, after_paren = read_parens_after(source, ident_end)
+	if not inner then return after_paren end
+
+	local args = duffle.split_top_level_commas(inner)
+	local scope_name = args[1] and duffle.trim(args[1]) or nil
+	local sym        = args[2] and duffle.trim(args[2]) or nil
+
+	-- Filter: only accept `R_<Sym>` form (matches `^R_[%w_]+$`).
+	if scope_name and sym and sym:match("^R_[%w_]+$") then
+		if scope_kind == "atom" then
+			out.atom_auto_regs = out.atom_auto_regs or {}
+			out.atom_auto_regs[scope_name] = out.atom_auto_regs[scope_name] or {}
+			out.atom_auto_regs[scope_name][sym] = sym
+		else
+			out.phase_auto_regs = out.phase_auto_regs or {}
+			out.phase_auto_regs[scope_name] = out.phase_auto_regs[scope_name] or {}
+			out.phase_auto_regs[scope_name][sym] = sym
+		end
+	end
+
+	return after_paren
+end
+
 -- Parse `atom_dbg_reg_default(R_X, <type>...)`;
 -- the second argument may be a `Type` or `Type*`/`Type**` chain. Records in `out.types[R_X]`.
 local function parse_atom_dbg_reg_default(source, pos, ident_end, line_of, out)
@@ -1280,12 +1361,54 @@ local function parse_mips_atom_comp_proc(source, pos, ident_end, line_of, out)
 	local name     = strip_ac_prefix(raw_name)
 	-- Position of body[1] in source = open_paren + 1 (start of inner) + last_brace_pos + 1 (past '{').
 	local body_off = open_paren + 2 + last_brace_pos
-
 	register_atom(out, "comp_proc", line_of(pos), name, body, body_off, raw_name, pos, after_paren, source)
 
 	return after_paren
 end
 
+--- Parse: `MipsAtom_Proc_(<name>, <abuilder>, { <body> })` — body is inside the LAST `{` in args.
+--- Per Task 12.10: full support for the runtime-proc atom form. Registers the atom
+--- with kind `"atom_proc"` so offsets.lua / components.lua can emit
+---   * `mac_<name>` aliases in `gen/macs.h` (the components pass)
+---   * `atom_offset__X__Y` defs in `gen/offsets.h` (the offsets pass)
+--- The atom name is the FIRST ident of the args (the second arg `ab` is the
+--- atom-builder, not the name). Unlike `MipsAtomComp_Proc_`, there is no `ac_`
+--- prefix on the symbol — `MipsAtom_Proc_` is the runtime-proc wrapper, so the
+--- symbol IS the bare atom name (e.g. `normalize_v3s4`, not `ac_normalize_v3s4`).
+--- @param source    string
+--- @param pos       integer
+--- @param ident_end integer
+--- @param line_of   fun(pos: integer): integer
+--- @param out       SourceScan
+--- @return integer
+local function parse_mips_atom_proc(source, pos, ident_end, line_of, out)
+	local  inner, after_paren, open_paren = read_parens_after(source, ident_end)
+	if not inner then return after_paren end
+
+	-- Find the LAST `{` in inner (the body brace, not any potential embedded braces in expressions).
+	local last_brace_pos = nil
+	for search_pos = #inner, 1, -1 do
+		if inner:sub(search_pos, search_pos) == "{" then last_brace_pos = search_pos; break end
+	end
+	if not last_brace_pos then return after_paren end
+
+	-- Use duffle.read_braces to find the matching close brace.
+	-- Uses `read_balanced` for delimiter-depth tracking.
+	-- If close_pos is past the end of inner, the brace didn't match (malformed input); skip.
+	local body, close_pos = duffle.read_braces(inner, last_brace_pos)
+	if close_pos > #inner + 1 then return after_paren end
+
+	-- The atom name is the FIRST ident of the args (matches MipsAtomComp_Proc_'s "first ident" rule).
+	-- MipsAtom_Proc_ has no `ac_` prefix; `strip_ac_prefix` is a no-op for unprefixed names.
+	local raw_name = inner:match("^%s*([%w_]+)") or "?"
+	local name     = strip_ac_prefix(raw_name)
+	-- Position of body[1] in source = open_paren + 1 (start of inner) + last_brace_pos + 1 (past '{').
+	local body_off = open_paren + 2 + last_brace_pos
+	register_atom(out, "atom_proc", line_of(pos), name, body, body_off, raw_name, pos, after_paren, source)
+
+	return after_paren
+end
+
 --- Parse: `MipsCode code_<name> { <body> }` (raw atom form — offsets pass only).
 --- @param source    string
 --- @param pos       integer
@@ -1396,7 +1519,7 @@ end
 ---   1. `typedef Struct_(<name>) { <body> } <alias>;` adds to type_name_registry (kind="struct"). 
 ---       Binds_* aliases also land in out.binds[].
 ---   2. `typedef Enum_(<underlying>, <name>) { <body> } <alias>;` 
----       adds to type_name_registry (kind="enum"). 
+---       Adds to type_name_registry (kind="enum"). 
 ---   3. `typedef <type> <alias>;` simple typedef alias.
 ---       Adds to type_name_registry (kind="typedef").
 ---   4. `typedef <type> TSet_(<name>);` duffle TSet_ convention.
@@ -1472,8 +1595,7 @@ local function parse_typedef_binds(source, pos, ident_end, line_of, out)
 		local  inner, after_paren = read_parens_after(source, id2_end, id2_end)
 		if not inner then return id2_end end
 		local tset_name = duffle.trim(inner)
-		-- Empty underlying span is acceptable; the TSet_ wrapper itself
-		-- encodes the alias identity (per the duffle TSet_ convention).
+		-- Empty underlying span is acceptable; the TSet_ wrapper itself encodes the alias identity (per the duffle TSet_ convention).
 		register_typedef_alias("", tset_name, pos, line_of, out)
 		attach_debug_skip_marker(out, "unrelated")
 		return after_paren
@@ -1607,6 +1729,16 @@ local function parse_enum_entry(source, body, body_offset, line_of, out, entry_n
 	local value, value_end = parse_enum_value(body, after_ws, out)
 	if value == nil then return value_start end
 
+	-- Capture the trailing C-comment (if any) before `skip_ws_and_cmt` discards it.
+	-- The `atom_auto_reg(<scope>, <sym>)` macro expands to `R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`,
+	-- so the scope name lives in the comment after the RHS value. Routes through `out.atom_entry_comments`
+	-- for downstream `parse_enum` to split into `out.atom_auto_regs` / `out.phase_auto_regs`.
+	local trailing_cmt = read_trailing_cmt_after(body, value_end)
+	if trailing_cmt then
+		out.atom_entry_comments = out.atom_entry_comments or {}
+		out.atom_entry_comments[entry_name] = trailing_cmt
+	end
+
 	local after_value       = duffle.skip_ws_and_cmt(body, value_end)
 	local has_atom_reg, end_after_atom_reg = check_bare_atom_reg(body, after_value)
 
@@ -1662,6 +1794,14 @@ local function parse_enum_body(source, body, body_offset, line_of, out)
 		else
 			local entry_name, name_end = duffle.read_ident(body, pos)
 			if entry_name then
+				-- In-enum `atom_auto_reg(<scope>, R_<Sym>)` / `phase_auto_reg(<scope>, R_<Sym>)` markers:
+				-- the C preprocessor expands them to `R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`,
+				-- but the metaprogram reads source-as-written so we must dispatch the parser here too.
+				-- Mirrors the top-level `DECL_PARSERS` entry for `atom_auto_reg` / `phase_auto_reg`.
+				if entry_name == "atom_auto_reg" or entry_name == "phase_auto_reg" then
+					local new_pos = parse_auto_reg_marker(body, pos, name_end, line_of, out)
+					if new_pos > pos then pos = new_pos else pos = name_end end
+				else
 					local after_name = duffle.skip_ws_and_cmt(body, name_end)
 					if body:byte(after_name) == BYTE_EQUAL then
 						local new_pos = parse_enum_entry(
@@ -1672,6 +1812,7 @@ local function parse_enum_body(source, body, body_offset, line_of, out)
 					else
 						pos = name_end
 					end
+				end
 			else
 				pos = pos + 1
 			end
@@ -1700,6 +1841,25 @@ local function parse_enum(source, pos, ident_end, line_of, out)
 	if not body then return after_brace end
 	parse_enum_body(source, body, body_off, line_of, out)
 
+	-- Route `atom_auto_reg:` / `phase_auto_reg:` markers discovered in trailing C-comments
+	-- into the per-source `atom_auto_regs` / `phase_auto_regs` projections.
+	-- Pattern matches the RHS expansion `R_<Sym> = R_<Sym>_Code /* <kind>_auto_reg: <scope> */`
+	-- emitted by the `atom_auto_reg` / `phase_auto_reg` macros in dsl.atom.h.
+	for entry_name, cmt_text in pairs(out.atom_entry_comments or {}) do
+		local atom_scope = cmt_text:match("atom_auto_reg:%s*([%w_]+)")
+		if atom_scope then
+			out.atom_auto_regs = out.atom_auto_regs or {}
+			out.atom_auto_regs[atom_scope] = out.atom_auto_regs[atom_scope] or {}
+			out.atom_auto_regs[atom_scope][entry_name] = entry_name
+		end
+		local phase_scope = cmt_text:match("phase_auto_reg:%s*([%w_]+)")
+		if phase_scope then
+			out.phase_auto_regs = out.phase_auto_regs or {}
+			out.phase_auto_regs[phase_scope] = out.phase_auto_regs[phase_scope] or {}
+			out.phase_auto_regs[phase_scope][entry_name] = entry_name
+		end
+	end
+
 	return after_brace
 end
 
@@ -1713,12 +1873,18 @@ end
 
 local DECL_PARSERS = {
 	MipsAtom_                  = parse_mips_atom,
+	MipsAtom_Proc_             = parse_mips_atom_proc,
 	MipsAtomComp_              = parse_mips_atom_comp,
 	MipsAtomComp_Proc_         = parse_mips_atom_comp_proc,
 	-- `atom_dbg_skip` is the only debug-skip parser entry. Every other
 	-- identifier follows the ordinary unrelated-token path; there is no alias.
 	atom_dbg_skip              = parse_dbg_skip_marker,
 	atom_dbg_reg_default       = parse_atom_dbg_reg_default,
+	-- `atom_auto_reg(atom, R_<Sym>)` and `phase_auto_reg(phase, R_<Sym>)` populate per-source
+	-- `out.atom_auto_regs` / `out.phase_auto_regs`; the cross-source merge lands in
+	-- `corpus.atom_auto_regs` / `corpus.phase_auto_regs` (first-wins).
+	atom_auto_reg              = parse_auto_reg_marker,
+	phase_auto_reg             = parse_auto_reg_marker,
 	MipsCode                   = parse_mips_code,
 	typedef                    = parse_typedef_binds,
 	_Pragma                    = parse_pragma_macro,
@@ -1753,6 +1919,14 @@ local function scan_source(source, source_file, code_macros, code_macro_bodies)
 		debug_skip_markers = {},
 		types             = {},
 		atom_views        = {},
+		-- Per-source projection for `atom_auto_reg(<atom>, R_<Sym>)` markers.
+		-- Each entry is keyed by atom_name; the inner table maps `R_<Sym>` -> `R_<Sym>` (raw LHS sym).
+		-- Merged cross-source into `corpus.atom_auto_regs` (first-wins).
+		atom_auto_regs    = {},
+		-- Per-source projection for `phase_auto_reg(<phase>, R_<Sym>)` markers.
+		-- Each entry is keyed by phase_label; the inner table maps `R_<Sym>` -> `R_<Sym>` (raw LHS sym).
+		-- Merged cross-source into `corpus.phase_auto_regs` (first-wins).
+		phase_auto_regs   = {},
 		line_of           = line_of,
 		-- Source-derived register-alias registry (atom_reg opt-in entries).
 		-- Keys are full R_* idents (never stripped); see parse_enum / parse_enum_body.
@@ -1992,6 +2166,8 @@ local function merge_corpus_registries(corpus)
 	corpus.atom_ctxs               = corpus.atom_ctxs               or {}
 	corpus.atom_phases             = corpus.atom_phases             or {}
 	corpus.atom_infos              = corpus.atom_infos              or {}
+	corpus.atom_auto_regs          = corpus.atom_auto_regs          or {}
+	corpus.phase_auto_regs         = corpus.phase_auto_regs         or {}
 	corpus.collisions              = corpus.collisions              or {}
 
 	-- Replace the existing corpus collections with empty tables so a re-run on the same corpus produces identical state (deterministic merge).
@@ -2035,7 +2211,7 @@ local function merge_corpus_registries(corpus)
 					corpus.collisions, "binds", bind_shape)
 			end
 
-			-- atoms_by_name: MipsAtom_(name) + MipsAtomComp_(name) + MipsAtomComp_Proc_(name).
+			-- atoms_by_name: MipsAtom_(name) + MipsAtom_Proc_(name) + MipsAtomComp_(name) + MipsAtomComp_Proc_(name).
 			-- Each atom carries `{line, name, body, body_off, kind, raw_name, ...}`.
 			-- Duplicate atom names across sources are first-wins + collision; see the atom_infos block below for the evidence list.
 			for _, atom_entry in ipairs(scan.atoms or {}) do
@@ -2070,6 +2246,22 @@ local function merge_corpus_registries(corpus)
 					corpus.collisions, "phase", phase_shape)
 			end
 
+			-- atom_auto_regs: keyed by atom scope name; each carries a `{R_<Sym> = R_<Sym>}` map.
+			-- Per-source entries are simple inner maps (no body / no shape comparison); first-wins suffices.
+			for atom_scope, syms in pairs(scan.atom_auto_regs or {}) do
+				if corpus.atom_auto_regs[atom_scope] == nil then
+					corpus.atom_auto_regs[atom_scope] = syms
+				end
+			end
+
+			-- phase_auto_regs: keyed by phase label; each carries a `{R_<Sym> = R_<Sym>}` map.
+			-- Per-source entries are simple inner maps (no body / no shape comparison); first-wins suffices.
+			for phase_label, syms in pairs(scan.phase_auto_regs or {}) do
+				if corpus.phase_auto_regs[phase_label] == nil then
+					corpus.phase_auto_regs[phase_label] = syms
+				end
+			end
+
 			-- atom_infos: ALWAYS append every record in source/declaration order.
 			-- Duplicates are preserved so the annotation pass can flag them via `check_unique_annotation`;
 			-- The merge is purely order-preserving.

scripts/passes/word_count_eval.lua

@@ -93,7 +93,7 @@ end
 --- 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.
+--- after the components pass iterates `corpus.source_order` and writes each source-directory's `gen/macs.h` file.
 ---
 --- Contract:
 ---   * `ctx.shared.corpus` MUST exist (canonical corpus ownership).

scripts/ps1_meta.lua

@@ -16,7 +16,7 @@
 
 -- Bootstrap: load `duffle_paths.lua` via this script's own path.
 -- Use `arg[0]` when this file is the entry script (`arg[0]` ends in "ps1_meta.lua");
--- fall back to `debug.getinfo(1, "S").source` when this file is being dofile()'d or require()'d (in which case `arg[0]` is the *caller's* path, not ours).
+-- fall back to `debug.getinfo(1, "S").source` when this file is being dofile()'d or require()'d (in which case `arg[0]` is the *caller's* path).
 -- That single statement: (a) sets `package.path` + `package.cpath`, (b) at the bottom returns `require("duffle")`.
 -- So the dofile's return value is the duffle module.
 local _is_entry_script = arg and arg[0] and arg[0]:match("ps1_meta%.lua$") ~= nil
@@ -54,45 +54,44 @@ local PASS_FLAG_DISPATCH_KEY   = "__pass__"
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class PassDescriptor
---- @field module string       -- module name passed to require()
+--- @field module string       -- Module name passed to require()
 --- @field kind   string       -- "shared" | "header-output" | "validation" | "diagnostic" | "report"
 ---                            -- Report severity is independent from process exit policy (see PASS_KIND_STOP_ON_ERROR).
---- @field deps   string[]     -- names of upstream passes
---- @field groups string[]?    -- OPTIONAL build-phase groups this pass is a root of
----                            -- (e.g. { "pre-link" }, { "post-link" }); absent ⇒ dependency-only
+--- @field deps   string[]     -- Names of upstream passes
+--- @field groups string[]?    -- OPTIONAL build-phase groups this pass is a root of (e.g. { "pre-link" }, { "post-link" }); absent ⇒ dependency-only
 
 --- @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
+--- @field path     string  -- Absolute path to the source file
+--- @field text     string  -- Full source text
+--- @field dir      string  -- Directory containing the source
+--- @field basename string  -- Filename without extension
 
 --- @class PassCtx
---- @field metadata_path      string                 -- path to word_count.metadata.h
---- @field shared             table                  -- cross-pass shared state
---- @field shared.corpus      table                  -- canonical authored-source/project projection
---- @field out_root           string                 -- output root (e.g. "build/gen")
+--- @field metadata_path      string                 -- Path to word_count.metadata.h
+--- @field shared             table                  -- Cross-pass shared state
+--- @field shared.corpus      table                  -- Authored-source/project projection
+--- @field out_root           string                 -- Output root (e.g. "build/gen")
 --- @field project_root       string                 -- PS1 repository root
 --- @field flags              table                  -- CLI flags + per-pass stash
---- @field verbose            boolean                -- if true, log diagnostic info
+--- @field verbose            boolean                -- If true, log diagnostic info
 
 --- @class Finding
---- @field line integer  -- source line (or 0 for pass-level)
---- @field msg  string   -- finding message
+--- @field line integer  -- Source line (or 0 for pass-level)
+--- @field msg  string   -- Finding message
 
 --- @class PassResult
---- @field outputs  PassOutputEntry[] -- emitted file paths
---- @field errors   Finding[]         -- build-stops (per-pass kind policy)
---- @field warnings Finding[]         -- informational
+--- @field outputs  PassOutputEntry[] -- Emitted file paths
+--- @field errors   Finding[]         -- Build-stops (per-pass kind policy)
+--- @field warnings Finding[]         -- Informational
 
 --- @class ParsedArgs
---- @field requested_set string[]   -- pass names to run (explicit --all expanded)
---- @field sources       string[]   -- exact --source values, retained in CLI order
+--- @field requested_set string[]   -- Pass names to run (explicit --all expanded)
+--- @field sources       string[]   -- Exact --source values, retained in CLI order
 --- @field unity_root    string|nil -- --unity-root value; mutually exclusive with sources
 --- @field metadata      string     -- --metadata value
 --- @field out_root      string     -- --out-root value (default "build/gen")
 --- @field project_root  string     -- PS1 repository root (derived from metadata by default)
---- @field verbose       boolean    -- if true, log diagnostic info
+--- @field verbose       boolean    -- If true, log diagnostic info
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- PASSES Table
@@ -119,6 +118,12 @@ local PASSES = {
 		kind   = "header-output",
 		deps   = {"scan-source", "word-counts"},
 	},
+	auto_reg = {
+		module = "passes.auto_reg",
+		kind   = "header-output",
+		deps   = {"components"},
+		groups = { "pre-link" },
+	},
 	["emission-model"] = {
 		module = "passes.emission_model",
 		kind   = "validation",
@@ -138,7 +143,7 @@ local PASSES = {
 	["static-analysis"] = {
 		module = "passes.static_analysis",
 		-- "diagnostic" — every `error`/`warning` finding is written to the report file;
-		-- the orchestrator does NOT exit non-zero on these findings (see PASS_KIND_STOP_ON_ERROR).
+		-- The orchestrator does NOT exit non-zero on these findings (see PASS_KIND_STOP_ON_ERROR).
 		-- Report severity is independent from process exit policy.
 		kind   = "diagnostic",
 		deps   = {"scan-source", "word-counts", "components", "emission-model"},
@@ -163,12 +168,12 @@ local PASSES = {
 }
 
 -- ────────────────────────────────────────────────────────────────────────────
--- Phase-root selection: derive the sorted set of roots belonging to a named build-phase group, then append them to `args.requested_set`.
+-- Phase-root selection: Derive the sorted set of roots belonging to a named build-phase group, then append them to `args.requested_set`.
 -- topo_sort closes the transitive deps from there; dispatch_passes runs every resolved pass without phase-filtering.
 -- ────────────────────────────────────────────────────────────────────────────
 
---- @param group_name string  -- the build-phase group ("pre-link" | "post-link")
---- @return string[]          -- sorted root pass names belonging to that group
+--- @param group_name string  -- Build-phase group ("pre-link" | "post-link")
+--- @return string[]          -- Sorted root pass names belonging to that group
 local function roots_for_group(group_name)
 	local names = {}
 	for name, pass in pairs(PASSES) do
@@ -206,7 +211,7 @@ end
 -- Report severity is independent from process exit policy.
 -- A "diagnostic" pass still writes every `error`/`warning` finding into its report file,
 -- but `report_validation_errors` returns early for non-stopping kinds, so nothing is printed to stderr and the orchestrator does not exit non-zero.
--- Adding a new pass kind requires listing it here explicitly; an unknown kind must not silently fall back to "true".
+-- Adding a new pass kind requires listing it here explicitly; An unknown kind must not silently fall back to "true".
 local PASS_KIND_STOP_ON_ERROR = {
 	["shared"]        = false,
 	["header-output"] = true,
@@ -216,8 +221,7 @@ local PASS_KIND_STOP_ON_ERROR = {
 }
 
 -- Closed set of CLI flags -> pass names.
--- Per-pass flags (e.g. --word-counts) live here; phase flags (--pre-link, --post-link, --all)
--- live in FLAG_HANDLERS because they own side effects or invoke group-derivation logic.
+-- Per-pass flags (e.g. --word-counts); phase flags (--pre-link, --post-link, --all) are within FLAG_HANDLERS because they own side effects or invoke group-derivation logic.
 -- dwarf-injection is *also* a per-pass opt-in flag, but its selection + opt-in state are both owned by the explicit FLAG_HANDLERS entry below
 -- (it sets args.flags.dwarf_injection and appends "dwarf-injection" to requested_set), so it is intentionally absent from this table.
 local PASS_FLAG_TO_NAME = {
@@ -246,7 +250,6 @@ end
 
 -- Per-flag handlers. Each handler takes (args, argv, arg_idx) and returns the new arg_idx (so multi-arg flags like --source FILE advance it). 
 -- Returning nil + os.exit() handles termination flags (--help). 
-
 local FLAG_HANDLERS = {}
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -272,9 +275,9 @@ PASS_FLAGS:
   Or pick any subset:
     --scan-source         Scan sources into the fat SourceScan payload
     --word-counts         Load metadata.h + scan for existing .macs.h
-    --components          Generate <module>/gen/<basename>.macs.h
+    --components          Generate <srcdir>/gen/macs.h (per-directory aggregation)
     --validate            Run atom annotation DSL validation
-    --offsets             Generate <module>/gen/<basename>.offsets.h
+    --offsets             Generate <srcdir>/gen/offsets.h (per-directory aggregation)
     --atoms-source-map    Generate <basename>.atoms.sourcemap.txt per source
     --dwarf-injection     [opt-in] Select the post-link dwarf-injection pass + set the opt-in flag. Requires --elf.
     --static-analysis     Static analysis: GTE pipeline-fill, mac_yield, ABI handoff, cycle budget
@@ -317,8 +320,7 @@ local function require_flag_value(argv, arg_idx, flag)
 	local next_known = type(value) == "string"
 		and (FLAG_HANDLERS[value] ~= nil or PASS_FLAG_TO_NAME[value] ~= nil)
 	if value == nil or next_known then
-		io.stderr:write("ps1_meta: " .. flag .. " requires "
-			.. FLAG_VALUE_NAMES[flag] .. "\n")
+		io.stderr:write("ps1_meta: " .. flag .. " requires " .. FLAG_VALUE_NAMES[flag] .. "\n")
 		os.exit(EXIT_INTERNAL_ERROR)
 	end
 	return value, arg_idx + 1
@@ -328,12 +330,10 @@ end
 -- Termination flags like --help call os.exit() instead.
 -- Populated AFTER print_help so the --help handler can reference it as an upvalue (Lua resolves locals at closure-call time, 
 -- but if the closure is defined before the local, it falls back to _G). 
-FLAG_HANDLERS["--help"] = function(args)
-	print_help()
-	os.exit(0)
-end
 
+FLAG_HANDLERS["--help"]    = function(args) print_help(); os.exit(0) end
 FLAG_HANDLERS["--verbose"] = function(args) args.verbose = true      end
+
 FLAG_HANDLERS["--source"] = function(args, argv, arg_idx)
 	local value, value_idx = require_flag_value(argv, arg_idx, "--source")
 	args.sources[#args.sources + 1] = value
@@ -496,8 +496,7 @@ local function build_ctx(args)
 		or normalized_project_root:sub(1, 2) == "//"
 		or normalized_project_root:sub(1, 1) == "/"
 	if not project_root_is_absolute then
-		-- canonical_path_key validates ordinary relative paths and rejects
-		-- drive-relative paths before the absolute-path rewrite is performed.
+		-- canonical_path_key validates ordinary relative paths and rejects drive-relative paths before the absolute-path rewrite is performed.
 		duffle.canonical_path_key(normalized_project_root)
 		project_root = duffle.normalize_path(duffle.to_absolute_path(normalized_project_root))
 	else
@@ -511,8 +510,7 @@ local function build_ctx(args)
 			project_root = project_root,
 		})
 		if not ok_resolve then
-			io.stderr:write("ps1_meta: cannot resolve --unity-root "
-				.. tostring(args.unity_root) .. ": " .. tostring(resolved) .. "\n")
+			io.stderr:write("ps1_meta: cannot resolve --unity-root " .. tostring(args.unity_root) .. ": " .. tostring(resolved) .. "\n")
 			os.exit(EXIT_INTERNAL_ERROR)
 		end
 		resolution = resolved
@@ -528,8 +526,7 @@ local function build_ctx(args)
 			local path = duffle.normalize_path(input_path)
 			local key_ok, key_or_error = pcall(duffle.canonical_path_key, path)
 			if not key_ok then
-				error("ps1_meta: invalid --source " .. input_path .. ": "
-					.. tostring(key_or_error), 0)
+				error("ps1_meta: invalid --source " .. input_path .. ": " .. tostring(key_or_error), 0)
 			end
 			local file = io.open(path, "r")
 			if not file then
@@ -627,9 +624,7 @@ local function topo_sort(passes, requested_set)
 		changed = false
 		for name, _ in pairs(needed) do
 			local pass = passes[name]
-			if not pass then
-				error("unknown pass '" .. name .. "' requested")
-			end
+			if not pass then error("unknown pass '" .. name .. "' requested") end
 			for _, dep in ipairs(pass.deps) do
 				if not needed[dep] then
 					needed[dep] = true

scripts/update_deps.ps1

@@ -14,16 +14,21 @@ $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'
+# $url_mkpsxiso   = 'https://github.com/Lameguy64/mkpsxiso.git'
+
+$url_mkpsxiso_win64 = 'https://github.com/Lameguy64/mkpsxiso/releases/download/v2.30/mkpsxiso-2.30-win64.zip'
 
 $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'
+$path_mkpsxiso   = join-path $path_toolchain 'mkpsxiso'
 
 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
+# clone-gitrepo $path_mkpsxiso   $url_mkpsxiso
 
 $path_armips_build = join-path $path_armips 'build'
 verify-path $path_armips_build
@@ -71,7 +76,7 @@ if (-not $luajit_prefix -or -not (Test-Path (Join-Path $luajit_prefix 'bin/luaji
 # 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
+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