Last adjustments for metaprogram, hitting a intermission checkpoint to do docs, writeups, and other research distillations.

code/duffle/dsl.atom.h

@@ -160,6 +160,8 @@
  * ----------------------------------------------------------------------------*/
 #define atom_bind(binds_struct)  /* atom_bind(binds_struct) */
 
+#define Binds_(type) (tmpl(Binds,type)) // TODO(Ed): Do we want to use this?
+
 /* ============================================================================
  * atom_label / atom_offset — branch target machinery
  *

code/duffle/gen/macs.h

@@ -228,21 +228,21 @@ WORD_COUNT(mac_gte_op_cross_v3s4, 13)
 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) \
+#define mac_gte_load_tri_verts(vbase, v0, v1, v2) \
-	shift_lleft(R_AT, r_v0, v3s2_byteoff) \
+	shift_lleft(R_AT, v0, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ 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) \
+,	shift_lleft(R_AT, v1, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ 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) \
+,	shift_lleft(R_AT, v2, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY2) \

code/duffle/gen/offsets.h

@@ -33,7 +33,7 @@ enum {
     atom_offset_example_atom_proc_skip = _atom_offset_example_atom_proc_skip,
 };
 
-// --- atom: build_normalize_v3s4 (63 words) ---
+// --- atom: normalize_v3s4 (62 words) ---
 
 #define _atom_offset_aligned_done_srav_path           3
 #define _atom_offset_srav_path_aligned_done           4

code/duffle/gp.h

@@ -21,7 +21,7 @@
  *    4. Semantic encoders      gp0_word_poly_f3(r,g,b)
  *    3. Composite encoders     enc_color_word(cmd, r, g, b)
  *    2. Per-field encoders     enc_gp0_color_r(r), enc_gp0_color_g(g), ...
- *    1. Bitfield layout consts gp0_color_red_shift = 0, gp0_color_red_width = 8
+ *    1. Bitfield layout consts gp0_color_red_pos = 0, gp0_color_red_width = 8
  *    0. Opcode IDs             gp0_cmd_poly_f3 = 0x20
  *
  *  Vendor mnemonics (gte_mtc2, gte_mfc2, etc.) are NOT in this header.
@@ -75,7 +75,7 @@ enum {
  *  ============================================================================
  *  8-bit GP0 opcodes (the upper byte of a primitive's first word). These are the BYTE only.
  *  NO macro body past this point uses a raw shift or raw mask.
- *  Mirrors the OPCODE_SHIFT / RS_SHIFT convention from mips.h.
+ *  Mirrors the OPCODE_POS / RS_POS convention from mips.h.
  * ============================================================================ */
 enum {
 	gp0_cmd_Nop             = 0x00,
@@ -117,9 +117,9 @@ enum {
 	gp0_cmd_SetDrawOffset        = 0xE5,
 	gp0_cmd_SetMaskBit           = 0xE6,
 
-	/* bitfield shifts / widths ----
+	/* bitfield offset pos / widths ----
 		* Generic GP0/GP1 command byte (upper 8 bits of every word sent to either port). */
-	gp0_cmd_shift = 24,
+	gp0_cmd_pos   = 24,
 	gp0_cmd_width =  8,
 
 	/* Color word layout (lives in Poly_F3.color, Poly_G4.c0..c3, etc.):
@@ -127,10 +127,10 @@ enum {
 		*   bits 23..16 = BLUE
 		*   bits 15..08 = GREEN
 		*   bits 07..00 = RED     (PSX GPU is BGR, NOT RGB) */
-	gp0_color_cmd_shift   = 24, gp0_color_cmd_width   = 8,
+	gp0_color_cmd_pos   = 24, gp0_color_cmd_width   = 8,
-	gp0_color_blue_shift  = 16, gp0_color_blue_width  = 8,
+	gp0_color_blue_pos  = 16, gp0_color_blue_width  = 8,
-	gp0_color_green_shift =  8, gp0_color_green_width = 8,
+	gp0_color_green_pos =  8, gp0_color_green_width = 8,
-	gp0_color_red_shift   =  0, gp0_color_red_width   = 8,
+	gp0_color_red_pos   =  0, gp0_color_red_width   = 8,
 };
 
 /* ============================================================================
@@ -143,12 +143,12 @@ enum {
  * ============================================================================ */
 
 /* ---- Layer 1.5: per-field encoders ---- */
-#define enc_gp0_cmd(cmd)       ((cmd) << gp0_cmd_shift)
+#define enc_gp0_cmd(cmd)       ((cmd) << gp0_cmd_pos)
 
-#define enc_gp0_color_cmd(cmd) ((cmd) << gp0_color_cmd_shift)
+#define enc_gp0_color_cmd(cmd) ((cmd) << gp0_color_cmd_pos)
-#define enc_gp0_color_r(r)     ((r)   << gp0_color_red_shift)
+#define enc_gp0_color_r(r)     ((r)   << gp0_color_red_pos)
-#define enc_gp0_color_g(g)     ((g)   << gp0_color_green_shift)
+#define enc_gp0_color_g(g)     ((g)   << gp0_color_green_pos)
-#define enc_gp0_color_b(b)     ((b)   << gp0_color_blue_shift)
+#define enc_gp0_color_b(b)     ((b)   << gp0_color_blue_pos)
 
 /* ---- Layer 2: composite encoders ---- */
 #define enc_color_word(cmd, r, g, b) (enc_gp0_color_cmd(cmd) | enc_gp0_color_r(r) | enc_gp0_color_g(g) | enc_gp0_color_b(b))
@@ -212,37 +212,37 @@ enum {
 	gp1_disp_VInterlace = 0x1,
 
 	/* ---- Layer 1: GP1 display-mode + range + draw-area shifts/widths ---- */
-	gp1_disp_hres_shift      =  0, gp1_disp_hres_width      = 2,
+	gp1_disp_hres_pos      =  0, gp1_disp_hres_width      = 2,
-	gp1_disp_vres_shift      =  2, gp1_disp_vres_width      = 1,
+	gp1_disp_vres_pos      =  2, gp1_disp_vres_width      = 1,
-	gp1_disp_color_shift     =  4, gp1_disp_color_width     = 1,
+	gp1_disp_color_pos     =  4, gp1_disp_color_width     = 1,
-	gp1_disp_interlace_shift =  5, gp1_disp_interlace_width = 1,
+	gp1_disp_interlace_pos =  5, gp1_disp_interlace_width = 1,
 
 	/* GP1 horizontal display range: bits 0..11 = X2, bits 12..23 = X1 */
-	gp1_hrange_x1_shift = 12, gp1_hrange_x1_width = 12,
+	gp1_hrange_x1_pos = 12, gp1_hrange_x1_width = 12,
-	gp1_hrange_x2_shift =  0, gp1_hrange_x2_width = 12,
+	gp1_hrange_x2_pos =  0, gp1_hrange_x2_width = 12,
 
 	/* GP1 vertical display range: bits 0..9 = Y2, bits 10..19 = Y1 */
-	gp1_vrange_y1_shift = 10, gp1_vrange_y1_width = 10,
+	gp1_vrange_y1_pos = 10, gp1_vrange_y1_width = 10,
-	gp1_vrange_y2_shift =  0, gp1_vrange_y2_width = 10,
+	gp1_vrange_y2_pos =  0, gp1_vrange_y2_width = 10,
 
 	/* GP1 draw area (top-left or bottom-right): bits 0..9 = X, bits 10..19 = Y
 		* (10-bit signed — caller pre-signs) */
-	gp1_draw_x_shift =  0, gp1_draw_x_width = 10,
+	gp1_draw_x_pos =  0, gp1_draw_x_width = 10,
-	gp1_draw_y_shift = 10, gp1_draw_y_width = 10,
+	gp1_draw_y_pos = 10, gp1_draw_y_width = 10,
 };
 
 /* ---- Layer 1.5: GP1 per-field encoders ---- */
-#define enc_gp1_disp_hres(h)      ((h) << gp1_disp_hres_shift)
+#define enc_gp1_disp_hres(h)      ((h) << gp1_disp_hres_pos)
-#define enc_gp1_disp_vres(v)      ((v) << gp1_disp_vres_shift)
+#define enc_gp1_disp_vres(v)      ((v) << gp1_disp_vres_pos)
-#define enc_gp1_disp_color(c)     ((c) << gp1_disp_color_shift)
+#define enc_gp1_disp_color(c)     ((c) << gp1_disp_color_pos)
-#define enc_gp1_disp_interlace(i) ((i) << gp1_disp_interlace_shift)
+#define enc_gp1_disp_interlace(i) ((i) << gp1_disp_interlace_pos)
 
-#define enc_gp1_hrange_x1(x1) ((x1) << gp1_hrange_x1_shift)
+#define enc_gp1_hrange_x1(x1) ((x1) << gp1_hrange_x1_pos)
-#define enc_gp1_hrange_x2(x2) ((x2) << gp1_hrange_x2_shift)
+#define enc_gp1_hrange_x2(x2) ((x2) << gp1_hrange_x2_pos)
-#define enc_gp1_vrange_y1(y1) ((y1) << gp1_vrange_y1_shift)
+#define enc_gp1_vrange_y1(y1) ((y1) << gp1_vrange_y1_pos)
-#define enc_gp1_vrange_y2(y2) ((y2) << gp1_vrange_y2_shift)
+#define enc_gp1_vrange_y2(y2) ((y2) << gp1_vrange_y2_pos)
-#define enc_gp1_draw_x(x)     ((x)  << gp1_draw_x_shift)
+#define enc_gp1_draw_x(x)     ((x)  << gp1_draw_x_pos)
-#define enc_gp1_draw_y(y)     ((y)  << gp1_draw_y_shift)
+#define enc_gp1_draw_y(y)     ((y)  << gp1_draw_y_pos)
 
 /* ---- Layer 2: GP1 composite encoders ---- */
 #define enc_gp1_disp_mode_word(h, v, c, i) (enc_gp0_cmd(gp1_cmd_DisplayMode)            | enc_gp1_disp_hres(h)  | enc_gp1_disp_vres(v) | enc_gp1_disp_color(c) | enc_gp1_disp_interlace(i))
@@ -553,16 +553,16 @@ typedef Struct_(Poly_GT4) {
  * ============================================================================ */
 enum {
 	/* ---- Layer 1: TPage bitfield shifts / widths ---- */
-	gp0_tpage_x_shift            =  0, gp0_tpage_x_width            =  4,
+	gp0_tpage_x_pos            =  0, gp0_tpage_x_width            =  4,
-	gp0_tpage_y_shift            =  4, gp0_tpage_y_width            =  1,
+	gp0_tpage_y_pos            =  4, gp0_tpage_y_width            =  1,
-	gp0_tpage_semi_trans_shift   =  5, gp0_tpage_semi_trans_width   =  2,
+	gp0_tpage_semi_trans_pos   =  5, gp0_tpage_semi_trans_width   =  2,
-	gp0_tpage_color_depth_shift  =  7, gp0_tpage_color_depth_width  =  2,
+	gp0_tpage_color_depth_pos  =  7, gp0_tpage_color_depth_width  =  2,
-	gp0_tpage_dither_shift       =  9, gp0_tpage_dither_width       =  1,
+	gp0_tpage_dither_pos       =  9, gp0_tpage_dither_width       =  1,
-	gp0_tpage_draw_to_disp_shift = 10, gp0_tpage_draw_to_disp_width =  1,
+	gp0_tpage_draw_to_disp_pos = 10, gp0_tpage_draw_to_disp_width =  1,
-	gp0_tpage_tex_disable_shift  = 11, gp0_tpage_tex_disable_width  =  1,
+	gp0_tpage_tex_disable_pos  = 11, gp0_tpage_tex_disable_width  =  1,
 
 	/* TPage color-depth payload values (NOT bit positions — these go in
-	 * the 2-bit field at gp0_tpage_color_depth_shift). */
+	 * the 2-bit field at gp0_tpage_color_depth_pos). */
 	gp0_tpage_color_4bpp  = 0x0,
 	gp0_tpage_color_8bpp  = 0x1,
 	gp0_tpage_color_16bpp = 0x2,
@@ -578,13 +578,13 @@ enum {
 };
 
 /* ---- Layer 1.5: TPage per-field encoders. Mirrors enc_gte_sf/mx/v in gte.h. ---- */
-#define enc_gp0_tpage_x(x)            ((x) << gp0_tpage_x_shift)
+#define enc_gp0_tpage_x(x)            ((x) << gp0_tpage_x_pos)
-#define enc_gp0_tpage_y(y)            ((y) << gp0_tpage_y_shift)
+#define enc_gp0_tpage_y(y)            ((y) << gp0_tpage_y_pos)
-#define enc_gp0_tpage_semi_trans(s)   ((s) << gp0_tpage_semi_trans_shift)
+#define enc_gp0_tpage_semi_trans(s)   ((s) << gp0_tpage_semi_trans_pos)
-#define enc_gp0_tpage_color_depth(c)  ((c) << gp0_tpage_color_depth_shift)
+#define enc_gp0_tpage_color_depth(c)  ((c) << gp0_tpage_color_depth_pos)
-#define enc_gp0_tpage_dither(d)       ((d) << gp0_tpage_dither_shift)
+#define enc_gp0_tpage_dither(d)       ((d) << gp0_tpage_dither_pos)
-#define enc_gp0_tpage_draw_to_disp(d) ((d) << gp0_tpage_draw_to_disp_shift)
+#define enc_gp0_tpage_draw_to_disp(d) ((d) << gp0_tpage_draw_to_disp_pos)
-#define enc_gp0_tpage_tex_disable(t)  ((t) << gp0_tpage_tex_disable_shift)
+#define enc_gp0_tpage_tex_disable(t)  ((t) << gp0_tpage_tex_disable_pos)
 
 /* ---- Layer 2: TPage composite encoder. Mirrors enc_gte_cmdw in gte.h ---- */
 #define enc_gp0_tpage_word(x, y, semi_trans, color_depth, dither, draw_to_disp, tex_disable) \
@@ -615,16 +615,16 @@ typedef Struct_(TexturePage) { U4 raw; };
  * ============================================================================ */
 enum {
 	/* ---- Layer 1: CLUT bitfield shifts / widths ---- */
-	gp0_clut_y_shift = 0, gp0_clut_y_width = 6,
+	gp0_clut_y_pos = 0, gp0_clut_y_width = 6,
-	gp0_clut_x_shift = 6, gp0_clut_x_width = 9,
+	gp0_clut_x_pos = 6, gp0_clut_x_width = 9,
 	/* CLUT-load cmd-byte variants — the upper byte of the GP0 word. */
 	gp0_clut_cmd_Load4bpp = 0x20,
 	gp0_clut_cmd_Load8bpp = 0x25,
 };
 
 /* ---- Layer 1.5: CLUT per-field encoders ---- */
-#define enc_gp0_clut_x(x) ((x) << gp0_clut_x_shift)
+#define enc_gp0_clut_x(x) ((x) << gp0_clut_x_pos)
-#define enc_gp0_clut_y(y) ((y) << gp0_clut_y_shift)
+#define enc_gp0_clut_y(y) ((y) << gp0_clut_y_pos)
 
 /* ---- Layer 2: CLUT composite encoder ---- */
 #define enc_gp0_clut_word(cmd, x, y) (enc_gp0_cmd(cmd) | enc_gp0_clut_x(x) | enc_gp0_clut_y(y))

code/duffle/gte.atom.c

@@ -63,10 +63,10 @@ FI_ Slice_MipsCode ac_gte_store_f3(AtomBuilder_R ab, U4 r_primitive_cursor) atom
 })
 
 /* 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_(ab, {
+I_ Slice_MipsCode ac_gte_load_tri_verts(AtomBuilder_R ab, Reg vbase, Reg v0, Reg v1, Reg v2) atom_dbg_skip MipsAtomComp_Proc_(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)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
+	shift_lleft(R_AT, v0, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ 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)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
+	shift_lleft(R_AT, v1, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ 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)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
+	shift_lleft(R_AT, v2, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ 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
@@ -267,28 +267,28 @@ internal S2 const gte_normalize_sqr_tbl[192] align_(2) = {
 	0x0820, 0x081c, 0x0818, 0x0814, 0x0810, 0x080c, 0x0808, 0x0804,
 };
 
-typedef Struct_(Binds_NormalizeV3S4) {
+typedef Struct_(Binds_normalize_v3s4) {
 	U2 src_offset;    /* offset of src V3_S4 within the BIOS scratchpad */
 	U2 dst_offset;    /* offset of dst V3_S4 within the BIOS scratchpad */
 };
-typedef Struct_(RegUse_build_normalize_v3s4) {
+typedef Struct_(RegUse_normalize_v3s4) {
 	union { Reg_(V3_S4) res, src; };
-	union { Reg t0, src_ptr, mac2; };
+	union { Reg r0, src_ptr, mac2; };
-	union { Reg t1, dst_ptr; };
+	union { Reg r1, dst_ptr; };
-	union { Reg t2, dst_offset, mac1, v_sqr_aligned; };
+	union { Reg r2, dst_offset, mac1, v_sqr_aligned; };
-	union { Reg t3, src_offset, btarget, shift_count, sqrtbl_index; };
+	union { Reg r3, src_offset, btarget, shift_count, sqrtbl_index; };
-	union { Reg t4, mac3, v_sqr_sum, half_shift_tmp, inv_len; };
+	union { Reg r4, mac3, v_sqr_sum, scale_exp, srav_shift; };
-	union { Reg t5, lzcr, half_shift; };
+	union { Reg r5, lzcr, inv_len; };
 };
 /* ─── Full normalize (all 4 stages inline) ───
  * Generic 4-stage GTE normalize (SQR → sum+LZCR → align+sqrtbl → GPF+srav). */
-internal MipsAtom* build_normalize_v3s4(AtomArena_R aa, RegUse_build_normalize_v3s4 r)
+internal MipsAtom* normalize_v3s4(AtomArena_R aa, RegUse_normalize_v3s4 r)
 MipsAtom_Proc_(aa, {
-	load_half(r.src_offset, R_TapePtr, O_(Binds_NormalizeV3S4, src_offset)),
+	load_half(r.src_offset, R_TapePtr, O_(Binds_normalize_v3s4, src_offset)),
-	load_half(r.dst_offset, R_TapePtr, O_(Binds_NormalizeV3S4, dst_offset)),
+	load_half(r.dst_offset, R_TapePtr, O_(Binds_normalize_v3s4, dst_offset)),
 	LdSlot_ add_u(r.src_ptr, R_ScratchBase, r.src_offset),
 	LdSlot_ add_u(r.dst_ptr, R_ScratchBase, r.dst_offset),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_NormalizeV3S4)),
+	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_normalize_v3s4)),
 
 	mac_load_v3s4(r.src, r.src_ptr, 0),
 
@@ -313,7 +313,6 @@ MipsAtom_Proc_(aa, {
 			sub_s(r.shift_count, r.shift_count, r.lzcr),
 			shift_aright_var(r.v_sqr_aligned, r.v_sqr_aligned, r.shift_count),
 	atom_label(aligned_done)
-		or_u(r.half_shift, r.half_shift_tmp, 0),
 		add_si(     r.v_sqr_aligned, r.v_sqr_aligned, -64),
 		shift_lleft(r.v_sqr_aligned, r.v_sqr_aligned, 1),
 		mac_load_word_imm(r.sqrtbl_index, & gte_normalize_sqr_tbl), add_u_self(r.sqrtbl_index, r.v_sqr_aligned),
@@ -326,13 +325,13 @@ MipsAtom_Proc_(aa, {
 		GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0), LdSlot_   // ac_yield: word 1
 		GteDelay_ add_ui_self(         R_TapePtr, S_(MipsCode)) // ac_yield: word 2
 	),
-	mac_shift_aright_var_v3s4_self(r.res, r.half_shift),
+	mac_shift_aright_var_v3s4_self(r.res, r.srav_shift),
 	mac_store_v3s4(r.res, r.dst_ptr, 0),
 
 	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
-	// mac_yield()
 })
 
+
 /* ─── GTE OP cross product (a × b → out) ───
  * Generalized V3_S4 cross product via GTE OP (OuterProduct12 libpsyx convention).
  * The >> 12 shift converts S12.20 → S12.0 OuterProduct12. */

code/duffle/gte.h

@@ -170,20 +170,20 @@ 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. 
+ * Offset position & 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.
+ * Mirrors the OPCODE_POS / RS_POS convention used in mips.h.
  */
 
-	gte_shift_sf  = 19,  gte_width_sf  = 1,
+	gte_pos_sf  = 19,  gte_width_sf  = 1,
-	gte_shift_mx  = 17,  gte_width_mx  = 2,
+	gte_pos_mx  = 17,  gte_width_mx  = 2,
-	gte_shift_v   = 15,  gte_width_v   = 2,
+	gte_pos_v   = 15,  gte_width_v   = 2,
-	gte_shift_cv  = 13,  gte_width_cv  = 2,
+	gte_pos_cv  = 13,  gte_width_cv  = 2,
-	gte_shift_lm  = 10,  gte_width_lm  = 1,
+	gte_pos_lm  = 10,  gte_width_lm  = 1,
-	gte_shift_cmd =  0,  gte_width_cmd = 6,
+	gte_pos_cmd =  0,  gte_width_cmd = 6,
 
 	/* 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_pos_fake_cmd   = 20,
 	gte_width_fake_cmd = 5,
 };
 
@@ -340,13 +340,13 @@ enum { _C2_TX_SUBS_ = 0
 #define gte_cmd_base (enc_op(op_cop2) | (1 << 25))
 
 /* Per-field encoders. Each one does (value & mask) << shift on its own. */
-#define enc_gte_sf(sf)      ((sf)  << gte_shift_sf )
+#define enc_gte_sf(sf)      ((sf)  << gte_pos_sf )
-#define enc_gte_mx(mx)      ((mx)  << gte_shift_mx )
+#define enc_gte_mx(mx)      ((mx)  << gte_pos_mx )
-#define enc_gte_v(v)        ((v)   << gte_shift_v  )
+#define enc_gte_v(v)        ((v)   << gte_pos_v  )
-#define enc_gte_cv(cv)      ((cv)  << gte_shift_cv )
+#define enc_gte_cv(cv)      ((cv)  << gte_pos_cv )
-#define enc_gte_lm(lm)      ((lm)  << gte_shift_lm )
+#define enc_gte_lm(lm)      ((lm)  << gte_pos_lm )
-#define enc_gte_cmd(cmd)    ((cmd) << gte_shift_cmd )
+#define enc_gte_cmd(cmd)    ((cmd) << gte_pos_cmd )
-#define enc_gte_fake_cmd(x) ((x)   << gte_shift_fake_cmd)
+#define enc_gte_fake_cmd(x) ((x)   << gte_pos_fake_cmd)
 
 /* Composite: all six GTE fields + the COP2/CO base. */
 #define enc_gte_cmdw(sf, mx, v, cv, lm, cmd) ( \

code/duffle/lottes_tape.h

@@ -99,8 +99,8 @@ enum {
 	R_Atom7  = R_T7,
 	R_Atom8  = R_T8,
 	R_Atom9  = R_T9,
-	R_Atom10 = R_V0, // Tend to be used with gte DMAs
+	R_Atom10 = R_V0, // Tend to be used with gte moves
-	R_Atom11 = R_V1, // Tend to be used with gte DMAs
+	R_Atom11 = R_V1, // Tend to be used with gte moves
 	R_Atom12 = R_A0,
 	R_Atom13 = R_A1,
 	R_Atom14 = R_A2,
@@ -163,6 +163,12 @@ typedef Slice_(MipsAtom);
 // Used for trivial mappings from one atom component proc to the command of a more baser (meant for type-mapping)
 #define MipsAtomComp_ProcMap_(ab, base_command) atom_dbg_skip MipsAtomComp_Proc_(ab, {base_command })
 
+// WIP: Atoms Assocated closely with each other to form a tape procedure. (Maybe also a phase in a procedure/pipeline?)
+
+#define AtomBundle_(name)              Struct_(tmpl(AtomBundle,name))
+#define AtomBundle_Len(name)           S_(tmpl(AtomBundle,name))/S_(MipsAtom*)
+#define AtomBundleEntry_(bundle,entry) tmpl(bundle,entry)
+
 /* 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.
@@ -242,13 +248,17 @@ FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ u4_(mem.ptr), mem.len
 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_ void tb_bind(TapeBuilder* tb, Slice data) { mem_copy(tb->ptr + tb->used * S_(MipsCode), u4_(data.ptr), data.len); tb->used += data.len / S_(MipsCode); }
+#define tb_bind_(tb,type,...) tb_bind(tb, (Slice){ (B1*)(& (type){__VA_ARGS__}), S_(type) }); static_assert(S_(type) % S_(MipsCode) == 0)
+
+// NOTE(Ed): Wip still ideating convention. Possibly will never use a composite.
+#define tb_emit_wbind_(tb,atom,...)       tb_emit(tb,atom); tb_bind_(tb,tmpl(Binds,atom),__VA_ARGS__)
+#define tb_emit_wbind2_(tb,atom,type,...) tb_emit(tb,atom); tb_bind_(tb,type,__VA_ARGS__)
 
 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))
+#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))
@@ -377,10 +387,6 @@ FI_ Reg regfile__alloc_helper(A2_U2 file, Reg r_id) {
 	}
 	return result; 
 }
-/* regfile_alloc picks the next free GPR from regfile_alloc_order.
- * The table is the first-fit allocation order: T0..T7, V0..V1, A0..A3,
- * S0..S7, T8..T9. The 24 entries leave room for the tape program to use
- * any of them while R0, R1, R26-R31 remain reserved. */
 I_ Reg regfile_alloc(RegFile_R rf) {
 	Reg allocated = 0;
 	for index_iter(U4, r_id, R_V0, <, R_T9) {

code/duffle/mips.h

@@ -252,12 +252,12 @@ enum {
 enum { _BitOffsets = 0
 /* Bit Offsets for MIPS Instruction Fields */
 
-	, OPCODE_SHIFT = 26
+	, OPCODE_POS = 26
-	, RS_SHIFT     = 21
+	, RS_POS     = 21
-	, RT_SHIFT     = 16
+	, RT_POS     = 16
-	, RD_SHIFT     = 11
+	, RD_POS     = 11
-	, SHAMT_SHIFT  = 6  /* Shift Amount */
+	, SHAMT_POS  = 6  /* Shift Amount: Offset Position */
-	, FC_SHIFT     = 0
+	, FC_POS     = 0
 
 /* IMM_MASK is the 16-bit two's-complement truncation for the immediate field.
  * It is NOT a range guard — it is load-bearing for negative branch offsets
@@ -268,12 +268,12 @@ enum { _BitOffsets = 0
 	, IMM_MASK     = 0xFFFF
 };
 
-#define enc_op(op)       ((op)    << OPCODE_SHIFT)
+#define enc_op(op)       ((op)    << OPCODE_POS)
-#define enc_rs(rs)       ((rs)    << RS_SHIFT)
+#define enc_rs(rs)       ((rs)    << RS_POS)
-#define enc_rt(rt)       ((rt)    << RT_SHIFT)
+#define enc_rt(rt)       ((rt)    << RT_POS)
-#define enc_rd(rd)       ((rd)    << RD_SHIFT)
+#define enc_rd(rd)       ((rd)    << RD_POS)
-#define enc_shamt(shamt) ((shamt) << SHAMT_SHIFT)
+#define enc_shamt(shamt) ((shamt) << SHAMT_POS)
-#define enc_fc(fc)       ((fc)    << FC_SHIFT)
+#define enc_fc(fc)       ((fc)    << FC_POS)
 #define enc_imm(imm)     ((imm) & IMM_MASK)
 
 /* MIPS R-Type Instruction Format (Register-to-Register) */

code/duffle/pad.h

@@ -4,10 +4,7 @@
 #	include "math.h"
 #endif
 
-/* PSX button bit positions — 1:1 with PSX-SPX docs at docs/psx-spx/docs/controllersandmemorycards.md:405-421.
+// PSX button bit positions: PSX-SPX docs/psx-spx/docs/controllersandmemorycards.md:405-421.
- * Wire is active-low (0 = pressed).
- * 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),
@@ -62,11 +59,7 @@ typedef Enum_(U4, PadStatus) {
 	PadStatus_Invalid,
 };
 
-/* Distinct from the game-facing PadStatus enum: PadRawStatus_Ok and PadRawStatus_Timeout are raw BIOS values;
+// 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,

code/duffle/psyq.h

@@ -104,7 +104,7 @@ 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");
+S4 psy_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.

code/hello_camera/gen/offsets.h

@@ -8,7 +8,7 @@
 #pragma region hello_camera
 
 
-// --- atom: pad_input_cube_rotation (61 words) ---
+// --- 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
@@ -26,7 +26,7 @@ enum {
     atom_offset_end_low_exit_stick = _atom_offset_end_low_exit_stick,
 };
 
-// --- atom: pad_input_cam (40 words) ---
+// --- atom: pad_input_cam (39 words) ---
 
 #define _atom_offset_left_x_exit_left_x               3
 #define _atom_offset_right_x_exit_right_x             3
@@ -44,7 +44,7 @@ enum {
     atom_offset_circle_z_exit_circle_z = _atom_offset_circle_z_exit_circle_z,
 };
 
-// --- atom: cube_g4_face (75 words) ---
+// --- atom: cube_g4_face (73 words) ---
 
 #define _atom_offset_cull_cube_g4_face_exit           41
 #define _atom_offset_bounds_chk_cube_g4_face_exit     24
@@ -54,7 +54,7 @@ enum {
     atom_offset_bounds_chk_cube_g4_face_exit = _atom_offset_bounds_chk_cube_g4_face_exit,
 };
 
-// --- atom: floor_f3_face (58 words) ---
+// --- atom: floor_f3_face (56 words) ---
 
 #define _atom_offset_culling_floor_f3_face_exit       25
 #define _atom_offset_bounds_chk_floor_f3_face_exit    16

code/hello_camera/hello_camera.atom.c

@@ -92,11 +92,6 @@ MipsAtomComp_Proc_(ab, {
 #pragma endregion MACs
 
 #pragma region Atom Procs
-// Modular Atoms
-
-#define AtomBundle_(name)              Struct_(tmpl(AtomBundle,name))
-#define AtomBundle_Len(name)           S_(tmpl(AtomBundle,name))/S_(MipsAtom*)
-#define AtomBundleEntry_(bundle,entry) tmpl(bundle,entry)
 
 #pragma region resolve_look_at
 /* ─── resolve_look_at bundle chain atoms ──────────────────────────── */
@@ -108,7 +103,7 @@ typedef AtomBundle_(resolve_look_at) { MipsAtom
 	*normalize_right_ux,
 	*cross_to_up,
 	*normalize_up_uy,
-	*pop_mv_trans;
+	*populate_mt3s4s2;
 };
 
 typedef Struct_(ResolveLookAtScratch) {
@@ -123,71 +118,56 @@ typedef Struct_(ResolveLookAtScratch) {
 	V3_S4 up_in;
 };
 
-/* Binds_ResolveLookAtSub — what the C side pushes onto the tape before input_and_sub.
- * The scratchpad base is no longer pushed because R_ScratchBase (= R_SP) is a tape carrier
- * preserved across atoms; the atom body reads 0x1F800000 directly from R_SP. */
-typedef Struct_(Binds_ResolveLookAt) {
-	MT3_S2S4* look_at;
-	P3_S4*    eye;
-	P3_S4*    target;
-	V3_S4*    up_in;
-};
 typedef Struct_(Binds_ResolveLookAtSub) {
 	P3_S4* target;
 	P3_S4* eye;
 	V3_S4* up_in;
 };
 typedef Struct_(RegUse_resolve_look_at_input_and_sub) {
-	Reg target; Reg eye; Reg up_in;
+	Reg target_ptr;
-	Reg t0; Reg t1; Reg t2; Reg t3; Reg t4;
+	Reg eye_ptr;
+	Reg up_in_ptr;
+	union { Reg_(V3_S4) r012, up_in,  eye; };
+	union { Reg_(V3_S4) r345, target, fwd; };
 };
 /* Atom 0 in the bundle: input_and_sub. Stages C-side inputs into the scratchpad and computes fwd = target - eye. */
 internal MipsAtom* AtomBundleEntry_(resolve_look_at,input_and_sub)(AtomArena_R aa, RegUse_resolve_look_at_input_and_sub r)
 atom_info(atom_bind(Binds_ResolveLookAtSub)) MipsAtom_Proc_(aa, {
-	load_word(r.target, R_TapePtr, O_(Binds_ResolveLookAtSub,target)),
+	load_word(r.target_ptr, R_TapePtr, O_(Binds_ResolveLookAtSub,target)),
-	load_word(r.eye,    R_TapePtr, O_(Binds_ResolveLookAtSub,eye)),
+	load_word(r.eye_ptr,    R_TapePtr, O_(Binds_ResolveLookAtSub,eye)),
-	load_word(r.up_in,  R_TapePtr, O_(Binds_ResolveLookAtSub,up_in)),
+	load_word(r.up_in_ptr,  R_TapePtr, O_(Binds_ResolveLookAtSub,up_in)),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_ResolveLookAtSub)),
+	LdSlot_ add_ui_self(    R_TapePtr, S_(Binds_ResolveLookAtSub)),
 
 	/* Stage up_in.x/y/z into the scratchpad. R_ScratchBase = R_SP = 0x1F800000. */
-	mac_load_word_v3( r.t0, r.t1, r.t2, r.up_in,   0), LdSlot_
+	mac_load_v3s4( r.up_in, r.up_in_ptr, 0), LdSlot_
-	mac_store_word_v3(r.t0, r.t1, r.t2, R_ScratchBase, O_(ResolveLookAtScratch,up_in)),
+	mac_store_v3s4(r.up_in, R_ScratchBase, O_(ResolveLookAtScratch,up_in)),
 
 	// Stage eye.x/y/z into the scratchpad (atom 6 reads these for the translation column).
-	mac_load_word_v3( r.t0, r.t1, r.t2, r.eye,      0), LdSlot_
+	mac_load_v3s4( r.eye, r.eye_ptr, 0), LdSlot_
-	mac_store_word_v3(r.t0, r.t1, r.t2, R_ScratchBase, O_(ResolveLookAtScratch,eye)),
+	mac_store_v3s4(r.eye, R_ScratchBase, O_(ResolveLookAtScratch,eye)),
 
 	/* Compute fwd = target - eye. */
-	// mac_load_p3s4(t3, R_AT, t4, r.eye,    0),
+	mac_load_v3s4(    r.target, r.target_ptr, 0), LdSlot_
-	mac_load_word_v3(r.t3, R_AT, r.t4, r.target, 0), LdSlot_
+	mac_sub_v3s4_self(r.fwd, r.eye),
-	mac_sub_s_v3_self(
+	mac_store_v3s4(   r.fwd, R_ScratchBase, O_(ResolveLookAtScratch,fwd)),
-		r.t3, R_AT, r.t4,
-		r.t0, r.t1, r.t2),
-	mac_store_word_v3(r.t3, R_AT, r.t4, R_ScratchBase, O_(ResolveLookAtScratch,fwd)),
 
 	mac_yield()
 })
 
-
+typedef Struct_(Binds_ResolveLookAt_PopulateMT3S4S2) {
-typedef Struct_(Binds_ResolveLookAtPopMvTrans) {
+	MT3_S2S4* look_at;  /* MT3_S2S4* — destination matrix address */
-	U4 look_at;  /* MT3_S2S4* — destination matrix address */
 };
-typedef Struct_(RegUse_resolve_look_at__pop_mv_trans) {
+typedef Struct_(RegUse_resolve_look_at_populate_mt3s4s2) {
 	Reg         look_at;
-	Reg_(V3_S4) row;             /* populate phase: load ux/uy/uz */
+	Reg         eye;            /* matrix_vector phase: load -eye */
-	union { Reg ux, v_x; } t6;   /* populate addr (canonical) → matrix_vector v_x */
+	Reg_(V3_S4) row;            /* populate phase: load ux/uy/uz */
-	union { Reg uy, v_y; } t7;   /* populate uy → matrix_vector v_y */
+	union { Reg r0, ux, vx; }; /* populate addr → matrix_vector v_x */
-	union { Reg uz, v_z; } t8;   /* populate uz → matrix_vector v_z */
+	union { Reg r1, uy, vy; }; /* populate uy   → matrix_vector v_y */
-	Reg         eye;             /* matrix_vector phase: load -eye */
+	union { Reg r2, uz, vz; }; /* populate uz   → matrix_vector v_z */
 };
-/* Atom 6 (fused): write look_at->m[][] from ux/uy/uz as packed S2 (populate),
+/* write look_at->m[][] from ux/uy/uz as packed S2 (populate),
  * ctc2 RT chain into C2[0..4] (matrix_vector), MVMVA RT*(-eye)>>12, store off
- * directly to look_at->t[] (trans_matrix). Replaces the previous 3 separate atoms
+ * directly to look_at->t[] (trans_matrix).
- * (populate + matrix_vector + trans_matrix).
- *
- * MT3_S2S4 { A3x3_S2 m; A3_S4 t; }
- *   m[][] is S2 packed (9 × 2 = 18 bytes at offset 0)
- *   t[0..2]   is S4       (3 × 4 = 12 bytes at offset 18)
  *
  * C11 ApplyMatrixLV semantics (gte.atom.c ac_apply_matrix_lv; libgte reference):
  *   1. ctc2 RT matrix (5 ctc2s to C2[0..4])
@@ -197,82 +177,51 @@ typedef Struct_(RegUse_resolve_look_at__pop_mv_trans) {
  *   4. mtc2 to IR1/2/3, nop2, MVMVA pass2 (sf=1, mx=0, v=3, cv=3)
  *   5. mfc2 MACs → off
  *   6. store off to look_at->t[] (skip scratch.eye intermediate)
- *
- * GPR codes (assigned by resolve_look_at_init):
- *   r_scratch : R_ResolveScratch (R_T4 carrier)
- *   r_look_at : ralloc() — also serves as the off-dst in the trans_matrix phase
- *   r_row     : V3_S4, reused for ux/uy/uz loads in populate phase
- *   r_eye     : ralloc() — &scratch.eye, used for -eye load in matrix_vector phase
- *   r_v_x/v_y/v_z : ralloc() — populate scratch addrs (ux/uy/uz), reused as
- *                    ctc2 transfer + MVMVA -eye temp in matrix_vector phase
- *   (v_x/v_y/v_z alias ux/uy/uz via the union; lifetime ends for ux/uy/uz after
- *    populate's mac_load_v3s4, so reusing for v.x/v.y/v.z is safe)
- * Pool cost: 1 carrier + 1 look_at + 3 row + 1 eye + 3 aliased = 9 GPRs
- *
- * Net word savings vs the previous 3-atom flow: ~15 words + 2 mac_yields + 1 tape pop.
- *   - 2 mac_yields (trans_matrix's + matrix_vector's) → fused into one yield
- *   - 1 redundant tb_data (look_at was pushed 2x; now once)
- *   - mac_trans_mt3s3s4 (6 words) → replaced by direct mac_store_v3s4
- *   - mac_store_v3s4 to scratch.eye (3 words intermediate) → eliminated
- *   - add_si for r_off_ptr (2 words) → eliminated
- *   - mac_store_v3s4 zero-store of t[] (3 words) → eliminated (matrix_vector writes
- *     off directly; no consumer needed the zero first)
- *   - 1 set_gte_mt3s2s4 ctc2 chain (13 baked words) → eliminated (matrix_vector
- *     has its own ctc2 RT chain; cube rendering atoms reload C2 state themselves)
  */
-internal MipsAtom* resolve_look_at__pop_mv_trans(AtomArena_R aa,
+internal MipsAtom* AtomBundleEntry_(resolve_look_at,populate_mt3s4s2)(AtomArena_R aa, RegUse_resolve_look_at_populate_mt3s4s2 r)
-	RegUse_resolve_look_at__pop_mv_trans r
+atom_info(atom_bind(Binds_ResolveLookAt_PopulateMT3S4S2)) MipsAtom_Proc_(aa, {
-) MipsAtom_Proc_(aa, {
 	/* --- Tape pop: look_at pointer --- */
-	load_word(r.look_at, R_TapePtr, O_(Binds_ResolveLookAtPopMvTrans,look_at)),
+	load_word(r.look_at, R_TapePtr, O_(Binds_ResolveLookAt_PopulateMT3S4S2,look_at)),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_ResolveLookAtPopMvTrans)),
+	LdSlot_ add_ui_self( R_TapePtr, S_(Binds_ResolveLookAt_PopulateMT3S4S2)),
 
-	/* --- Scratch addresses for ux/uy/uz/eye (populate phase; t6/t7/t8 alias ux/uy/uz).
+	add_si(r.ux,  R_ScratchBase, O_(ResolveLookAtScratch, ux)), LdSlot_
-	 * R_ScratchBase (= R_SP) holds 0x1F800000; no per-atom bake is required because
+	add_si(r.uy,  R_ScratchBase, O_(ResolveLookAtScratch, uy)),
-	 * R_SP is a tape carrier preserved across atoms. --- */
+	add_si(r.uz,  R_ScratchBase, O_(ResolveLookAtScratch, uz)),
-	add_si(r.t6.ux, R_ScratchBase, O_(ResolveLookAtScratch, ux)),  LdSlot_
+	add_si(r.eye, R_ScratchBase, O_(ResolveLookAtScratch, eye)),
-	add_si(r.t7.uy, R_ScratchBase, O_(ResolveLookAtScratch, uy)),
-	add_si(r.t8.uz, R_ScratchBase, O_(ResolveLookAtScratch, uz)),
-	add_si(r.eye,   R_ScratchBase, O_(ResolveLookAtScratch, eye)),
 
-	/* --- POPULATE phase: write look_at->m[][] from ux/uy/uz as packed S2 --- */
+	/* write look_at->m[][] from ux/uy/uz as packed S2 */
-	mac_load_v3s4(r.row, r.t6.ux, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[0])),
+	mac_load_v3s4(r.row, r.ux, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[0])),
-	mac_load_v3s4(r.row, r.t7.uy, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[1])),
+	mac_load_v3s4(r.row, r.uy, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[1])),
-	mac_load_v3s4(r.row, r.t8.uz, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[2])),
+	mac_load_v3s4(r.row, r.uz, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[2])),
 
-	/* --- MATRIX-VECTOR phase: ctc2 RT chain + MVMVA RT*(-eye)>>12 --- */
+	/* ctc2 RT chain + MVMVA RT * (-eye) >> 12 */
-	/* RT packing (per libgte ApplyMatrixLV convention; see gte.h:217-220 +
+	/*   C2[0] = (RT12<<16)|RT11  ← ctc2 RT11 from m[0][0..1]
-	 * atom_6b_disasm_comparison.md:28-32):
+	 *   C2[1] = (RT21<<16)|RT13  ← ctc2 RT12 from m[0][2..3]
-	 *   C2[0] = (RT12<<16)|RT11  ← ctc2 RT11 from m[0][0..1] packed word
+	 *   C2[2] = (RT23<<16)|RT22  ← ctc2 RT13 from m[1][1..2]
-	 *   C2[1] = (RT21<<16)|RT13  ← ctc2 RT12 from m[0][2..3] packed word
+	 *   C2[3] = (RT32<<16)|RT31  ← ctc2 RT21 from m[2][0..1]
-	 *   C2[2] = (RT23<<16)|RT22  ← ctc2 RT13 from m[1][1..2] packed word
+	 *   C2[4] = (RT33<<16)|junk  ← ctc2 RT22 from m[2][2] (half) */
-	 *   C2[3] = (RT32<<16)|RT31  ← ctc2 RT21 from m[2][0..1] packed word
+	load_word(  r.vx, r.look_at, O_(MT3_S2S4, m[0][0])), /* RT11|RT12 */ LdSlot_
-	 *   C2[4] = (RT33<<16)|junk  ← ctc2 RT22 from m[2][2] (half)
+	load_word(  r.vy, r.look_at, O_(MT3_S2S4, m[0][2])), /* RT13|RT21 */ LdSlot_ gte_mv_to_ctrl_r(r.vx, gte_cr_RT11),
-	 * Each ctc2 writes a WHOLE 32-bit C2 slot; the "macro name" identifies
+	load_word(  r.vz, r.look_at, O_(MT3_S2S4, m[1][1])), /* RT22|RT23 */ LdSlot_ gte_mv_to_ctrl_r(r.vy, gte_cr_RT12),
-	 * which C2 register, not which 16-bit half. */
+	load_word(  r.vx, r.look_at, O_(MT3_S2S4, m[2][0])), /* RT31|RT32 */ LdSlot_ gte_mv_to_ctrl_r(r.vz, gte_cr_RT13),
-	load_word(  r.t6.v_x, r.look_at, O_(MT3_S2S4, m[0][0])), /* RT11|RT12 */ LdSlot_
+	load_half_u(r.vy, r.look_at, O_(MT3_S2S4, m[2][2])), /* RT33 */      LdSlot_ gte_mv_to_ctrl_r(r.vx, gte_cr_RT21),
-	load_word(  r.t7.v_y, r.look_at, O_(MT3_S2S4, m[0][2])), /* RT13|RT21 */ LdSlot_ gte_mv_to_ctrl_r(r.t6.v_x, gte_cr_RT11),
+
-	load_word(  r.t8.v_z, r.look_at, O_(MT3_S2S4, m[1][1])), /* RT22|RT23 */ LdSlot_ gte_mv_to_ctrl_r(r.t7.v_y, gte_cr_RT12),
+	GteDelay_ mac_load_word_v3(r.vx, r.vy, r.vz, r.eye, 0), LdSlot_ 
-	load_word(  r.t6.v_x, r.look_at, O_(MT3_S2S4, m[2][0])), /* RT31|RT32 */ LdSlot_ gte_mv_to_ctrl_r(r.t8.v_z, gte_cr_RT13),
+	mac_sub_s_v3(r.vx, r.vy, r.vz, R_0, R_0, R_0, r.vx, r.vy, r.vz),
-	load_half_u(r.t7.v_y, r.look_at, O_(MT3_S2S4, m[2][2])), /* RT33 */      LdSlot_ gte_mv_to_ctrl_r(r.t6.v_x, gte_cr_RT21),
+
-	/* pos = -eye. The three loads also retire the last CTC2. */                  gte_mv_to_ctrl_r(r.t7.v_y, gte_cr_RT22),
+	gte_mv_to_data_r(r.vx, C2_IR1),
-	GteDelay_ mac_load_word_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, r.eye, 0), LdSlot_ 
+	gte_mv_to_data_r(r.vy, C2_IR2),
-	mac_sub_s_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, R_0, R_0, R_0, r.t6.v_x, r.t7.v_y, r.t8.v_z),
+	gte_mv_to_data_r(r.vz, C2_IR3),
-	/* mtc2 pos (as S16) to IR1/2/3. The GTE takes low 16 bits. pos fits in S16. For negative pos, the 32-bit sign-extended value's low 16 bits = correct S16. */
-	gte_mv_to_data_r(r.t6.v_x, C2_IR1),
-	gte_mv_to_data_r(r.t7.v_y, C2_IR2),
-	gte_mv_to_data_r(r.t8.v_z, C2_IR3),
 	GteDelay_ nop2,
 
-	/* MVMVA pass 2 — C11 ApplyMatrixLV command.
+	/* MVMVA pass 2 — C11 ApplyMatrixLV command. sf=1, mx=0 (RT), v=3 (IR), cv=3. Reads RT × IR >> 12. */
-	 * sf=1, mx=0 (RT), v=3 (IR), cv=3. Reads RT × IR >> 12. */
+	gte_cmdw_mvmva_c11_pass2,                        GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0),            // ac_yield: word 1
-	gte_cmdw_mvmva_c11_pass2,                                      GteDelay_ nop,
+	mac_gte_mv_from_data_r_mac123(r.vx, r.vy, r.vz), GteDelay_ add_ui_self(         R_TapePtr, S_(MipsCode)), // ac_yield: word 2
-	mac_gte_mv_from_data_r_mac123(r.t6.v_x, r.t7.v_y, r.t8.v_z),   GteDelay_ nop,
 
-	/* --- TRANS-MATRIX phase: store off directly to look_at->t[] (skip scratch.eye intermediate) --- */
+	/* store off directly to look_at->t[] (skip scratch.eye intermediate) */
-	mac_store_word_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, r.look_at, O_(MT3_S2S4, t)),
+	mac_store_word_v3(r.vx, r.vy, r.vz, r.look_at, O_(MT3_S2S4, t)),
 
-	mac_yield()
+	jump_reg(R_AtomJmp), BdSlot_ nop, // ac_yield: word 3-4
 })
 #pragma endregion resolve_look_at
 
@@ -339,23 +288,6 @@ internal MipsAtom_(screen_env_init) atom_info(atom_phase(screen_init)
 	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 */
@@ -522,7 +454,7 @@ internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
 	load_word(R_T1, R_Cam, O_(Camera,pos.x)),
 
 	// D-pad Left → cam.pos.x -= 50.  and_i fulfills BD-slot for load on R_Cam.
-	LdSlot_ and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(left_x, exit_left_x)), BdSlot_ mac_yield_load(), LdSlot_
+	LdSlot_ and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(left_x, exit_left_x)), BdSlot_ nop,
 		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.x)), 
 	atom_label(exit_left_x)
 
@@ -544,16 +476,16 @@ internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
 
 	/* D-pad Cross → cam.pos.z -= 50. Load pos.z BEFORE the andi. */
 	load_word(R_T1, R_Cam, O_(Camera,pos.z)), LdSlot_
-	and_i(R_T3, R_T0, Pad_Cross), branch_le_zero(R_T3, atom_offset(cross_z, exit_cross_z)), BdSlot_ nop,
+	and_i(R_T3, R_T0, Pad_Cross), branch_le_zero(R_T3, atom_offset(cross_z, exit_cross_z)), BdSlot_ load_word(R_AtomJmp, R_TapePtr, 0), LdSlot_ // ac_yield: word 1
 		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)), BdSlot_ nop,
+	and_i(R_T3, R_T0, Pad_Circle), branch_le_zero(R_T3, atom_offset(circle_z, exit_circle_z)), BdSlot_ add_ui_self(R_TapePtr, S_(MipsCode)), // ac_yield: word 2
 		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(),
+	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
 };
 
 enum {
@@ -596,11 +528,13 @@ 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)),
 
-	LdSlot_ mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), GteDelay_ load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)), LdSlot_
+	LdSlot_ mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), 
-	GteDelay_ nop, gte_cmdw_rotate_translate_perspective_triple,
+		GteDelay_ load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)), LdSlot_
+		GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0),          LdSlot_ //ac_yield: word 2,
+	gte_cmdw_rotate_translate_perspective_triple,
 	gte_cmdw_nclip,
 
-	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ nop,
+	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ add_ui_self(R_TapePtr, S_(MipsCode)), // ac_yield: word 1
 	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 —
@@ -632,7 +566,7 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 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()
+	jump_reg(R_AtomJmp), BdSlot_ nop      // ac_yield: word 3-4
 };
 
 typedef Struct_(Binds_FloorTri) {
@@ -662,13 +596,13 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 	, 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),
+	mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), GteDelay_ nop2,
-	nop2, gte_cmdw_rotate_translate_perspective_triple, // 2 nops retire the final cpu -> gte writes before RTPT
+	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),
+	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0), // ac_yield: word 1
-	nop, branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop, // required gte -> cpu load-delay slot.
+	branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), BdSlot_ add_ui_self(R_TapePtr, S_(MipsCode)),  // ac_yield: word 2
 		/* Format Primitive */
 		mac_gte_store_f3(R_PrimCursor),
 
@@ -678,7 +612,7 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 		/* 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,
+		branch_equal(R_AT, R_0,  atom_offset(bounds_chk, floor_f3_face_exit)), BdSlot_ 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) */
@@ -689,7 +623,7 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 /* 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()
+	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
 };
 
 typedef Struct_(Binds_SyncPrimitiveArena) { U4 used; U4 cursor; };

code/hello_camera/hello_camera.c

@@ -80,9 +80,6 @@ typedef Struct_(SMemory) {
 	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
-
 	U1 ct_init_atom_mem[CT_InitAtomMem_Size];
 	MipsAtom* normalize_v3s4;
 	MipsAtom* gte_cross_v3s4;
@@ -114,10 +111,10 @@ I_ void resolve_look_at_c11(MT3_S2S4* look_at, P3_S4* eye, P3_S4* target, V3_S4*
 	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.
+	psy_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,   up_in, & right); psy_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.
+	cross_v3s4(& uz, & ux,    & up);    psy_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;
@@ -149,15 +146,15 @@ internal void compile_init_atoms(void) {
 		});
 	regfile_reset(& rf);
 
-	smem.normalize_v3s4 = build_normalize_v3s4(& ab,
+	smem.normalize_v3s4 = normalize_v3s4(& ab,
-		RegUse_(build_normalize_v3s4) {
+		RegUse_(normalize_v3s4) {
 			.res = ralloc_v3(),
-			.t0     = ralloc(),
+			.r0     = ralloc(),
-			.t1     = ralloc(),
+			.r1     = ralloc(),
-			.t2     = ralloc(),
+			.r2     = ralloc(),
-			.t3     = ralloc(),
+			.r3     = ralloc(),
-			.t4     = ralloc(),
+			.r4     = ralloc(),
-			.t5     = ralloc(),
+			.r5     = ralloc(),
 		});
 	regfile_reset(& rf);
 
@@ -167,26 +164,20 @@ internal void compile_init_atoms(void) {
 }
 
 internal void compile_resolve_look_at(void) {
-	AtomArena ab = atomarena_make(slice_ut_arr(smem.resolve_look_at_mem));
 	AtomBundle_resolve_look_at_R bundle = C_(void*, smem.resolve_look_at_bundle);
-
+	AtomArena ab = atomarena_make(slice_ut_arr(smem.resolve_look_at_mem));
-	/* R_ScratchBase (= R_SP) is a tape carrier preserved across atoms; no carrier
+	RegFile   rf = regfile(regfile_abi_mask);
-	 * pin is needed in the regfile. The standard 24-register pool is sufficient. */
-	RegFile rf = regfile(regfile_abi_mask);
 #define ralloc() regfile_alloc(& rf)
 #define ralloc_v3() { ralloc(), ralloc(), ralloc() }
-
 	bundle->input_and_sub = AtomBundleEntry_(resolve_look_at, input_and_sub)(& ab,
 		RegUse_(resolve_look_at_input_and_sub) {
-			.target  = ralloc(),
+			.target_ptr = ralloc(),
-			.eye     = ralloc(),
+			.eye_ptr    = ralloc(),
-			.up_in   = ralloc(),
+			.up_in_ptr  = ralloc(),
-			.t0      = ralloc(),
+			.up_in      = ralloc_v3(),
-			.t1      = ralloc(),
+			.r012       = ralloc_v3(),
-			.t2      = ralloc(),
+			.r345       = {ralloc(), R_AT, ralloc() },
-			.t3      = ralloc(),
+	});
-			.t4      = ralloc(),
-		});
 	regfile_reset(& rf);
 
 	bundle->normalize_fwd_uz   = smem.normalize_v3s4;
@@ -195,62 +186,58 @@ internal void compile_resolve_look_at(void) {
 	bundle->cross_to_up        = smem.gte_cross_v3s4;
 	bundle->normalize_up_uy    = smem.normalize_v3s4;
 
-	bundle->pop_mv_trans = resolve_look_at__pop_mv_trans(& ab,
+	bundle->populate_mt3s4s2 = AtomBundleEntry_(resolve_look_at,populate_mt3s4s2)(& ab,
-		RegUse_(resolve_look_at__pop_mv_trans){
+		RegUse_(resolve_look_at_populate_mt3s4s2){
 			.look_at = ralloc(),
 			.eye     = ralloc(),
 			.row     = ralloc_v3(),
-			.t6      = ralloc(),
+			.r0      = ralloc(),
-			.t7      = ralloc(),
+			.r1      = ralloc(),
-			.t8      = ralloc(),
+			.r2      = ralloc(),
 		});
 
-	/* Sanity check: arena didn't overflow. */
+	assert(ab.used <= ResolveLookAtArena_Size); // Sanity check: arena didn't overflow.
-	assert(ab.used <= ResolveLookAtArena_Size);
 #undef ralloc
 }
 
-/* Emit the resolve_look_at bundle into the tape. Called once per frame from update(). */
+// Emit the resolve_look_at bundle into the tape. Called once per frame from update().
-I_ void resolve_look_at(TapeBuilder_R tb
+I_ void resolve_look_at(TapeBuilder_R tb,	MT3_S2S4* look_at, P3_S4* eye, P3_S4* target,	V3_S4* up_in) {
-	,	MT3_S2S4* look_at
-	,	P3_S4*    eye
-	,	P3_S4*    target
-	,	V3_S4*    up_in
-){
 	/* Typed view of the scratchpad for field-address arithmetic. */
-	ResolveLookAtScratch* sp = C_scratch(ResolveLookAtScratch*);
+	ResolveLookAtScratch*        sp     = C_scratch(ResolveLookAtScratch*);
 	AtomBundle_resolve_look_at_R bundle = C_(void*, smem.resolve_look_at_bundle);
-
+	tb_emit(tb, bundle->input_and_sub); tb_bind_(tb, Binds_ResolveLookAtSub, 
-	tb_emit(tb, bundle->input_and_sub); {
+		.target = target,
-		tb_data(tb, u4_(target));
+		.eye    = eye,
-		tb_data(tb, u4_(eye));
+		.up_in  = up_in,
-		tb_data(tb, u4_(up_in));
+	);
-	}
+	tb_emit(tb, bundle->normalize_fwd_uz); tb_bind_(tb, Binds_normalize_v3s4,
-	tb_emit(tb, bundle->normalize_fwd_uz); {
+		.src_offset = O_(ResolveLookAtScratch,fwd),
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, fwd) | (O_(ResolveLookAtScratch, uz) << 16)));
+		.dst_offset = O_(ResolveLookAtScratch,uz),
-	}
+	);
-	tb_emit(tb, bundle->cross_to_right); {
+	tb_emit(tb, bundle->cross_to_right); tb_bind_(tb, Binds_gte_cross_v3s4,
-		tb_data(tb, u4_(& sp->uz));
+		.src_a = & sp->uz,
-		tb_data(tb, u4_(& sp->up_in));
+		.src_b = & sp->up_in,
-		tb_data(tb, u4_(& sp->right));
+		.out   = & sp->right,
-	}
+	);
-	tb_emit(tb, bundle->normalize_right_ux); {
+	tb_emit(tb, bundle->normalize_right_ux); tb_bind_(tb, Binds_normalize_v3s4, 
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, right) | (O_(ResolveLookAtScratch, ux) << 16)));
+		.src_offset = O_(ResolveLookAtScratch,right),
-	}
+		.dst_offset = O_(ResolveLookAtScratch,ux),
-	tb_emit(tb, bundle->cross_to_up); {
+	);
-		tb_data(tb, u4_(& sp->uz));
+	tb_emit(tb, bundle->cross_to_up); tb_bind_(tb, Binds_gte_cross_v3s4, 
-		tb_data(tb, u4_(& sp->ux));
+		.src_a = & sp->uz,
-		tb_data(tb, u4_(& sp->up));
+		.src_b = & sp->ux,
-	}
+		.out   = & sp->up,
-	tb_emit(tb, bundle->normalize_up_uy); {
+	);
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, up) | (O_(ResolveLookAtScratch, uy) << 16)));
+	tb_emit(tb, bundle->normalize_up_uy); tb_bind_(tb, Binds_normalize_v3s4,
-	}
+		.src_offset = O_(ResolveLookAtScratch,up),
-	tb_emit(tb, bundle->pop_mv_trans); {
+		.dst_offset = O_(ResolveLookAtScratch,uy),
-		tb_data(tb, u4_(look_at));
+	);
-	}
+	tb_emit(tb, bundle->populate_mt3s4s2); tb_bind_(tb, Binds_ResolveLookAt_PopulateMT3S4S2, 
+		.look_at = look_at,
+	);
 }
+FI_ void camera_look_at(TapeBuilder_R tb, Camera* c, P3_S4* target, V3_S4* up_in) { resolve_look_at(tb, & 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));
@@ -260,15 +247,15 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		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(& tb,   u4_(& smem.pad_raw[0]));
-				tb_data_(state, & smem.pad[0]);
+				tb_data(& tb, u4_(& 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(& tb, u4_(& smem.pad[0]));
-				tb_data_(cam, & smem.cam);
+				tb_data(& tb, u4_(& smem.cam));
 
 			// tb_emit_(pad_input_cube_rotation);
 			// 	tb_data_(state,     & smem.pad[0]);
@@ -301,7 +288,7 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	if (use_c11_path == false)
 	{
 		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));
+			camera_look_at(& tb, & smem.cam, & smem.cube.pos, & v3s4(0, -fp_one, 0));
 		}
 	}
 
@@ -384,7 +371,6 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		// smem.floor.rot.y += 5;
 	}
 }
-GCC_OPTIMIZATION_ENABLE
 
 void render(void) {
 }
@@ -401,12 +387,9 @@ void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_
 	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);
@@ -451,4 +434,3 @@ int main(void)
 	};
 	return 0;
 }
-GCC_OPTIMIZATION_ENABLE

scripts/duffle.lua

@@ -1,11 +1,47 @@
 --- duffle.lua — facade over duffle_scan / duffle_isa / duffle_emit.
-local scan = require("duffle_scan")
-local isa  = require("duffle_isa")
-local emit = require("duffle_emit")
-local M    = {}
 
+--- @class DuffleExport
+--- bag: open module-export keys from duffle_scan / duffle_isa / duffle_emit
+
+local scan = require("duffle_scan") ---@type DuffleExport
+local isa  = require("duffle_isa")  ---@type DuffleExport
+local emit = require("duffle_emit") ---@type DuffleExport
+local M    = {}                     ---@type DuffleExport
+
+--- @alias Path      string
+--- @alias LineNum   integer
+--- @alias ByteOff   integer
+--- @alias MacroName string
+--- @alias AtomName  string
+--- @alias Severity  string
+
+--- @class SourceFile
+--- @field path     Path
+--- @field text     string
+--- @field dir      string
+--- @field basename string
+--- @field scan     SourceScan|nil
+
+--- @class CorpusView
+--- @field register_alias_registry table<string,   AliasEntry>
+--- @field type_name_registry      table<string,   TypeNameEntry>
+--- @field atom_views              table<AtomName, AtomViewEntry>
+--- @field atom_ctxs               table<AtomName, AtomCtxEntry>
+--- @field atom_phases             table<string,   AtomPhaseGroup>
+--- @field binds_by_name           table<string,   BindsEntry>
+--- @field atoms_by_name           table<AtomName, AtomEntry>
+--- @field atom_infos              AtomInfoEntry[]
+--- @field components              table<string, Component>
+--- @field component_atom_infos    AtomInfoEntry[]|nil
+--- @field tape_chains             table<string, TapeChain>|nil
+--- @field source_order            SourceFile[]
+--- @field collisions              CorpusCollision[]
+
+--- @param src   DuffleExport
+--- @param label string
+--- @return nil
 local function merge(src, label)
-	for k, v in pairs(src) do
+	for k, v in pairs(src) do ---@type string, any
 		if M[k] ~= nil and M[k] ~= v then
 			error("duffle facade name collision on " .. tostring(k) .. " from " .. label, 0)
 		end
@@ -17,8 +53,10 @@ merge(scan, "duffle_scan")
 merge(isa,  "duffle_isa")
 merge(emit, "duffle_emit")
 
+--- @param ctx PassCtx
+--- @return CorpusView
 function M.corpus_view(ctx)
-	local  corpus = ctx and ctx.shared and ctx.shared.corpus
+	local  corpus = ctx and ctx.shared and ctx.shared.corpus ---@type Corpus
 	if not corpus then error("requires ctx.shared.corpus", 0) end
 	return {
 		register_alias_registry = corpus.register_alias_registry or {},
@@ -31,16 +69,21 @@ function M.corpus_view(ctx)
 		atom_infos              = corpus.atom_infos              or {},
 		components              = corpus.components              or {},
 		component_atom_infos    = corpus.component_atom_infos    or {},
-		component_body_index    = corpus.component_body_index    or {},
 		tape_chains             = corpus.tape_chains             or {},
 		source_order            = corpus.source_order            or {},
 		collisions              = corpus.collisions              or {},
 	}
 end
 
+--- @param rules    CheckRule[]
+--- @param phase    string
+--- @param item     AtomEntry|SourceFile
+--- @param pipe_ctx PassScratch
+--- @param findings Finding[]
+--- @return nil
 function M.run_check_rules(rules, phase, item, pipe_ctx, findings)
-	for _, rule in ipairs(rules) do
+	for _, rule in ipairs(rules) do ---@type integer, CheckRule
-		local fn = rule[phase]
+		local fn = rule[phase] ---@type (fun(item: AtomEntry|SourceFile, pipe_ctx: PassScratch, findings: Finding[]): nil)|nil
 		if    fn then fn(item, pipe_ctx, findings) end
 	end
 end

scripts/duffle_isa.lua

@@ -1,16 +1,169 @@
 --- duffle_isa.lua — encoder / GTE / hardware tables.
-local M = {}
+
+--- @class InstructionImm
+--- @field arg    integer
+--- @field signed boolean|nil
+--- @field width  integer
+
+--- @class InstructionValue
+--- @field dest      integer
+--- @field op        string
+--- @field sources   integer[]|nil
+--- @field immediate integer|nil
+--- @field source    integer|nil
+
+--- @class InstructionRow
+--- @field cycles        integer
+--- @field kind          string
+--- @field reads         integer[]|nil
+--- @field writes        integer[]|nil
+--- @field imm           InstructionImm[]|nil
+--- @field value         InstructionValue|nil
+--- @field delay_slot    boolean|nil
+--- @field suppress_arg1 table<string, string>|nil  -- bag: GPR ident -> reason
+
+--- @class TapeAtomMacroRow
+--- @field kind  string
+--- @field binds boolean
+
+--- @class GteCommandPort
+--- @field register string
+--- @field role     string
+
+--- @class GteCommandLatch
+--- @field register string
+--- @field required integer
+
+--- @class GteCommandRow
+--- @field aliases string[]
+--- @field cycles  integer
+--- @field inputs  string[]
+--- @field outputs GteCommandPort[]
+--- @field latch   GteCommandLatch[]
+
+--- @class GteCrAliasGroup
+--- @field [1] integer   -- C2 control-register slot
+--- @field [2] string[]  -- aliases that share that slot
+
+--- @class GtePackedSlotRelation
+--- @field slot   integer
+--- @field first  string
+--- @field second string
+
+--- @class HardwareRelationPort
+--- @field domain string
+--- @field arg    integer
+
+--- @class HardwareRelationVisibility
+--- @field kind     string
+--- @field required integer
+
+--- @class HardwareRelationEvidence
+--- @field confidence string
+--- @field source     string
+
+--- @class HardwareRelationRow
+--- @field id                string
+--- @field semantic          string
+--- @field consumer          string
+--- @field token             string
+--- @field direction         string
+--- @field reads             HardwareRelationPort
+--- @field writes            HardwareRelationPort
+--- @field visibility        HardwareRelationVisibility|nil
+--- @field evidence          HardwareRelationEvidence
+--- @field violation_kind    string
+--- @field destination_match string|nil
+--- @field fanout_to         string[]|nil
+--- @field required          integer|nil
+--- @field clear_on_consumer boolean|nil
+--- @field stage             boolean|nil
+--- @field cu2_transition    boolean|nil
+--- @field status_register   integer|nil
+
+--- @class Cu2TransitionPolicy
+--- @field status_register integer
+--- @field enable_bit      integer
+--- @field required        integer
+--- @field visibility_kind string
+--- @field evidence        HardwareRelationEvidence
+
+--- @class GprRole
+--- @field name     string
+--- @field pool     boolean
+--- @field optional boolean
+--- @field carrier  boolean
+
+--- @class DuffleIsa
+--- @field GPR_ROLE                    table<string, GprRole>
+--- @field TAPE_ATOM_MACROS            table<string, TapeAtomMacroRow>
+--- @field DELAY_MARKERS               table<string, boolean>
+--- @field INSTRUCTION                 table<string, InstructionRow>
+--- @field GTE_COMMAND                 table<string, GteCommandRow>
+--- @field ALIAS_TO_CANONICAL          table<string, string>
+--- @field instr                       fun(ident: string): InstructionRow|nil
+--- @field gte_canon                   fun(ident: string): string
+--- @field gte                         fun(ident: string): GteCommandRow|nil
+--- @field GTE_CR_ALIAS_GROUPS         GteCrAliasGroup[]
+--- @field GTE_PACKED_SLOT_RELATIONS   GtePackedSlotRelation[]
+--- @field OPERAND_READ_POSITIONS      table<string, integer[]>
+--- @field GP0_CMD_SIZE                table<integer, integer>
+--- @field GP0_CMD_BY_SHAPE            table<string, integer>
+--- @field UNKNOWN_INSTRUCTION_CYCLES  integer
+--- @field HARDWARE_RELATIONS          HardwareRelationRow[]
+--- @field CU2_TRANSITION_POLICY       Cu2TransitionPolicy
+
+local M = {} ---@type DuffleIsa
 
 -- Section 7: domain tables
 -- ════════════════════════════════════════════════════════════════════════════
 
+-- One GprRole row per name. Construction order is the auto_reg pool order,
+-- then R_AT, then the three carriers. Index by name into M.GPR_ROLE.
+--- @type table<string, GprRole>
+M.GPR_ROLE = {
+	{ name = "R_V0",          pool = true,  optional = true, carrier = false },
+	{ name = "R_V1",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T0",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T1",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T2",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T3",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T4",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T5",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T6",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T7",          pool = true,  optional = true, carrier = false },
+	{ name = "R_A0",          pool = true,  optional = true, carrier = false },
+	{ name = "R_A1",          pool = true,  optional = true, carrier = false },
+	{ name = "R_A2",          pool = true,  optional = true, carrier = false },
+	{ name = "R_A3",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S0",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S1",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S2",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S3",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S4",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S5",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S6",          pool = true,  optional = true, carrier = false },
+	{ name = "R_S7",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T8",          pool = true,  optional = true, carrier = false },
+	{ name = "R_T9",          pool = true,  optional = true, carrier = false },
+	{ name = "R_AT",          pool = false, optional = true, carrier = false },
+	{ name = "R_TapePtr",     pool = false, optional = true, carrier = true  },
+	{ name = "R_AtomJmp",     pool = false, optional = true, carrier = true  },
+	{ name = "R_ScratchBase", pool = false, optional = true, carrier = true  },
+}
+for _, row in ipairs(M.GPR_ROLE) do ---@type integer, GprRole
+	M.GPR_ROLE[row.name] = row
+end
+
 -- atom_info sub-calls: atom_bind, atom_reads, atom_writes, atom_view, atom_reg_types, atom_ctx, atom_phase.
+--- @type table<string, TapeAtomMacroRow>
 M.TAPE_ATOM_MACROS = {
 	["atom_info"] = { kind = "info", binds = false },
 }
 
 -- Empty C macros that prefix the next encoder. Zero words.
 -- BdSlot_ nop is one nop word. The marker is not the BD instruction.
+--- @type table<string, boolean>  -- bag: marker prefix -> true
 M.DELAY_MARKERS = {
 	["GteDelay_"] = true,
 	["LdSlot_"]   = true,
@@ -18,7 +171,8 @@ M.DELAY_MARKERS = {
 	["DmaSlot_"]  = true,
 }
 
--- One row per encoder. Old table names are load-time views (build_isa_views).
+-- One row per encoder. Read through duffle.instr.
+--- @type table<string, InstructionRow>
 M.INSTRUCTION = {
 	["BdSlot_"]            = { cycles = 0,  kind = "marker", },
 	["LdSlot_"]            = { cycles = 0,  kind = "marker", },
@@ -115,6 +269,7 @@ M.INSTRUCTION = {
 }
 
 -- One row per GTE command. Alias cycle numbers live here, not on INSTRUCTION.
+--- @type table<string, GteCommandRow>
 M.GTE_COMMAND = {
 	["gte_cmdw_avsz3"] = {
 		aliases = { "gte_avg_sort_z3", "gte_avsz3", "gte_cmdw_avg_sort_z3" },
@@ -296,60 +451,28 @@ M.GTE_COMMAND = {
 	},
 }
 
+--- @param ident string
+--- @return InstructionRow|nil
 function M.instr    (ident) return M.INSTRUCTION            [ident]          end
+--- @param ident string
+--- @return string
 function M.gte_canon(ident) return M.ALIAS_TO_CANONICAL     [ident] or ident end
+--- @param ident string
+--- @return GteCommandRow|nil
 function M.gte      (ident) return M.GTE_COMMAND[M.gte_canon(ident)]         end
 
-local function build_isa_views()
+--- @return nil
+local function build_alias_map()
+	--- @type table<string, string>  -- bag: alias or canon -> canon
 	M.ALIAS_TO_CANONICAL = {}
-	for canon, row in pairs(M.GTE_COMMAND) do
+	for canon, row in pairs(M.GTE_COMMAND) do ---@type string, GteCommandRow
 		M.ALIAS_TO_CANONICAL[canon] = canon
-		for _, alias in ipairs(row.aliases or {}) do
+		for _, alias in ipairs(row.aliases or {}) do ---@type integer, string
 			M.ALIAS_TO_CANONICAL[alias] = canon
 		end
 	end
-	M.INSTRUCTION_LATENCY     = {}
-	M.INSTRUCTION_GPR_EFFECTS = {}
-	M.IMMEDIATE_FIELD_WIDTHS  = {}
-	M.GPR_VALUE_RULES         = {}
-	M.CONTROL_TRANSFER_DELAY_SLOT_POLICIES = {}
-	for name, row in pairs(M.INSTRUCTION) do
-		M.INSTRUCTION_LATENCY[name] = row.cycles
-		if row.reads or row.writes then
-			M.INSTRUCTION_GPR_EFFECTS[name] = {
-				reads  = row.reads or {},
-				writes = row.writes or {},
-			}
-		end
-		if row.imm   then M.IMMEDIATE_FIELD_WIDTHS[name] = row.imm end
-		if row.value then M.GPR_VALUE_RULES       [name] = row.value end
-		if (row.kind == "branch" or row.kind == "jump" or row.kind == "call")
-			and row.delay_slot ~= false then
-			M.CONTROL_TRANSFER_DELAY_SLOT_POLICIES[name] = {
-				family        = row.kind,
-				suppress_arg1 = row.suppress_arg1,
-			}
-		end
-	end
-	M.GTE_COMMAND_ALIASES = {}
-	M.GTE_COMMAND_INPUTS  = {}
-	M.GTE_COMMAND_OUTPUTS = {}
-	M.GTE_COMMAND_LATCH_WINDOWS = {}
-	for canon, row in pairs(M.GTE_COMMAND) do
-		M.GTE_COMMAND_ALIASES    [canon] = canon
-		M.INSTRUCTION_LATENCY    [canon] = row.cycles
-		M.INSTRUCTION_GPR_EFFECTS[canon] = { reads = {}, writes = {} }
-		for _, alias in ipairs(row.aliases or {}) do
-			M.GTE_COMMAND_ALIASES    [alias] = canon
-			M.INSTRUCTION_LATENCY    [alias] = row.cycles
-			M.INSTRUCTION_GPR_EFFECTS[alias] = { reads = {}, writes = {} }
-		end
-		M.GTE_COMMAND_INPUTS       [canon] = row.inputs
-		M.GTE_COMMAND_OUTPUTS      [canon] = row.outputs
-		M.GTE_COMMAND_LATCH_WINDOWS[canon] = row.latch
-	end
 end
-build_isa_views()
+build_alias_map()
 
 
 --- GTE control-register alias groups.
@@ -359,6 +482,7 @@ build_isa_views()
 --- Cross-alias writes inside one atom body, or across the wave-context boundary, silently clobber each other.
 --- The `check_gte_cr_alias_writes` check warns about each pair per source. See `docs/gte_reference.md` §"Control-register alias table"
 --- for the HW rationale and the libgte outer-product convention.
+--- @type GteCrAliasGroup[]
 M.GTE_CR_ALIAS_GROUPS = {
 	{ 24, { "gte_cr_RBK", "gte_cr_OFX" } },   -- background R vs screen offset X
 	{ 25, { "gte_cr_GBK", "gte_cr_OFY" } },   -- background G vs screen offset Y
@@ -366,6 +490,7 @@ M.GTE_CR_ALIAS_GROUPS = {
 }
 
 -- Packed RT slots named by the gte.h packed-slot comment. First must be written before second.
+--- @type GtePackedSlotRelation[]
 M.GTE_PACKED_SLOT_RELATIONS = {
 	{ slot = 2, first = "gte_cr_RT13", second = "gte_cr_RT22" },
 }
@@ -380,6 +505,7 @@ M.GTE_PACKED_SLOT_RELATIONS = {
 --   * 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).
+--- @type table<string, integer[]>  -- bag: encoder ident -> GPR operand positions
 M.OPERAND_READ_POSITIONS = {
 	-- CPU ALU with one or two GPR operands. Reads every GPR operand.
 	["add_ui"]                 = {1, 2},
@@ -479,6 +605,7 @@ M.OPERAND_READ_POSITIONS = {
 --   set_poly_gt3(p)  -> set_len(p, 9)   -> 10 total GP0 0x34
 --   set_poly_g4(p)   -> set_len(p, 8)   ->  9 total GP0 0x38
 --   set_poly_gt4(p)  -> set_len(p, 12)  -> 13 total GP0 0x3C
+--- @type table<integer, integer>  -- bag: GP0 cmd byte -> word count
 M.GP0_CMD_SIZE = {
 	[0x20] =  5,  -- Poly_F3
 	[0x24] =  8,  -- Poly_FT3
@@ -492,6 +619,7 @@ M.GP0_CMD_SIZE = {
 
 -- Shape suffix (after `ac_format_` / `mac_format_` prefix) -> GP0 cmd byte.
 -- Lets the static-analysis check derive the cmd byte from a macro name like `mac_format_g4_color` -> `g4` -> 0x38 -> 9 expected words.
+--- @type table<string, integer>  -- bag: shape suffix -> GP0 cmd byte
 M.GP0_CMD_BY_SHAPE = {
 	["f3"]  = 0x20, ["ft3"] = 0x24,
 	["f4"]  = 0x28, ["ft4"] = 0x2C,
@@ -499,6 +627,7 @@ M.GP0_CMD_BY_SHAPE = {
 	["g4"]  = 0x38, ["gt4"] = 0x3C,
 }
 
+--- @type integer
 M.UNKNOWN_INSTRUCTION_CYCLES = 1
 
 -- Hardware-relation policy table.
@@ -531,6 +660,7 @@ M.UNKNOWN_INSTRUCTION_CYCLES = 1
 --   * passes/static_analysis.lua::analyze_hardware_relations          (forward walker).
 --   * passes/static_analysis.lua::transfer_hazards CHECK_RULES reader (renders hazards onto `findings`).
 -- This table is consumed by the hardware-relation analyzer and hazard renderer.
+--- @type HardwareRelationRow[]
 M.HARDWARE_RELATIONS = {
 	-- CPU → COP2 data register (MTC2). The ordinary default is 2 cached words between producer and consumer (cpuspecifications.md:407-419).
 	{
@@ -721,6 +851,7 @@ M.HARDWARE_RELATIONS = {
 -- Bounded Status/SR.CU2 transition policy.
 -- The value lattice and the transition consumer both read this immutable row; no second value pass is permitted.
 -- The source says the enable/disable transition takes "2 clock cycles or so", so the boundary is conservative rather than exact.
+--- @type Cu2TransitionPolicy
 M.CU2_TRANSITION_POLICY = {
 	status_register = 12,
 	enable_bit      = 0x40000000,

scripts/duffle_paths.lua

@@ -16,10 +16,13 @@
 --- Net effect: the caller gets the duffle module in one statement; no separate `dofile(...)` + `require("duffle")` dance.
 ---
 
-local M = {}
+--- @class DufflePaths
+--- @field setup fun(): nil
+
+local M = {} ---@type DufflePaths
 
 -- Cache key for the repo root. Stored in `package.loaded` (process-global) so all 8 entry scripts + passes scripts share one resolution.
-local CACHE_KEY = "__duffle_repo_root__"
+local CACHE_KEY = "__duffle_repo_root__" ---@type string
 
 --- Resolve the repo root from this script's own path. Zero shell spawn.
 --- `duffle_paths.lua` always lives at `<repo>/scripts/duffle_paths.lua`, so the repo root is the parent of the directory containing this script.
@@ -30,14 +33,14 @@ local CACHE_KEY = "__duffle_repo_root__"
 local function find_repo_root()
 	if package.loaded[CACHE_KEY] then return package.loaded[CACHE_KEY] end
 
-	local source = debug.getinfo(1, "S").source
+	local source = debug.getinfo(1, "S").source ---@type string
 	-- Strip the leading `@` (Lua's dofile marker) and the trailing `/duffle_paths.lua` filename.
 	-- What remains is the directory containing this script, i.e. `<repo>/scripts/`.
-	local scripts_dir = source and source:match("^@?(.*)[/\\]duffle_paths%.lua$")
+	local scripts_dir = source and source:match("^@?(.*)[/\\]duffle_paths%.lua$") ---@type string|nil
 	if not scripts_dir then return nil end
 
 	-- The repo root is the parent of `scripts/`. Strip the trailing `scripts/` (with or without trailing slash).
-	local root = scripts_dir:gsub("scripts[\\/]?$", "")
+	local root = scripts_dir:gsub("scripts[\\/]?$", "") ---@type string
 	root = root:gsub("\\", "/")
 	if root == "" then root = "./" end
 	if not root:match("/$") then root = root .. "/" end
@@ -50,8 +53,9 @@ end
 --- This script does NOT touch the OS environment: no `os.setenv`, no `os.putenv`, no `$PATH` mods. 
 --- It just sets `package.path` and `package.cpath` (the standard Lua way to register module search dirs). 
 --- lpeg is built by `update_deps.ps1` to `toolchain/lpeg/`, which we wire into `package.cpath` here (so `require("lpeg")` from `duffle.lua` resolves without any global state).
+--- @return nil
 function M.setup()
-	local  repo_root = find_repo_root()
+	local  repo_root = find_repo_root() ---@type string|nil
 	if not repo_root then
 		-- Unreachable in practice: find_repo_root() derives the repo root from this script's own source path via debug.getinfo(1, "S").source (no subprocess, no git CLI, <1ms).
 		-- A nil return means the source path did not match the expected <repo>/scripts/duffle_paths.lua layout — a packaging bug, not a "missing git repo" condition.
@@ -59,8 +63,8 @@ function M.setup()
 		os.exit(2)
 	end
 
-	local scripts_dir = repo_root .. "scripts/"
+	local scripts_dir = repo_root .. "scripts/"        ---@type string
-	local passes_dir  = repo_root .. "scripts/passes/"
+	local passes_dir  = repo_root .. "scripts/passes/" ---@type string
 	package.path = scripts_dir .. "?.lua;"
 		.. scripts_dir .. "?/init.lua;"
 		.. passes_dir  .. "?.lua;"
@@ -70,8 +74,8 @@ function M.setup()
 	-- lpeg: built by `update_deps.ps1` to `toolchain/lpeg/lpeg.dll`.
 	-- lfs: compiled from pcsx-redux's vendored luafilesystem source to `toolchain/lfs/lfs.dll`.
 	-- Wire both directories into cpath so `require("lpeg")` and `require("lfs")` resolve.
-	local lpeg_dir = repo_root .. "toolchain/lpeg/"
+	local lpeg_dir = repo_root .. "toolchain/lpeg/" ---@type string
-	local lfs_dir  = repo_root .. "toolchain/lfs/"
+	local lfs_dir  = repo_root .. "toolchain/lfs/"  ---@type string
 	package.cpath = lpeg_dir .. "?.dll;"
 		.. lfs_dir  .. "?.dll;"
 		.. package.cpath

scripts/elf32.lua

@@ -22,7 +22,94 @@
 -- 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 = {}
+--- @class Elf32Adapter
+--- @field read_u8_at  fun(off: integer): integer|nil
+--- @field read_u16_at fun(off: integer): integer|nil
+--- @field read_u32_at fun(off: integer): integer|nil
+--- @field read_size   fun(): integer
+
+--- @class Elf32Header
+--- @field e_entry     integer
+--- @field e_shoff     integer
+--- @field e_shentsize integer
+--- @field e_shnum     integer
+--- @field e_shstrndx  integer
+--- @field error       string|nil
+
+--- @class Elf32Section
+--- @field sh_name   integer
+--- @field sh_type   integer
+--- @field sh_flags  integer
+--- @field sh_addr   integer
+--- @field sh_offset integer
+--- @field sh_size   integer
+--- @field sh_link   integer
+--- @field name      string
+
+--- @class Elf32Sym
+--- @field value integer
+--- @field size  integer
+--- @field info  integer
+--- @field shndx integer
+
+--- @class Elf32HeaderLayout
+--- @field magic_offset       integer
+--- @field magic              string
+--- @field class_offset       integer
+--- @field endian_offset      integer
+--- @field header_bytes       integer
+--- @field e_entry_offset     integer
+--- @field e_shoff_offset     integer
+--- @field e_shentsize_offset integer
+--- @field e_shnum_offset     integer
+--- @field e_shstrndx_offset  integer
+
+--- @class Elf32SectionLayout
+--- @field sh_name_offset   integer
+--- @field sh_type_offset   integer
+--- @field sh_flags_offset  integer
+--- @field sh_addr_offset   integer
+--- @field sh_offset_offset integer
+--- @field sh_size_offset   integer
+--- @field sh_link_offset   integer
+--- @field sh_entsize_bytes integer
+
+--- @class Elf32SymLayout
+--- @field st_name         integer
+--- @field st_value        integer
+--- @field st_size         integer
+--- @field st_info         integer
+--- @field sym_entry_bytes integer
+
+--- @class Elf32Mod
+--- @field ELFCLASS32             integer
+--- @field ELFDATA2LSB            integer
+--- @field EM_MIPS                integer
+--- @field SHT_SYMTAB             integer
+--- @field SHT_STRTAB             integer
+--- @field SHT_NOBITS             integer
+--- @field SHF_WRITE              integer
+--- @field SHF_ALLOC              integer
+--- @field SHF_EXECINSTR          integer
+--- @field ELF32_HEADER           Elf32HeaderLayout
+--- @field ELF32_SECTION          Elf32SectionLayout
+--- @field ELF32_SYM              Elf32SymLayout
+--- @field dw_dwarf32_terminator  integer
+--- @field read_u32               fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field read_u16               fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field read_u8                fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field size                   fun(adapter: Elf32Adapter): integer
+--- @field read_u32_le            fun(buf: string, off: integer): integer
+--- @field read_u16_le            fun(buf: string, off: integer): integer
+--- @field validate_adapter       fun(adapter: any): boolean, string|nil
+--- @field get_str                fun(strtab: string, off: integer): string|nil
+--- @field parse_elf32_headers    fun(adapter: Elf32Adapter): Elf32Header|nil, string|nil
+--- @field walk_sections          fun(adapter: Elf32Adapter, hdr: Elf32Header): Elf32Section[]|nil, string|nil
+--- @field read_section_bytes     fun(adapter: Elf32Adapter, section: Elf32Section): string|nil
+--- @field read_named_section     fun(adapter: Elf32Adapter, sections: Elf32Section[], name: string): string|nil, string|nil
+--- @field collect_symbols        fun(adapter: Elf32Adapter, sections: Elf32Section[]): table<string, Elf32Sym>|nil, string|nil
+
+local M = {} ---@type Elf32Mod
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Little-endian readers (bit-weighted accumulator, math.floor only)
@@ -39,7 +126,7 @@ local M = {}
 --- **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 adapter Elf32Adapter
 --- @param off     integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u32(adapter, off)
@@ -50,7 +137,7 @@ function M.read_u32(adapter, off)
 end
 
 --- Read a 2-byte little-endian unsigned integer from `adapter` at zero-based wire offset `off`.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param off integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u16(adapter, off)
@@ -59,7 +146,7 @@ function M.read_u16(adapter, off)
 end
 
 --- Read a 1-byte unsigned integer from `adapter` at zero-based wire offset `off`.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param off integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u8(adapter, off)
@@ -67,7 +154,7 @@ function M.read_u8(adapter, off)
 end
 
 --- Total adapter byte length.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @return integer
 function M.size(adapter)
 	return adapter.read_size()
@@ -76,8 +163,11 @@ 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.
+--- @param buf string
+--- @param off integer
+--- @return integer
 function M.read_u32_le(buf, off)
-	local byte_off = off + 1
+	local byte_off = off + 1 ---@type integer
 	return buf:byte(byte_off)
 		+ buf:byte(byte_off + 0x01) * 0x00000100
 		+ buf:byte(byte_off + 0x02) * 0x00010000
@@ -89,7 +179,7 @@ end
 --- @param off integer  -- zero-based wire offset
 --- @return integer
 function M.read_u16_le(buf, off)
-	local byte_off = off + 1
+	local byte_off = off + 1 ---@type integer
 	return buf:byte(byte_off) + buf:byte(byte_off + 0x01) * 0x00000100
 end
 
@@ -116,6 +206,7 @@ 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).
+--- @type Elf32HeaderLayout
 M.ELF32_HEADER = {
 	magic_offset         = 0x00,  -- 4 bytes; expected "\127ELF"
 	magic                = "\127ELF",
@@ -134,6 +225,7 @@ M.ELF32_HEADER = {
 -- ---------------------------------------------------------------------------
 -- Each entry is 40 bytes (sh_entsize_bytes = 0x28 = 40);
 -- zero-based, field offsets relative to the start of the entry.
+--- @type Elf32SectionLayout
 M.ELF32_SECTION = {
 	sh_name_offset    = 0x00,  -- 4-byte LE; offset into .shstrtab
 	sh_type_offset    = 0x04,  -- 4-byte LE; section type (SHT_*)
@@ -150,6 +242,7 @@ M.ELF32_SECTION = {
 -- ---------------------------------------------------------------------------
 -- Each entry is 16 bytes (sym_entry_bytes = 0x10 = 16);
 -- zero-based, field offsets relative to the start of the entry.
+--- @type Elf32SymLayout
 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)
@@ -186,11 +279,11 @@ end
 --- 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
+--- @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)
+	local  end_pos = strtab:find("\0", off + 1, true) ---@type integer|nil
 	if not end_pos then return nil end
 	return strtab:sub(off + 1, end_pos - 1)
 end
@@ -205,39 +298,39 @@ end
 --- 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
+--- @param adapter Elf32Adapter
---- @return table|nil, string|nil
+--- @return Elf32Header|nil, string|nil
 function M.parse_elf32_headers(adapter)
-	local  ok, err = M.validate_adapter(adapter)
+	local  ok, err = M.validate_adapter(adapter) ---@type boolean, string|nil
 	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 b1 = M.read_u8(adapter, 0) ---@type integer|nil
-	local b2 = M.read_u8(adapter, 1)
+	local b2 = M.read_u8(adapter, 1) ---@type integer|nil
-	local b3 = M.read_u8(adapter, 2)
+	local b3 = M.read_u8(adapter, 2) ---@type integer|nil
-	local b4 = M.read_u8(adapter, 3)
+	local b4 = M.read_u8(adapter, 3) ---@type integer|nil
 	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)
+	local class = M.read_u8(adapter, M.ELF32_HEADER.class_offset) ---@type integer|nil
 	if    class ~= M.ELFCLASS32 then
 		return nil, "unsupported_elf_class"
 	end
 
-	local data = M.read_u8(adapter, M.ELF32_HEADER.endian_offset)
+	local data = M.read_u8(adapter, M.ELF32_HEADER.endian_offset) ---@type integer|nil
 	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_entry     = M.read_u32(adapter, M.ELF32_HEADER.e_entry_offset)     ---@type integer|nil
-	local e_shoff     = M.read_u32(adapter, M.ELF32_HEADER.e_shoff_offset)
+	local e_shoff     = M.read_u32(adapter, M.ELF32_HEADER.e_shoff_offset)     ---@type integer|nil
-	local e_shentsize = M.read_u16(adapter, M.ELF32_HEADER.e_shentsize_offset)
+	local e_shentsize = M.read_u16(adapter, M.ELF32_HEADER.e_shentsize_offset) ---@type integer|nil
-	local e_shnum     = M.read_u16(adapter, M.ELF32_HEADER.e_shnum_offset)
+	local e_shnum     = M.read_u16(adapter, M.ELF32_HEADER.e_shnum_offset)     ---@type integer|nil
-	local e_shstrndx  = M.read_u16(adapter, M.ELF32_HEADER.e_shstrndx_offset)
+	local e_shstrndx  = M.read_u16(adapter, M.ELF32_HEADER.e_shstrndx_offset)  ---@type integer|nil
 	if not (e_entry and e_shoff and e_shentsize and e_shnum and e_shstrndx) then
 		return nil, "truncated_header"
 	end
@@ -254,11 +347,11 @@ 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 adapter Elf32Adapter
 --- @param sh_off  integer
---- @return table|nil, string|nil  -- entry, error
+--- @return Elf32Section|nil, string|nil
 local function read_section_entry(adapter, sh_off)
-	local entry = {
+	local entry = { ---@type Elf32Section
 		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),
@@ -279,22 +372,22 @@ end
 --- (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 adapter Elf32Adapter
---- @param hdr     table  -- the table returned by parse_elf32_headers
+--- @param hdr     Elf32Header
---- @return table|nil, string|nil
+--- @return Elf32Section[]|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)
+	local file_size = M.size(adapter) ---@type integer
 	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 = {}
+	local sections = {} ---@type Elf32Section[]
-	for i = 0, hdr.e_shnum - 1 do
+	for i = 0, hdr.e_shnum - 1 do ---@type integer
-		local sh_off = hdr.e_shoff + i * hdr.e_shentsize
+		local sh_off = hdr.e_shoff + i * hdr.e_shentsize ---@type integer
-		local entry, err = read_section_entry(adapter, sh_off)
+		local entry, err = read_section_entry(adapter, sh_off) ---@type Elf32Section|nil, string|nil
 		if not entry then return nil, err end
 		sections[i + 1] = entry
 	end
@@ -303,17 +396,17 @@ function M.walk_sections(adapter, hdr)
 		return nil, "missing_shstrtab"
 	end
 
-	local  shstrtab = sections[hdr.e_shstrndx + 1]
+	local  shstrtab = sections[hdr.e_shstrndx + 1] ---@type Elf32Section|nil
 	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)
+	local  shstrtab_bytes = M.read_section_bytes(adapter, shstrtab) ---@type string|nil
 	if not shstrtab_bytes then return nil, "truncated_section_headers" end
 
-	for _, s in ipairs(sections) do
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		s.name = M.get_str(shstrtab_bytes, s.sh_name) or ""
 	end
 
@@ -322,15 +415,15 @@ 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 adapter Elf32Adapter
---- @param section table  -- one entry from walk_sections
+--- @param section Elf32Section
 --- @return string|nil
 function M.read_section_bytes(adapter, section)
-	local size = section.sh_size
+	local size = section.sh_size ---@type integer
 	if    size == 0 then return "" end
-	local out = {}
+	local out = {} ---@type string[]
-	for i = 0, size - 1 do
+	for i = 0, size - 1 do ---@type integer
-		local b = M.read_u8(adapter, section.sh_offset + i)
+		local b = M.read_u8(adapter, section.sh_offset + i) ---@type integer|nil
 		if    b == nil then return nil end
 		out[#out + 1] = string.char(b)
 	end
@@ -339,15 +432,15 @@ 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 adapter  Elf32Adapter
---- @param sections table  -- 1-based array from walk_sections
+--- @param sections Elf32Section[]
 --- @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
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		if   s.name == name then
-			local bytes = M.read_section_bytes(adapter, s)
+			local bytes = M.read_section_bytes(adapter, s) ---@type string|nil
 			if not bytes then return nil, "truncated_section_data" end
 			return bytes, nil
 		end
@@ -359,47 +452,47 @@ end
 --- 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 adapter  Elf32Adapter
---- @param sections table
+--- @param sections Elf32Section[]
---- @return table|nil, string|nil
+--- @return table<string, Elf32Sym>|nil, string|nil
 function M.collect_symbols(adapter, sections)
 	if not sections then return nil, "missing_sections" end
-	local symbols = {}
+	local symbols   = {}              ---@type table<string, Elf32Sym>  -- bag: symbol name -> Elf32Sym
-	local file_size = M.size(adapter)
+	local file_size = M.size(adapter) ---@type integer
-	for _, s in ipairs(sections) do
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		if s.sh_type == M.SHT_SYMTAB then
-			local  strtab = sections[s.sh_link + 1]
+			local  strtab = sections[s.sh_link + 1] ---@type Elf32Section|nil
 			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)
+			local  strtab_bytes = M.read_section_bytes(adapter, strtab) ---@type string|nil
 			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)
+			local  symtab_bytes = M.read_section_bytes(adapter, s) ---@type string|nil
 			if not symtab_bytes then return nil, "truncated_section_headers" end
-			local n = #symtab_bytes / M.ELF32_SYM.sym_entry_bytes
+			local n = #symtab_bytes / M.ELF32_SYM.sym_entry_bytes ---@type number
-			for j = 0, n - 1 do
+			for j = 0, n - 1 do ---@type integer
-				local e = s.sh_offset + j * M.ELF32_SYM.sym_entry_bytes
+				local e        = s.sh_offset + j * M.ELF32_SYM.sym_entry_bytes ---@type integer
-				local st_name  = M.read_u32(adapter, e + M.ELF32_SYM.st_name)
+				local st_name  = M.read_u32(adapter, e + M.ELF32_SYM.st_name)  ---@type integer|nil
 				if    st_name then
-					local st_value = M.read_u32(adapter, e + M.ELF32_SYM.st_value)
+					local st_value = M.read_u32(adapter, e + M.ELF32_SYM.st_value) ---@type integer|nil
-					local st_size  = M.read_u32(adapter, e + M.ELF32_SYM.st_size)
+					local st_size  = M.read_u32(adapter, e + M.ELF32_SYM.st_size)  ---@type integer|nil
-					local st_info  = M.read_u8(adapter, e + M.ELF32_SYM.st_info)
+					local st_info  = M.read_u8(adapter, e + M.ELF32_SYM.st_info)   ---@type integer|nil
 					-- 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 b1 = M.read_u8(adapter, e + 14) ---@type integer|nil
-					local b2 = M.read_u8(adapter, e + 15)
+					local b2 = M.read_u8(adapter, e + 15) ---@type integer|nil
 					if not (b1 and b2) then
 						return nil, "truncated_section_headers"
 					end
-					local st_shndx = b1 + b2 * 0x100
+					local st_shndx = b1 + b2 * 0x100 ---@type integer
-					local name = M.get_str(strtab_bytes, st_name) or ""
+					local name = M.get_str(strtab_bytes, st_name) or "" ---@type string
 					if    name ~= "" then
 						symbols[name] = {
 							value = st_value,

scripts/passes/annotation.lua

@@ -10,8 +10,8 @@
 
 -- Bootstrap follows the entry scripts; `scripts/duffle_paths.lua` sets package.path and package.cpath. See `ps1_meta.lua` for the rationale.
 -- `debug.getinfo(1, "S").source` locates this file for standalone and orchestrated runs, then `duffle_paths.lua` returns the loaded `duffle` module.
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- The annotation pass reads the source-derived registries from scan_source:
 --   * pipe_ctx.register_alias_registry — for atom_dbg_reg_default(R_X, ...) and atom_reg_types(R_X, ...) member-identity checks
@@ -21,76 +21,40 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class SourceFile
+-- SourceFile, PassCtx, PassResult, PassShared, Corpus, Finding: see ps1_meta.lua
---- @field path     string  -- Absolute path to the source file
+-- SourceScan, AtomEntry, AtomInfoEntry, BindsEntry, RegTypeDefault, AtomViewEntry: see scan_source.lua
---- @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
+--- @class RegTypeOccurrence
---- @field sources            SourceFile[]
+--- @field reg         string
---- @field metadata_path      string
+--- @field type_name   string
---- @field shared             table
+--- @field source_line integer
---- @field shared.word_counts table<string, integer>
---- @field out_root           string
---- @field project_root       string
---- @field upstream           table<string, table>
---- @field flags              table
---- @field verbose            boolean
-
---- @class PassResult
---- @field outputs  table[]
---- @field errors   table[]
---- @field warnings table[]
-
---- @class AtomAnnotation
---- @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)
-
---- @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 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 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
 
 --- @class Findings
 --- @field errors   Finding[]
 --- @field warnings Finding[]
 --- @field info     Finding[]
 
---- @class PipeCtx
+-- PassScratch: see ps1_meta.lua
---- @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) 
 
 --- @class AnnotatedResult
 --- @field atoms    AtomEntry[]
---- @field annots   AtomAnnotation[]
+--- @field annots   AtomInfoEntry[]
 --- @field macros   MacroEntry[]
 --- @field binds    BindsEntry[]
 --- @field errors   Finding[]
 --- @field warnings Finding[]
 --- @field info     Finding[]
+--- @field source   string|nil
+
+--- @class CheckRule
+--- @field per_annot (fun(item: AtomInfoEntry, pipe_ctx: PassScratch, findings: Findings): nil)|nil
+
+--- @class SourceScan
+--- @field type_occurrences RegTypeOccurrence[]|nil
+
+--- @class AnnotationPass
+--- @field validate fun(ctx: PassCtx, src: SourceFile, corpus_pipe_ctx: PassScratch|nil): AnnotatedResult
+--- @field run      fun(ctx: PassCtx): PassResult
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Per-check functions (the CHECK_RULES table's payload)
@@ -99,24 +63,27 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --- `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.
---- @param a        AtomAnnotation
+--- @param info     AtomInfoEntry
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
-local function check_atom_decl_exists(a, pipe_ctx, findings)
+--- @return nil
-	if not pipe_ctx.atom_index[a.name] then
+local function check_atom_decl_exists(info, pipe_ctx, findings)
+	if not pipe_ctx.atom_index[info.atom_name] then
 		findings.errors[#findings.errors + 1] = {
-			line = a.line,
+			line = info.info_line,
-			msg  = string.format("annotation for '%s' has no matching MipsAtom_(%s) { ... }", a.name, a.name),
+			msg  = string.format("annotation for '%s' has no matching MipsAtom_(%s) { ... }", info.atom_name, info.atom_name),
 		}
 	end
 end
 
 --- Check:     Every atom may have AT MOST ONE annotation.
 --- Post-loop: Needs full-corpus `annot_counts` from pipe_ctx.
---- @param pipe_ctx PipeCtx
+--- @param _item    AtomInfoEntry|nil
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_unique_annotation(_item, pipe_ctx, findings)
-	for name, n in pairs(pipe_ctx.annot_counts) do
+	for name, n in pairs(pipe_ctx.annot_counts) do ---@type string, integer
 		if n > 1 then
 			findings.errors[#findings.errors + 1] = {
 				line = pipe_ctx.atom_index[name] and pipe_ctx.atom_index[name].line or 0,
@@ -128,28 +95,30 @@ end
 
 --- Check: BIND atoms must reference a real Binds_* struct.
 --- I keep this as a warning so the annotation pass can report the common test-fixture case; `check_abi_handoff` in static analysis supplies the build-stopping error.
---- @param a        AtomAnnotation
+--- @param info     AtomInfoEntry
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
-local function check_binds_struct_exists(a, pipe_ctx, findings)
+--- @return nil
-	if not a.binds                   then return end
+local function check_binds_struct_exists(info, pipe_ctx, findings)
-	if pipe_ctx.binds_index[a.binds] then return end
+	if not info.binds                   then return end
+	if pipe_ctx.binds_index[info.binds] then return end
 	findings.warnings[#findings.warnings + 1] = {
-		line = a.line,
+		line = info.info_line,
 		msg  = string.format("'%s' binds '%s' but no Struct_(%s) { ... } " 
 			.. "declaration found (also flagged as an error by check_abi_handoff in the static-analysis pass)"
-			, a.name, a.binds, a.binds),
+			, info.atom_name, info.binds, info.binds),
 	}
 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 m        MacroEntry
---- @param wc table<string, integer> -- Shared word-count table (from ctx.shared.word_counts)
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_macro_word_drift(m, pipe_ctx, findings)
-	local wc = (pipe_ctx and pipe_ctx.word_counts) or {}
+	local wc = (pipe_ctx and pipe_ctx.word_counts) or {} ---@type WordCounts
-	local  declared = wc[m.name]
+	local  declared = wc[m.name]                         ---@type integer|nil
 	if not declared then
 		findings.errors[#findings.errors + 1] = {
 			line = m.line,
@@ -173,12 +142,13 @@ end
 --- Check: atom_dbg_reg_default(R_X, <type>) targets an alias in `pipe_ctx.register_alias_registry` and a type in `pipe_ctx.type_name_registry`.
 --- Pointer depth remains bounded to 0 or 1, and duplicate defaults remain errors.
 --- @param _src     SourceFile -- unused (kept for the per_source shape)
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_semantic_reg_defaults(_src, pipe_ctx, findings)
 	-- Detect duplicate defaults using the ordered occurrence list (the out.types hash only retains the last declaration).
-	local seen_first_line = {}
+	local seen_first_line = {}                               ---@type table<string, integer>  -- bag: register ident -> first source line
-	for _, occ in ipairs(pipe_ctx.type_occurrences or {}) do
+	for _, occ in ipairs(pipe_ctx.type_occurrences or {}) do ---@type integer, RegTypeOccurrence
 		if seen_first_line[occ.reg] == nil then
 			seen_first_line[occ.reg] = occ.source_line
 		else
@@ -190,9 +160,9 @@ local function check_semantic_reg_defaults(_src, pipe_ctx, findings)
 			}
 		end
 	end
-	local reg_registry  = pipe_ctx.register_alias_registry or {}
+	local reg_registry  = pipe_ctx.register_alias_registry or {} ---@type table<string, AliasEntry>
-	local type_registry = pipe_ctx.type_name_registry      or {}
+	local type_registry = pipe_ctx.type_name_registry      or {} ---@type table<string, TypeNameEntry>
-	for reg, def in pairs(pipe_ctx.types or {}) do
+	for reg, def in pairs(pipe_ctx.types or {}) do               ---@type string, RegTypeDefault
 		if not reg_registry[reg] then
 			findings.errors[#findings.errors + 1] = {
 				line = def.source_line,
@@ -223,14 +193,15 @@ end
 --- Check: atom_reg_types(R_X, <type>) entries target an alias in `pipe_ctx.register_alias_registry` and a type in `pipe_ctx.type_name_registry`.
 --- A bare `atom_reg` marker opts the `R_<n>` alias into GPR identity; references to R_T0..R_T3 require the same explicit marker.
 --- @param _src     SourceFile
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_atom_reg_types(_src, pipe_ctx, findings)
-	local reg_registry  = pipe_ctx.register_alias_registry or {}
+	local reg_registry  = pipe_ctx.register_alias_registry or {} ---@type table<string, AliasEntry>
-	local type_registry = pipe_ctx.type_name_registry      or {}
+	local type_registry = pipe_ctx.type_name_registry      or {} ---@type table<string, TypeNameEntry>
-	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do
+	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do       ---@type integer, AtomInfoEntry
 		if ai.reg_type_overrides then
-			for reg, ov in pairs(ai.reg_type_overrides) do
+			for reg, ov in pairs(ai.reg_type_overrides) do ---@type string, RegTypeOverride
 				if not reg_registry[reg] then
 					findings.errors[#findings.errors + 1] = {
 						line = ai.info_line,
@@ -254,14 +225,15 @@ end
 
 --- Check: atom_view(Binds_X) entries reference a Binds_* struct with at least one field.
 --- @param _src     SourceFile
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_atom_view_layout(_src, pipe_ctx, findings)
-	for atom_name, view in pairs(pipe_ctx.atom_views or {}) do
+	for atom_name, view in pairs(pipe_ctx.atom_views or {}) do ---@type string, AtomViewEntry
 		if not view.binds_name then
 			-- The atom had atom_reg_types but no atom_view; no layout check needed.
 		else
-			local bs = pipe_ctx.binds_index[view.binds_name]
+			local bs = pipe_ctx.binds_index[view.binds_name] ---@type BindsEntry|nil
 			if not bs then
 				findings.errors[#findings.errors + 1] = {
 					line = view.info_line,
@@ -282,16 +254,17 @@ local function check_atom_view_layout(_src, pipe_ctx, findings)
 end
 
 --- Check: Binds_* structs require unique field names because atom_view uses those names for typed-field lookup in gdb.
---- @param _src SourceFile
+--- @param _src     SourceFile
---- @param pipe_ctx PipeCtx
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_binds_no_duplicate_fields(_src, pipe_ctx, findings)
-	for _, bs in ipairs(pipe_ctx.binds_list or {}) do
+	for _, bs in ipairs(pipe_ctx.binds_list or {}) do ---@type integer, BindsEntry
-		local seen = {}
+		local seen = {}                        ---@type table<string, integer>  -- bag: field name -> occurrence count
-		for _, f in ipairs(bs.fields or {}) do
+		for _, f in ipairs(bs.fields or {}) do ---@type integer, TypeField
 			seen[f.name] = (seen[f.name] or 0) + 1
 		end
-		for name, count in pairs(seen) do
+		for name, count in pairs(seen) do ---@type string, integer
 			if count > 1 then
 				findings.errors[#findings.errors + 1] = {
 					line = bs.line,
@@ -314,12 +287,13 @@ end
 ---   5. pending + no target_kind    -> dangling (no following declaration)
 ---   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 marker    DebugSkipMarker
---- @param _pipe_ctx PipeCtx     -- Unused; kept for consistency with per_annot // TODO(Ed): Remove?
+--- @param _pipe_ctx PassScratch     -- Unused; kept for consistency with per_annot
---- @param findings Findings
+--- @param findings  Findings
+--- @return nil
 local function check_skip_marker(marker, _pipe_ctx, findings)
-	local kind = marker.marker_kind
+	local kind = marker.marker_kind ---@type string
-	local line = marker.marker_line
+	local line = marker.marker_line ---@type integer
 	-- 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
@@ -372,15 +346,16 @@ end
 --- Warn when a source references an unregistered alias.
 --- 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
+--- @param pipe_ctx PassScratch
 --- @param findings Findings
+--- @return nil
 local function check_wave_context_migration(_src, pipe_ctx, findings)
 	if not (pipe_ctx.types and next(pipe_ctx.types)) then return end
 	if not (pipe_ctx.atom_infos_list) then return end
-	local reg_registry = pipe_ctx.register_alias_registry or {}
+	local reg_registry = pipe_ctx.register_alias_registry or {} ---@type table<string, AliasEntry>
-	for _, ai in ipairs(pipe_ctx.atom_infos_list) do
+	for _, ai in ipairs(pipe_ctx.atom_infos_list) do            ---@type integer, AtomInfoEntry
 		if ai.reg_type_overrides then
-			for reg, _ in pairs(ai.reg_type_overrides) do
+			for reg, _ in pairs(ai.reg_type_overrides) do ---@type string, RegTypeOverride
 				if not reg_registry[reg] then
 					findings.warnings[#findings.warnings + 1] = {
 						line = 0,
@@ -400,14 +375,14 @@ end
 -- ════════════════════════════════════════════════════════════════════════════
 --
 -- Each rule entry picks one of four "shapes" of dispatch:
---   per_annot(annot, pipe_ctx, findings)        -- runs once per AtomAnnotation
+--   per_annot(info, pipe_ctx, findings)         -- runs once per scan.atom_infos row
 --   post(pipe_ctx, findings)                    -- runs once after all per_annot calls complete (full-corpus aggregation)
 --   per_macro(macro, wc, findings)              -- runs once per TAPE_WORDS / _Pragma macro declaration
 --   per_skip_marker(marker, pipe_ctx, findings) -- runs once per src.scan.debug_skip_markers entry
 --
 -- Adding a new check = 1 row here + 1 function above. The `validate()` dispatch loop never needs editing.
 
-local CHECK_RULES = {
+local CHECK_RULES = { ---@type CheckRule[]
 	{ name = "atom_decl_exists",          per_annot       = check_atom_decl_exists          },
 	{ name = "binds_struct_exists",       per_annot       = check_binds_struct_exists       },
 	{ name = "unique_annotation",         post            = check_unique_annotation         },
@@ -428,11 +403,11 @@ local CHECK_RULES = {
 --- 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.
 --- @param ctx PassCtx
---- @return PipeCtx
+--- @return PassScratch
 local function build_corpus_pipe_ctx(ctx)
-	local view = duffle.corpus_view(ctx)
+	local view         = duffle.corpus_view(ctx) ---@type PassScratch
-	local annot_counts = {}
+	local annot_counts = {}                      ---@type table<string, integer>  -- bag: atom name -> annotation count
-	for _, info in ipairs(view.atom_infos) do
+	for _, info in ipairs(view.atom_infos) do    ---@type integer, AtomInfoEntry
 		if info and info.atom_name then
 			annot_counts[info.atom_name] = (annot_counts[info.atom_name] or 0) + 1
 		end
@@ -446,40 +421,17 @@ 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 PassScratch|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)
-	local scan = src.scan
+	local scan = src.scan ---@type SourceScan
-
-	-- Project the pre-scanned atoms to the AtomEntry shape this pass needs.
-	local atoms = {}
-	for _, a in ipairs(scan.atoms) do
-		if a.kind == "atom" or a.kind == "atom_proc" then
-			atoms[#atoms + 1] = { line = a.line, name = a.raw_name or a.name }
-		end
-	end
-
-	-- Project the pre-scanned atom_infos to AtomAnnotation shape.
-	local annots = {}
-	for _, info in ipairs(scan.atom_infos) do
-		annots[#annots + 1] = {
-			line   = info.info_line,
-			macro  = "atom_info",
-			name   = info.atom_name,
-			kind   = "info",
-			binds  = info.binds,
-			reads  = info.reads or {},
-			writes = info.writes or {},
-			errors = info.errors,
-		}
-	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 seen_defaults   = {}; for reg, _ in pairs (scan.types      or {}) do seen_defaults[reg] = (seen_defaults[reg] or 0) + 1 end ---@type table<string, integer>  -- bag: register ident -> occurrence count
-	local atom_infos_list = {}; for _, ai  in ipairs(scan.atom_infos or {}) do atom_infos_list[#atom_infos_list + 1] = ai         end
+	local atom_infos_list = {}; for _, ai  in ipairs(scan.atom_infos or {}) do atom_infos_list[#atom_infos_list + 1] = ai         end ---@type AtomInfoEntry[]
 
-	local pipe_ctx = {
+	local pipe_ctx = { ---@type PassScratch
 		atom_index               = {},
 		binds_index              = {},
 		annot_counts             = corpus_pipe_ctx.annot_counts,
@@ -493,28 +445,34 @@ local function validate(ctx, src, corpus_pipe_ctx)
 		register_alias_registry  = corpus_pipe_ctx.register_alias_registry,
 		type_name_registry       = corpus_pipe_ctx.type_name_registry,
 	}
-	for _, a in ipairs(atoms)      do pipe_ctx.atom_index [a.name] = a end
+	local atoms = {}                  ---@type AtomEntry[]
-	for _, b in ipairs(scan.binds) do pipe_ctx.binds_index[b.name] = b end
+	for _, a in ipairs(scan.atoms) do ---@type integer, AtomEntry
+		if a.kind == "atom" or a.kind == "atom_proc" then
+			atoms[#atoms + 1] = a
+			pipe_ctx.atom_index[a.raw_name or a.name] = a
+		end
+	end
+	for _, b in ipairs(scan.binds) do pipe_ctx.binds_index[b.name] = b end ---@type integer, BindsEntry
 
 	-- Findings live in a single struct with three lists (errors / warnings / info).
 	-- Each check writes to the list appropriate for its severity.
-	local findings = { errors = {}, warnings = {}, info = {} }
+	local findings = { errors = {}, warnings = {}, info = {} } ---@type Findings
 
 	-- Lift parse-time errors already recorded in scan_source's atom_info payload into this pass's findings list.
-	for _, a in ipairs(annots) do
+	for _, info in ipairs(scan.atom_infos) do ---@type integer, AtomInfoEntry
-		if a.errors then
+		if info.errors then
-			for _, msg in ipairs(a.errors) do
+			for _, msg in ipairs(info.errors) do ---@type integer, string
 				findings.errors[#findings.errors + 1] = {
-					line = a.line,
+					line = info.info_line,
-					msg  = string.format("'%s': %s", a.name, msg),
+					msg  = string.format("'%s': %s", info.atom_name, msg),
 				}
 			end
 		end
 	end
 
 	-- THE per-annotation pipeline. ONE loop. CHECK_RULES dispatches per_annot rules.
-	for _, a in ipairs(annots) do
+	for _, info in ipairs(scan.atom_infos) do ---@type integer, AtomInfoEntry
-		duffle.run_check_rules(CHECK_RULES, "per_annot", a, pipe_ctx, findings)
+		duffle.run_check_rules(CHECK_RULES, "per_annot", info, pipe_ctx, findings)
 	end
 
 	-- Post-loop rules (one-shot checks that need full-corpus aggregation in pipe_ctx).
@@ -522,14 +480,14 @@ local function validate(ctx, src, corpus_pipe_ctx)
 
 	-- scan_source records each marker in scan.debug_skip_markers; this loop validates each record independently and emits at most one error per marker.
 	-- Valid markers stamp `debug_skip = true` on the following atom or component declaration, which downstream consumers read directly.
-	local skip_markers = scan.debug_skip_markers or {}
+	local skip_markers = scan.debug_skip_markers or {} ---@type DebugSkipMarker[]
-	for _, marker in ipairs(skip_markers) do
+	for _, marker in ipairs(skip_markers) do           ---@type integer, DebugSkipMarker
 		duffle.run_check_rules(CHECK_RULES, "per_skip_marker", marker, pipe_ctx, findings)
 	end
 
 	-- Per-macro rules (TAPE_WORDS vs WORD_COUNT drift).
 	pipe_ctx.word_counts = corpus_pipe_ctx.word_counts
-	for _, m in ipairs(scan.macros) do
+	for _, m in ipairs(scan.macros) do ---@type integer, MacroEntry
 		duffle.run_check_rules(CHECK_RULES, "per_macro", m, pipe_ctx, findings)
 	end
 
@@ -541,12 +499,12 @@ local function validate(ctx, src, corpus_pipe_ctx)
 	findings.info[#findings.info + 1] = {
 		line = 0,
 		msg  = string.format("scanned: %d atom(s), %d annotation(s), %d macro-word-decl(s), %d binds struct(s)"
-			, #atoms, #annots, #scan.macros, #scan.binds),
+			, #atoms, #scan.atom_infos, #scan.macros, #scan.binds),
 	}
 
 	return {
 		atoms    = atoms,
-		annots   = annots,
+		annots   = scan.atom_infos,
 		macros   = scan.macros,
 		binds    = scan.binds,
 		errors   = findings.errors,
@@ -559,9 +517,7 @@ end
 -- M.run — orchestrator entry
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class M
+local M = {} ---@type AnnotationPass
-
-local M = {}
 
 -- Expose `validate` for downstream passes (e.g. report.lua) that need to re-render the per-source results into a per-MODULE report.
 M.validate = validate
@@ -569,32 +525,32 @@ M.validate = validate
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type PassOutputEntry[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
 	-- Build the shared pipe_ctx once for this run; every validate() call sees the same cross-source registries.
 	-- The corpus owns the canonical cross-source registries; per-source scans retain body / declaration ownership.
-	local corpus_pipe_ctx = build_corpus_pipe_ctx(ctx)
+	local corpus_pipe_ctx = build_corpus_pipe_ctx(ctx) ---@type PassScratch
-	local corpus = ctx.shared.corpus
+	local corpus          = ctx.shared.corpus          ---@type Corpus
 
 	-- Group `corpus.sources_by_dir` by module, validate every source in each bucket, and emit one errors.h per directory.
-	local by_dir = (corpus and corpus.sources_by_dir) or {}
+	local by_dir = (corpus and corpus.sources_by_dir) or {} ---@type table<string, SourceFile[]>
 
-	for dir, dir_sources in pairs(by_dir) do
+	for dir, dir_sources in pairs(by_dir) do ---@type string, SourceFile[]
-		local dir_basename = dir:match("([^/\\]+)$") or dir
+		local dir_basename = dir:match("([^/\\]+)$") or dir ---@type string
-		local dir_atoms    = 0
+		local dir_atoms    = 0                              ---@type integer
-		local dir_errors   = {}
+		local dir_errors   = {}                             ---@type Finding[]
-		local dir_warnings = {}
+		local dir_warnings = {}                             ---@type Finding[]
-		for _, src in ipairs(dir_sources) do
+		for _, src in ipairs(dir_sources) do                ---@type integer, SourceFile
-			local result  = validate(ctx, src, corpus_pipe_ctx)
+			local result  = validate(ctx, src, corpus_pipe_ctx) ---@type AnnotatedResult
 			result.source = src.path                           -- tag for downstream rendering
 			dir_atoms = dir_atoms + #result.atoms
-			for _, e in ipairs(result.errors) do
+			for _, e in ipairs(result.errors) do ---@type integer, Finding
 				dir_errors[#dir_errors + 1] = { line = e.line, msg = e.msg, source = src.path }
 				errors    [#errors     + 1] = { line = e.line, msg = e.msg }
 			end
-			for _, w in ipairs(result.warnings) do
+			for _, w in ipairs(result.warnings) do ---@type integer, Finding
 				dir_warnings[#dir_warnings + 1] = { line = w.line, msg = w.msg }
 				warnings    [#warnings     + 1] = { line = w.line, msg = w.msg }
 			end

scripts/passes/atoms_source_map.lua

@@ -37,9 +37,9 @@
 -- 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 _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
-local elf_dwarf      = require("elf_dwarf")
+local elf_dwarf      = require("elf_dwarf")                                       ---@type ElfDwarfMod
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
@@ -47,37 +47,72 @@ local elf_dwarf      = require("elf_dwarf")
 
 -- Format version emitted as the first line. Bump + add a migration test if the format changes; 
 -- the gdb runtime loader rejects mismatches (E2).
-local FORMAT_VERSION = 1
+local FORMAT_VERSION = 1 ---@type integer
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class AtomSourceMapCtx
---- @field shared             table   -- `ctx.shared`
+--- @field shared        PassShared
---- @field shared.corpus      table   -- source-order registry; single writer is build_ctx
+--- @field out_root      string
---- @field shared.word_counts table
+--- @field flags         PassFlags
---- @field out_root           string  -- output root (e.g. "build/gen")
+--- @field project_root  string|nil
---- @field flags              table   -- `ctx.flags`; reads `flags.gdb_runtime` + `flags.elf_path`
+
+--- @class WordMapEntry
+--- @field pos        integer
+--- @field line       integer
+--- @field text       string
+--- @field body_line  integer
+--- @field gpr_keys   string[]|nil
+--- @field invocation InvocationRecord|nil
+
+--- @class NmAddr
+--- @field [1] integer  -- st_value
+--- @field [2] integer  -- st_size
+
+--- @class GdbAtomRecord
+--- @field idx        integer|nil
+--- @field name       string
+--- @field src_path   string
+--- @field file_base  string
+--- @field addr       integer
+--- @field size_bytes integer
+--- @field words      integer
+--- @field entries    WordMapEntry[]
+
+--- @class ElfDwarfMod
+--- @field read_nm fun(elf_path: Path): table<string, NmAddr>
+
+--- @class AtomSourceMapPass
+--- @field render_source_map      fun(src: SourceFile): string
+--- @field render_provenance      fun(src: SourceFile, wc: WordCounts): string
+--- @field render_atom_source_map fun(atom: AtomEntry): string
+--- @field render_atom_provenance fun(atom: AtomEntry, wc: WordCounts, rel_path: string): string
+--- @field run                    fun(ctx: PassCtx): PassResult
+
+--- @class AtomEntry
+--- @field paths AtomPaths|nil
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Atom-path renderers
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- Join word boundaries (from `items`) to per-word call text + source lines (from `word_events`).
---- @param atom table
+--- @param atom AtomEntry
---- @return table[], integer
+--- @return WordMapEntry[]
+--- @return integer
 local function canonical_word_entries(atom)
-	local paths      = atom.paths or {}
+	local paths      = atom.paths or {}         ---@type AtomPaths
-	local events     = paths.word_events or {}
+	local events     = paths.word_events or {}  ---@type WordEvent[]
-	local word_items = {}
+	local word_items = {}                       ---@type EmissionItem[]
-	for _, item in ipairs(paths.items or {}) do
+	for _, item in ipairs(paths.items or {}) do ---@type integer, EmissionItem
 		if item.kind == "word" then word_items[#word_items + 1] = item end
 	end
 
-	local entries = {}
+	local entries = {}                    ---@type WordMapEntry[]
-	for index, event in ipairs(events) do
+	for index, event in ipairs(events) do ---@type integer, WordEvent
-		local item = word_items[index] or {}
+		local item = word_items[index] or {} ---@type EmissionItem
 		entries[#entries + 1] = {
 			pos        = event.i or (index - 1),
 			line       = event.call_line or item.line or 0,
@@ -97,19 +132,20 @@ end
 ---   `WORD N  CALL <src-path>:<src-line>  RAW` (raw `.word` outside any mac_* component)
 --- Component identity comes from the outermost invocation record; the count-table lookup confirms the component was declared in `corpus.word_counts` 
 --- (populated by word_count_eval + components passes).
---- @param src  table
+--- @param src  SourceFile
---- @param atom table
+--- @param atom AtomEntry
---- @param wc   table -- identity alias of corpus.word_counts
+--- @param wc   WordCounts
---- @return string[], integer
+--- @return string[]
+--- @return integer
 local function emit_provenance_stanza(src, atom, wc)
-	local lines          = {}
+	local lines          = {}                           ---@type string[]
-	local rel_path       = src.path:gsub("\\\\", "/")
+	local rel_path       = src.path:gsub("\\\\", "/")   ---@type string
-	local entries, total = canonical_word_entries(atom)
+	local entries, total = canonical_word_entries(atom) ---@type WordMapEntry[], integer
 	lines[#lines + 1] = string.format('ATOM %s "%s" 0', atom.raw_name or atom.name, rel_path)
 
-	for _, entry in ipairs(entries) do
+	for _, entry in ipairs(entries) do ---@type integer, WordMapEntry
-		local inv         = entry.invocation
+		local inv         = entry.invocation                         ---@type InvocationRecord|nil
-		local macro_count = inv and wc["mac_" .. inv.component_name]
+		local macro_count = inv and wc["mac_" .. inv.component_name] ---@type integer|nil
 		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
@@ -125,11 +161,11 @@ local function emit_provenance_stanza(src, atom, wc)
 end
 
 --- Render the full provenance file content for one source.
---- @param src table
+--- @param src SourceFile
---- @param wc  table
+--- @param wc  WordCounts
 --- @return string
 local function render_provenance(src, wc)
-	local lines = {}
+	local lines = {} ---@type string[]
 	lines[#lines + 1] = "# FORMAT_VERSION 1"
 	lines[#lines + 1] = "# auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT"
 	lines[#lines + 1] = "# Per-.word provenance: maps each emitted .word to its call site (atom body"
@@ -138,14 +174,16 @@ local function render_provenance(src, wc)
 	lines[#lines + 1] = "# dwarf_injection to synthesize DW_TAG_inlined_subroutine instances + per-word"
 	lines[#lines + 1] = "# line program rows for native source-level step into component bodies."
 
+	--- @param atom AtomEntry
+	--- @return nil
 	local function append(atom)
-		local stanza = emit_provenance_stanza(src, atom, wc)
+		local stanza = emit_provenance_stanza(src, atom, wc)          ---@type string[]
-		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
+		for _, line in ipairs(stanza) do lines[#lines + 1] = line end ---@type integer, string
 	end
-	for _, atom in ipairs(src.scan.atoms or {}) do
+	for _, atom in ipairs(src.scan.atoms or {}) do ---@type integer, AtomEntry
 		if atom.paths then append(atom) end
 	end
-	for _, atom in ipairs(src.scan.raw_atoms or {}) do
+	for _, atom in ipairs(src.scan.raw_atoms or {}) do ---@type integer, AtomEntry
 		if atom.paths then append(atom) end
 	end
 
@@ -154,17 +192,17 @@ end
 
 --- Render one atom's stanza for the sourcemap.txt form (ATOM header line, N WORD lines, ENDATOM marker).
 --- Returns (lines, total_words).
---- @param src    table
+--- @param src  SourceFile
---- @param atom   table
+--- @param atom AtomEntry
---- @param wc     table
+--- @return string[]
---- @return string[], integer
+--- @return integer
 local function emit_atom_stanza(src, atom)
-	local lines          = {}
+	local lines          = {}                           ---@type string[]
-	local rel_path       = src.path:gsub("\\\\", "/")
+	local rel_path       = src.path:gsub("\\\\", "/")   ---@type string
-	local entries, total = canonical_word_entries(atom)
+	local entries, total = canonical_word_entries(atom) ---@type WordMapEntry[], integer
 
 	lines[#lines + 1] = string.format('ATOM %s "%s" 0', atom.raw_name or atom.name, rel_path)
-	for _, entry in ipairs(entries) do
+	for _, entry in ipairs(entries) do ---@type integer, WordMapEntry
 		lines[#lines + 1] = string.format("WORD %d  LINE %d  TEXT %s",
 			entry.pos, entry.line, entry.text)
 	end
@@ -175,22 +213,23 @@ end
 
 --- Render the full source map file content for one source (one .atoms.sourcemap.txt per source). Mirrors offsets.lua's
 --- `project_atoms` shape: scan.atoms + scan.raw_atoms, no kind filter.
---- @param src table
+--- @param src SourceFile
---- @param wc  table
 --- @return string
 local function render_source_map(src)
-	local lines       = {}
+	local lines       = {} ---@type string[]
 	lines[#lines + 1] = "# FORMAT_VERSION " .. FORMAT_VERSION
 	lines[#lines + 1] = "# auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT"
 
+	--- @param atom AtomEntry
+	--- @return nil
 	local function append(atom)
-		local stanza = emit_atom_stanza(src, atom)
+		local stanza = emit_atom_stanza(src, atom)                    ---@type string[]
-		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
+		for _, line in ipairs(stanza) do lines[#lines + 1] = line end ---@type integer, string
 	end
-	for _, atom in ipairs(src.scan.atoms or {}) do
+	for _, atom in ipairs(src.scan.atoms or {}) do ---@type integer, AtomEntry
 		if atom.paths then append(atom) end
 	end
-	for _, atom in ipairs(src.scan.raw_atoms or {}) do
+	for _, atom in ipairs(src.scan.raw_atoms or {}) do ---@type integer, AtomEntry
 		if atom.paths then append(atom) end
 	end
 
@@ -211,20 +250,22 @@ end
 
 --- Build the list of atoms with addresses + word entries. Shared helper for the gdb-runtime file emission.
 --- @param ctx PassCtx
---- @return table[] -- list of {idx, name, src_path, file_base, addr, size_bytes, words, entries}
+--- @return GdbAtomRecord[]
 local function build_atom_table(ctx)
-	local addrs   = elf_dwarf.read_nm(ctx.flags.elf_path)
+	local addrs   = elf_dwarf.read_nm(ctx.flags.elf_path) ---@type table<string, NmAddr>
-	local corpus  = ctx.shared and ctx.shared.corpus
+	local corpus  = ctx.shared and ctx.shared.corpus      ---@type Corpus|nil
-	local matched = {}
+	local matched = {}                                    ---@type GdbAtomRecord[]
 
-	for _, src in ipairs(corpus.source_order or {}) do
+	for _, src in ipairs(corpus.source_order or {}) do ---@type integer, SourceFile
-		local file_base = src.path:match("([^/\\\\]+)$") or src.path
+		local file_base = src.path:match("([^/\\\\]+)$") or src.path ---@type string
+		--- @param atom AtomEntry
+		--- @return nil
 		local function append(atom)
 			if not atom.paths then return end
-			local  name = atom.raw_name or atom.name
+			local  name = atom.raw_name or atom.name ---@type string
-			local  info = addrs[name]
+			local  info = addrs[name]                ---@type NmAddr|nil
 			if not info then return end
-			local entries, total = canonical_word_entries(atom)
+			local entries, total = canonical_word_entries(atom) ---@type WordMapEntry[], integer
 			matched[#matched + 1] = {
 				name       = name,
 				src_path   = src.path,
@@ -235,13 +276,16 @@ local function build_atom_table(ctx)
 				entries    = entries,
 			}
 		end
-		for _, atom in ipairs((src.scan or {}).atoms or {}) do append(atom) end
+		for _, atom in ipairs((src.scan or {}).atoms or {}) do append(atom) end     ---@type integer, AtomEntry
-		for _, atom in ipairs((src.scan or {}).raw_atoms or {}) do append(atom) end
+		for _, atom in ipairs((src.scan or {}).raw_atoms or {}) do append(atom) end ---@type integer, AtomEntry
 	end
 
 	-- Deterministic order: sort by address (matches `nm` output ordering).
+	--- @param a GdbAtomRecord
+	--- @param b GdbAtomRecord
+	--- @return boolean
 	table.sort(matched, function(a, b) return a.addr < b.addr end)
-	for i, a in ipairs(matched) do a.idx = i - 1 end
+	for i, a in ipairs(matched) do a.idx = i - 1 end ---@type integer, GdbAtomRecord
 	return matched
 end
 
@@ -252,13 +296,14 @@ end
 ---
 --- Why hardcoded per-atom: gdb's `$` substitution doesn't concat inside var names — `$__atom_name_$__i` in a `while`
 --- loop resolves to one literal identifier, not `name_i`. Compile-time emission is the only path.
---- @param lines   table  -- output line buffer (mutated in place)
+--- @param lines   string[]
---- @param matched table  -- list of atom records from `build_atom_table`
+--- @param matched GdbAtomRecord[]
+--- @return nil
 local function append_gdb_commands(lines, matched)
 	-- ── tape_atoms ──
 	-- Hardcoded one printf per atom. No loop.
 	lines[#lines + 1] = "define tape_atoms"
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		-- gdb 12.1 quirk: literals in printf args require an attached target.
 		-- Use the per-atom convenience vars set above as printf args.
 		lines[#lines + 1] = string.format('  printf "  %%-32s @ 0x%%08x  %%4d words\\n", $__atom_name_%d, $__atom_addr_%d, $__atom_words_%d',
@@ -273,7 +318,7 @@ local function append_gdb_commands(lines, matched)
 	-- ── break_atom (generic) + per-atom break_atom_X ──
 	lines[#lines + 1] = "define break_atom"
 	lines[#lines + 1] = '  echo "Usage: break_atom_<exact_name>  (pick from the list below)"'
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		lines[#lines + 1] = string.format('  printf "  break_atom_%%-32s\\n", $__atom_name_%d', a.idx)
 	end
 	lines[#lines + 1] = "end"
@@ -282,7 +327,7 @@ local function append_gdb_commands(lines, matched)
 	lines[#lines + 1] = "end"
 	lines[#lines + 1] = ""
 
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		lines[#lines + 1] = string.format("define break_atom_%s", a.name)
 		lines[#lines + 1] = string.format("  break *$__atom_addr_%d", a.idx)
 		lines[#lines + 1] = string.format('  printf "  Breakpoint set at %s (0x%%08x)\\n", $__atom_addr_%d', a.name, a.idx)
@@ -296,7 +341,7 @@ local function append_gdb_commands(lines, matched)
 	-- ── step_atom / next_atom ──
 	-- Hardcoded one tbreak per atom. No loop.
 	lines[#lines + 1] = "define step_atom"
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		lines[#lines + 1] = string.format("  tbreak *$__atom_addr_%d", a.idx)
 	end
 	lines[#lines + 1] = "  continue"
@@ -319,7 +364,7 @@ local function append_gdb_commands(lines, matched)
 	lines[#lines + 1] = "define where_in_atom"
 	lines[#lines + 1] = "  set $__pc = (unsigned int)$pc"
 	lines[#lines + 1] = "  set $__matched = 0"
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		-- Precompute end_addr (gdb 12.1's expression evaluator chokes on `addr + words*4`).
 		lines[#lines + 1] = string.format("  set $__end_%d = $__atom_addr_%d + $__atom_words_%d * 4", a.idx, a.idx, a.idx)
 		lines[#lines + 1] = string.format("  if $__pc >= $__atom_addr_%d && $__pc < $__end_%d", a.idx, a.idx)
@@ -328,15 +373,15 @@ local function append_gdb_commands(lines, matched)
 		lines[#lines + 1] = string.format("    set $__word = ($__pc - $__atom_addr_%d) / 4", a.idx)
 		lines[#lines + 1] = string.format('    printf "word:    %%d/%%d\\n", $__word, $__atom_words_%d', a.idx)
 		-- One inner-if per WORD entry. Each word's line + text hardcoded.
-		for _, we in ipairs(a.entries) do
+		for _, we in ipairs(a.entries) do ---@type integer, WordMapEntry
 			lines[#lines + 1] = string.format("    if $__word == %d", we.pos)
 			-- Escape TEXT for printf format string.
-			local escaped_text = we.text:gsub("%%", "%%%%"):gsub('"', '\\"')
+			local escaped_text = we.text:gsub("%%", "%%%%"):gsub('"', '\\"') ---@type string
 			lines[#lines + 1] = string.format('      printf "source:  %%s:%%d  %%s\\n", $__atom_file_%d, %d, "%s"', a.idx, we.line, escaped_text)
 			lines[#lines + 1] = "    end"
 		end
 		-- Fallback for words beyond the source map (shouldn't happen if nm matches).
-		local max_word = 0
+		local max_word = 0 ---@type integer
 		if #a.entries > 0 then max_word = a.entries[#a.entries].pos end
 		lines[#lines + 1] = string.format('    if $__word > %d', max_word)
 		lines[#lines + 1] = '      printf "source:  (no source-map entry for word %%d; map may be stale)\\n", $__word'
@@ -361,7 +406,7 @@ local function append_gdb_commands(lines, matched)
 	lines[#lines + 1] = "  set $__in_atom = 0"
 	lines[#lines + 1] = "  set $__did_step = 0"
 	lines[#lines + 1] = "  set $__pc = (unsigned int)$pc"
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		-- Precompute end_addr in the convenience var (single expression gdb handles).
 		lines[#lines + 1] = string.format("  set $__end_%d = $__atom_addr_%d + $__atom_words_%d * 4", a.idx, a.idx, a.idx)
 		lines[#lines + 1] = string.format("  if $__pc >= $__atom_addr_%d && $__pc < $__end_%d", a.idx, a.idx)
@@ -395,9 +440,10 @@ end
 --- Emit the gdb-runtime file (post-link). Pure gdb scripting — addresses come from `mipsel-none-elf-nm -S`, get embedded
 --- in `<ctx.out_root>/gdb_tape_atoms_runtime.gdb`, and load via `set $var = ...` + `define ... end` blocks at gdb source-time.
 --- @param ctx PassCtx
+--- @return nil
 local function emit_gdb_runtime(ctx)
 	if not (ctx.flags and ctx.flags.gdb_runtime) then return end
-	local  elf_path = ctx.flags.elf_path
+	local  elf_path = ctx.flags.elf_path ---@type string|nil
 	if not elf_path or elf_path == "" then
 		io.stderr:write("[atoms_source_map] --gdb-runtime requires --elf <elf>\n")
 		return
@@ -408,13 +454,13 @@ local function emit_gdb_runtime(ctx)
 		return
 	end
 
-	local matched = build_atom_table(ctx)
+	local matched = build_atom_table(ctx) ---@type GdbAtomRecord[]
 	if #matched == 0 then
 		io.stderr:write("[atoms_source_map] --gdb-runtime: no atoms matched against nm symbols (stale scan?).\n")
 		return
 	end
 
-	local lines = {}
+	local lines = {} ---@type string[]
 	lines[#lines + 1] = "# Auto-generated by ps1_meta.lua (passes/atoms_source_map.lua)"
 	lines[#lines + 1] = "# DO NOT EDIT — re-run ps1_meta.lua --atoms-source-map --gdb-runtime to regenerate"
 	lines[#lines + 1] = "# Sourced by scripts/gdb/gdb_tape_atoms.gdb (the wrapper)."
@@ -435,7 +481,7 @@ local function emit_gdb_runtime(ctx)
 
 	-- Per-atom convenience vars (used as printf args; literals aren't accepted
 	-- without an attached target on gdb 12.1).
-	for _, a in ipairs(matched) do
+	for _, a in ipairs(matched) do ---@type integer, GdbAtomRecord
 		lines[#lines + 1] = string.format('set $__atom_name_%d = "%s"', a.idx, gdb_escape(a.name))
 		lines[#lines + 1] = string.format("set $__atom_addr_%d = 0x%x", a.idx, a.addr)
 		lines[#lines + 1] = string.format("set $__atom_words_%d = %d", a.idx, a.words)
@@ -451,10 +497,12 @@ local function emit_gdb_runtime(ctx)
 	-- Confirmation line for the source operator.
 	lines[#lines + 1] = 'printf "[gdb_tape_atoms] runtime loaded %d atoms from %s\\n", $__atom_count, $__elf_path'
 
-	local out_path
+	local out_path ---@type string
 	-- Move out of `<out_root>/gdb_tape_atoms_runtime.gdb` to `<out_root>/../gdb_tape_atoms_runtime.gdb` when the conventional `<out_root>` is `<build>/gen`
 	-- (any equivalent spelling — relative, absolute backslash, absolute forward-slash, trailing-separator variants).
 	-- This puts the gdb runtime alongside the ELF at `build/` rather than under the report subdir.
+	--- @param p string
+	--- @return boolean
 	local function ends_with_gen_dir(p)
 		if type(p) ~= "string" then return false end
 		return p:match("[/\\]gen[/\\]?$") ~= nil or p == "build/gen" or p == "build\\gen"
@@ -462,7 +510,7 @@ local function emit_gdb_runtime(ctx)
 	if ends_with_gen_dir(ctx.out_root) then
 		-- Strip the trailing `/gen` segment, then write the runtime script under `build/`.
 		-- e.g. "C:/projects/Pikuma/ps1/build/gen" -> "C:/projects/Pikuma/ps1/build".
-		local parent = ctx.out_root:gsub("[/\\]gen[/\\]?$", "")
+		local parent = ctx.out_root:gsub("[/\\]gen[/\\]?$", "") ---@type string
 		out_path = parent .. "/gdb_tape_atoms_runtime.gdb"
 	else
 		out_path = ctx.out_root .. "/gdb_tape_atoms_runtime.gdb"
@@ -476,27 +524,27 @@ end
 -- M — module exports
 -- ════════════════════════════════════════════════════════════════════════════
 
-local M = {}
+local M = {} ---@type AtomSourceMapPass
 
 -- Expose the pure render functions so `report.lua` and the focused tests can call them directly without triggering the file-emit path.
 M.render_source_map = render_source_map
 M.render_provenance = render_provenance
 
 --- Render ONE atom's sourcemap stanza.
---- @param atom table   -- atom record (must have `atom.paths` populated)
+--- @param atom AtomEntry
 --- @return string
 function M.render_atom_source_map(atom)
 	assert(type(atom) == "table", "render_atom_source_map: atom must be a table")
 	assert(type(atom.paths) == "table", "render_atom_source_map: atom.paths must be a table")
-	local entries, total = canonical_word_entries(atom)
+	local entries, total = canonical_word_entries(atom) ---@type WordMapEntry[], integer
-	local lines = {}
+	local lines = {}                                    ---@type string[]
 	lines[#lines + 1] = string.format("ATOM %s  %d", (atom.raw_name or atom.name), total)
-	for _, entry in ipairs(entries) do
+	for _, entry in ipairs(entries) do ---@type integer, WordMapEntry
-		local word_line = string.format("WORD %d  LINE %d  TEXT %s",
+		local word_line = string.format("WORD %d  LINE %d  TEXT %s", ---@type string
 			entry.pos, entry.line, entry.text)
-		local keys = {}
+		local keys = {}    ---@type string[]
-		for pos = 1, 16 do
+		for pos = 1, 16 do ---@type integer
-			local k = entry.gpr_keys and entry.gpr_keys[pos]
+			local k = entry.gpr_keys and entry.gpr_keys[pos] ---@type string|nil
 			if type(k) == "string" and k:sub(1, 7) == "reguse:" then
 				keys[#keys + 1] = k
 			end
@@ -514,25 +562,23 @@ end
 ---
 --- `rel_path` is the source path (forward-slashes) embedded in every `CALL` line.
 --- The .md caller (report.lua) is expected to derive this once per `## <source>` heading and pass it down for each atom in that source.
---- @param atom      table   -- atom record (must have `atom.paths` populated)
+--- @param atom     AtomEntry
---- @param wc        table   -- identity alias of `corpus.word_counts`
+--- @param wc       WordCounts
---- @param rel_path  string  -- source path (forward-slashes) for `CALL` fields
+--- @param rel_path string
 --- @return string
 function M.render_atom_provenance(atom, wc, rel_path)
 	assert(type(atom)       == "table", "render_atom_provenance:  atom must be a table")
 	assert(type(atom.paths) == "table", "render_atom_provenance:  atom.paths must be a table")
 	assert(type(rel_path)   == "string", "render_atom_provenance: rel_path must be a string")
-	local entries, total = canonical_word_entries(atom)
+	local entries, total = canonical_word_entries(atom) ---@type WordMapEntry[], integer
-	local lines = {}
+	local lines = {}                                    ---@type string[]
 	lines[#lines + 1] = string.format("ATOM %s  %d", (atom.raw_name or atom.name), total)
-	for _, entry in ipairs(entries) do
+	for _, entry in ipairs(entries) do ---@type integer, WordMapEntry
-		local inv = entry.invocation
+		local inv         = entry.invocation                                ---@type InvocationRecord|nil
-		local macro_count = inv and wc and wc["mac_" .. inv.component_name]
+		local macro_count = inv and wc and wc["mac_" .. inv.component_name] ---@type integer|nil
 		if inv and macro_count ~= nil then
-			lines[#lines + 1] = string.format(
+			lines[#lines + 1] = string.format('WORD %d  CALL %s:%d  MACRO %s "%s:%d" BODY %d'
-				'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)
-				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)
@@ -548,17 +594,17 @@ end
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type PassOutputEntry[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" or type(corpus.source_order) ~= "table" then
 		error("atoms_source_map.run requires ctx.shared.corpus.source_order (canonical corpus).", 0)
 	end
 
 	-- Word counts come from `corpus.word_counts` (populated by word_count_eval + components passes).
-	local wc = corpus.word_counts or {}
+	local wc = corpus.word_counts or {} ---@type WordCounts
 	if not next(wc) then
 		warnings[#warnings + 1] = {
 			line = 0,

scripts/passes/auto_reg.lua

@@ -9,8 +9,7 @@
 --- 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
+--- 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.
---- 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).
@@ -19,50 +18,56 @@
 --- 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.
 
+--- @alias GprIdent string
+
+--- @class GprAllocMap
+--- @field [string] GprIdent  -- bag: auto-reg symbol -> physical GPR
+
+--- @class AutoRegOutput
+--- @field auto_reg_h string
+
 --- @class AutoRegResult
---- @field outputs  table[]  -- {kind=, path=} entries
+--- @field outputs  AutoRegOutput[]
---- @field errors   table[]  -- {line=, msg=}  entries (build-stops)
+--- @field errors   Finding[]
---- @field warnings table[]  -- {line=, msg=}  entries (build-continues)
+--- @field warnings Finding[]
 
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+--- @class AutoRegPass
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+--- @field run  fun(ctx: PassCtx): AutoRegResult
+--- @field POOL GprIdent[]
 
--- ════════════════════════════════════════════════════════════════════════════
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
--- THE GPR ALLOCATION POOL — what's allocatable, and (more importantly) WHY
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
--- ════════════════════════════════════════════════════════════════════════════
+local isa            = require("duffle_isa")                                      ---@type DuffleIsa
---
+
--- The auto-reg pass picks physical GPRs for `atom_auto_reg(...)` / `phase_auto_reg(...)` markers.
+--- ════════════════════════════════════════════════════════════════════════════
--- The 24-register pool covers R2-R25 (the user/atom allocatable surface):
+--- THE GPR ALLOCATION POOL — what's allocatable, and (more importantly) WHY
---   R_T0..R_T7, R_V0..R_V1, R_A0..A3, R_S0..S7, R_T8..T9.
+--- ════════════════════════════════════════════════════════════════════════════
--- Excluded (and never added to the pool):
---   R_0          (code 0)  — hardwired zero. Cannot be written.
---   R_AT         (code 1)  — assembler temporary. Reserved by the MIPS O32 ABI.
---   R_A0..A3                — explicitly omitted above even though their integer codes
---                              map to POOL entries; the pool-construction loop below
---                              only references the POOL string literals, never the
---                              integer codes, so they are NOT auto-allocated by default.
---                              (A0-A3 become available when the user adds them to
---                              POOL or hardcodes an R_A0 reference in the atom body.)
---   R_K0/K1      (codes 26-27) — kernel / interrupt handler reserves. Never touched by user code.
---   R_GP/SP/FP/RA (codes 28-31) — R_SP/R_FP/R_RA are tape-runtime carriers between
---                              tape_enter and tape_exit; R_GP stays the host global pointer.
 ---
-local POOL = {
+--- The auto-reg pass picks physical GPRs for `atom_auto_reg(...)` / `phase_auto_reg(...)` markers.
-	"R_T0", "R_T1", "R_T2", "R_T3",
+--- The 24-register pool covers R2-R25 (the user/atom allocatable surface):
-	"R_T4", "R_T5", "R_T6", "R_T7",
+---   R_T0..R_T7, R_V0..R_V1, R_A0..A3, R_S0..S7, R_T8..T9.
-	"R_V0", "R_V1",
+--- Excluded (and never added to the pool):
-	"R_A0", "R_A1", "R_A2", "R_A3",
+---   R_0          (code 0)   — Hardwired zero. Cannot be written.
-	"R_S0", "R_S1", "R_S2", "R_S3",
+---   R_AT         (code 1)   — Assembler temporary. Reserved by the MIPS O32 ABI.
-	"R_S4", "R_S5", "R_S6", "R_S7",
+---   R_A0..A3                — Explicitly omitted above even though their integer codes map to POOL entries;
-	"R_T8", "R_T9",
+---                             the pool-construction loop below only references the POOL string literals, never the integer codes, so they are NOT auto-allocated by default.
-}
+---                             (A0-A3 become available when the user adds them to POOL or hardcodes an R_A0 reference in the atom body.)
+---   R_K0/K1       (codes 26-27) — Kernel / interrupt handler reserves. Never touched by user code.
+---   R_GP/SP/FP/RA (codes 28-31) — R_SP/R_FP/R_RA are tape-runtime carriers between tape_enter and tape_exit; R_GP stays the host global pointer.
+---
+local POOL = {} ---@type GprIdent[]
+for _, row in ipairs(isa.GPR_ROLE) do ---@type integer, GprRole
+	if row.pool then
+		POOL[#POOL + 1] = row.name
+	end
+end
 
 -- 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 = {
+local INT_CODE_TO_POOL_GPR = { ---@type table<integer, GprIdent>  -- bag: MIPS GPR code -> POOL ident
 	[2]  = "R_V0", [3]  = "R_V1",
 	[4]  = "R_A0", [5]  = "R_A1", [6]  = "R_A2", [7]  = "R_A3",
 	[8]  = "R_T0", [9]  = "R_T1", [10] = "R_T2", [11] = "R_T3",
@@ -73,25 +78,31 @@ local INT_CODE_TO_POOL_GPR = {
 }
 
 -- Stable sort for deterministic allocation order.
+--- @param tbl table<string, string>  -- bag: key set only; values unused
+--- @return string[]
 local function stable_sort_keys(tbl)
-	local keys = {}
+	local keys = {}                                ---@type string[]
-	for k in pairs(tbl) do keys[#keys + 1] = k end
+	for k in pairs(tbl) do keys[#keys + 1] = k end ---@type string
 	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.
+--- @param phase_label string
+--- @param decls table<string, string>  -- bag: auto-reg symbol -> decl payload
+--- @return GprAllocMap
+--- @return Finding[]
 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   = {}
+	local pool   = {}                                ---@type GprIdent[]
-	for i = 1, #POOL do pool[i] = POOL[i] end
+	for i = 1, #POOL do pool[i] = POOL[i] end        ---@type integer
-	local result = {}
+	local result = {}                                ---@type GprAllocMap
-	local errors = {}
+	local errors = {}                                ---@type Finding[]
-	for _, sym in ipairs(stable_sort_keys(decls)) do
+	for _, sym in ipairs(stable_sort_keys(decls)) do ---@type integer, string
-		local next_gpr = table.remove(pool, 1)
+		local next_gpr = table.remove(pool, 1) ---@type GprIdent|nil
 		if not next_gpr then
 			errors[#errors + 1] = {
 				line = 0,
@@ -115,13 +126,16 @@ end
 -- 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.
+--- @param corpus Corpus
+--- @return table<GprIdent, boolean>
+--- @return table<string, GprIdent>
 local function build_user_pins(corpus)
-	local user_pinned  = {}
+	local user_pinned  = {} ---@type table<GprIdent, boolean>  -- bag: pinned physical GPR -> true
-	local alias_to_gpr = {}
+	local alias_to_gpr = {} ---@type table<string, GprIdent>  -- bag: alias ident -> physical 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
+	for alias_name, alias_entry in pairs(corpus.register_alias_registry) do ---@type string, AliasEntry
 		if alias_entry.has_atom_reg and alias_entry.code then
-			local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code]
+			local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code] ---@type GprIdent|nil
 			if gpr then
 				user_pinned[gpr]         = true
 				alias_to_gpr[alias_name] = gpr
@@ -131,30 +145,33 @@ local function build_user_pins(corpus)
 	return user_pinned, alias_to_gpr
 end
 
--- Find every physical GPR referenced in the atom body, via EITHER:
+--- 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;
+---   (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.
+---   (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
+--- Returns { [physical_gpr_ident] = count }.
--- only needs the presence of each GPR (boolean test), but keeping count preserves the
+--- Clash-detection and source-pool-exclusion logic only needs the presence of each GPR (boolean test), 
--- original find_hardcoded_rn shape so callers can switch without churn.
+--- 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.
+--- The alias pattern is sorted lexicographically to keep the regex deterministic.
+--- @param body_text string
+--- @param alias_to_gpr table<string, GprIdent>  -- bag: alias ident -> physical GPR
+--- @return table<GprIdent, integer>
 local function find_used_gprs(body_text, alias_to_gpr)
-	local found = {}
+	local found = {} ---@type table<GprIdent, integer>  -- bag: physical GPR -> hit count
 	-- (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
+	for gpr in body_text:gmatch("(R_T%d+|R_V%d+|R_A%d+|R_S%d+)") do ---@type GprIdent
 		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 = {}
+		local aliases = {}                       ---@type string[]
-		for alias_name in pairs(alias_to_gpr) do
+		for alias_name in pairs(alias_to_gpr) do ---@type string
 			aliases[#aliases + 1] = alias_name
 		end
 		table.sort(aliases)
-		local pattern = "(" .. table.concat(aliases, "|") .. ")"
+		local pattern = "(" .. table.concat(aliases, "|") .. ")" ---@type string
-		for alias_name in body_text:gmatch(pattern) do
+		for alias_name in body_text:gmatch(pattern) do           ---@type string
-			local gpr = alias_to_gpr[alias_name]
+			local gpr = alias_to_gpr[alias_name] ---@type GprIdent|nil
 			if gpr and not found[gpr] then
 				found[gpr] = 1
 			end
@@ -164,26 +181,31 @@ local function find_used_gprs(body_text, alias_to_gpr)
 end
 
 -- Emit one gen/auto_reg.h header per directory.
+--- @param out_dir string
+--- @param dir string
+--- @param sources SourceFile[]
+--- @param mappings GprAllocMap
+--- @return string|nil
 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"
+	local out_path = out_dir .. "/" .. "auto_reg.h" ---@type string
 	duffle.ensure_dir(out_dir)
-	local lines = {
+	local lines = { ---@type string[]
 		"#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
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
 		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
+	for _, sym in ipairs(stable_sort_keys(mappings)) do ---@type integer, string
-		local gpr         = mappings[sym]
+		local gpr         = mappings[sym]  ---@type GprIdent
-		local gpr_code    = gpr .. "_Code"
+		local gpr_code    = gpr .. "_Code" ---@type string
 		lines[#lines + 1] = "#define " .. sym .. "_Code " .. gpr_code
 	end
 	lines[#lines + 1] = ""
@@ -196,16 +218,16 @@ end
 -- Pass entry
 -- ════════════════════════════════════════════════════════════════════════════
 
-local M = {}
+local M = {} ---@type AutoRegPass
 
 --- @param ctx PassCtx
 --- @return AutoRegResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type AutoRegOutput[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("auto_reg.run requires ctx.shared.corpus", 0)
 	end
@@ -215,17 +237,17 @@ function M.run(ctx)
 	--  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)
+	local user_pinned, alias_to_gpr = build_user_pins(corpus) ---@type table<GprIdent, boolean>, table<string, GprIdent>
 
 	-- 1. Allocate phase pools first (phase declarations take precedence over per-atom declarations).
-	local phase_allocations = {}
+	local phase_allocations = {}                                     ---@type table<string, GprAllocMap>  -- bag: phase_label -> alloc map
-	for phase_label, decls in pairs(corpus.phase_auto_regs or {}) do
+	for phase_label, decls in pairs(corpus.phase_auto_regs or {}) do ---@type string, table<string, string>
-		local mapping, errs = allocate_phase(phase_label, decls)
+		local mapping, errs = allocate_phase(phase_label, decls) ---@type GprAllocMap, Finding[]
-		for sym, gpr in pairs(mapping) do
+		for sym, gpr in pairs(mapping) do                        ---@type string, GprIdent
 			phase_allocations[phase_label]      = phase_allocations[phase_label] or {}
 			phase_allocations[phase_label][sym] = gpr
 		end
-		for _, e in ipairs(errs) do
+		for _, e in ipairs(errs) do ---@type integer, Finding
 			errors[#errors + 1] = e
 		end
 	end
@@ -234,16 +256,16 @@ function M.run(ctx)
 	-- 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 = {}
+	local atom_name_to_phase = {}                                ---@type table<AtomName, string>  -- bag: atom name -> phase label
-	for phase_label, entry in pairs(corpus.atom_phases or {}) do
+	for phase_label, entry in pairs(corpus.atom_phases or {}) do ---@type string, AtomPhaseGroup
-		for _, atom_name in ipairs(entry.atoms or {}) do
+		for _, atom_name in ipairs(entry.atoms or {}) do ---@type integer, AtomName
 			atom_name_to_phase[atom_name] = phase_label
 		end
 	end
 
-	local atom_allocations = {}
+	local atom_allocations = {}                                    ---@type table<AtomName, GprAllocMap>  -- bag: atom scope -> alloc map
-	for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do
+	for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do ---@type AtomName, table<string, string>
-		local phase_label = atom_name_to_phase[atom_scope]
+		local phase_label = atom_name_to_phase[atom_scope] ---@type string|nil
 		-- 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)
@@ -253,27 +275,26 @@ function M.run(ctx)
 		-- 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 = {}
+		local used = {}                                                                            ---@type table<GprIdent, boolean>  -- bag: committed or body-referenced GPR -> true
-		for _, m in pairs(phase_allocations) do for _, gpr in pairs(m) do used[gpr] = true end end
+		for _, m in pairs(phase_allocations) do for _, gpr in pairs(m) do used[gpr] = true end end ---@type integer, GprAllocMap
-		for _, m in pairs(atom_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 ---@type integer, GprAllocMap
 		-- (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]
+		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope] ---@type AtomEntry|nil
 		if atom and atom.body then
-			local body_used = find_used_gprs(atom.body, alias_to_gpr)
+			local body_used = find_used_gprs(atom.body, alias_to_gpr) ---@type table<GprIdent, integer>
-			for gpr in pairs(body_used) do used[gpr] = true end
+			for gpr in pairs(body_used) do used[gpr] = true end       ---@type GprIdent
 		end
-		local source_pool = {}
+		local source_pool = {}        ---@type GprIdent[]
-		for _, gpr in ipairs(POOL) do
+		for _, gpr in ipairs(POOL) do ---@type integer, GprIdent
-			-- Exclude (a) prior commitments, (b) USER-PINNED GPRs (wave-context carriers
+			-- Exclude (a) prior commitments, (b) USER-PINNED GPRs (wave-context carriers declared via atom_reg + _Code defs, preserved across atoms globally).
-			-- 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 = {}
+		local result = {}                                ---@type GprAllocMap
-		for _, sym in ipairs(stable_sort_keys(decls)) do
+		for _, sym in ipairs(stable_sort_keys(decls)) do ---@type integer, string
-			local next_gpr = table.remove(source_pool, 1)
+			local next_gpr = table.remove(source_pool, 1) ---@type GprIdent|nil
 			if not next_gpr then
 				errors[#errors + 1] = {
 					line = 0,
@@ -295,11 +316,11 @@ function M.run(ctx)
 	-- 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
+	for atom_scope, decls in pairs(atom_allocations) do ---@type AtomName, GprAllocMap
-		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope] ---@type AtomEntry|nil
-		if atom and atom.body then
+		if    atom and atom.body then
-			local used_in_body = find_used_gprs(atom.body, alias_to_gpr)
+			local used_in_body = find_used_gprs(atom.body, alias_to_gpr) ---@type table<GprIdent, integer>
-			for sym, allocated_gpr in pairs(decls) do
+			for sym, allocated_gpr in pairs(decls) do                    ---@type string, GprIdent
 				if used_in_body[allocated_gpr] and used_in_body[allocated_gpr] > 0 then
 					warnings[#warnings + 1] = {
 						line  = atom.line or 0,
@@ -314,30 +335,32 @@ function M.run(ctx)
 
 	-- 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 {}
+	local sources_by_dir = corpus.sources_by_dir or {} ---@type table<string, SourceFile[]>
-	for dir, sources in pairs(sources_by_dir) do
+	for dir, sources in pairs(sources_by_dir) do       ---@type string, SourceFile[]
-		local per_dir_mappings = {}
+		local per_dir_mappings = {}      ---@type GprAllocMap
-		for _, src in ipairs(sources) do
+		for _, src in ipairs(sources) do ---@type integer, SourceFile
 			-- 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 scope_name in pairs(src.scan and src.scan.atom_auto_regs or {}) do ---@type string
-				for sym, gpr in pairs(atom_allocations[scope_name] or {}) do
+				for sym, gpr in pairs(atom_allocations[scope_name] or {}) do ---@type string, GprIdent
 					per_dir_mappings[sym] = gpr
 				end
 			end
-			for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do
+			for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do ---@type string
-				for sym, gpr in pairs(phase_allocations[scope_name] or {}) do
+				for sym, gpr in pairs(phase_allocations[scope_name] or {}) do ---@type string, GprIdent
 					per_dir_mappings[sym] = gpr
 				end
 			end
 		end
-		local out_dir  = dir .. "/gen"
+		local out_dir  = dir .. "/gen"                                            ---@type string
-		local out_path = emit_auto_reg_h(out_dir, dir, sources, per_dir_mappings)
+		local out_path = emit_auto_reg_h(out_dir, dir, sources, per_dir_mappings) ---@type string|nil
 		if out_path then outputs[#outputs + 1] = { auto_reg_h = out_path } end
 	end
 	return { outputs = outputs, errors = errors, warnings = warnings }
 end
 
+M.POOL = POOL
+
 return M

scripts/passes/components.lua

@@ -1,6 +1,6 @@
 --- passes/components.lua — Component-macro header generator.
 ---
---- Ownership: `corpus.word_counts`, `corpus.components`, and `corpus.component_body_index`.
+--- Ownership: `corpus.word_counts` and `corpus.components`.
 --- 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 (kind="comp_bare" / "comp_proc"),
@@ -22,71 +22,77 @@
 -- 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 "./"
+local _bootstrap_dir  = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle          = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle          = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- Atom component declaration identifiers.
-local ATOM_COMP_PROC  = "MipsAtomComp_Proc_"
+local ATOM_COMP_PROC  = "MipsAtomComp_Proc_" ---@type string
-local MIPS_ATOM       = "Slice_MipsCode"  -- prefix on the function declaration that wraps an AtomComp_Proc_
+local MIPS_ATOM       = "Slice_MipsCode"     ---@type string -- prefix on the function declaration that wraps an AtomComp_Proc_
 
 -- Component-name prefixes.
-local AC_PREFIX       = "ac_"  -- arg to MipsAtomComp_(ac_X); the X is the atom name
+local AC_PREFIX       = "ac_"  ---@type string -- arg to MipsAtomComp_(ac_X); the X is the atom name
-local AC_PREFIX_LEN   = 3
+local AC_PREFIX_LEN   = 3      ---@type integer
-local MAC_PREFIX      = "mac_" -- prefix on generated macros; the rest is the atom name
+local MAC_PREFIX      = "mac_" ---@type string -- prefix on generated macros; the rest is the atom name
-local MAC_PREFIX_LEN  = 4
+local MAC_PREFIX_LEN  = 4      ---@type integer
 
 -- ASCII byte values used in tokenization.
-local BYTE_NEWLINE    = 10
+local BYTE_NEWLINE    = 10 ---@type integer
-local BYTE_SLASH      = 47
+local BYTE_SLASH      = 47 ---@type integer
 
 -- Output gen subdirectory + filename (per-directory aggregation; the directory name is the namespace).
-local GEN_SUBDIR      = "gen"
+local GEN_SUBDIR      = "gen"    ---@type string
-local MACS_FILENAME   = "macs.h"
+local MACS_FILENAME   = "macs.h" ---@type string
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class SourceFile
+-- SourceFile, PassCtx, PassResult: see ps1_meta.lua
---- @field path     string  -- Absolute path to the source file
+-- DuffleExport: see duffle.lua
---- @field text     string  -- Full source text
+-- SourceScan, AtomEntry, CorpusCollision, CollisionSite: see scan_source.lua
---- @field dir      string  -- Directory containing the source
+-- BodyToken: see emission_model.lua
---- @field basename string  -- Filename without extension
+-- WordCounts: see word_count_eval.lua
---- @field scan     table   -- Pre-scanned SourceScan payload (from duffle.scan_source)
+-- InstructionRow, GteCommandRow: see duffle_isa.lua
-
---- @class PassCtx
---- @field sources            SourceFile[]           -- All source files in the build
---- @field metadata_path      string                 -- Path to word_count.metadata.h
---- @field shared             table                  -- Cross-pass shared state
---- @field out_root           string                 -- Output root (e.g. "build/gen")
---- @field project_root       string                 -- Project root (e.g. "code/")
---- @field upstream           table<string, table>   -- Per-pass upstream outputs
---- @field flags              table                  -- CLI flags
---- @field verbose            boolean                -- Log diagnostic info
-
---- @class PassResult
---- @field outputs  table[]  -- {kind=, path=} entries describing emit files
---- @field errors   table[]  -- {line=, msg=}  entries; build-stops
---- @field warnings table[]  -- {line=, msg=}  entries; build-succeeds
 
 --- @class Component
---- @field name       string     -- Atom name (without `ac_` prefix)
+--- @field name         string         -- Atom name (without `ac_` prefix)
---- @field body       string     -- Brace-delimited body (without the braces)
+--- @field body         string         -- Brace-delimited body (without the braces)
---- @field args       string|nil -- Function-args string (function form only)
+--- @field body_off     integer|nil    -- Byte offset of body[1] in source
---- @field line       integer    -- Source line of the declaration
+--- @field body_tokens  BodyToken[]|nil
---- @field comment    string|nil -- Scanner-owned `declaration_comment`; the components pass reads it from the scanner record
+--- @field args         string|nil     -- Function-args string (function form only)
---- @field kind       string     -- "comp_bare" | "comp_proc"  (atom_proc is NOT a component — see `project_components`)
+--- @field arg_names    string[]|nil   -- Formal names with leading `ab` dropped
---- @field debug_skip boolean    -- Mirror of `a.debug_skip` (scanner-owned); true iff a bare `atom_dbg_skip` marker immediately preceded the declaration
+--- @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
+--- @field path         string|nil     -- Slash-normalized source path (collision sites)
+--- @field source       string|nil     -- Absolute source path (emit)
+--- @field line_of      (fun(pos: integer): integer)|nil
+--- @field cycle_cost   integer|nil    -- From metadata[c.name]; nil when the body was not costed
+--- @field gp0_contrib  integer|nil    -- From metadata[c.name]; nil when the body was not costed
+
+--- @class ComponentMeta
+--- @field cycle_cost  integer
+--- @field gp0_contrib integer
+
+--- @class ComponentMetaMap
+--- @field [string] ComponentMeta  -- bag: bare component name -> meta
+
+--- @class MacsOutput
+--- @field macs_h string
+
+--- @class ComponentsPass
+--- @field run fun(ctx: PassCtx): PassResult
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Local helpers (file I/O + path normalization)
 -- ════════════════════════════════════════════════════════════════════════════
 
-local M = {}
+local M = {} ---@type ComponentsPass
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Back-walk helpers (composed into the entry point below: find_function_args_for)
@@ -100,16 +106,15 @@ local M = {}
 --- Returns the args string (e.g., `"U4 off, U4 code, U1 r, U1 g, U1 b"`) or nil if no function declaration is found.
 ---
 --- After the `sym` arg was dropped from MipsAtomComp_Proc_, the component name
---- and the args both come from the preceding `FI_ Slice_MipsCode ac_X(args)`
+--- and the args both come from the preceding `FI_ Slice_MipsCode ac_X(args)` declaration.
---- declaration. The shared `duffle.find_function_decl_for` helper does the
+--- The shared `duffle.find_function_decl_for` helper does the backward walk; this function returns just the args.
---- backward walk; this function returns just the args.
 ---
 --- @param source     string
 --- @param name       string  (retained for signature stability; unused — the walk derives the name)
 --- @param before_pos integer
 --- @return string|nil
 local function find_function_args_for(source, name, before_pos)
-	local _, args_inner = duffle.find_function_decl_for(source, before_pos, #MIPS_ATOM)
+	local _, args_inner = duffle.find_function_decl_for(source, before_pos, #MIPS_ATOM) ---@type string|nil, string|nil
 	return args_inner
 end
 
@@ -125,24 +130,24 @@ end
 --- @return string[]|nil
 local function extract_arg_names(args_str)
 	if not args_str or args_str == "" then return nil end
-	local names  = {}
+	local names  = {}                                      ---@type string[]
-	local tokens = duffle.split_top_level_commas(args_str)
+	local tokens = duffle.split_top_level_commas(args_str) ---@type string[]
-	for _, tok in ipairs(tokens) do
+	for _, tok in ipairs(tokens) do                        ---@type integer, string
-		local trimmed = duffle.trim(tok)
+		local trimmed = duffle.trim(tok) ---@type string
 		if trimmed ~= "" then
 			-- Strip trailing block comment (/* ... */) from the token, if present.
 			-- split_top_level_commas only skips block comments at TOP LEVEL (between commas),
 			-- not block comments embedded WITHIN a token between a parameter and a trailing comma.
 			-- Without this strip, the identifier-walk below stops at the `/` of `*/` and returns
 			-- the wrong name (or nothing). See `test_extract_arg_names_handles_trailing_block_comments`.
-			local trimmed_end = #trimmed
+			local trimmed_end = #trimmed ---@type integer
 			if trimmed_end >= 2 and trimmed:sub(trimmed_end - 1, trimmed_end) == "*/" then
 				-- Find the matching `/*` that opens the trailing comment.
 				-- Walk back from the `*/` looking for `/*` (whitespace + `/*`).
-				local close_pos = trimmed_end - 1   -- position of the second-to-last char
+				local close_pos = trimmed_end - 1   ---@type integer -- position of the second-to-last char
 				-- Walk back: skip trailing whitespace, then look for the `/*` opener.
 				while close_pos > 1 do
-					local ch = trimmed:sub(close_pos, close_pos)
+					local ch = trimmed:sub(close_pos, close_pos) ---@type string
 					if ch == " " or ch == "\t" or ch == "\n" or ch == "\r" then
 						close_pos = close_pos - 1
 					else
@@ -150,8 +155,8 @@ local function extract_arg_names(args_str)
 					end
 				end
 				-- Now scan back from close_pos for the `/*` opener (slashes are at close_pos-1 and close_pos-2).
-				local opener_pos = nil
+				local opener_pos = nil     ---@type integer|nil
-				local scan = close_pos - 3
+				local scan = close_pos - 3 ---@type integer
 				while scan >= 1 do
 					if trimmed:sub(scan, scan + 1) == "/*" then
 						opener_pos = scan
@@ -170,9 +175,9 @@ local function extract_arg_names(args_str)
 			trimmed_end = #trimmed
 			if trimmed_end >= 4 and trimmed:sub(trimmed_end, trimmed_end) == "]" then
 				-- Walk back: skip digits, expect `[`.
-				local bracket_pos = trimmed_end - 1
+				local bracket_pos = trimmed_end - 1 ---@type integer
 				while bracket_pos > 1 do
-					local ch = trimmed:sub(bracket_pos, bracket_pos)
+					local ch = trimmed:sub(bracket_pos, bracket_pos) ---@type string
 					if ch >= "0" and ch <= "9" then
 						bracket_pos = bracket_pos - 1
 					else
@@ -186,18 +191,18 @@ local function extract_arg_names(args_str)
 			if trimmed == "" then goto continue end
 			-- Find the identifier at the end: walk back over trailers (whitespace + `*` + `[]`),
 			-- then walk back over the identifier chars (alnum + `_`).
-			local ident_end = #trimmed
+			local ident_end = #trimmed ---@type integer
 			while ident_end > 0 do
-				local ch = trimmed:sub(ident_end, ident_end)
+				local ch = trimmed:sub(ident_end, ident_end) ---@type string
 				if ch == " " or ch == "\t" or ch == "*" or ch == "]" or ch == "[" then
 					ident_end = ident_end - 1
 				else
 					break
 				end
 			end
-			local ident_start = ident_end
+			local ident_start = ident_end ---@type integer
 			while ident_start > 0 do
-				local ch = trimmed:sub(ident_start, ident_start)
+				local ch = trimmed:sub(ident_start, ident_start) ---@type string
 				if duffle.is_alnum_byte(string.byte(ch)) or ch == "_" then
 					ident_start = ident_start - 1
 				else
@@ -205,7 +210,7 @@ local function extract_arg_names(args_str)
 				end
 			end
 			ident_start = ident_start + 1
-			local name = trimmed:sub(ident_start, ident_end)
+			local name = trimmed:sub(ident_start, ident_end) ---@type string
 			if name ~= "" then names[#names + 1] = name end
 			::continue::
 		end
@@ -214,8 +219,10 @@ local function extract_arg_names(args_str)
 	return names
 end
 
+--- @param args_str string|nil
+--- @return string[]|nil
 local function formal_arg_names(args_str)
-	local names = extract_arg_names(args_str)
+	local names = extract_arg_names(args_str) ---@type string[]|nil
 	if not names then return nil end
 	if names[1] == "ab" then table.remove(names, 1) end
 	if #names == 0 then return nil end
@@ -234,11 +241,11 @@ end
 --- Carries the scanner-owned `debug_skip` flag forward so the generated projection can emit `/* atom_dbg_skip */`
 --- before the authored comment and so `update_canonical_components` can mirror the same field onto `corpus.components[name]`.
 --- @param source string  -- the full source text (needed for backward lookups)
---- @param scan   table   -- SourceScan from duffle.scan_source
+--- @param scan   SourceScan
 --- @return Component[]
 local function project_components(source, scan)
-	local out = {}
+	local out = {}                    ---@type Component[]
-	for _, a in ipairs(scan.atoms) do
+	for _, a in ipairs(scan.atoms) do ---@type integer, AtomEntry
 		-- 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
@@ -249,10 +256,10 @@ local function project_components(source, scan)
 			-- 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)
+			local args = find_function_args_for(source, a.raw_name, a.ident_pos) ---@type string|nil
 			-- 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.
-			local comment = a.declaration_comment or ""
+			local comment = a.declaration_comment or "" ---@type string
 			out[#out + 1] = {
 				line        = a.line,
 				name        = a.name,
@@ -283,23 +290,23 @@ end
 --- @param s string
 --- @return string
 local function convert_line_comments_to_block(s)
-	local result = s
+	local result = s       ---@type string
-	local pos    = 1
+	local pos    = 1       ---@type integer
-	local len    = #result
+	local len    = #result ---@type integer
 	while pos <= len do
-		local is_double_slash = result:byte(pos) == BYTE_SLASH
+		local is_double_slash = result:byte(pos) == BYTE_SLASH ---@type boolean
 			and pos + 1 <= len and result:byte(pos + 1) == BYTE_SLASH
 		if not is_double_slash then
 			pos = pos + 1
 		else
 			-- Find end of line.
-			local eol = pos
+			local eol = pos ---@type integer
 			while eol <= len and result:byte(eol) ~= BYTE_NEWLINE do
 				eol = eol + 1
 			end
-			local before  = result:sub(1, pos - 1)
+			local before  = result:sub(1, pos - 1)       ---@type string
-			local comment = result:sub(pos + 2, eol - 1)  -- skip the `//`
+			local comment = result:sub(pos + 2, eol - 1) ---@type string -- skip the `//`
-			local after
+			local after                                  ---@type string
 			if eol <= len and result:byte(eol) == BYTE_NEWLINE then
 				after = " */" .. result:sub(eol)  -- keep the newline
 			else
@@ -336,11 +343,11 @@ end
 --- @param tok string
 --- @return string
 local function strip_leading_delay_marker(tok)
-	local ident = duffle.read_ident(tok, 1)
+	local  ident = duffle.read_ident(tok, 1) ---@type string|nil
 	if not ident or not duffle.DELAY_MARKERS[ident] then return tok end
-	local rest = tok:sub(#ident + 1):match("^%s*(.*)$") or ""
+	local rest = tok:sub(#ident + 1):match("^%s*(.*)$") or "" ---@type string
 	while rest:sub(1, 2) == "/*" do
-		local close = rest:find("*/", 3, true)
+		local  close = rest:find("*/", 3, true) ---@type integer|nil
 		if not close then return "" end
 		rest = rest:sub(close + 2):match("^%s*(.*)$") or ""
 	end
@@ -351,23 +358,23 @@ end
 --- in a single source's `count_all_components` pass; the in-progress -1 sentinel detects cycles (A -> B -> A).
 --- @param name         string -- the component name (without `mac_`)
 --- @param comp_by_name table<string, Component>
---- @param wc           table<string, integer>
+--- @param wc           WordCounts
---- @param cache        table<string, integer>
+--- @param cache        table<string, integer>  -- bag: name -> count; -1 in-progress sentinel
 --- @return integer
 local function word_count_rec(name, comp_by_name, wc, cache)
 	if cache[name] ~= nil then return cache[name] end
 	cache[name] = -1  -- mark in-progress (cycle detection)
-	local cc = comp_by_name[name]
+	local cc = comp_by_name[name] ---@type Component|nil
-	local n
+	local n                       ---@type integer
 	if cc then
 		n = 0
-		local tokens = cc.body_tokens
+		local tokens = cc.body_tokens ---@type BodyToken[]
-		for _, t in ipairs(tokens) do
+		for _, t in ipairs(tokens) do ---@type integer, BodyToken
-			local trimmed = t.tok
+			local trimmed = t.tok ---@type string
 			if trimmed ~= "" then
-				local work = trimmed
+				local work = trimmed ---@type string
 				while true do
-					local marker = duffle.read_ident(work, 1)
+					local marker = duffle.read_ident(work, 1) ---@type string|nil
 					if marker and duffle.DELAY_MARKERS[marker] then
 						work = strip_leading_delay_marker(work)
 						if work == "" then break end
@@ -376,7 +383,7 @@ local function word_count_rec(name, comp_by_name, wc, cache)
 					end
 				end
 				if work ~= "" then
-					local lookup = strip_mac_prefix(duffle.read_ident(work, 1))
+					local lookup = strip_mac_prefix(duffle.read_ident(work, 1)) ---@type string|nil
 					if lookup == "atom_label" or lookup == "atom_offset" then
 						-- Pure metaprogram anchors; emit zero words.
 					elseif lookup and comp_by_name[lookup] then
@@ -406,14 +413,14 @@ end
 --- references hit memoized values instead of re-walking the body.
 --- Cycle detection (A -> B -> A) is preserved via the in-progress `-1` sentinel in `cache`.
 --- @param components Component[]
---- @param wc         table<string, integer>
+--- @param wc         WordCounts
---- @return table<string, integer>  -- map of component name (without `mac_`) -> word count
+--- @return table<string, integer>  -- bag: bare component name -> word count
 local function count_all_components(components, wc)
-	local comp_by_name = {}
+	local comp_by_name = {}                                           ---@type table<string, Component>
-	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end
+	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end ---@type integer, Component
-	local cache        = {}
+	local cache        = {}                                           ---@type table<string, integer>  -- bag: memo; -1 in-progress sentinel
-	local counts       = {}
+	local counts       = {}                                           ---@type table<string, integer>  -- bag: bare name -> word count
-	for _, c in ipairs(components) do
+	for _, c in ipairs(components) do                                 ---@type integer, Component
 		counts[c.name] = word_count_rec(c.name, comp_by_name, wc, cache)
 	end
 	return counts
@@ -428,115 +435,87 @@ end
 -- 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,
+--- (internal) One walk of a component body that fills both `cycle_cost` and `gp0_contrib`.
---- recursing through nested `mac_*` calls (so `mac_format_g4_color`'s cost = 4 × `mac_pack_color_word`'s cost).
+--- Cycle: sum `isa.cycles` / `gte.cycles` / `latency[ident]` / 1 per leaf, recurse `mac_*`.
---- Special rule: `mac_yield`'s cost = 0 (per `lottes_tape.h:125-130` "the runtime cost lands in the next atom's prologue").
+--- `mac_yield` cycle_cost is 0 (runtime cost lands in the next atom's prologue); its gp0 still comes from the token walk.
+--- GP0: count `gte_sw` and `store_word` / `store_half` / `store_byte` that target `R_PrimCursor` / `O_(Poly_` / `r_prim_cursor` / `r_primitive_cursor` / `r_base`.
+--- `insert_ot_tag*` gp0_contrib is 0; cycle still comes from the body walk.
+--- Missing component: cycle 1, gp0 0.
 --- @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 latency      table<string, integer>  -- bag: ident -> cycle cost
---- @param cache        table<string, integer>  -- shared memoization; `-1` sentinel detects cycles
+--- @param cache        ComponentMetaMap
---- @return integer
+--- @return ComponentMeta
-local function cycle_cost_rec(name, comp_by_name, latency, cache)
+local function component_meta_rec(name, comp_by_name, latency, cache)
 	if cache[name] ~= nil then return cache[name] end
-	cache[name] = -1
+	cache[name] = { cycle_cost = -1, gp0_contrib = -1 }
-	local cc = comp_by_name[name]
+	local cc = comp_by_name[name] ---@type Component|nil
-	local n
+	local cycle_cost              ---@type integer
+	local gp0_contrib             ---@type integer
 	if cc then
-		if name == "yield" then
+		local skip_cycle = (name == "yield")                   ---@type boolean
-			-- mac_yield's cost is 0 by convention (the runtime cost lands in the next atom's prologue).
+		local skip_gp0   = name:match("^insert_ot_tag") ~= nil ---@type boolean
-			n = 0
+		cycle_cost  = 0
-		else
+		gp0_contrib = 0
-			n = 0
+		if not skip_cycle or not skip_gp0 then
-			local tokens = cc.body_tokens
+			local tokens = cc.body_tokens ---@type BodyToken[]
-			for _, t in ipairs(tokens) do
+			for _, t in ipairs(tokens) do ---@type integer, BodyToken
-				local trimmed = t.tok
+				local trimmed = t.tok ---@type string
 				if trimmed ~= "" then
-					local ident = duffle.read_ident(trimmed, 1)
+					local ident = duffle.read_ident(trimmed, 1) ---@type string|nil
-					if ident and ident:sub(1, MAC_PREFIX_LEN) == MAC_PREFIX then
+					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)                                 ---@type string
-						local nested = ident:sub(MAC_PREFIX_LEN + 1)
+						local nested_meta = component_meta_rec(nested, comp_by_name, latency, cache) ---@type ComponentMeta
-						n = n + cycle_cost_rec(nested, comp_by_name, latency, cache)
+						if not skip_cycle then
+							cycle_cost = cycle_cost + nested_meta.cycle_cost
+						end
+						if not skip_gp0 then
+							gp0_contrib = gp0_contrib + nested_meta.gp0_contrib
+						end
 					else
-						-- Leaf instruction or pseudo-macro.
+						if not skip_cycle then
-						local isa = duffle.instr(ident)
+							local isa = duffle.instr(ident) ---@type InstructionRow|nil
-						local gte = duffle.gte(ident)
+							local gte = duffle.gte(ident)   ---@type GteCommandRow|nil
-						n = n + ((isa and isa.cycles) or (gte and gte.cycles) or latency[ident] or 1)
+							cycle_cost = cycle_cost + ((isa and isa.cycles) or (gte and gte.cycles) or latency[ident] or 1)
+						end
+						if not skip_gp0 then
+							if ident == "gte_sw" then
+								gp0_contrib = gp0_contrib + 1
+							elseif ident == "store_word" or ident == "store_half" or ident == "store_byte" then
+								if trimmed:find("R_PrimCursor", 1, true)
+									or trimmed:find("O_(Poly_", 1, true)
+									or trimmed:find("r_prim_cursor", 1, true)
+									or trimmed:find("r_primitive_cursor", 1, true)
+									or trimmed:find("r_base", 1, true)
+								then
+									gp0_contrib = gp0_contrib + 1
+								end
+							end
+						end
 					end
 				end
 			end
 		end
 	else
-		n = 1
+		cycle_cost  = 1
+		gp0_contrib = 0
 	end
-	cache[name] = n
+	cache[name] = { cycle_cost = cycle_cost, gp0_contrib = gp0_contrib }
-	return n
+	return cache[name]
-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 name:match("^insert_ot_tag") then
-		cache[name] = 0
-		return 0
-	end
-	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 == "gte_sw" then
-					n = n + 1
-				elseif ident == "store_word" or ident == "store_half" or ident == "store_byte" then
-					if trimmed:find("R_PrimCursor", 1, true)
-						or trimmed:find("O_(Poly_", 1, true)
-						or trimmed:find("r_prim_cursor", 1, true)
-						or trimmed:find("r_primitive_cursor", 1, true)
-						or trimmed:find("r_base", 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
+--- One memoization cache; a nested `mac_Y` inside a `mac_X` body computes both fields once.
---- a nested `mac_Y` reference inside a `mac_X` body computes its values once.
 --- @param components Component[]
---- @param latency    table<string, integer>
+--- @param latency    table<string, integer>  -- bag: ident -> cycle cost
---- @return table<string, {cycle_cost=integer, gp0_contrib=integer}>
+--- @return ComponentMetaMap
 local function compute_components_metadata(components, latency)
-	local comp_by_name = {}
+	local comp_by_name = {}                                           ---@type table<string, Component>
-	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end
+	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end ---@type integer, Component
-	local cc_cache  = {}
+	local cache = {}                                                  ---@type ComponentMetaMap
-	local gc_cache  = {}
+	local out   = {}                                                  ---@type ComponentMetaMap
-	local out       = {}
+	for _, c in ipairs(components) do                                 ---@type integer, Component
-	for _, c in ipairs(components) do
+		out[c.name] = component_meta_rec(c.name, comp_by_name, latency, cache)
-		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
@@ -550,11 +529,11 @@ end
 --- @param s string
 --- @return string[]
 local function split_comment_lines(s)
-	local out   = {}
+	local out   = {} ---@type string[]
-	local pos   = 1
+	local pos   = 1  ---@type integer
-	local s_len = #s
+	local s_len = #s ---@type integer
 	while pos <= s_len do
-		local nl = s:find("\n", pos, true)
+		local nl = s:find("\n", pos, true) ---@type integer|nil
 		if not nl then
 			out[#out + 1] = s:sub(pos)
 			break
@@ -573,7 +552,7 @@ end
 --- @param args_str string|nil
 --- @return string
 local function signature_from_args(args_str)
-	local names = formal_arg_names(args_str)
+	local names = formal_arg_names(args_str) ---@type string[]|nil
 	if names then
 		return table.concat(names, ", ")
 	end
@@ -582,63 +561,59 @@ end
 
 --- Strip the trailing `" \"` (space + backslash) line continuation from the last body line.
 --- The last 2 chars are always that pair.
+--- @param lines string[]
+--- @return nil
 local function strip_trailing_continuation(lines)
-	local last = lines[#lines]
+	local last = lines[#lines] ---@type string
 	if    last:sub(-2) == " \\" then
 		lines[#lines] = last:sub(1, -3)
 	end
 end
 
---- Classify a token as a "pure delay marker token" (a delay-marker identifier
+--- Classify a token as a "pure delay marker token" (a delay-marker identifier with no following instruction — only whitespace and/or block comments).
---- with no following instruction — only whitespace and/or block comments).
 --- Examples that match:
 ---   * `GteDelay_`                               → marker alone
 ---   * `GteDelay_  /* RT diagonal: D1 = a.x... */` → marker + block comment
 ---   * `GteDelay_  /* RT diagonal: ... */\n\t`    → marker + comment + trailing whitespace
---- Examples that DO NOT match (these contain a real instruction after the marker
+--- Examples that DO NOT match (these contain a real instruction after the marker and must be preserved verbatim so the instruction still gets emitted):
---- and must be preserved verbatim so the instruction still gets emitted):
 ---   * `GteDelay_ nop2`
 ---   * `GteDelay_ add_si(r.dst_ptr, r.scratch, dst_offset)`
 ---
---- Why this classification matters: the metaprogram emits tokens separated by `,`
+--- Why this classification matters: the metaprogram emits tokens separated by `,` and joins them with `\<newline>` line continuations. After C preprocessor
---- and joins them with `\<newline>` line continuations. After C preprocessor
 --- phase 2 (line splicing), the macro body collapses to a single logical line.
---- Each delay-marker identifier expands to empty (its definition
+--- Each delay-marker identifier expands to empty (its definition `#define GteDelay_ // ...` consumes the `//` line comment during preprocessing
---- `#define GteDelay_ // ...` consumes the `//` line comment during preprocessing
+--- of the definition itself, leaving an empty replacement list). 
---- of the definition itself, leaving an empty replacement list). When a token
+--- When a token is purely a delay marker with only a trailing comment, the `,` the metaprogram normally adds before 
---- is purely a delay marker with only a trailing comment, the `,` the metaprogram
+--- each token-after-the-first brackets empty content and produces the syntax error `,,` (`expected expression before ',' token`) at C compile.
---- normally adds before each token-after-the-first brackets empty content and
+--- The metaprogram therefore emits such tokens WITHOUT the leading `,` (see `token_skips_leading_comma`) —
---- produces the syntax error `,,` (`expected expression before ',' token`) at
+--- but the marker + trailing comment are still emitted verbatim so the annotation is preserved in `gen/macs.h`.
---- C compile. The metaprogram therefore emits such tokens WITHOUT the leading
---- `,` (see `token_skips_leading_comma`) — but the marker + trailing comment
---- are still emitted verbatim so the annotation is preserved in `gen/macs.h`.
 --- @param tok string  -- a single token from split_top_level_commas (already trimmed at the start, may contain trailing whitespace + block comment)
 --- @return boolean
 local function is_pure_delay_marker_token(tok)
-	local markers = duffle.DELAY_MARKERS
+	local markers = duffle.DELAY_MARKERS ---@type table<string, boolean>  -- bag: delay-marker ident -> true
 	if type(markers) ~= "table" then return false end
 
 	-- Identify a leading delay-marker identifier (e.g. `GteDelay_`).
-	local ident_end = 1
+	local ident_end = 1 ---@type integer
 	while ident_end <= #tok do
-		local ch = tok:sub(ident_end, ident_end)
+		local ch = tok:sub(ident_end, ident_end) ---@type string
 		if ch:match("[%w_]") then
 			ident_end = ident_end + 1
 		else
 			break
 		end
 	end
-	local ident = tok:sub(1, ident_end - 1)
+	local ident = tok:sub(1, ident_end - 1) ---@type string
 	if not markers[ident] then return false end
 
 	-- Walk the remainder: only whitespace and block comments are allowed.
-	local scan = ident_end
+	local scan = ident_end ---@type integer
 	while scan <= #tok do
-		local ch = tok:sub(scan, scan)
+		local ch = tok:sub(scan, scan) ---@type string
 		if    ch:match("%s") then
 			scan = scan + 1
 		elseif ch == "/" and tok:sub(scan + 1, scan + 1) == "*" then
-			local close = tok:find("*/", scan + 2, true)
+			local close = tok:find("*/", scan + 2, true) ---@type integer|nil
 			if not close then return false end
 			scan = close + 2
 		else
@@ -655,17 +630,14 @@ end
 --- followed by whitespace + optional block comment and NOTHING ELSE) expand
 --- to empty at C preprocessor time. Emitting them WITHOUT the leading `,`
 --- separator that the metaprogram normally adds before each token after the
---- first keeps exactly one `,` between the surrounding real expressions in
+--- first keeps exactly one `,` between the surrounding real expressions in the spliced macro body:
---- the spliced macro body:
----
 ---   * before this rule:  `<tok1> ,\t<gdelay> ,\t<tok3>` → after expansion
 ---                        `<tok1> ,  /* comment */ , <tok3>` → `,,` syntax error.
 ---   * after  this rule:  `<tok1> \t<gdelay> ,\t<tok3>` → after expansion
 ---                        `<tok1>  /* comment */ , <tok3>` → `<tok1>, <tok3>` — valid.
 ---
---- Tokens like `GteDelay_ nop2` keep the leading `,` (the marker is followed
+--- Tokens like `GteDelay_ nop2` keep the leading `,`
---- by a real instruction, so the marker + instruction together need the
+--- (the marker is followed by a real instruction, so the marker + instruction together need the separator on the LEFT to land between two real expressions).
---- separator on the LEFT to land between two real expressions).
 --- @param tok string
 --- @return boolean  -- true if the token needs NO leading `,` separator.
 local function token_skips_leading_comma(tok)
@@ -675,16 +647,24 @@ end
 --- Emit the `#define mac_X(sig) \<newline>\t<tok1> \<newline>,\t<tok2> ...` block.
 --- Converts `//` line comments to `/* */` block comments in each token so they don't break the C macro `\` line continuations.
 ---
---- Pure delay-marker tokens (`GteDelay_` / `LdSlot_` / `BdSlot_` / `DmaSlot_` with only a trailing block comment, no real instruction) are emitted WITHOUT a leading `,` separator; the annotation IS preserved in the generated header (so the comment + marker remain visible to anyone reading `gen/macs.h`), but the C preprocessor expands the marker to empty, so leaving the `,` separator out is what stops the `,,` syntax error. See `token_skips_leading_comma` for the contract.
+--- Pure delay-marker tokens (`GteDelay_` / `LdSlot_` / `BdSlot_` / `DmaSlot_` with only a trailing block comment, no real instruction) are emitted WITHOUT a leading `,` separator;
+--- the annotation IS preserved in the generated header
+--- (so the comment + marker remain visible to anyone reading `gen/macs.h`), but the C preprocessor expands the marker to empty, so leaving the `,`
+--- separator out is what stops the `,,` syntax error. See `token_skips_leading_comma` for the contract.
+--- @param lines  string[]
+--- @param c      Component
+--- @param sig    string
+--- @param tokens string[]
+--- @return nil
 local function emit_macro_body(lines, c, sig, tokens)
-	for tok_idx = 1, #tokens do
+	for tok_idx = 1, #tokens do ---@type integer
 		tokens[tok_idx] = convert_line_comments_to_block(tokens[tok_idx])
 	end
 	if #tokens == 0 then return end
 	lines[#lines + 1] = "#define mac_" .. c.name .. "(" .. sig .. ") \\"
 	lines[#lines + 1] = "\t" .. tokens[1] .. " \\"
-	for tok_idx = 2, #tokens do
+	for tok_idx = 2, #tokens do ---@type integer
-		local sep = token_skips_leading_comma(tokens[tok_idx]) and "\t" or ",\t"
+		local sep = token_skips_leading_comma(tokens[tok_idx]) and "\t" or ",\t" ---@type string
 		lines[#lines + 1] = sep .. tokens[tok_idx] .. " \\"
 	end
 	strip_trailing_continuation(lines)
@@ -695,12 +675,11 @@ end
 --- For skipped components, a `/* atom_dbg_skip */` marker comment is emitted immediately before the authored comment block.
 --- The marker is a single line, the comment comes next, and the `#define` line follows. The `debug_skip` stamp is scanner-owned
 --- (`a.debug_skip == true` on the declaration record); the components pass projects it directly.
---- @param c          Component
+--- @param c      Component
---- @param components Component[]
+--- @param counts table<string, integer>  -- bag: bare component name -> word count
---- @param wc         table<string, integer>
 --- @return string[]  -- list of lines for this component
 local function build_component_lines(c, counts)
-	local lines = {}
+	local lines = {} ---@type string[]
 
 	-- 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);
@@ -710,16 +689,16 @@ local function build_component_lines(c, counts)
 	end
 
 	if c.comment and c.comment ~= "" then
-		for _, line in ipairs(split_comment_lines(c.comment)) do
+		for _, line in ipairs(split_comment_lines(c.comment)) do ---@type integer, string
 			lines[#lines + 1] = line
 		end
 	end
 
-	local tokens = duffle.split_top_level_commas(c.body)
+	local tokens = duffle.split_top_level_commas(c.body)         ---@type string[]
-	for i = 1, #tokens do tokens[i] = duffle.trim(tokens[i]) end
+	for i = 1, #tokens do tokens[i] = duffle.trim(tokens[i]) end ---@type integer
-	local sig = signature_from_args(c.args)
+	local sig = signature_from_args(c.args)                      ---@type string
 	-- Direct lookup against the per-source precomputed `counts` table (built once by count_all_components).
-	local n   = counts[c.name]
+	local n   = counts[c.name] ---@type integer
 
 	if n > 0 then
 		emit_macro_body(lines, c, sig, tokens)
@@ -742,11 +721,11 @@ end
 --- @param sources SourceFile[] -- Sources contributing to this directory (for the header comment)
 --- @return string[]
 local function header_boilerplate(dir, sources)
-	local source_lines = { "// Directory: " .. duffle.to_absolute_path(dir) .. "/" }
+	local source_lines = { "// Directory: " .. duffle.to_absolute_path(dir) .. "/" } ---@type string[]
-	for _, src in ipairs(sources) do
+	for _, src in ipairs(sources) do                                                 ---@type integer, SourceFile
 		source_lines[#source_lines + 1] = "//   source: " .. duffle.to_absolute_path(src.path)
 	end
-	local source_blob = table.concat(source_lines, "\n")
+	local source_blob = table.concat(source_lines, "\n") ---@type string
 	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.
@@ -774,8 +753,8 @@ end
 --- @return string  -- Output directory
 --- @return string  -- Full output path
 local function compute_macs_h_path(dir)
-	local  out_dir  = dir .. "/" .. GEN_SUBDIR
+	local  out_dir  = dir .. "/" .. GEN_SUBDIR        ---@type string
-	local  out_path = out_dir .. "/" .. MACS_FILENAME
+	local  out_path = out_dir .. "/" .. MACS_FILENAME ---@type string
 	return out_dir, out_path
 end
 
@@ -785,20 +764,20 @@ end
 --- @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)
+--- @param counts     table<string, integer>  -- bag: bare component name -> word count
 --- @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(dir)
+	local out_dir, out_path = compute_macs_h_path(dir)         ---@type string, string
-	local lines             = header_boilerplate(dir, sources)
+	local lines             = header_boilerplate(dir, sources) ---@type string[]
 
-	for _, c in ipairs(components) do
+	for _, c in ipairs(components) do ---@type integer, Component
-		for _, l in ipairs(build_component_lines(c, counts)) do
+		for _, l in ipairs(build_component_lines(c, counts)) do ---@type integer, string
 			lines[#lines + 1] = l
 		end
 	end
 
-	local content = table.concat(lines, "\n") .. "\n"
+	local content = table.concat(lines, "\n") .. "\n" ---@type string
 	duffle.ensure_dir(out_dir)
 	duffle.write_file_lf(out_path, content)
 	print(string.format("  -> %s", out_path))
@@ -811,59 +790,55 @@ end
 
 --- (internal) Extend `corpus.word_counts` with this source's component macros so offsets sees them without re-reading the file.
 --- First declaration wins: a later caller's count is dropped (the existing entry from the first source is preserved).
---- @param corpus     table  -- the corpus
+--- @param corpus     Corpus
 --- @param components Component[]
---- @param counts     table<string, integer>  -- precomputed word counts (from count_all_components)
+--- @param counts     table<string, integer>  -- bag: bare component name -> word count
+--- @return nil
 local function update_canonical_word_counts(corpus, components, counts)
-	local wc = corpus.word_counts
+	local wc = corpus.word_counts     ---@type WordCounts
-	for _, c in ipairs(components) do
+	for _, c in ipairs(components) do ---@type integer, Component
-		local key = "mac_" .. c.name
+		local key = "mac_" .. c.name ---@type string
 		if wc[key] == nil then
 			wc[key] = counts[c.name]
 		end
 	end
 end
 
---- @class ComponentDef
+--- (internal) Populate `corpus.components` with this source's one component row per bare name.
---- @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`.
 --- 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 corpus     Corpus
 --- @param src        SourceFile
 --- @param components Component[]
---- @param metadata    table<string, {cycle_cost=integer, gp0_contrib=integer}>
+--- @param metadata   ComponentMetaMap
-local function update_canonical_components(corpus, src, components, metadata)
+--- @param scan       SourceScan
-	local rel_path = src.path:gsub("\\", "/")
+--- @return nil
-	for _, c in ipairs(components) do
+local function update_canonical_components(corpus, src, components, metadata, scan)
+	local rel_path = src.path:gsub("\\", "/")               ---@type string
+	local line_of  = scan and scan.line_of                  ---@type (fun(pos: integer): integer)|nil
+	for _, c in ipairs(components) do                       ---@type integer, Component
 		-- 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
+		local m = metadata and metadata[c.name] or nil ---@type ComponentMeta|nil
 		if corpus.components[c.name] == nil then
-			corpus.components[c.name] = {
+			c.path        = rel_path
-				name        = c.name,
+			c.source      = src.path
-				line        = c.line,
+			c.line_of     = line_of
-				path        = rel_path,
+			c.kind        = c.kind or "comp_bare"
-				kind        = c.kind or "comp_bare",
+			c.debug_skip  = c.debug_skip == true
-				debug_skip  = c.debug_skip == true,
+			c.cycle_cost  = m and m.cycle_cost  or nil
-				cycle_cost  = m and m.cycle_cost  or nil,
+			c.gp0_contrib = m and m.gp0_contrib or nil
-				gp0_contrib = m and m.gp0_contrib or nil,
+			corpus.components[c.name] = c
-			}
 		else
 			-- A second declaration of the same bare name: record a typed collision so static-analysis + the report can surface it.
 			-- Identical-shape declarations (same path + line) reuse the first-wins entry without a collision record.
-			local existing = corpus.components[c.name]
+			local existing = corpus.components[c.name] ---@type Component
 			if existing.path ~= rel_path or existing.line ~= c.line then
-				local kind       = c.kind or "comp_bare"
+				local kind       = c.kind or "comp_bare"        ---@type string
-				local first_kind = existing.kind or "comp_bare"
+				local first_kind = existing.kind or "comp_bare" ---@type string
 				corpus.collisions[#corpus.collisions + 1] = {
 					kind              = "component",
 					name              = c.name,
@@ -877,39 +852,15 @@ local function update_canonical_components(corpus, src, components, metadata)
 	end
 end
 
---- (internal) Populate `corpus.component_body_index` with this source's body index entries.
---- First declaration wins; later declarations are dropped (no separate collision record: the components collision is already surfaced by `update_canonical_components`).
---- The pass writes to `corpus.component_body_index` only (the corpus owns this projection).
---- @param corpus     table  -- the corpus
---- @param src        SourceFile
---- @param components Component[]
---- @param scan       table  -- the SourceScan payload (for line_of)
-local function update_canonical_component_body_index(corpus, src, components, scan)
-	local line_of = scan and scan.line_of
-	for _, c in ipairs(components) do
-		if corpus.component_body_index[c.name] == nil then
-			corpus.component_body_index[c.name] = {
-				body_tokens = c.body_tokens,
-				body_off    = c.body_off,
-				line_of     = line_of,
-				source      = src.path,
-				declaration = c.line,
-				kind        = c.kind,
-				arg_names   = c.arg_names,
-			}
-		end
-	end
-end
-
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type MacsOutput[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
 	-- Corpus ownership gate.
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("components.run requires ctx.shared.corpus.", 0)
 	end
@@ -924,21 +875,20 @@ function M.run(ctx)
 
 	-- Projection ownership:
 	--   * `corpus.word_counts["mac_"..name]` — current component count
-	--   * `corpus.components[name]`         — bare-name component definition
+	--   * `corpus.components[name]`         — one row: body, line_of, source, cost
-	--   * `corpus.component_body_index[name]` — body / line_of / source index
 	-- The pass writes to the corpus only; consumers read from the corpus directly.
 
 	-- 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)
+	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order) ---@type table<string, SourceFile[]>
-	for dir, sources in pairs(sources_by_dir) do
+	for dir, sources in pairs(sources_by_dir) do                                                     ---@type string, SourceFile[]
 		-- 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 aggregated_components = {} ---@type Component[]
-		local metadata_per_source   = {}
+		local metadata_per_source   = {} ---@type table<SourceFile, ComponentMetaMap>
-		for _, src in ipairs(sources) do
+		for _, src in ipairs(sources) do ---@type integer, SourceFile
-			local per_source = project_components(src.text, src.scan) or {}
+			local per_source = project_components(src.text, src.scan) or {} ---@type Component[]
-			for _, c in ipairs(per_source) do
+			for _, c in ipairs(per_source) do                               ---@type integer, Component
 				aggregated_components[#aggregated_components + 1] = c
 			end
 			if #per_source > 0 then
@@ -948,17 +898,16 @@ function M.run(ctx)
 		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 counts    = count_all_components(aggregated_components, corpus.word_counts)           ---@type table<string, integer>  -- bag: bare name -> word count
-			local macs_path = emit_component_macros_h(ctx, dir, sources, aggregated_components, counts)
+			local macs_path = emit_component_macros_h(ctx, dir, sources, aggregated_components, counts) ---@type string|nil
 			if macs_path then
 				outputs[#outputs + 1] = { macs_h = macs_path }
 				-- 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
+				for _, src in ipairs(sources) do ---@type integer, SourceFile
-					local per_source = project_components(src.text, src.scan) or {}
+					local per_source = project_components(src.text, src.scan) or {} ---@type Component[]
 					if #per_source > 0 then
-						update_canonical_components(corpus, src, per_source, metadata_per_source[src])
+						update_canonical_components(corpus, src, per_source, metadata_per_source[src], src.scan)
-						update_canonical_component_body_index(corpus, src, per_source, src.scan)
 					end
 				end
 			end

scripts/passes/emission_model.lua

@@ -1,7 +1,7 @@
 --- passes/emission_model.lua: Per-atom emission projection.
 ---
 --- The `emission-model` pass owns `atom.paths`, the canonical per-atom mutable surface for atoms and raw atoms with bodies in `ctx.shared.corpus.source_order`.
---- For each atom, the pass invokes `duffle.project_emission(body_text, component_index, word_counts, components)`.
+--- For each atom, the pass invokes `duffle.project_emission(body_text, components, word_counts, components)`.
 --- It stores the ordered `items` stream plus the dense `word_events` / `markers` / `invocations` views on `atom.paths`.
 ---
 --- Public boundary:
@@ -26,13 +26,94 @@
 ---
 --- `passes.scan_source` strips its private `_code_macros` / `_code_macro_bodies` tables before this pass runs.
 
-local M = {}
+--- @class BodyToken
+--- @field tok string
+--- @field rel integer
+
+--- @class EmissionItem
+--- @field kind                    string
+--- @field encoder                 string|nil
+--- @field args                    string[]|nil
+--- @field i                       integer|nil
+--- @field word_count              integer|nil
+--- @field line                    integer|nil
+--- @field call_text               string|nil
+--- @field root_call_text          string|nil
+--- @field invocation_ids          integer[]|nil
+--- @field outermost_invocation_id integer|nil
+--- @field gpr_keys                string[]|nil
+--- @field ident                   string|nil
+--- @field isa_kind                string|nil
+--- @field nop_words               integer|nil
+--- @field is_yield                boolean|nil
+--- @field is_load                 boolean|nil
+--- @field is_branch               boolean|nil
+--- @field is_unconditional_jump   boolean|nil
+--- @field is_terminal_jump        boolean|nil
+--- @field gp0_shape               string|nil
+--- @field name                    string|nil
+--- @field target                  string|nil
+--- @field word_index              integer|nil
+--- @field consuming_encoder       string|nil
+--- @field consuming_arg_pos       integer|nil
+--- @field invocation_id           integer|nil
+
+--- @class WordEvent
+--- @field i                       integer
+--- @field encoder                 string
+--- @field args                    string[]
+--- @field def_path                string
+--- @field def_line                integer
+--- @field call_text               string|nil
+--- @field root_call_text          string|nil
+--- @field invocation_ids          integer[]
+--- @field outermost_invocation_id integer
+--- @field word_count              integer
+--- @field gpr_keys                string[]|nil
+--- @field ident                   string
+--- @field kind                    string
+--- @field nop_words               integer
+--- @field is_yield                boolean
+--- @field is_load                 boolean
+--- @field is_branch               boolean
+--- @field is_unconditional_jump   boolean
+--- @field is_terminal_jump        boolean
+--- @field gp0_shape               string|nil
+--- @field body_line               integer|nil
+--- @field call_line               integer|nil
+--- @field call_path               string|nil
+
+--- @class EmissionMarker
+--- @field kind              string
+--- @field name              string
+--- @field line              integer
+--- @field word_index        integer
+--- @field target            string|nil
+--- @field consuming_encoder string|nil
+--- @field consuming_arg_pos integer|nil
+
+-- Finding: see ps1_meta.lua
+
+--- @class AtomPaths
+--- @field tokens       BodyToken[]
+--- @field line_in_body table<integer, integer>  -- bag: body byte offset -> 1-based line
+--- @field items        EmissionItem[]
+--- @field word_events  WordEvent[]
+--- @field markers      EmissionMarker[]
+--- @field invocations  InvocationRecord[]
+--- @field errors       Finding[]
+--- @field warnings     Finding[]
+
+--- @class EmissionModelPass
+--- @field run fun(ctx: PassCtx): PassResult
+
+local M = {} ---@type EmissionModelPass
 
 -- ─────────────────────────────────────────────────────────────────────────
 -- Bootstrap: load `duffle_paths.lua` via debug.getinfo so the module works standalone (run as `luajit passes/emission_model.lua`) and when require'd from the orchestrator.
 -- ─────────────────────────────────────────────────────────────────────────
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- ─────────────────────────────────────────────────────────────────────────
 -- Helpers
@@ -45,12 +126,17 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --   * ROOT invocations (`inv.parent_id == 0`) receive body-relative `call_line` values directly from `M.LineIndex(body_text)` in the walker.
 --     The source `line_of` closure supplies physical lines at the close site, so this function converts each root value exactly once.
 --   * INNER invocations (`inv.parent_id ~= 0`) receive physical `call_line` values directly from the COMPONENT's `line_of` in the walker.
---     Recursive descent forwards that closure through `corpus.component_body_index[name].line_of`; those values arrive physical and remain unchanged.
+--     Recursive descent forwards that closure through `corpus.components[name].line_of`; those values arrive physical and remain unchanged.
 --
 -- After this function, every `inv.call_line` is physical. DWARF and provenance output read it directly.
 -- The word-event loop forwards the already-physical `outer_inv.call_line` into `we.call_line` for words inside an invocation.
+--- @param projection EmissionProjection
+--- @param atom_record AtomEntry
+--- @param src SourceFile
+--- @param corpus Corpus
+--- @return nil
 local function stamp_root_provenance(projection, atom_record, src, corpus)
-	local root_line_of   = src.scan and src.scan.line_of
+	local root_line_of   = src.scan and src.scan.line_of ---@type (fun(pos: integer): integer)|nil
 	assert(type(root_line_of) == "function"
 		, "emission_model: src.scan.line_of is required (canonical LineIndex closure over the source text) to stamp physical provenance")
 	assert(type(atom_record.body_off) == "number"
@@ -58,26 +144,29 @@ 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 ---@type integer
-	local component_index = corpus.component_body_index or {}
+	local components = corpus.components or {}                                              ---@type table<string, Component>
-	local word_items      = {}
+	local word_items      = {}                                                              ---@type EmissionItem[]
 
-	for _, item in ipairs(projection.items) do
+	for _, item in ipairs(projection.items) do ---@type integer, EmissionItem
 		if item.kind == "word" then word_items[#word_items + 1] = item end
 	end
 
 	-- Resolve one word's physical body line, where the byte containing that word appears in source.
 	--   * Component expansions carry `invocation_ids`; the component's full-file `line_of` leaves `item.line` physical.
 	--   * Raw tokens in the root atom body carry an empty `invocation_ids` list and a body-relative `item.line`; convert them here.
+	--- @param event WordEvent
+	--- @param item EmissionItem
+	--- @return integer
 	local function body_line_for(event, item)
-		local ids = event.invocation_ids or {}
+		local ids = event.invocation_ids or {} ---@type integer[]
 		-- The innermost open invocation identifies which line index the walker used.
 		-- A component `line_of` makes `item.line` physical; the atom's `body_text` line index makes it body-relative.
 		if ids and #ids > 0 then
-			local inner_id  = ids[#ids]
+			local inner_id  = ids[#ids]                                     ---@type integer
-			local inner_inv = inner_id and projection.invocations[inner_id]
+			local inner_inv = inner_id and projection.invocations[inner_id] ---@type InvocationRecord|nil
 			if inner_inv then
-				local component = component_index[inner_inv.component_name]
+				local component = components[inner_inv.component_name] ---@type Component|nil
 				if component and component.line_of then
 					-- Walker used `comp.line_of`, which is the source's physical LineIndex. item.line is already physical.
 					return item.line or 0
@@ -92,8 +181,8 @@ local function stamp_root_provenance(projection, atom_record, src, corpus)
 	-- Stamp the root source path onto invocation records whose `call_path` the walker left empty.
 	-- The walker passes `body_entry.source` to `emit_invoke_begin`; `M.project_emission` creates the root `body_entry` with source `""`, leaving its `call_path` empty.
 	-- This stamp gives every invocation a physical `call_path` matching `passes/atoms_source_map.lua`'s in-memory provenance projection.
-	local root_path = src.path or ""
+	local root_path = src.path or ""                ---@type string
-	for _, inv in ipairs(projection.invocations) do
+	for _, inv in ipairs(projection.invocations) do ---@type integer, InvocationRecord
 		if inv.call_path == nil or inv.call_path == "" then
 			inv.call_path = root_path
 		end
@@ -102,7 +191,7 @@ local function stamp_root_provenance(projection, atom_record, src, corpus)
 	-- Normalize `inv.call_line` to a physical source line.
 	--   * ROOT  invocations (`parent_id == 0`) carry body-relative `call_line` values from `M.LineIndex(body_text)`; convert them once with `root_body_line`.
 	--   * INNER invocations (`parent_id ~= 0`) carry physical `call_line` values from the component's `line_of`; retain them unchanged.
-	for _, inv in ipairs(projection.invocations) do
+	for _, inv in ipairs(projection.invocations) do ---@type integer, InvocationRecord
 		if inv.parent_id == 0 then
 			inv.call_line = (root_body_line or 0) + (inv.call_line or 1) - 1
 		end
@@ -111,14 +200,14 @@ local function stamp_root_provenance(projection, atom_record, src, corpus)
 	-- Build `body_lines` for each invocation.
 	-- `atoms_source_map` and `dwarf_injection` read `inv.body_lines[k]` directly from the invocation record created here.
 	-- Component words already carry physical `item.line` values from the walker's COMPONENT line index, so `body_line_for` returns them unchanged.
-	for _, inv in ipairs(projection.invocations) do
+	for _, inv in ipairs(projection.invocations) do ---@type integer, InvocationRecord
-		local sw  = inv.start_word
+		local sw  = inv.start_word ---@type integer
-		local ew  = inv.end_word
+		local ew  = inv.end_word   ---@type integer
-		local bls = {}
+		local bls = {}             ---@type integer[]
-		for i = sw, ew do
+		for i = sw, ew do          ---@type integer
-			local it = projection.items and projection.items[i]
+			local it = projection.items and projection.items[i] ---@type EmissionItem|nil
 			if    it and it.kind == "word" then
-				local fake_event = { invocation_ids = { inv.id } }
+				local fake_event = { invocation_ids = { inv.id } } ---@type WordEvent
 				bls[#bls + 1]    = body_line_for(fake_event, it) or 0
 			end
 		end
@@ -128,15 +217,15 @@ local function stamp_root_provenance(projection, atom_record, src, corpus)
 	-- Resolve each `word_event`'s physical `body_line` and `call_line`.
 	-- For words inside an invocation, `we.call_line` identifies the OUTER atom source line containing the `mac_X(...)` token that triggered expansion.
 	-- The root-invocation conversion above makes every `inv.call_line` physical; forward it directly and use each raw word's `body_line` as the fallback.
-	for index, we in ipairs(projection.word_events) do
+	for index, we in ipairs(projection.word_events) do ---@type integer, WordEvent
-		local item      = word_items[index] or {}
+		local item      = word_items[index] or {} ---@type EmissionItem
-		local body_line = body_line_for(we, item)
+		local body_line = body_line_for(we, item) ---@type integer
 		item.line    = body_line
 		we.body_line = body_line
 
-		local call_line = body_line
+		local call_line = body_line                        ---@type integer
-		local outer_id  = we.outermost_invocation_id or 0
+		local outer_id  = we.outermost_invocation_id or 0  ---@type integer
-		local outer_inv = projection.invocations[outer_id]
+		local outer_inv = projection.invocations[outer_id] ---@type InvocationRecord|nil
 		if outer_inv then
 			-- `outer_inv.call_line` is physical after the conversion loop above, so use it directly.
 			call_line = outer_inv.call_line
@@ -151,16 +240,20 @@ end
 
 -- Project one atom record into `atom.paths`.
 -- Mutates the atom record in-place and returns the projection (for pass-level error/warning accumulation).
+--- @param atom_record AtomEntry
+--- @param src SourceFile
+--- @param corpus Corpus
+--- @return EmissionProjection
 local function project_atom(atom_record, src, corpus)
-	local body  = atom_record.body or ""
+	local body  = atom_record.body or ""            ---@type string
-	local wc    = corpus.word_counts or {}
+	local wc    = corpus.word_counts or {}          ---@type WordCounts
-	local cbi   = corpus.component_body_index or {}
+	local comps = corpus.components or {}           ---@type table<string, Component>
-	local schema = nil
+	local schema = nil                              ---@type RegUseSchema|nil
 	if atom_record.reg_use_schema_name then
 		schema = corpus.reg_use_schemas and corpus.reg_use_schemas[atom_record.reg_use_schema_name]
 	end
 	-- That construction site stamps `invocation.debug_skip` while appending each record to `proj.invocations`.
-	local proj  = duffle.project_emission(body, cbi, wc, corpus.components, {
+	local proj  = duffle.project_emission(body, comps, wc, comps, { ---@type EmissionProjection
 		reg_use_schema = schema,
 		reg_use_param  = atom_record.reg_use_param_name,
 		atom_name      = atom_record.name,
@@ -168,16 +261,25 @@ local function project_atom(atom_record, src, corpus)
 	})
 	if atom_record.reg_use_schema_name and not schema then
 		proj.errors[#proj.errors + 1] = {
-			kind = "reguse_missing_schema",
+			kind        = "error",
-			msg  = string.format("RegUse schema %q is missing", atom_record.reg_use_schema_name),
+			check       = "reguse_missing_schema",
+			msg         = string.format("RegUse schema %q is missing", atom_record.reg_use_schema_name),
+			schema_name = atom_record.reg_use_schema_name,
 		}
 	end
-	for _, err in ipairs(corpus.reg_use_errors or {}) do
+	for _, err in ipairs(corpus.reg_use_errors or {}) do ---@type integer, RegUseError
 		if err.schema_name == atom_record.reg_use_schema_name then
-			proj.errors[#proj.errors + 1] = err
+			proj.errors[#proj.errors + 1] = {
+				kind        = "error",
+				check       = err.kind,
+				line        = err.line or err.source_line or 0,
+				msg         = err.msg or "",
+				source      = err.source or err.source_file,
+				schema_name = err.schema_name,
+			}
 		end
 	end
-	local paths = {
+	local paths = { ---@type AtomPaths
 		tokens       = atom_record.body_tokens or {},
 		line_in_body = duffle.build_body_line_index(body),
 		items        = proj.items,
@@ -199,37 +301,44 @@ end
 --- @param ctx PassCtx  -- { shared = { corpus = ... }, out_root, ... }
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type PassOutputEntry[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx and ctx.shared and ctx.shared.corpus
+	local corpus = ctx and ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus)              ~= "table" then error("emission_model: ctx.shared.corpus is required (canonical projection)", 0) end
 	if type(corpus.source_order) ~= "table" then error("emission_model: ctx.shared.corpus.source_order is required", 0) end
 
 	-- Project once, collect errors + warnings for one atom.
 	-- Kind must be one of: atom | atom_proc | raw_atom | comp_bare | comp_proc.
+	--- @param atom AtomEntry
+	--- @param src SourceFile
+	--- @return nil
 	local function process_atom(atom, src)
 		if not (atom and atom.body) then return end
-		local kind = atom.kind
+		local kind = atom.kind ---@type string
 		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)
+		local proj = project_atom(atom, src, corpus) ---@type EmissionProjection
-		for _, e in ipairs(proj.errors) do
+		for _, e in ipairs(proj.errors) do           ---@type integer, Finding
-			-- Preserve `kind` (cycle / count_mismatch / unbalanced) so readers dispatch on the diagnostic class and leave the message string as display text.
+			-- Finding.kind is severity. Finding.check holds the diagnostic code
+			-- (cycle / count_mismatch / unbalanced / reguse_*).
 			errors[#errors + 1] = {
-				kind   = e.kind,
+				kind        = "error",
-				line   = e.line,
+				check       = e.check,
-				msg    = e.msg,
+				line        = e.line,
-				source = e.source or src.path,
+				msg         = e.msg,
+				source      = e.source or src.path,
+				schema_name = e.schema_name,
 			}
 		end
-		for _, w in ipairs(proj.warnings) do
+		for _, w in ipairs(proj.warnings) do ---@type integer, Finding
 			warnings[#warnings + 1] = {
-				kind = w.kind,
+				kind  = "warning",
-				line = w.line,
+				check = w.check,
-				msg  = w.msg,
+				line  = w.line,
+				msg   = w.msg,
 			}
 		end
 	end
@@ -237,12 +346,12 @@ function M.run(ctx)
 	-- Walk `corpus.source_order`; within each source, visit atoms followed by raw_atoms.
 	-- 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
+	for _, src in ipairs(corpus.source_order) do ---@type integer, SourceFile
-		local scan = src.scan or {}
+		local scan = src.scan or {}                ---@type SourceScan
-		for _, atom in ipairs(scan.atoms or {}) do
+		for _, atom in ipairs(scan.atoms or {}) do ---@type integer, AtomEntry
 			process_atom(atom, src)
 		end
-		for _, atom in ipairs(scan.raw_atoms or {}) do
+		for _, atom in ipairs(scan.raw_atoms or {}) do ---@type integer, AtomEntry
 			process_atom(atom, src)
 		end
 	end

scripts/passes/offsets.lua

@@ -9,13 +9,6 @@
 --- 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).
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -27,41 +20,25 @@
 -- 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 "./"
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- Offset macro/enum naming prefixes (the emitted header uses these).
-local OFFSET_MACRO_PREFIX = "_atom_offset_"
+local OFFSET_MACRO_PREFIX = "_atom_offset_" ---@type string
-local OFFSET_ENUM_PREFIX  = "atom_offset_"
+local OFFSET_ENUM_PREFIX  = "atom_offset_"  ---@type string
 
 -- Column width for the `#define _atom_offset_F_T = N` alignment.
-local OFFSET_MACRO_COL = 44
+local OFFSET_MACRO_COL = 44 ---@type integer
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class SourceFile
+-- SourceFile, PassCtx, PassResult: see ps1_meta.lua
---- @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 -- Corpus projection
---- @field shared.word_counts table
---- @field out_root           string -- Output root (e.g. "build/gen")
-
---- @class PassResult
---- @field outputs  table[]  -- {kind=, path=} entries describing emit files
---- @field errors   table[]  -- {line=, msg=}  entries; build-stops
---- @field warnings table[]  -- {line=, msg=}  entries; build-succeeds
 
 --- @class BranchOffset
 --- @field tag               string      -- Marker tag (e.g. "F" in `atom_offset(F, T)`)
@@ -76,6 +53,32 @@ local OFFSET_MACRO_COL = 44
 --- @field total_words integer        -- Total word count of the atom body
 --- @field offsets     BranchOffset[] -- Per-branch offset list
 
+--- @class OffsetBranch
+--- @field tag               string
+--- @field target            string
+--- @field branch_word       integer
+--- @field consuming_encoder string|nil
+--- @field consuming_arg_pos integer|nil
+--- @field line              integer|nil
+
+--- @class MarkerProjectState
+--- @field labels   table<string, integer>  -- bag: label name -> word index
+--- @field branches OffsetBranch[]
+
+--- @class OffsetConst
+--- @field macro_name string
+--- @field enum_name  string
+--- @field value      integer
+
+--- @class OffsetOutput
+--- @field offsets_h string
+
+--- @class OffsetsPass
+--- @field run fun(ctx: PassCtx): PassResult
+
+--- @class AtomEntry
+--- @field paths AtomPaths|nil
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- Canonical marker projection
 -- ════════════════════════════════════════════════════════════════════════════
@@ -83,10 +86,16 @@ local OFFSET_MACRO_COL = 44
 -- MARKER_PROJECTORS is the marker-kind data table.
 -- 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 = {
+local MARKER_PROJECTORS = { ---@type table<string, fun(state: MarkerProjectState, marker: EmissionMarker): nil>
+	--- @param state MarkerProjectState
+	--- @param marker EmissionMarker
+	--- @return nil
 	label = function(state, marker)
 		state.labels[marker.name] = marker.word_index
 	end,
+	--- @param state MarkerProjectState
+	--- @param marker EmissionMarker
+	--- @return nil
 	offset = function(state, marker)
 		state.branches[#state.branches + 1] = {
 			tag                = marker.name,
@@ -100,12 +109,13 @@ local MARKER_PROJECTORS = {
 
 --- Project canonical marker records into the two lookup tables used by the offset renderer.
 --- No source text, body text, or body token is inspected.
---- @param markers table[] -- atom.paths.markers
+--- @param markers EmissionMarker[]
---- @return table<string, integer>, table[]
+--- @return table<string, integer>
+--- @return OffsetBranch[]
 local function project_markers(markers)
-	local state = { labels = {}, branches = {} }
+	local state = { labels = {}, branches = {} } ---@type MarkerProjectState
-	for _, marker in ipairs(markers or {}) do
+	for _, marker in ipairs(markers or {}) do    ---@type integer, EmissionMarker
-		local project = MARKER_PROJECTORS[marker.kind]
+		local project = MARKER_PROJECTORS[marker.kind] ---@type (fun(state: MarkerProjectState, marker: EmissionMarker): nil)|nil
 		if    project then project(state, marker) end
 	end
 	return state.labels, state.branches
@@ -124,32 +134,35 @@ end
 ---     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.
----
+---   missing `consuming_encoder` -> ERROR. A lone top-level `atom_offset` is not a branch.
---- 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[]
+--- @param branches OffsetBranch[]
---- @param errors   table[]
+--- @param errors   Finding[]
 --- @return BranchOffset[]
 local function compute_offsets(labels, branches, errors)
-	local results = {}
+	local results = {}               ---@type BranchOffset[]
-	for _, br in ipairs(branches) do
+	for _, br in ipairs(branches) do ---@type integer, OffsetBranch
-		local target = labels[br.target]
+		local target = labels[br.target] ---@type integer|nil
 		if not target then
 			errors[#errors + 1] = {
 				line = br.line or 0,
 				msg  = "Branch target '" .. br.target .. "' has no atom_label (at word " .. br.branch_word .. ")",
 			}
 		else
-			local consuming = br.consuming_encoder
+			local consuming = br.consuming_encoder ---@type string|nil
-			if consuming == "jump_reg" or consuming == "call_reg" or consuming == "jump_link" then
+			if consuming == nil or consuming == "" then
+				errors[#errors + 1] = {
+					line = br.line or 0,
+					msg  = "atom_offset requires a consuming encoder (branch_*, jump, call_addr); top-level atom_offset is invalid; at word " .. br.branch_word,
+				}
+			elseif consuming == "jump_reg" or consuming == "call_reg" or consuming == "jump_link" then
 				errors[#errors + 1] = {
 					line = br.line or 0,
 					msg  = "atom_offset cannot be used with " .. consuming
 						.. " (register-form jumps have no offset field); at word " .. br.branch_word,
 				}
 			else
-				-- All other consuming instructions (including `branch_*`, `jump`, `call_addr`, and nil for top-level markers) use the same relative offset value.
+				-- Consuming instructions with an offset field (`branch_*`, `jump`, `call_addr`) 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.
 				results[#results + 1] = {
 					target             = br.target,
@@ -175,7 +188,7 @@ end
 
 --- (internal) Build a constant-table entry `{macro_name, enum_name, value}` from a BranchOffset.
 --- @param bo BranchOffset
---- @return table
+--- @return OffsetConst
 local function make_offset_const(bo)
 	return {
 		macro_name = OFFSET_MACRO_PREFIX .. bo.tag .. "_" .. bo.target,
@@ -187,20 +200,21 @@ end
 --- (internal) Emit one atom's offset constants + enum into the lines buffer.
 --- @param add  fun(s: string)
 --- @param atom AtomData
+--- @return nil
 local function emit_atom_offsets(add, atom)
 	if #atom.offsets == 0 then return end
 	add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
 	add("")
-	local consts = {}
+	local consts = {}                   ---@type OffsetConst[]
-	for _, r in ipairs(atom.offsets) do
+	for _, r in ipairs(atom.offsets) do ---@type integer, BranchOffset
 		consts[#consts + 1] = make_offset_const(r)
 	end
-	for _, c in ipairs(consts) do
+	for _, c in ipairs(consts) do ---@type integer, OffsetConst
 		add("#define " .. pad_right(c.macro_name, OFFSET_MACRO_COL) .. "  " .. c.value)
 	end
 	add("")
 	add("enum {")
-	for _, c in ipairs(consts) do
+	for _, c in ipairs(consts) do ---@type integer, OffsetConst
 		add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
 	end
 	add("};")
@@ -208,19 +222,21 @@ local function emit_atom_offsets(add, atom)
 end
 
 --- Generate the per-directory .offsets.h header.
---- @param dir          string     -- the absolute source directory
+--- @param dir        string
---- @param sources      table[]    -- sources contributing to this directory (for the header comment)
+--- @param sources    SourceFile[]
---- @param atoms_data   AtomData[]
+--- @param atoms_data AtomData[]
 --- @return string
 local function generate_header(dir, sources, atoms_data)
-	local dir_basename = duffle.basename_no_ext(dir)
+	local dir_basename = duffle.basename_no_ext(dir) ---@type string
 
-	local lines = {}
+	local lines = {} ---@type string[]
+	--- @param s string
+	--- @return nil
 	local function add(s) lines[#lines + 1] = s end
 
 	add("// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT")
 	add("// Directory: " .. dir:gsub("/", "\\") .. "\\")
-	for _, src in ipairs(sources) do
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
 		add("//   source: " .. src.path:gsub("/", "\\"))
 	end
 	add("#pragma once")
@@ -228,7 +244,7 @@ local function generate_header(dir, sources, atoms_data)
 	add("#pragma region " .. dir_basename)
 	add("")
 	add("")
-	for _, atom in ipairs(atoms_data) do
+	for _, atom in ipairs(atoms_data) do ---@type integer, AtomData
 		emit_atom_offsets(add, atom)
 	end
 	add("#pragma endregion " .. dir_basename)
@@ -236,22 +252,24 @@ local function generate_header(dir, sources, atoms_data)
 	return table.concat(lines, "\n") .. "\n"
 end
 
-local M = {}
+local M = {} ---@type OffsetsPass
 
 --- (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 dir     string       -- the absolute source directory
+--- @param dir     string
---- @param sources SourceFile[] -- sources in this directory
+--- @param sources SourceFile[]
---- @param errors  table[]
+--- @param errors  Finding[]
---- @return string|nil  -- the offsets_h path
+--- @return string|nil
 local function process_directory(ctx, dir, sources, errors)
-	local atoms_data = {}
+	local atoms_data = {} ---@type AtomData[]
 
+	--- @param atom AtomEntry
+	--- @return nil
 	local function append_atom(atom)
-		local  paths = atom and atom.paths
+		local  paths = atom and atom.paths ---@type AtomPaths|nil
 		if not paths then return end
-		local labels, branches = project_markers(paths.markers)
+		local labels, branches = project_markers(paths.markers) ---@type table<string, integer>, OffsetBranch[]
 		atoms_data[#atoms_data + 1] = {
 			name        = atom.raw_name or atom.name,
 			total_words = #(paths.word_events or {}),
@@ -259,14 +277,14 @@ local function process_directory(ctx, dir, sources, errors)
 		}
 	end
 
-	for _, src in ipairs(sources) do
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
-		local scan = src.scan or {}
+		local scan = src.scan or {}                                          ---@type SourceScan
-		for _, atom in ipairs(scan.atoms or {}) do append_atom(atom) end
+		for _, atom in ipairs(scan.atoms or {}) do append_atom(atom) end     ---@type integer, AtomEntry
-		for _, atom in ipairs(scan.raw_atoms or {}) do append_atom(atom) end
+		for _, atom in ipairs(scan.raw_atoms or {}) do append_atom(atom) end ---@type integer, AtomEntry
 	end
 	if #atoms_data == 0 then return nil end
 
-	local out_path = dir .. "/gen/offsets.h"
+	local out_path = dir .. "/gen/offsets.h" ---@type string
 	duffle.ensure_dir(duffle.dirname(out_path))
 	duffle.write_file(out_path, generate_header(dir, sources, atoms_data))
 	return out_path
@@ -278,11 +296,11 @@ end
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
+	local outputs  = {} ---@type OffsetOutput[]
-	local errors   = {}
+	local errors   = {} ---@type Finding[]
-	local warnings = {}
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("offsets.run requires ctx.shared.corpus", 0)
 	end
@@ -291,9 +309,9 @@ function M.run(ctx)
 	end
 
 	-- 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)
+	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order) ---@type table<string, SourceFile[]>
-	for dir, sources in pairs(sources_by_dir) do
+	for dir, sources in pairs(sources_by_dir) do                                                     ---@type string, SourceFile[]
-		local out_path = process_directory(ctx, dir, sources, errors)
+		local out_path = process_directory(ctx, dir, sources, errors) ---@type string|nil
 		if out_path then
 			outputs[#outputs + 1] = { offsets_h = out_path }
 		end

scripts/passes/word_count_eval.lua

@@ -4,13 +4,13 @@
 ---   1. **Public utility** `M.count_token_words(token, wc)`: Used by `passes/offsets.lua`, `passes/annotation.lua`, and other passes.
 ---   2. **Pass entry** `M.run(ctx)`: Loads the authored `word_count.metadata.h` into `ctx.shared.corpus.word_counts` for downstream passes.
 ---      The generated `.macs.h` files are OUTPUT artifacts and are NOT inputs to this pass;
----      Current component counts are owned by `passes/components.lua` (which populates `corpus.word_counts` and `corpus.component_body_index`
+---      Current component counts are owned by `passes/components.lua` (which populates `corpus.word_counts` and `corpus.components`
 ---      AFTER computing each current count from the just-built body + `corpus.word_counts`).
 ---
 --- **Canonical contract**:
 ---   * `ctx.shared.corpus.word_counts` is the count table.
 ---   * `corpus.word_counts` is the sole count table. Consumers read `corpus.word_counts` directly.
----   * `ctx.shared.components` and `ctx.shared.component_body_index` are NOT created by this pass (projections only).
+---   * `ctx.shared.components` is NOT created by this pass (projections only).
 ---   * No `.macs.h` recursive discovery (no `scan_dir`, no scan cache, no `_invalidate_scan_cache`).
 ---
 --- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
@@ -23,44 +23,28 @@
 -- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
 -- Uses `debug.getinfo` to find this file's own directory, so it works both standalone and when require'd from the orchestrator.
 -- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class WordCounts
---- @field [string] integer  -- macro name -> word count
+--- @field [string] integer  -- bag: macro name -> word count
 
---- @class SourceFile
+--- @class WordCountEval
---- @field path     string  -- absolute path to the source file
+--- @field count_token_words fun(token: string, wc: WordCounts): integer
---- @field text     string  -- the full source text
+--- @field run               fun(ctx: PassCtx): PassResult
---- @field dir      string  -- the directory containing the source
---- @field basename string  -- filename without extension
 
---- @class PassCtx
+-- SourceFile, PassCtx, PassResult: see ps1_meta.lua
---- @field sources            SourceFile[]  -- all source files in the build
+-- DuffleExport: see duffle.lua (facade returned by duffle_paths.lua)
---- @field metadata_path      string        -- path to word_count.metadata.h
---- @field shared             table         -- cross-pass shared state
---- @field shared.corpus      table         -- canonical corpus (required)
---- @field shared.corpus.word_counts WordCounts -- canonical count table (populated by this pass)
---- @field out_root           string        -- output root (e.g. "build/gen")
---- @field project_root       string        -- project root (e.g. "code/")
---- @field upstream           table<string, table>  -- per-pass upstream outputs
---- @field flags              table         -- CLI flags
---- @field verbose            boolean       -- if true, log diagnostic info
-
---- @class PassResult
---- @field outputs  table[]  -- {kind=, path=} entries describing emit files
---- @field errors   table[]  -- {line=, msg=} entries; build-stops
---- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module exports
 -- ════════════════════════════════════════════════════════════════════════════
 
-local M = {}
+local M = {} ---@type WordCountEval
 
 -- ┌────────────────────────────────────────────────────────────────────┐
 -- │ Shared utility: count_token_words                                  │
@@ -74,12 +58,12 @@ local M = {}
 --- @param wc    WordCounts -- the shared word-count table
 --- @return integer
 function M.count_token_words(token, wc)
-	local s = duffle.trim(token)
+	local s = duffle.trim(token) ---@type string
 	if    s == "" then return 0 end
-	local name, after = duffle.read_ident(s, 1)
+	local name, after = duffle.read_ident(s, 1) ---@type string|nil, integer
 	if not name then return 1 end
 	if wc[name] then return wc[name] end
-	local paren_pos = duffle.skip_ws_and_cmt(s, after)
+	local paren_pos = duffle.skip_ws_and_cmt(s, after) ---@type integer
 	if s:sub(paren_pos, paren_pos) == "(" then
 		io.stderr:write("  warning: unknown macro '" .. name .. "', assuming 1 word\n")
 	end
@@ -105,7 +89,7 @@ end
 --- @return PassResult
 function M.run(ctx)
 	-- 1. Canonical-corpus ownership gate.
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("word_count_eval.run requires ctx.shared.corpus (canonical corpus). The fixture must install the corpus before running this pass.", 0)
 	end
@@ -117,7 +101,7 @@ function M.run(ctx)
 
 	-- 3. Load authored metadata. Generated .macs.h files are NOT scanned
 	--    (the pass computes their counts from the just-built bodies after disk emission; see passes/components.lua).
-	local wc = duffle.load_word_counts(ctx.metadata_path)
+	local wc = duffle.load_word_counts(ctx.metadata_path) ---@type WordCounts
 
 	-- 4. Assign the count table. ONE assignment, no copy. The assignment creates no secondary alias.
 	corpus.word_counts = wc

scripts/ps1_meta.lua

@@ -19,8 +19,8 @@
 -- 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
+local _is_entry_script = arg and arg[0] and arg[0]:match("ps1_meta%.lua$") ~= nil ---@type boolean
-local _bootstrap_src
+local _bootstrap_src                                                              ---@type string
 if _is_entry_script then
 	_bootstrap_src = arg[0]
 else
@@ -28,26 +28,26 @@ else
 	-- strip the leading "@" so the directory match works in both cases.
 	_bootstrap_src = debug.getinfo(1, "S").source:sub(2)
 end
-local duffle = dofile((_bootstrap_src:match("(.*[/\\])") or "./") .. "duffle_paths.lua")
+local duffle = dofile((_bootstrap_src:match("(.*[/\\])") or "./") .. "duffle_paths.lua") ---@type DuffleExport
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- Exit codes (per the --help text and the post-build summary convention).
-local EXIT_OK                  = 0
+local EXIT_OK                  = 0 ---@type integer
-local EXIT_VALIDATION_ERRORS   = 1
+local EXIT_VALIDATION_ERRORS   = 1 ---@type integer
-local EXIT_INTERNAL_ERROR      = 2
+local EXIT_INTERNAL_ERROR      = 2 ---@type integer
 
 -- Default --out-root value if not provided.
-local DEFAULT_OUT_ROOT         = "build/gen"
+local DEFAULT_OUT_ROOT         = "build/gen" ---@type string
 
 -- Sentinel for "all passes" in `PASS_FLAG_TO_NAME`. Distinguishes `--all` from the per-pass flags (which map to individual pass names).
-local ALL_PASSES_SENTINEL      = "__all__"
+local ALL_PASSES_SENTINEL      = "__all__" ---@type string
 
 -- Sentinel key for the pass-flag dispatcher in `FLAG_HANDLERS`. 
 -- The actual pass names are looked up via `PASS_FLAG_TO_NAME`, not direct dispatch, so this key never matches a real flag.
-local PASS_FLAG_DISPATCH_KEY   = "__pass__"
+local PASS_FLAG_DISPATCH_KEY   = "__pass__" ---@type string
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
@@ -60,38 +60,119 @@ local PASS_FLAG_DISPATCH_KEY   = "__pass__"
 --- @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
+--- @class Corpus
---- @field path     string  -- Absolute path to the source file
+--- @field unity_root              string|nil
---- @field text     string  -- Full source text
+--- @field project_root            string
---- @field dir      string  -- Directory containing the source
+--- @field code_root               string
---- @field basename string  -- Filename without extension
+--- @field source_order            SourceFile[]
+--- @field sources_by_path         table<Path, SourceFile>
+--- @field sources_by_dir          table<string, SourceFile[]>
+--- @field atoms_by_name           table<AtomName, AtomEntry>
+--- @field binds_by_name           table<string, BindsEntry>
+--- @field atom_infos              AtomInfoEntry[]
+--- @field register_alias_registry table<string, AliasEntry>
+--- @field type_name_registry      table<string, TypeNameEntry>
+--- @field atom_views              table<AtomName, AtomViewEntry>
+--- @field atom_ctxs               table<AtomName, AtomCtxEntry>
+--- @field atom_phases             table<string, AtomPhaseGroup>
+--- @field word_counts             WordCounts
+--- @field components              table<string, Component>
+--- @field atom_bundles            table<string, AtomBundle>|nil
+--- @field tape_emits              TapeEmit[]|nil
+--- @field collisions              CorpusCollision[]
+--- @field resolver                SourceResolver
+--- @field component_atom_infos    AtomInfoEntry[]|nil
+--- @field atom_auto_regs          table<AtomName, table<string, string>>|nil
+--- @field phase_auto_regs         table<string, table<string, string>>|nil
+--- @field reg_use_schemas         table<string, RegUseSchema>|nil
+--- @field reg_use_errors          RegUseError[]|nil
+--- @field static_analysis_results table<string, AtomAnalysis>|nil
+--- @field tape_chains             table<string, TapeChain>|nil
+
+--- @class PassShared
+--- @field corpus Corpus
+
+--- @class PassFlags
+--- @field gdb_runtime     boolean|nil
+--- @field dwarf_injection boolean|nil
+--- @field elf_path        string|nil
 
 --- @class PassCtx
---- @field metadata_path      string                 -- Path to word_count.metadata.h
+--- @field metadata_path string                 -- Path to word_count.metadata.h
---- @field shared             table                  -- Cross-pass shared state
+--- @field shared        PassShared             -- Cross-pass shared state
---- @field shared.corpus      table                  -- Authored-source/project projection
+--- @field out_root      string                 -- Output root (e.g. "build/gen")
---- @field out_root           string                 -- Output root (e.g. "build/gen")
+--- @field project_root  string                 -- PS1 repository root
---- @field project_root       string                 -- PS1 repository root
+--- @field flags         PassFlags              -- CLI flags + per-pass stash
---- @field flags              table                  -- CLI flags + per-pass stash
+--- @field verbose       boolean                -- If true, log diagnostic info
---- @field verbose            boolean                -- If true, log diagnostic info
 
+--- CheckName: see static_analysis.lua. AtomName: see duffle.lua.
 --- @class Finding
---- @field line integer  -- Source line (or 0 for pass-level)
+--- @field line         integer
---- @field msg  string   -- Finding message
+--- @field msg          string
+--- @field kind         string|nil     -- error | warning | info
+--- @field atom         AtomName|nil
+--- @field check        CheckName|nil
+--- @field source       string|nil     -- optional; emit/reguse path
+--- @field schema_name  string|nil     -- optional; emit/reguse
+
+--- @class PassScratch
+--- @field corpus                   Corpus|nil
+--- @field info_by_atom             table<string, AtomInfoEntry>|nil
+--- @field binds_index              table<string, BindsEntry>|nil
+--- @field atom_index               table<string, AtomEntry>|nil
+--- @field annot_counts             table<string, integer>|nil  -- bag
+--- @field types                    table<string, RegTypeDefault>|nil
+--- @field atom_views               table<string, AtomViewEntry>|nil
+--- @field seen_defaults            table<string, integer>|nil  -- bag
+--- @field seen_field               table<string, integer>|nil  -- bag
+--- @field _scan                    SourceScan|nil
+--- @field word_counts              WordCounts|nil
+--- @field register_alias_registry  table<string, AliasEntry>|nil
+--- @field type_name_registry       table<string, TypeNameEntry>|nil
+--- @field type_occurrences         RegTypeOccurrence[]|nil
+--- @field atom_infos_list          AtomInfoEntry[]|nil
+--- @field binds_list               BindsEntry[]|nil
+--- @field unknown_seen             table<string, integer>|nil  -- bag
+--- @field atoms                    AtomEntry[]|nil
+--- @field components_by_name       table<string, Component>|nil
+--- @field atoms_by_name            table<string, AtomEntry>|nil
+--- @field tape_chains              table<string, string[]>|nil
+--- @field source_order             SourceFile[]|nil
+--- @field component_atom_infos     AtomInfoEntry[]|nil
+--- @field atom_infos_all           AtomInfoEntry[]|nil
+--- @field gte_cr_alias_groups      GteCrAliasGroup[]|nil
+--- @field line_for_word_event      (fun(ev: WordEvent): integer)|nil
+
+--- @class PassOutputEntry
+--- @field kind string
+--- @field path string
 
 --- @class PassResult
---- @field outputs  PassOutputEntry[] -- Emitted file paths
+--- @field outputs  PassOutputEntry[]
 --- @field errors   Finding[]         -- Build-stops (per-pass kind policy)
 --- @field warnings Finding[]         -- Informational
+--- @field info     Finding[]|nil     -- static_analysis only
 
 --- @class ParsedArgs
---- @field requested_set string[]   -- Pass names to run (explicit --all expanded)
+--- @field requested_set string[]       -- Pass names to run (explicit --all expanded)
---- @field sources       string[]   -- Exact --source values, retained in CLI order
+--- @field sources       string[]       -- Exact --source values, retained in CLI order
---- @field unity_root    string|nil -- --unity-root value; mutually exclusive with sources
+--- @field unity_root    string|nil     -- --unity-root value; mutually exclusive with sources
---- @field metadata      string     -- --metadata value
+--- @field metadata      string         -- --metadata value
---- @field out_root      string     -- --out-root value (default "build/gen")
+--- @field out_root      string         -- --out-root value (default "build/gen")
---- @field project_root  string     -- PS1 repository root (derived from metadata by default)
+--- @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
+--- @field flags         PassFlags|nil  -- Per-pass stash; copied onto PassCtx.flags
+
+--- @alias FlagHandler fun(args: ParsedArgs, argv: string[]|nil, arg_idx: integer|nil): integer|nil
+
+--- @class PassModule
+--- @field run fun(ctx: PassCtx): PassResult
+
+--- @class Ps1MetaMod
+--- @field PASSES                  table<string, PassDescriptor>
+--- @field PASS_KIND_STOP_ON_ERROR table<string, boolean>
+--- @field parse_args              fun(argv: string[]): ParsedArgs
+--- @field build_ctx               fun(args: ParsedArgs): PassCtx
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- PASSES Table
@@ -104,7 +185,7 @@ local PASS_FLAG_DISPATCH_KEY   = "__pass__"
 -- A row without a `groups` entry is dependency-only: it runs only when a transitive dep requests it, 
 -- but it remains directly requestable through its explicit CLI flag (e.g. --atoms-source-map, --scan-source).
 
-local PASSES = {
+local PASSES = { ---@type table<string, PassDescriptor>
 	["scan-source"] = {
 		module = "passes.scan_source",
 		kind   = "shared", deps = {},
@@ -174,10 +255,10 @@ local PASSES = {
 --- @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 = {}
+	local names = {}                   ---@type string[]
-	for name, pass in pairs(PASSES) do
+	for name, pass in pairs(PASSES) do ---@type string, PassDescriptor
 		if pass.groups then
-			for _, g in ipairs(pass.groups) do
+			for _, g in ipairs(pass.groups) do ---@type integer, string
 				if g == group_name then
 					names[#names + 1] = name
 					break
@@ -192,15 +273,16 @@ end
 --- Append every root belonging to `group_name` to `args.requested_set`.
 --- Errors loudly if no PASSES row declares the group, so a typo'd or future-removed group name
 --- cannot silently fall through to pre-link (or any other default) and dispatch nothing.
---- @param args ParsedArgs
+--- @param args       ParsedArgs
 --- @param group_name string
+--- @return nil
 local function request_roots_for_group(args, group_name)
-	local roots = roots_for_group(group_name)
+	local roots = roots_for_group(group_name) ---@type string[]
 	if #roots == 0 then
 		error(string.format("ps1_meta: build-phase group %q has zero roots in PASSES; check PASSES rows for a `groups = { %q }` field"
 			, group_name, group_name))
 	end
-	for _, name in ipairs(roots) do
+	for _, name in ipairs(roots) do ---@type integer, string
 		args.requested_set[#args.requested_set + 1] = name
 	end
 end
@@ -208,7 +290,7 @@ end
 -- Pass-kind taxonomy: findings always print. No pass kind stops the build.
 -- Report severity is independent from process exit policy.
 -- 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 = {
+local PASS_KIND_STOP_ON_ERROR = { ---@type table<string, boolean>  -- bag: pass kind -> stop-on-error
 	["shared"]        = false,
 	["header-output"] = false,
 	["validation"]    = false,
@@ -220,7 +302,7 @@ local PASS_KIND_STOP_ON_ERROR = {
 -- 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 = {
+local PASS_FLAG_TO_NAME = { ---@type table<string, string>  -- bag: CLI flag -> pass name or ALL_PASSES_SENTINEL
 	["--word-counts"]       = "word-counts",
 	["--components"]        = "components",
 	["--validate"]          = "annotation",
@@ -235,24 +317,26 @@ local PASS_FLAG_TO_NAME = {
 --- Append every pass name to args.requested_set.
 --- Names are derived from PASSES (no parallel name list); used by --all and by any caller that wants the full closure.
 --- @param args ParsedArgs
+--- @return nil
 local function request_all_passes(args)
-	local names = {}
+	local names = {}                                          ---@type string[]
-	for name in pairs(PASSES) do names[#names + 1] = name end
+	for name in pairs(PASSES) do names[#names + 1] = name end ---@type string
 	table.sort(names)
-	for _, n in ipairs(names) do
+	for _, n in ipairs(names) do ---@type integer, string
 		args.requested_set[#args.requested_set + 1] = n
 	end
 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 = {}
+local FLAG_HANDLERS = {} ---@type table<string, FlagHandler>
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- CLI parsing
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- Print the CLI usage to stdout and exit 0.
+--- @return nil
 local function print_help()
 	io.write([[
 ps1_meta.lua - Tape-atom metaprogram orchestrator
@@ -291,8 +375,7 @@ COMMON_FLAGS:
   --help                Show this help and exit
 
 EXIT CODES:
-  0  All requested passes succeeded
+  0  Ran. Findings print on stderr and in the report; they do not fail the process.
-  1  Validation errors found
   2  Metaprogram internal error
 
 EXAMPLES:
@@ -302,7 +385,7 @@ EXAMPLES:
 ]])
 end
 
-local FLAG_VALUE_NAMES = {
+local FLAG_VALUE_NAMES = { ---@type table<string, string>  -- bag: flag -> value metavar
 	["--source"]       = "FILE",
 	["--unity-root"]   = "FILE",
 	["--metadata"]     = "PATH",
@@ -311,9 +394,14 @@ local FLAG_VALUE_NAMES = {
 	["--elf"]          = "PATH",
 }
 
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @param flag    string
+--- @return string
+--- @return integer
 local function require_flag_value(argv, arg_idx, flag)
-	local value      = argv[arg_idx + 1]
+	local value      = argv[arg_idx + 1]       ---@type string|nil
-	local next_known = type(value) == "string"
+	local next_known = type(value) == "string" ---@type boolean
 		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")
@@ -327,49 +415,81 @@ end
 -- 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). 
 
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--help"]    = function(args) print_help(); os.exit(0) end
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--verbose"] = function(args) args.verbose = true      end
 
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--source"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--source")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--source") ---@type string, integer
 	args.sources[#args.sources + 1] = value
 	return value_idx
 end
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--unity-root"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--unity-root")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--unity-root") ---@type string, integer
 	args.unity_root = value
 	return value_idx
 end
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--metadata"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--metadata")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--metadata") ---@type string, integer
 	args.metadata = value
 	return value_idx
 end
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--out-root"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--out-root")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--out-root") ---@type string, integer
 	args.out_root = value
 	return value_idx
 end
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--project-root"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--project-root")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--project-root") ---@type string, integer
 	args.project_root = value
 	return value_idx
 end
 
 -- Per-pass stash flags. Read by `passes/atoms_source_map.lua` to opt into the post-link gdb-runtime emission.
 -- Same shape as the existing per-flag handlers. mutates `args.flags` (which propagates into `ctx.flags`).
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--gdb-runtime"] = function(args)
 	args.flags = args.flags or {}
 	args.flags.gdb_runtime = true
 end
+--- @param args    ParsedArgs
+--- @param argv    string[]
+--- @param arg_idx integer
+--- @return integer
 FLAG_HANDLERS["--elf"] = function(args, argv, arg_idx)
-	local value, value_idx = require_flag_value(argv, arg_idx, "--elf")
+	local value, value_idx = require_flag_value(argv, arg_idx, "--elf") ---@type string, integer
 	args.flags = args.flags or {}
 	args.flags.elf_path = value
 	return value_idx
 end
 -- Enable DWARF injection (default OFF). Opts in to the post-link pass and sets the flag in one shot.
 -- The explicit handler below owns both selection and opt-in state, so --dwarf-injection is intentionally absent from PASS_FLAG_TO_NAME.
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--dwarf-injection"] = function(args)
 	args.flags                 = args.flags or {}
 	args.flags.dwarf_injection = true
@@ -377,12 +497,16 @@ FLAG_HANDLERS["--dwarf-injection"] = function(args)
 end
 -- Build-phase flags: --pre-link and --post-link request the roots of their declared groups (see roots_for_group).
 -- topo_sort closes transitive deps from those roots; dispatch_passes runs every pass in the resolved closure without phase-filtering.
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--pre-link"] = function(args)
 	request_roots_for_group(args, "pre-link")
 end
 -- Batch post-link phase: gdb-runtime + dwarf-injection in one luajit cold start.
 -- Sets the same opt-in flags as --gdb-runtime + --dwarf-injection and selects the post-link build-phase group.
 -- elf is required; parse_args enforces it after all flags are parsed.
+--- @param args ParsedArgs
+--- @return nil
 FLAG_HANDLERS["--post-link"]      = function(args)
 	args.flags = args.flags or {}
 	args.flags.gdb_runtime     = true
@@ -393,8 +517,11 @@ end
 -- `--dwarf-injection` also emits atom-local debug data.
 
 -- Pass-flag handler. Reads the closed-set table, expands --all, appends to requested_set.
+--- @param args ParsedArgs
+--- @param a    string
+--- @return nil
 FLAG_HANDLERS[PASS_FLAG_DISPATCH_KEY] = function(args, a)
-	local name = PASS_FLAG_TO_NAME[a]
+	local name = PASS_FLAG_TO_NAME[a] ---@type string|nil
 	if name == ALL_PASSES_SENTINEL then
 		request_all_passes(args)
 		return
@@ -406,7 +533,7 @@ end
 --- @param argv string[]
 --- @return ParsedArgs
 local function parse_args(argv)
-	local args = {
+	local args = { ---@type ParsedArgs
 		requested_set = {},
 		sources       = {},
 		unity_root    = nil,
@@ -416,10 +543,10 @@ local function parse_args(argv)
 		verbose       = false,
 	}
 
-	local pos = 1
+	local pos = 1 ---@type integer
 	while pos <= #argv do
-		local a       = argv[pos]
+		local a       = argv[pos]        ---@type string
-		local handler = FLAG_HANDLERS[a]
+		local handler = FLAG_HANDLERS[a] ---@type FlagHandler|nil
 		if handler then
 			pos = handler(args, argv, pos) or pos
 		elseif PASS_FLAG_TO_NAME[a] then
@@ -444,14 +571,14 @@ local function parse_args(argv)
 	-- `<repo>/code/duffle/word_count.metadata.h` is the canonical metadata location. 
 	-- `project_root` names `<repo>`; the resolver derives `<project_root>/code` separately.
 	if not args.project_root then
-		local metadata_dir = duffle.dirname(duffle.normalize_path(args.metadata))
+		local metadata_dir = duffle.dirname(duffle.normalize_path(args.metadata)) ---@type string
-		local code_root    = duffle.dirname(metadata_dir)
+		local code_root    = duffle.dirname(metadata_dir)                         ---@type string
 		args.project_root  = duffle.dirname(code_root)
 	else
 		args.project_root = duffle.normalize_path(args.project_root)
 	end
 
-	local has_unity = type(args.unity_root) == "string" and args.unity_root ~= ""
+	local has_unity = type(args.unity_root) == "string" and args.unity_root ~= "" ---@type boolean
 	if has_unity and #args.sources > 0 then
 		io.stderr:write("ps1_meta: --unity-root FILE and --source FILE are mutually exclusive\n")
 		os.exit(EXIT_INTERNAL_ERROR)
@@ -464,10 +591,10 @@ local function parse_args(argv)
 	-- Post-link opt-ins (--gdb-runtime, --dwarf-injection) write output that depends on the linked ELF.
 	-- Without --elf the metaprogram can't satisfy those requests, so refuse loud and early.
 	-- This covers the explicit --post-link batch, --dwarf-injection by itself, and --gdb-runtime by itself.
-	local flags      = args.flags or {}
+	local flags      = args.flags or {}                             ---@type PassFlags
-	local elf_path   = flags.elf_path
+	local elf_path   = flags.elf_path                               ---@type string|nil
-	local has_elf    = type(elf_path) == "string" and #elf_path > 0
+	local has_elf    = type(elf_path) == "string" and #elf_path > 0 ---@type boolean
-	local post_links = flags.gdb_runtime or flags.dwarf_injection
+	local post_links = flags.gdb_runtime or flags.dwarf_injection   ---@type boolean
 	if post_links and not has_elf then
 		io.stderr:write("ps1_meta: --elf PATH is required for post-link output\n")
 		os.exit(EXIT_INTERNAL_ERROR)
@@ -486,9 +613,9 @@ end
 --- @param args ParsedArgs
 --- @return PassCtx
 local function build_ctx(args)
-	local normalized_project_root  = duffle.normalize_path(args.project_root)
+	local normalized_project_root  = duffle.normalize_path(args.project_root) ---@type string
-	local project_root             = normalized_project_root
+	local project_root             = normalized_project_root                  ---@type string
-	local project_root_is_absolute = normalized_project_root:match("^%a:/")
+	local project_root_is_absolute = normalized_project_root:match("^%a:/")   ---@type boolean
 		or normalized_project_root:sub(1, 2) == "//"
 		or normalized_project_root:sub(1, 1) == "/"
 	if not project_root_is_absolute then
@@ -499,9 +626,9 @@ local function build_ctx(args)
 		-- Do not route POSIX/UNC/drive-absolute paths through to_absolute_path.
 		duffle.canonical_path_key(project_root)
 	end
-	local resolution
+	local resolution ---@type Corpus
 	if args.unity_root then
-		local ok_resolve, resolved = pcall(duffle.resolve_source_corpus, {
+		local ok_resolve, resolved = pcall(duffle.resolve_source_corpus, { ---@type boolean, Corpus|string
 			unity_root   = args.unity_root,
 			project_root = project_root,
 		})
@@ -511,59 +638,18 @@ local function build_ctx(args)
 		end
 		resolution = resolved
 	else
-		local source_order    = {}
+		local ok_exact, exact = pcall(duffle.resolve_exact_sources, { ---@type boolean, Corpus|string
-		local sources_by_path = {}
+			sources      = args.sources,
-		local resolver = {
+			project_root = project_root,
-			resolved = {},
+		})
-			skipped  = {},
+		if not ok_exact then
-			shadowed = {},
+			io.stderr:write("ps1_meta: cannot resolve --source: " .. tostring(exact) .. "\n")
-		}
+			os.exit(EXIT_INTERNAL_ERROR)
-		for _, input_path in ipairs(args.sources) do
-			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)
-			end
-			local file = io.open(path, "r")
-			if not file then
-				io.stderr:write("ps1_meta: cannot open --source " .. input_path .. "\n")
-				os.exit(EXIT_INTERNAL_ERROR)
-			end
-			local text = file:read("*a")
-			file:close()
-
-			local source = {
-				path     = path,
-				text     = text,
-				dir      = duffle.dirname(path),
-				basename = duffle.basename_no_ext(path),
-			}
-			source_order[#source_order + 1] = source
-			local key = key_or_error
-			if not sources_by_path[key] then sources_by_path[key] = source end
-			resolver.resolved[#resolver.resolved + 1] = {
-				include_path  = path,
-				include_text  = nil,
-				root_source   = nil,
-				root_line     = nil,
-				candidate_a   = path,
-				candidate_b   = nil,
-				selected_path = path,
-				disposition   = "exact",
-			}
 		end
-		resolution = {
+		resolution = exact
-			unity_root      = nil,
-			project_root    = project_root,
-			code_root       = duffle.normalize_path(project_root .. "/code"),
-			source_order    = source_order,
-			sources_by_path = sources_by_path,
-			sources_by_dir  = duffle.group_sources_by_dir(source_order),
-			resolver        = resolver,
-		}
 	end
 
-	local corpus = {
+	local corpus = { ---@type Corpus
 		unity_root              = resolution.unity_root,
 		project_root            = resolution.project_root,
 		code_root               = resolution.code_root,
@@ -580,11 +666,12 @@ local function build_ctx(args)
 		atom_phases             = {},
 		word_counts             = {},
 		components              = {},
-		component_body_index    = {},
+		atom_bundles            = {},
+		tape_emits              = {},
 		collisions              = {},
 		resolver                = resolution.resolver,
 	}
-	local ctx = {
+	local ctx = { ---@type PassCtx
 		metadata_path = args.metadata,
 		shared        = { corpus = corpus },
 		out_root      = args.out_root,
@@ -613,15 +700,15 @@ end
 --- Keeping these blocks local makes the topological sort self-contained.
 local function topo_sort(passes, requested_set)
 	-- Dependency closure: include every pass transitively required by `requested_set`.
-	local needed = {}
+	local needed = {}                                               ---@type table<string, boolean>  -- bag: pass name -> needed
-	for _, name in ipairs(requested_set) do needed[name] = true end
+	for _, name in ipairs(requested_set) do needed[name] = true end ---@type integer, string
-	local changed = true
+	local changed = true                                            ---@type boolean
 	while changed do
 		changed = false
-		for name, _ in pairs(needed) do
+		for name, _ in pairs(needed) do ---@type string, boolean
-			local pass = passes[name]
+			local pass = passes[name] ---@type PassDescriptor
 			if not pass then error("unknown pass '" .. name .. "' requested") end
-			for _, dep in ipairs(pass.deps) do
+			for _, dep in ipairs(pass.deps) do ---@type integer, string
 				if not needed[dep] then
 					needed[dep] = true
 					changed = true
@@ -631,10 +718,10 @@ local function topo_sort(passes, requested_set)
 	end
 
 	-- In-degree calculation: count each needed pass's needed dependencies.
-	local in_degree = {}
+	local in_degree = {}                                    ---@type table<string, integer>  -- bag: pass name -> in-degree
-	for name, _ in pairs(needed) do in_degree[name] = 0 end
+	for name, _ in pairs(needed) do in_degree[name] = 0 end ---@type string, boolean
-	for name, _ in pairs(needed) do
+	for name, _ in pairs(needed) do                         ---@type string, boolean
-		for _, dep in ipairs(passes[name].deps) do
+		for _, dep in ipairs(passes[name].deps) do ---@type integer, string
 			if needed[dep] then
 				in_degree[name] = in_degree[name] + 1
 			end
@@ -642,21 +729,21 @@ local function topo_sort(passes, requested_set)
 	end
 
 	-- Ready-queue seeding: add zero-in-degree passes in deterministic order.
-	local ready = {}
+	local ready = {}                     ---@type string[]
-	for name, deg in pairs(in_degree) do
+	for name, deg in pairs(in_degree) do ---@type string, integer
 		if deg == 0 then ready[#ready + 1] = name end
 	end
 	table.sort(ready)
 
 	-- Ready-queue drain: decrement dependents when each pass is emitted.
 	-- Newly-zero-degree passes are inserted back into the ready queue (kept sorted).
-	local order = {}
+	local order = {} ---@type string[]
 	while #ready > 0 do
-		local just_finished = table.remove(ready, 1)
+		local just_finished = table.remove(ready, 1) ---@type string
 		order[#order + 1] = just_finished
-		for name, _ in pairs(needed) do
+		for name, _ in pairs(needed) do ---@type string, boolean
 			if name ~= just_finished then
-				for _, dep in ipairs(passes[name].deps) do
+				for _, dep in ipairs(passes[name].deps) do ---@type integer, string
 					if dep == just_finished then
 						in_degree[name] = in_degree[name] - 1
 						if in_degree[name] == 0 then
@@ -672,10 +759,10 @@ local function topo_sort(passes, requested_set)
 	-- Cycle detection: if `order` doesn't include all needed passes, some are stuck with in_degree > 0
 	-- (the cycle closed on itself before Kahn could process them).
 	-- Without this check, a fully-closed cycle (e.g. A -> B -> A) would silently return an empty order list, leaving the orchestrator to dispatch nothing.
-	local needed_count = 0
+	local needed_count = 0                                        ---@type integer
-	for _ in pairs(needed) do needed_count = needed_count + 1 end  -- count hash entries; Lua's #t doesn't work
+	for _ in pairs(needed) do needed_count = needed_count + 1 end ---@type string -- count hash entries; Lua's #t doesn't work
 	if #order ~= needed_count then
-		for name, deg in pairs(in_degree) do
+		for name, deg in pairs(in_degree) do ---@type string, integer
 			if deg > 0 then
 				error("dependency cycle detected involving pass '" .. name .. "'")
 			end
@@ -696,9 +783,9 @@ end
 --- @param result    PassResult
 --- @return boolean
 local function report_validation_errors(pass_name, pass, result)
-	local has_errors = result.errors and #result.errors > 0
+	local has_errors = result.errors and #result.errors > 0 ---@type boolean
 	if not has_errors then return false end
-	for _, e in ipairs(result.errors) do
+	for _, e in ipairs(result.errors) do ---@type integer, Finding
 		io.stderr:write(string.format("[%s] line %d: %s\n", pass_name, e.line or 0, e.msg or ""))
 	end
 	return PASS_KIND_STOP_ON_ERROR[pass.kind] == true
@@ -709,11 +796,11 @@ end
 --- @param order string[]
 --- @return boolean  -- true if any validation errors were reported
 local function dispatch_passes(ctx, order)
-	local had_errors = false
+	local had_errors = false             ---@type boolean
-	for _, pass_name in ipairs(order) do
+	for _, pass_name in ipairs(order) do ---@type integer, string
-		local pass   = PASSES[pass_name]
+		local pass   = PASSES[pass_name]    ---@type PassDescriptor
-		local mod    = require(pass.module)
+		local mod    = require(pass.module) ---@type PassModule
-		local result = mod.run(ctx)
+		local result = mod.run(ctx)         ---@type PassResult
 		if report_validation_errors(pass_name, pass, result) then
 			had_errors = true
 		end
@@ -723,16 +810,16 @@ end
 
 --- Main entry point. Runs the requested passes in dep-topological order.
 --- @param argv string[]
+--- @return nil
 local function main(argv)
-	local ok, err = pcall(function()
+	local ok, err = pcall(function() ---@type boolean, string|nil
-		local args = parse_args(argv)
+		local args = parse_args(argv) ---@type ParsedArgs
-		local ctx  = build_ctx(args)
+		local ctx  = build_ctx(args)  ---@type PassCtx
+		
+		local requested = args.requested_set           ---@type string[]
+		local closed    = topo_sort(PASSES, requested) ---@type string[]
 
-		local requested = args.requested_set
+		dispatch_passes(ctx, closed)
-		local closed    = topo_sort(PASSES, requested)
-
-		local had_errors = dispatch_passes(ctx, closed)
-		if had_errors then os.exit(EXIT_VALIDATION_ERRORS) end
 	end)
 
 	if not ok then
@@ -746,7 +833,7 @@ end
 -- Module export for in-process consumers (tests that dofile this script).
 -- The conditional `main(...)` call below only fires when this file is invoked as the entry script (arg[0] ends in "ps1_meta.lua");
 -- in dofile() mode (test's arg[0] does not match), main() is skipped and the chunk returns `_M` to the caller.
-local _M = {
+local _M = { ---@type Ps1MetaMod
 	PASSES                   = PASSES,
 	PASS_KIND_STOP_ON_ERROR  = PASS_KIND_STOP_ON_ERROR,
 	parse_args               = parse_args,