eliminated most lag (runs in ms)

script running is slow need to fix.

.gitignore

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

code/duffle/gen/duffle.macs.h

@@ -1,7 +1,7 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #pragma once
 #endif
-// Auto-generated by tape_atom_annotation_pass.lua — DO NOT EDIT
+// Auto-generated by ps1_meta.lua — DO NOT EDIT
 // Source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
 // Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
 
@@ -50,14 +50,14 @@ WORD_COUNT(mac_gte_load_tri_verts, 18)
 #define mac_insert_ot_tag_f3(...) \
 	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
 ,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
-,	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* AT = old_ot_head */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
-,	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits) /* V0 = (5 - 1) << 24 = 4 << 24 */ \
+,	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (5 - 1) << 24 = 4 << 24 */ \
-,	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
 ,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
-,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)) /* prim->tag = packed(prim_length, old_addr) */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
-,	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
-,	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)) \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* OrderingTable[OTZ] = PrimCursor */
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
 WORD_COUNT(mac_insert_ot_tag_f3, 11)
 
 /* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
@@ -65,18 +65,18 @@ WORD_COUNT(mac_insert_ot_tag_f3, 11)
 #define mac_insert_ot_tag_g4(...) \
 	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
 ,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
-,	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* AT = old_ot_head */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
-,	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits) /* V0 = (9 - 1) << 24 = 8 << 24 */ \
+,	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (9 - 1) << 24 = 8 << 24 */ \
-,	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
 ,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
-,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)) /* prim->tag = packed(prim_length, old_addr) */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
-,	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
-,	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)) \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
-,	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)) /* OrderingTable[OTZ] = PrimCursor */
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
 WORD_COUNT(mac_insert_ot_tag_g4, 11)
 
-#define mac_pack_color_word(off, code, r, g, b) \
+#define mac_pack_color_word(off, cmd, r, g, b) \
-	load_upper_i(R_AT, (code) << 8  | (b)) \
+	load_upper_i(R_AT, (cmd) << 8  | (b)) \
 ,	or_i_self(   R_AT, ((g)   << 8) | (r)) \
 ,	store_word(  R_AT, R_PrimCursor, (off))
 WORD_COUNT(mac_pack_color_word, 3)
@@ -102,8 +102,8 @@ WORD_COUNT(mac_format_g4_color, 12)
 
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
  * G4 triangle portion to p0/p1/p2.
- * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen,
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
- * SXY2=v2.screen). MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
  * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
  * three registers aligned with v0/v1/v2 you must store before RTPS).
  * The macro name declares the pipeline position; check #6 (GTE state-

code/duffle/gp.h

@@ -49,12 +49,8 @@
 /* IO base address (KSEG2 0x1F800000+ for the I/O register region).
  * The 16-bit upper half `IO_BASE_ADDR_HI16` is the form used by
  * tape-side macros that pin a register to hold the IO base and access
- * ports via offsets — `lui $reg, 0x1F80` (1 word) then `sw $data,
+ * ports via offsets — `lui $reg, 0x1F80` (1 word) then `sw $data, GPIO_PORT*_OFFSET($reg)` (1 word). 
- * GPIO_PORT*_OFFSET($reg)` (1 word). Mirrors the `IO_BASE_ADDR equ
+ * Mirrors the `IO_BASE_ADDR equ 0x1F80` + `gpio_port0 equ 0x1810` pattern from graphics_hello/gp.s. */
- * 0x1F80` + `gpio_port0 equ 0x1810` pattern from graphics_hello/gp.s.
- *
- * See lottes_tape.h `R_GpIoBase` + `mac_gp0_send_imm` for the
- * wave-context form that composes these primitives. */
 enum {
     IO_BASE_ADDR      = 0x1F800000,  /* full 32-bit I/O region base */
     IO_BASE_ADDR_HI16 = 0x1F80,      /* fits in a single `lui $reg, 0x1F80` */
@@ -80,13 +76,12 @@ enum {
  *  GP0 command byte constants + Layer 1 (GPU bitfield shifts)
  *  ============================================================================
  *
- *  8-bit GP0 opcodes (the upper byte of a primitive's first word).
+ *  8-bit GP0 opcodes (the upper byte of a primitive's first word). These are the BYTE only.
- *  These are the BYTE only; pre-baked 32-bit words are in §10.4.
  *  The layer-1 bitfield-layout constants live in the same enum block
- *  so the encoder in §10.4 can reference them by name. NO macro body
+ *  so the encoder can reference them by name. 
- *  past this point uses a raw shift or raw mask — every shift/width/mask
+ *  NO macro body past this point uses a raw shift or raw mask. 
- *  is named here, named once. Mirrors the OPCODE_SHIFT / RS_SHIFT /
+ *  Every shift/width/mask is named here, named once. 
- *  REG_MASK convention from mips.h.
+ *  Mirrors the OPCODE_SHIFT / RS_SHIFT / REG_MASK convention from mips.h.
  * ============================================================================ */
 enum {
     gp0_cmd_Nop             = 0x00,
@@ -120,8 +115,7 @@ enum {
     gp0_cmd_tile_8          = 0x68,
     gp0_cmd_tile_16         = 0x70,
 
-    /* State setters (not drawing primitives; set render context).
+    /* State setters (not drawing primitives; set render context). */
-     * Per PSX-SPX graphicsprocessingunitgpu.md §"GP0 Other Commands". */
     gp0_cmd_DrawModeSetting      = 0xE1,  /* TPage / draw-mode (semi-trans, dither, etc.) */
     gp0_cmd_SetTextureWindow     = 0xE2,
     gp0_cmd_SetDrawArea_TopLeft  = 0xE3,
@@ -130,9 +124,7 @@ enum {
     gp0_cmd_SetMaskBit           = 0xE6,
 
     /* bitfield shifts / widths / masks ----
-     *
+     * Generic GP0/GP1 command byte (upper 8 bits of every word sent to either port). */
-     * Generic GP0/GP1 command byte (upper 8 bits of every word sent
-     * to either port). Used by `enc_gp0_cmd(cmd)` and friends below. */
     gp0_cmd_shift = 24,
     gp0_cmd_width =  8,
     gp0_cmd_mask  = 0xFF,
@@ -153,19 +145,19 @@ enum {
  *  ============================================================================
  *
  *  Layer 1.5 encoders take one field's value, mask it to its own width,
- *  and shift it to its own position. Mirrors `enc_op` / `enc_rs` /
+ *  and shift it to its own position. 
- *  `enc_rt` in mips.h and `enc_gte_sf` / `enc_gte_mx` in gte.h. Layer-2 composite encoders 
+ *  Mirrors `enc_op` / `enc_rs` / `enc_rt` in mips.h and `enc_gte_sf` / `enc_gte_mx` in gte.h. 
- *  OR the per-field encoders together; layer-3 semantic macros delegate to the composites.
+ *  Layer-2 composite encoders OR the per-field encoders together; layer-3 semantic macros delegate to the composites.
  *  No raw shifts or magic numbers in any macro body below this point.
  * ============================================================================ */
 
 /* ---- Layer 1.5: per-field encoders ---- */
-#define enc_gp0_cmd(cmd)       (((cmd) & gp0_cmd_mask)           << gp0_cmd_shift)
+#define enc_gp0_cmd(cmd)       (((cmd) & gp0_cmd_mask)         << gp0_cmd_shift)
 
-#define enc_gp0_color_cmd(cmd) (((cmd) & gp0_color_cmd_mask)     << gp0_color_cmd_shift)
+#define enc_gp0_color_cmd(cmd) (((cmd) & gp0_color_cmd_mask)   << gp0_color_cmd_shift)
-#define enc_gp0_color_r(r)     (((r)   & gp0_color_red_mask)     << gp0_color_red_shift)
+#define enc_gp0_color_r(r)     (((r)   & gp0_color_red_mask)   << gp0_color_red_shift)
-#define enc_gp0_color_g(g)     (((g)   & gp0_color_green_mask)   << gp0_color_green_shift)
+#define enc_gp0_color_g(g)     (((g)   & gp0_color_green_mask) << gp0_color_green_shift)
-#define enc_gp0_color_b(b)     (((b)   & gp0_color_blue_mask)    << gp0_color_blue_shift)
+#define enc_gp0_color_b(b)     (((b)   & gp0_color_blue_mask)  << gp0_color_blue_shift)
 
 /* ---- 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))
@@ -291,15 +283,7 @@ enum {
  *  Pre-baked GPU state words
  *  ============================================================================
  *
- *  Common command words for boot-time GPU init and standard
+ *  Common command words for boot-time GPU init and standard display configurations.
- *  display configurations. Each one is a pure compile-time integer
- *  constant ready to drop into a `.word` directive.
- *
- *  These are the equivalents of the `gp_HorizontalDisplayRange_3168_608`,
- *  `gp_VerticalDisplayRange_264_24`, `gp_DisplayMode_320x240_15bit_NTSC`,
- *  `gp_SetDrawMode_DrawAllowed`, `gp_DMA_*` `.equ`s from the pre-rewrite
- *  gp.h / graphics_hello/gp.s, rebuilt using the layer-cake encoders so
- *  no magic numbers appear in any body.
  * ============================================================================ */
 
 /* ---- Display enable (1-bit payload on DisplayEnable cmd) ---- */
@@ -339,7 +323,7 @@ enum {
 #define gp1_word_vertical_range_pal    enc_gp1_vrange_word(gp1_vrange_PAL_y1,  gp1_vrange_PAL_y2)
 
 /* ---- Draw-mode setting (TPage / draw-area allowance) ---- */
-/* The pre-baked "drawing enabled" word is the standard post-init state. */
+/* The "drawing enabled" word is the standard post-init state. */
 enum {
     gp0_DrawMode_DrawToDispBit = 10,
 };
@@ -373,16 +357,14 @@ enum {
  *  Primitive structs (8 polygon variants + tag)
  *  ============================================================================
  *
- *  Each struct follows the GPU-documented memory layout for the corresponding
+ *  Each struct follows the GPU-documented memory layout for the corresponding primitive command. 
- *  primitive command. The PolyTag is the OT-link header; the rest of the
+ *  The PolyTag is the OT-link header; the rest of the struct is the primitive's body.
- *  struct is the primitive's body.
  *
- *  The current working layouts match the existing demo (floor_tri uses
+ *  The current working layouts match the existing demo 
- *  Poly_F3; cube_tri uses Poly_G4). They are NOT necessarily byte-identical
+ *  (floor_tri uses Poly_F3; cube_tri uses Poly_G4). 
- *  to the PSX-SPX reference layout — the demo layout uses color+vertex
+ *  They are NOT necessarily byte-identical to the PSX-SPX reference layout. 
- *  interleaving that doesn't match the standard PSX SDK file format. For
+ *  The demo layout uses color+vertex interleaving that doesn't match the standard PSX SDK file format. 
- *  PSX-SDK file compatibility, the textured variants (FT*, GT*) would need
+ *  For PSX-SDK file compatibility, the textured variants (FT*, GT*) would need layout adjustments.
- *  layout adjustments; out of scope for this track.
  * ============================================================================ */
 
 /* ---------- RGB8 (3-byte packed color) ---------- */
@@ -391,12 +373,12 @@ typedef Struct_(RGB8) { B1 r; B1 g; B1 b; };
 
 /* ---------- PolyTag (the OT-link header; 1 word) ---------- */
 enum {
-    polytag_len_bits  =  8,
+    PolyTag_len_bits  =  8,
-    polytag_addr_bits = 24,
+    PolyTag_addr_bits = 24,
 };
 typedef Struct_(PolyTag) {
 	union {
-		U4 bf_addr_len;
+		U4 code;
 		struct {
 			U4 addr: 24;
 			U4 len:  8;
@@ -404,15 +386,14 @@ typedef Struct_(PolyTag) {
 	};
 };
 
-/* DSL cast convention: every cast uses `C_()`, every pointer qualifier
+/* DSL cast convention: every cast uses `C_()`, every pointer qualifier is `R_` (restrict) or `V_` (volatile).
- * is `R_` (restrict) or `V_` (volatile). No raw C-style casts. RHS values
+ * No raw C-style casts. RHS values are assumed to be `U4` — caller passes a `U4` directly. */
- * are assumed to be `U4` — caller passes a `U4` directly. */
 #define set_len(tag,v)  (C_(PolyTag_R,tag)->len  = u4_(v))
 #define set_addr(tag,v) (C_(PolyTag_R,tag)->addr = u4_(v))
 /* `set_code` is no longer in the new PolyTag design — the code byte lives
  *  in the primitive body (e.g. `((Poly_F3*)(p))->code`), not in the tag.
- *  Use the typed primitive structs (Poly_F3, Poly_G4, etc.) and the
+ *  Use the typed primitive structs (Poly_F3, Poly_G4, etc.) and the `set_poly_*` setters, 
- *  `set_poly_*` setters, which set both the tag's length and the code. */
+ *  which set both the tag's length and the code. */
 #define get_len(tag)  C_(U4,C_(PolyTag_R,tag)->len)
 #define get_addr(tag) C_(U4,C_(PolyTag_R,tag)->addr)
 
@@ -438,7 +419,7 @@ typedef Struct_(Poly_F4) {
     };
 };
 
-/* ---------- Poly_G3 (Gouraud Triangle; 6 words) ---------- */
+/* ---------- Poly_G3 (Gouraud Triangle; 7 words) ---------- */
 typedef Struct_(Poly_G3) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -446,7 +427,7 @@ typedef Struct_(Poly_G3) {
     V2_S2 p2;
 };
 
-/* ---------- Poly_G4 (Gouraud Quad; 5 words in the demo's interleaved layout) ---------- */
+/* ---------- Poly_G4 (Gouraud Quad; 9 words) ---------- */
 typedef Struct_(Poly_G4) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -468,7 +449,7 @@ typedef Struct_(Poly_FT3) {
     V2_S2 p2; U1 u2; U1 v2;
 };
 
-/* ---------- Poly_FT4 (Flat Textured Quad; placeholder layout) ---------- */
+/* ---------- Poly_FT4 (Flat Textured Quad) ---------- */
 typedef Struct_(Poly_FT4) {
     U4   tag;
     RGB8 color;
@@ -481,7 +462,7 @@ typedef Struct_(Poly_FT4) {
     V2_S2 p3; U1 u3; U1 v3;
 };
 
-/* ---------- Poly_GT3 (Gouraud Textured Triangle; placeholder layout) ---------- */
+/* ---------- Poly_GT3 (Gouraud Textured Triangle) ---------- */
 typedef Struct_(Poly_GT3) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -494,7 +475,7 @@ typedef Struct_(Poly_GT3) {
     V2_S2 tp2; U1 u2; U1 v2;
 };
 
-/* ---------- Poly_GT4 (Gouraud Textured Quad; placeholder layout) ---------- */
+/* ---------- Poly_GT4 (Gouraud Textured Quad) ---------- */
 typedef Struct_(Poly_GT4) {
     U4    tag; RGB8 c0; B1 code;
     V2_S2 p0;  RGB8 c1; B1 pad1;
@@ -509,7 +490,7 @@ typedef Struct_(Poly_GT4) {
     V2_S2 tp3; U1 u3; U1 v3;
 };
 
-/* ---------- Primitive setters (C-level, no emitted words) ----------
+/* ---------- Primitive setters (C-level) ----------
  * DSL cast convention: every cast via C_(), every pointer via R_/V_. */
 #define set_poly_f3(p)  set_len(p, 4),  C_(Poly_F3_R, p)->code = gp0_cmd_poly_f3
 #define set_poly_ft3(p) set_len(p, 7),  C_(Poly_FT3_R,p)->code = gp0_cmd_poly_ft3
@@ -647,7 +628,7 @@ enum {
  *
  *  Future?: add `tim_load_to_vram(tim_ptr, vram_addr)` that
  *  emits the necessary GP0 commands. Stoppped for now at the
- *  struct + enum level for this track.
+ *  struct + enum level.
  * ============================================================================ */
 enum {
     tim_file_id_magic = 0x10,
@@ -660,7 +641,7 @@ enum {
 };
 
 typedef Struct_(TIM_Header) {
-    U4 file_id;        /* always 0x10 = "TIM" magic */
+    U4 file_id;       /* always 0x10 = "TIM" magic */
     U4 version;       /* ignored; always 0 */
     U4 flags;         /* bits 0..2 = type, bit 3 = has_clut */
 };

code/duffle/gte.h

@@ -37,49 +37,6 @@
  *  Hand-rolled DSL for emitting GTE/MIPS instruction words as raw `.word`
  *  constants from C. No GCC inline-assembly string syntax in the code body.
  *
- *  PHILOSOPHY
- *  ----------
- *  1. A 32-bit instruction word is composed from per-field encoders. Each
- *     encoder knows only its own bit range; the composite ORs them together.
- *     No magic numbers inside any encoder body. Every shift and mask is a
- *     named constant from the bitfield-layout enum below.
- *
- *  2. Pure (compile-time) instructions. Every GTE *command* (RTPS, RTPT,
- *     NCLIP, MVMVA, …) and every COP2 *transfer* (ctc2/cfc2) with a constant
- *     rs/rt/rd — are emitted as a single integer constant via
- *     `asm_inline(...)` from gcc_asm.h. The C compiler constant-folds
- *     these into `.word` directives in .rodata.
- *
- *  3. Runtime-base-register instructions (lwc2, swc2, lw, sw, …) cannot be
- *     a pure compile-time word because the `rs` field is chosen by the
- *     compiler at codegen. For these we use a "placeholder-pun" pattern:
- *     a fixed register number (R_T4 = $12) is baked into the rs field of
- *     the `.word` constant, and the macro declares a `"r"(arg)` input
- *     constraint plus a clobber on the same register. The compiler is
- *     therefore *forced* to bind `arg` to that exact register, and the
- *     constant is correct.
- *
- *  USAGE
- *  -----
- *      // Pure command sequence — all bits compile-time:
- *      asm volatile(
- *          asm_inline( gte_cmd_rtpt , gte_cmd_nclip , gte_cmd_avsz3 )
- *          asm_clobber( clbr_volatile_gprs )
- *      );
- *
- *      // Runtime-base-register load — caller picks the base GPR:
- *      register V3_S2* p_in_12 __asm__("$12") = verts[0].ptr;
- *      gte_load_v0(p_in_12, R_T4);   // R_T4 = 12 = $t4 = $12
- *
- *      // Three independent bases for an RTPT pipeline:
- *      register V3_S2* p0 gcc_reg(R_T4) = verts[0].ptr;
- *      register V3_S2* p1 gcc_reg(R_T5) = verts[1].ptr;
- *      register V3_S2* p2 gcc_reg(R_T6) = verts[2].ptr;
- *      gte_load_v0(p0, R_T4);
- *      gte_load_v1(p1, R_T5);
- *      gte_load_v2(p2, R_T6);
- *      gte_rtpt();
- *
  *  STYLE NOTES
  *  -----------
  *  - Per-field encoders are named `enc_gte_<field>(value)` and each one
@@ -94,8 +51,7 @@
  *
  *  SEE ALSO
  *  --------
- *  - gcc_asm.h: the `.word` emitter (`asm_inline`, `asm_clobber`, clobbers)
+ *  - mips.h: The MIPS encoder layer this builds on.
- *  - mips.h:    the MIPS encoder layer this builds on
  */
 
 /* C2 data registers */
@@ -222,8 +178,8 @@ enum {
  *                                    \_____ GTE_PAYLOAD _____/       \__ GTE_CMD __/
  *
  * Shifts/masks below are the *bit positions* and *bit widths* of each
- * configurable field, used by the ENC_GTE_CMD encoder. Mirrors the
+ * configurable field, used by the ENC_GTE_CMD encoder. 
- * OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
+ * Mirrors the OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
  */
 
 	gte_shift_sf  = 19,  gte_width_sf  = 1,  gte_mask_sf  = 0x1,

code/duffle/lottes_tape.h

@@ -17,8 +17,7 @@ typedef Slice_MipsCode MipsAtom;
 #define MipsAtom_(sym) MipsCode tmpl(code,sym) [] align_(4) =
 
 // Bare form: file-scope declaration with hardcoded body.
-// Used for components with no args (e.g., ac_load_tri_indices) or
+// Used for components with no args (e.g., ac_load_tri_indices) or identifier-args (hardcoded register names).
-// identifier-args (hardcoded register names).
 //   MipsAtomComp_(ac_X) { body }
 // expands to:
 //   MipsCode ac_X[] align_(4) = { body };
@@ -133,14 +132,14 @@ MipsAtomComp_(ac_gte_load_tri_verts) {
 MipsAtomComp_(ac_insert_ot_tag_f3) {
 	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
 	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
-	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // AT = old_ot_head
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
-	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits), // V0 = (5 - 1) << 24 = 4 << 24
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (5 - 1) << 24 = 4 << 24
-	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
 	or_u(        R_AT, R_AT, R_V0),                            // Merge length
-	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)), // prim->tag = packed(prim_length, old_addr)
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
-	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
-	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)),
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // OrderingTable[OTZ] = PrimCursor
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
 };
 
 /* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
@@ -148,23 +147,21 @@ MipsAtomComp_(ac_insert_ot_tag_f3) {
 MipsAtomComp_(ac_insert_ot_tag_g4) {
 	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
 	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
-	load_word(   R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // AT = old_ot_head
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
-	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits), // V0 = (9 - 1) << 24 = 8 << 24
+	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (9 - 1) << 24 = 8 << 24
-	mask_upper(  R_AT, R_AT,         S_(polytag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
 	or_u(        R_AT, R_AT, R_V0),                            // Merge length
-	store_word(  R_AT, R_PrimCursor, O_(PolyTag,bf_addr_len)), // prim->tag = packed(prim_length, old_addr)
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
-	shift_lleft( R_AT, R_PrimCursor, S_(polytag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
-	shift_lright(R_AT, R_AT,         S_(polytag_len_bits)),
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
-	store_word(  R_AT, R_T1,         O_(PolyTag,bf_addr_len)), // OrderingTable[OTZ] = PrimCursor
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
 };
 
 /* Words: 3; Emits one (cmd|color) word to R_PrimCursor at the given
- * byte offset. Internal helper used by the *_format_*_color macros.
+ * byte offset. Internal helper used by the *_format_*_color macros. */
- * Args: off = U4 byte offset, code = GP0 cmd byte (0 for c1/c2/c3 of
+FI_ MipsAtom ac_pack_color_word(U4 off, U4 cmd, U1 r, U1 g, U1 b)
- * a Poly_G4), r/g/b = 8-bit RGB byte values. */
-FI_ MipsAtom ac_pack_color_word(U4 off, U4 code, U1 r, U1 g, U1 b)
 MipsAtomComp_Proc_(ac_pack_color_word, {
-	load_upper_i(R_AT, (code) << 8  | (b)),
+	load_upper_i(R_AT, (cmd) << 8  | (b)),
 	or_i_self(   R_AT, ((g)   << 8) | (r)),
 	store_word(  R_AT, R_PrimCursor, (off)),
 })
@@ -199,8 +196,8 @@ MipsAtomComp_Proc_(ac_format_g4_color, {
 
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
  * G4 triangle portion to p0/p1/p2.
- * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen,
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
- * SXY2=v2.screen). MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
  * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
  * three registers aligned with v0/v1/v2 you must store before RTPS).
  * The macro name declares the pipeline position; check #6 (GTE state-
@@ -321,9 +318,9 @@ internal MipsAtom_(diag_color) {
 	add_u_self(      R_T1,       R_T6),         
 	
 	load_word(   R_AT, R_T1, 0),        
-	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << polytag_len_bits),
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits),
 	store_word(  R_AT, R_T7, 0),       
-	shift_lleft(R_AT, R_T7, S_(polytag_len_bits)), shift_lright(R_AT, R_AT, S_(polytag_len_bits)),         
+	shift_lleft(R_AT, R_T7, S_(PolyTag_len_bits)), shift_lright(R_AT, R_AT, S_(PolyTag_len_bits)),         
 	or_u_self(  R_AT, R_V0),          
 	store_word( R_AT, R_T1, 0),       
 

code/graphics_hello_psyq/hello_gpu.c

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

code/graphics_hello_psyq/hello_gpu.h

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

code/gte_hello/hello_gte_tape.c

@@ -123,7 +123,6 @@ MipsAtom_(floor_f3_face) atom_info(
 	nop,
 	branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop,
 	/* Format Primitive */
-	// mac_format_f3_color(0x20FF, 0xFFFF),  // works
 	mac_format_f3_color(0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
 	mac_gte_store_f3_post_rtpt(),
 	

readme.md

@@ -6,19 +6,27 @@ A rest from the usual.
 
 ## Dependencies
 
-I will be programming from a Windows 11 machine:
+I will be programming from a Windows 11 machine (may eventually try this on the Steam Deck...):
 ![system_info](./docs/assets/system_info.png)
 
-```ps1
-# not really used yet for scripts (may never)
-scoop install lua
-```
-
 [armips](https://github.com/Kingcom/armips)
 
 * Supports doing bare-metal assembly for the ps1
 * `scoop install armips` or just clone and build..
 
+[luajit-2.1](https://github.com/LuaJIT/LuaJIT.git)
+
+```
+scoop install luajit
+```
+
+* Used for lua scripts
+* Particularly, ps1_meta.lua which is a staged metaprogram pass for the custom C11 Assembly DSL used in this codebase.
+
+[lpeg](https://github.com/roberto-ieru/LPeg.git)
+
+* Lua is slow (even jitted) so this helps.
+
 [pscx-redux](https://github.com/grumpycoders/pcsx-redux/): A collection of tools, research, hardware design, and libraries aiming at development and reverse engineering on the PlayStation 1.
 
 * Used as the runtime sandbox emulated the ps1
@@ -57,3 +65,4 @@ scoop install lua
 ![polys!](./docs/assets/pcsx-redux.main_2025-08-03_20-45-35.png)  
 ![hello_psyq!](./docs/assets/pcsx-redux_2025-08-05_23-01-19.png)
 ![cube!](./docs/assets/pcsx-redux_2025-10-11_03-04-01.png)
+![cube and floor!](./docs/assets/pcsx-redux_2026-07-10_22-47-02.png)

scripts/audit_lua_nesting.lua

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

scripts/duffle_paths.lua

@@ -0,0 +1,113 @@
+--- duffle_paths.lua — Single-line bootstrap helper for the tape-atom Lua scripts.
+---
+--- Each entry script (ps1_meta.lua + the 7 passes/*.lua files) starts with one of:
+---   ```lua
+---   -- Entry script (ps1_meta.lua — `arg[0]` is set):
+---   local duffle = dofile((arg[0]:match("(.*[/\\])") or "./") .. "duffle_paths.lua")
+---
+---   -- Pass module (debug.getinfo path resolution; works both standalone and when require'd):
+---   local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+---   local duffle = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+---   ```
+---
+--- That small bootstrap: (a) locates this helper via `arg[0]` / `debug.getinfo`,
+--- (b) loads it (which sets `package.path` + `package.cpath` via cached `git rev-parse`),
+--- (c) at the bottom calls `require("duffle")` (now resolvable since `package.path` was just set) and returns the duffle M.
+--- Net effect: the caller gets the duffle module in one statement; no separate `dofile(...)` + `require("duffle")` dance.
+---
+--- Replaces the prior 2-line (entry) or 4-line (pass) pattern that had the call site do its own path resolution + duplicated setup.
+
+local M = {}
+
+-- Cache key for the repo root. Stored in `package.loaded` (process-global) so all 8 entry scripts + passes scripts share one resolution.
+local CACHE_KEY = "__duffle_repo_root__"
+
+--- Resolve the repo root from this script's own path. Zero shell spawn.
+--- `duffle_paths.lua` always lives at `<repo>/scripts/duffle_paths.lua`, so the repo root is the
+--- parent of the directory containing this script. We derive it directly from `debug.getinfo(1, "S").source`
+--- (returns `@<path>` for the currently-running chunk).
+---
+--- Replaces the prior `io.popen("git rev-parse --show-toplevel")` approach, which cost ~100-180ms per
+--- LuaJIT process on Windows due to git's CLI startup. The path-derive approach costs <1ms.
+---
+--- If this script's path can't be parsed (shouldn't happen — dofile/debug.getinfo always populates source),
+--- fall back to a defensive walk: starting from this script's directory, walk UP until we find a parent that
+--- contains a `scripts/` directory. The first match is the repo root.
+--- @return string|nil
+local function find_repo_root()
+	if package.loaded[CACHE_KEY] then return package.loaded[CACHE_KEY] end
+
+	local source = debug.getinfo(1, "S").source
+	-- Strip the leading `@` (Lua's dofile marker) and the trailing `/duffle_paths.lua` filename.
+	-- What remains is the directory containing this script, i.e. `<repo>/scripts/` (with trailing slash or not).
+	local scripts_dir = source and source:match("^@?(.*)[/\\]duffle_paths%.lua$")
+	if scripts_dir then
+		-- The repo root is the parent of `scripts/`. Strip the trailing `scripts/` (with or without trailing slash).
+		local root = scripts_dir:gsub("scripts[\\/]?$", "")
+		root = root:gsub("\\", "/")
+		if root == "" then root = "./" end
+		if not root:match("/$") then root = root .. "/" end
+		package.loaded[CACHE_KEY] = root
+		return root
+	end
+
+	-- Defensive fallback: walk UP from this script's directory until we find a parent that contains `scripts/`.
+	-- In practice this branch never fires — debug.getinfo always returns a source for dofile()'d chunks.
+	local lfs = pcall(require, "lfs") and require("lfs") or nil
+	if lfs then
+		local dir = source and source:match("^@?(.*[/\\])") or "./"
+		dir = dir:gsub("\\", "/")
+		while dir and dir ~= "" do
+			local candidate_scripts = dir .. "scripts"
+			if lfs.attributes(candidate_scripts, "mode") == "directory" then
+				dir = dir:gsub("/$", "")
+				package.loaded[CACHE_KEY] = dir .. "/"
+				return dir .. "/"
+			end
+			local parent = dir:match("^(.*)/[^/]+/$")
+			if not parent then break end
+			dir = parent .. "/"
+		end
+	end
+
+	return nil
+end
+
+--- Set `package.path` (for `require("duffle")` + `require("passes.X")`) and
+--- `package.cpath` (for `lpeg.dll`).
+---
+--- This script does NOT touch the OS environment: no `os.setenv`, no `os.putenv`, no `$PATH` mods. 
+--- It just sets `package.path` and `package.cpath` (the standard Lua way to register module search dirs). 
+--- lpeg is built by `update_deps.ps1` to `toolchain/lpeg/`, 
+--- which we wire into `package.cpath` here (so `require("lpeg")` from `duffle.lua` resolves without any global state).
+function M.setup()
+	local repo_root = find_repo_root()
+	if not repo_root then
+		io.stderr:write("[duffle_paths] git rev-parse failed -- not in a git repo?\n")
+		os.exit(2)
+	end
+
+	local scripts_dir = repo_root .. "scripts/"
+	local passes_dir  = repo_root .. "scripts/passes/"
+	package.path = scripts_dir .. "?.lua;"
+		.. scripts_dir .. "?/init.lua;"
+		.. passes_dir  .. "?.lua;"
+		.. passes_dir  .. "?/init.lua;"
+		.. package.path
+
+	-- lpeg: built by `update_deps.ps1` to `toolchain/lpeg/lpeg.dll`.
+	-- lfs: compiled from pcsx-redux's vendored luafilesystem source to `toolchain/lfs/lfs.dll`.
+	-- Wire both directories into cpath so `require("lpeg")` and `require("lfs")` resolve.
+	local lpeg_dir = repo_root .. "toolchain/lpeg/"
+	local lfs_dir  = repo_root .. "toolchain/lfs/"
+	package.cpath = lpeg_dir .. "?.dll;"
+		.. lfs_dir  .. "?.dll;"
+		.. package.cpath
+end
+
+-- Run the setup as a side effect.
+M.setup()
+
+-- Now that package.path includes scripts/, `require("duffle")` resolves. Return the duffle module
+-- so callers can do `local duffle = dofile(...duffle_paths.lua)` in one line.
+return require("duffle")

scripts/passes/annotation.lua

@@ -1,49 +1,29 @@
--- passes/annotation.lua
+--- passes/annotation.lua — Atom-annotation DSL validator.
---
+---
--- Validate atom annotation DSL usage in source files. Reads:
+--- Validates `MipsAtom_(name) atom_info(atom_bind(Binds_X), atom_reads(...), atom_writes(...)) { ... }` declarations in source files.
---   - atom_annot / atom_init / atom_setup / atom_commit / atom_bind
+--- Also reads: `Binds_*` struct declarations (`typedef Struct_(Binds_X) { ... };`)
---     / atom_terminate / atom_label / atom_offset / TAPE_WORDS
+---
---   - atom_resource / atom_region / atom_group / atom_cadence / atom_async
+--- Source scanning: done ONCE upstream by `duffle.scan_source()` (ps1_meta.lua pre-scans each
---   - Binds_* struct declarations
+--- source and stashes the result in `src.scan`). This pass is pure: read from the scan, run
--- Writes:
+--- checks, emit findings. No source re-walking.
---   - <ctx.out_root>/<basename>.errors.h         (with #error directives on findings)
+---
---   - <ctx.out_root>/<basename>.annotations.txt  (human-readable summary)
+--- Writes:
--- Ported from scripts/tape_atom_annotation_pass.lua:78-545 + 1081-1407
+---   - `<ctx.out_root>/<dir_basename>.errors.h` — one per module, with `#error` directives on findings (the C compile will surface the error)
--- (validation only — NOT rendering, which goes to passes/report.lua).
+---   - The annotations.txt report is rendered by `passes/report.lua` from the per-module results stashed in `ctx.flags._annot_results`
---
+---
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex.
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible
 
--- ════════════════════════════════════════════════════════════════════════════
+-- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
--- Module-scope requires + package.path setup
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
--- ════════════════════════════════════════════════════════════════════════════
+-- Uses `debug.getinfo` to find this file's own directory, so it works
-
+-- both standalone and when require'd from the orchestrator.
-local script_path = arg and arg[0] or "?"
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
-local last_sep = 0
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
-for i = 1, #script_path do
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
-	local c = script_path:sub(i, i)
+local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
-	if c == "/" or c == "\\" then last_sep = i end
-end
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
-package.path   = script_dir .. "../?.lua;" .. script_dir .. "../?/init.lua;" .. script_dir .. "?.lua;" .. package.path
-
-local duffle              = require("duffle")
-local is_space            = duffle.is_space
-local is_alpha            = duffle.is_alpha
-local is_alnum            = duffle.is_alnum
-local trim                = duffle.trim
-local find_byte           = duffle.find_byte
-local read_file           = duffle.read_file
 local write_file          = duffle.write_file
 local ensure_dir          = duffle.ensure_dir
-local dirname             = duffle.dirname
-local basename_no_ext     = duffle.basename_no_ext
-local skip_str_or_cmt     = duffle.skip_str_or_cmt
-local skip_ws_and_cmt     = duffle.skip_ws_and_cmt
-local read_ident          = duffle.read_ident
-local read_parens         = duffle.read_parens
-local read_braces         = duffle.read_braces
-local scan_to_char        = duffle.scan_to_char
-local split_top_level_commas = duffle.split_top_level_commas
 
 -- Domain tables (single source of truth in duffle.lua).
 local WAVE_CONTEXT_REGS = duffle.WAVE_CONTEXT_REGS
@@ -52,492 +32,100 @@ local TAPE_ATOM_MACROS  = duffle.TAPE_ATOM_MACROS
 local function is_wave_context_reg(n) return WAVE_CONTEXT_REGS[n] ~= nil  end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Hand-rolled split helpers (no regex patterns used)
+-- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Split a string at top-level commas. Used inside TAPE_ATOM_* macro
+--- @class SourceFile
---- bodies where nested parens/braces/brackets are possible.
+--- @field path     string  -- absolute path to the source file
-local function split_csv_top(s)
+--- @field text     string  -- the full source text
-	local tokens = {}
+--- @field dir      string  -- the directory containing the source
-	local i, start = 1, 1
+--- @field basename string  -- filename without extension
-	local depth = 0
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
-	while i <= #s do
-		local c = s:sub(i, i)
-		if c == "(" or c == "{" or c == "[" then
-			depth = depth + 1
-			i = i + 1
-		elseif c == ")" or c == "}" or c == "]" then
-			depth = depth - 1
-			i = i + 1
-		elseif c == "," and depth == 0 then
-			tokens[#tokens + 1] = s:sub(start, i - 1)
-			i = i + 1
-			start = i
-		else
-			i = i + 1
-		end
-	end
-	local last = s:sub(start)
-	if trim(last) ~= "" then tokens[#tokens + 1] = last end
-	return tokens
-end
 
---- Split a string into whitespace-separated tokens.
+--- @class PassCtx
---- Hand-rolled (no regex patterns).
+--- @field sources            SourceFile[]
-local function split_ws(s)
+--- @field metadata_path      string
-	local tokens = {}
+--- @field shared             table
-	local i, n = 1, 1
+--- @field shared.word_counts table<string, integer>
-	local len = #s
+--- @field out_root           string
-	while i <= len do
+--- @field project_root       string
-		-- Skip whitespace.
+--- @field upstream           table<string, table>
-		while i <= len and is_space(s:sub(i, i)) do i = i + 1 end
+--- @field flags              table
-		if i > len then break end
+--- @field flags._annot_results table[]   -- stashed by annotation pass; consumed by report.lua
-		local start = i
+--- @field dry_run            boolean
-		-- Take non-whitespace run.
+--- @field verbose            boolean
-		while i <= len and not is_space(s:sub(i, i)) do i = i + 1 end
+
-		tokens[n] = s:sub(start, i - 1)
+--- @class PassResult
-		n = n + 1
+--- @field outputs  table[]
-	end
+--- @field errors   table[]
-	return tokens
+--- @field warnings table[]
-end
+
+--- @class AtomAnnotation
+--- @field line    integer       -- source line of the atom_info call
+--- @field macro   string        -- the macro name (always "atom_info" in the new shape)
+--- @field name    string        -- the atom name
+--- @field kind    string        -- always "info"
+--- @field binds   string|nil    -- Binds_X name if any
+--- @field reads   string[]      -- R_* names (read targets)
+--- @field writes  string[]      -- R_* names (write targets)
+
+--- @class Finding
+--- @field line integer  -- source line (or 0 for pass-level)
+--- @field msg  string   -- finding message
+
+--- @class AnnotatedResult
+--- @field atoms    AtomEntry[]
+--- @field annots   AtomAnnotation[]
+--- @field macros   MacroEntry[]
+--- @field binds    BindsEntry[]
+--- @field errors   Finding[]
+--- @field warnings Finding[]
+--- @field info     Finding[]
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Parse TAPE_ATOM_ANNOT(...) calls
+-- Validation
--- ════════════════════════════════════════════════════════════════════════════
-
--- Recognize a `atom_bind(...)`, `atom_reads(...)`, or `atom_writes(...)`
--- sub-call embedded inside an atom_info arg list. Returns the kind
--- ("atom_bind" / "atom_reads" / "atom_writes") and the inner content,
--- or nil if the token isn't a recognized sub-call form. Flattened via
--- a prefix lookup instead of a nested if/elseif chain.
-local REGS_CALL_PREFIX = {
-	["atom_writes("] = { kind = "atom_writes", inner_offset = 13 },
-	["atom_reads("]  = { kind = "atom_reads",  inner_offset = 12 },
-	["atom_bind("]   = { kind = "atom_bind",   inner_offset = 11, single_ident = true },
-}
-
-local function parse_regs_call(s)
-	if s:sub(-1) ~= ")" then return nil end
-	-- Try longest prefix first so "atom_writes(" wins over "atom_reads("
-	-- when both 12-char prefixes would otherwise match. Lengths:
-	--   atom_writes(  = 12 chars, offset 13
-	--   atom_reads(   = 11 chars, offset 12
-	--   atom_bind(    = 10 chars, offset 11
-	local spec = REGS_CALL_PREFIX[s:sub(1, 12)]
-	if not spec then
-		spec = REGS_CALL_PREFIX[s:sub(1, 11)]
-	end
-	if not spec then
-		spec = REGS_CALL_PREFIX[s:sub(1, 10)]
-	end
-	if not spec then return nil end
-	local inner = s:sub(spec.inner_offset, -2)
-	if spec.single_ident then
-		-- atom_bind takes a single Binds_* type ident. Trim and pass through.
-		return spec.kind, trim(inner)
-	end
-	return spec.kind, inner
-end
-
--- Resolve any phase_* / R_* alias macros in a register list.
--- (Phase / region / cadence aliases have been dropped. Kept as an
--- identity function so callers can stay uniform.)
-local function resolve_reg_aliases(regs)
-	return regs
-end
-
--- Parse a comma-separated inner content (e.g. inside atom_reads(...))
--- into a list of trimmed identifiers with aliases resolved.
-local function parse_regs_list(inner)
-	local out = {}
-	for _, r in ipairs(split_csv_top(inner)) do
-		local trimmed = trim(r)
-		if trimmed ~= "" then out[#out + 1] = trimmed end
-	end
-	return resolve_reg_aliases(out)
-end
-
--- Parse a single token (from split_csv_top) into an arg entry.
--- Three forms: register-list call, bare identifier,
--- "other" (preserved as text).
-local function parse_arg_token(s)
-	local kind, inner = parse_regs_call(s)
-	if kind then
-		if kind == "atom_bind" then
-			return { kind = kind, value = inner }  -- single ident, not a list
-		end
-		return { kind = kind, value = parse_regs_list(inner) }
-	end
-	local id = read_ident(s, 1)
-	if id and trim(s) == id then
-		return { kind = "ident", value = id }
-	end
-	return { kind = "other", value = s }
-end
-
---- Extract identifier args from a parenthesized group. Returns a list
---- of {kind, value} pairs where kind is one of:
----   "ident"        -- a bare identifier (e.g. phase_work)
----   "atom_reads"   -- an atom_reads(...) call: value is the register list
----   "atom_writes"  -- an atom_writes(...) call: value is the register list
----   "other"        -- something we can't classify (preserved as text)
-local function parse_atom_annot_args(inner)
-	local args = {}
-	for _, tok in ipairs(split_csv_top(inner)) do
-		local s = trim(tok)
-		if s ~= "" then
-			args[#args + 1] = parse_arg_token(s)
-		end
-	end
-	return args
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Parse TAPE_WORDS(mac_X, N) pragma directives
--- ════════════════════════════════════════════════════════════════════════════
-
---- Find every TAPE_WORDS(mac_X, N) pragma in source.
---- Accepts both forms:
----   _Pragma("mac_X tape_atom words=N")     (operator form)
----   #pragma mac_X tape_atom words=N        (directive form)
-local function find_macro_word_annotations(source)
-	local line_of = duffle.LineIndex(source)
-	local out = {}
-	local len = #source
-	local i   = 1
-	while i <= len do
-		i = skip_ws_and_cmt(source, i); if i > len then break end
-		-- Skip preprocessor directives (lines starting with #).
-		if source:sub(i, i) == "#" then
-			local j = i
-			while j <= len and source:sub(j, j) ~= "\n" do j = j + 1 end
-			i = j + 1
-		else
-			local ident, after = read_ident(source, i)
-			if not ident then
-				i = i + 1
-			elseif ident == "_Pragma" then
-				local open = skip_ws_and_cmt(source, after)
-				if source:sub(open, open) == "(" then
-					local str, str_end = read_parens(source, open)
-					str = trim(str)
-					if str:sub(1, 1) == '"' and str:sub(-1) == '"' then
-						local inner = str:sub(2, -2)
-						local space = find_byte(inner, " ", 1)
-						if space then
-							local name = inner:sub(1, space - 1)
-							local rest = inner:sub(space + 1)
-							local eq = find_byte(rest, "=", 1)
-							if eq then
-								local key  = trim(rest:sub(1, eq - 1))
-								local val  = trim(rest:sub(eq + 1))
-								if key == "tape_atom words" or key == "words" then
-									local n = tonumber(val) or 0
-									out[#out + 1] = {
-										line = line_of(i),
-										name = name,
-										words = n,
-									}
-								end
-							end
-						end
-					end
-					i = str_end
-				else
-					i = open + 1
-				end
-			elseif ident == "pragma" then
-				-- Directive form: `#pragma mac_X tape_atom words=N`
-				local rest_start = skip_ws_and_cmt(source, after)
-				local j = rest_start
-				while j <= len and source:sub(j, j) ~= "\n" do j = j + 1 end
-				local line_text = trim(source:sub(rest_start, j - 1))
-				local tokens = split_ws(line_text)
-				if #tokens >= 3 and tokens[2] == "tape_atom" and tokens[3]:sub(1, 6) == "words=" then
-					local name = tokens[1]
-					local n    = tonumber(tokens[3]:sub(7)) or 0
-					out[#out + 1] = { line = line_of(i), name = name, words = n }
-				elseif #tokens >= 2 and tokens[2]:sub(1, 6) == "words=" then
-					local name = tokens[1]
-					local n    = tonumber(tokens[2]:sub(7)) or 0
-					out[#out + 1] = { line = line_of(i), name = name, words = n }
-				end
-				i = j
-			else
-				i = after
-			end
-		end
-	end
-	return out
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Parse `typedef Struct_(Binds_X) { ... };` declarations
--- ════════════════════════════════════════════════════════════════════════════
-
---- Find every Binds_* struct declaration.
---- Returns a list of {line, name, fields = {{name, byte_offset}, ...}}.
-local function find_binds_structs(source)
-	local line_of = duffle.LineIndex(source)
-	local out = {}
-	local len = #source
-	local i   = 1
-	while i <= len do
-		i = skip_ws_and_cmt(source, i); if i > len then break end
-		if source:sub(i, i) == "#" then
-			local j = i
-			while j <= len and source:sub(j, j) ~= "\n" do j = j + 1 end
-			i = j + 1
-		else
-			local ident, after = read_ident(source, i)
-			if not ident then
-				i = i + 1
-			elseif ident == "typedef" then
-				local j = skip_ws_and_cmt(source, after)
-				local id2, after2 = read_ident(source, j)
-				if id2 ~= "Struct_" then
-					i = after2 or (j + 1)
-				elseif id2 == "Struct_" then
-					local open = skip_ws_and_cmt(source, after2)
-					if source:sub(open, open) == "(" then
-						local inner, after_paren = read_parens(source, open)
-						local name = trim(inner)
-						local brace = scan_to_char(source, "{", after_paren)
-						if brace then
-							local body, after_brace = read_braces(source, brace)
-							local fields = {}
-							local byte_off = 0
-							local k = 1
-							while k <= #body do
-								k = skip_ws_and_cmt(body, k); if k > #body then break end
-								local tid, tafter = read_ident(body, k)
-								if not tid then
-									k = k + 1
-								elseif tid == "U4" then
-									local fid, fafter = read_ident(body, skip_ws_and_cmt(body, tafter))
-									if fid then
-										fields[#fields + 1] = { name = fid, offset = byte_off }
-										byte_off = byte_off + 4
-									end
-									k = fafter or tafter + 1
-								else
-									k = tafter + 1
-								end
-							end
-							-- Only emit Binds_* structs.
-							if name:sub(1, 6) == "Binds_" then
-								out[#out + 1] = {
-									line   = line_of(i),
-									name   = name,
-									fields = fields,
-									bytes  = byte_off,
-								}
-							end
-							i = after_brace
-						else
-							i = open + 1
-						end
-					else
-						i = open + 1
-					end
-				else
-					i = after2 or (j + 1)
-				end
-			else
-				i = after
-			end
-		end
-	end
-	return out
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Find every MipsAtom_(name) { ... } declaration in source
--- ════════════════════════════════════════════════════════════════════════════
-
-local function find_atom_names(source)
-	local line_of = duffle.LineIndex(source)
-	local out  = {}
-	local len  = #source
-	local i    = 1
-	while i <= len do
-		i = skip_ws_and_cmt(source, i); if i > len then break end
-		local ident, after = read_ident(source, i)
-		if not ident then
-			i = i + 1
-		elseif ident == "MipsAtom_" then
-			local open = skip_ws_and_cmt(source, after)
-			if source:sub(open, open) == "(" then
-				local inner, after_paren = read_parens(source, open)
-				local a = 1
-				while a <= #inner and is_space(inner:sub(a, a)) do a = a + 1 end
-				local b = a
-				while b <= #inner and is_alnum(inner:sub(b, b)) do b = b + 1 end
-				local name = inner:sub(a, b - 1)
-				if name ~= "" then
-					out[#out + 1] = { line = line_of(i), name = name }
-				end
-				local brace = scan_to_char(source, "{", after_paren)
-				if brace then
-					local _, after_brace = read_braces(source, brace)
-					i = after_brace
-				else
-					i = open + 1
-				end
-			else
-				i = open + 1
-			end
-		else
-			i = after
-		end
-	end
-	return out
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Find atom annotations (atom_annot / atom_init / atom_setup / atom_commit
--- / atom_bind / atom_terminate)
--- ════════════════════════════════════════════════════════════════════════════
-
---- True iff the parsed arg is a register-list call (any recognized form).
-local function is_regs_arg(a)
-	return a and (a.kind == "atom_reads" or a.kind == "atom_writes" or a.kind == "regs")
-end
-
---- Per-macro arg-shape handlers. Each takes (entry, args) and mutates
---- Per-atom_info sub-call dispatch. Each takes (entry, args) and mutates
---- entry.{reads, writes, binds, errors}. The new annotation shape is:
----
----   MipsAtom_(name) atom_info(
----        atom_bind(Binds_X)
----      , atom_reads(...)
----      , atom_writes(...)
----   ) { ... };
----
---- All sub-calls are order-independent; each is dispatched on its
---- `kind` (atom_bind / atom_reads / atom_writes) when parsed.
-local ANNOT_ARG_HANDLERS = {}
-
--- atom_info(atom_bind(Binds_X), atom_reads(...), atom_writes(...))
-function ANNOT_ARG_HANDLERS.info(entry, args)
-	for _, arg in ipairs(args) do
-		if arg.kind == "atom_bind" then
-			entry.binds = arg.value
-		elseif arg.kind == "atom_reads" then
-			entry.reads = arg.value
-		elseif arg.kind == "atom_writes" then
-			entry.writes = arg.value
-		elseif arg.kind == "ident" then
-			-- Reserved for future phase tokens. Currently ignored.
-			-- (Could be reintroduced as `phase_*` sub-calls of atom_info.)
-		else
-			entry.errors[#entry.errors + 1] = string.format(
-				"unexpected atom_info arg kind=%s value=%s", arg.kind, tostring(arg.value))
-		end
-	end
-end
-
--- Build a new annotation entry with the standard shape.
-local function new_annot_entry(line, ident, name, kind)
-	return {
-		line   = line,
-		macro  = ident,
-		name   = name,
-		kind   = kind,
-		binds  = nil,
-		reads  = {},
-		writes = {},
-		errors = {},
-	}
-end
-
---- Find every MipsAtom_(name) declaration in source, then look for an
---- immediately-following atom_info(...) call. If present, parse its
---- sub-calls into a normalized annotation entry linked to the MipsAtom_
---- name. If no atom_info follows, emit NO annotation entry (atoms
---- without annotations are valid in the new minimal shape).
-local function find_atom_annotations(source)
-	local line_of = duffle.LineIndex(source)
-	local annots = {}
-	local len = #source
-	local i   = 1
-	while i <= len do
-		i = skip_ws_and_cmt(source, i); if i > len then break end
-		-- Skip preprocessor directives (lines starting with #).
-		if source:sub(i, i) == "#" then
-			local j = i
-			while j <= len and source:sub(j, j) ~= "\n" do j = j + 1 end
-			i = j + 1
-			goto continue
-		end
-
-		local ident, after = read_ident(source, i)
-		if not ident then
-			i = i + 1
-		elseif ident == "MipsAtom_" then
-			local open = skip_ws_and_cmt(source, after)
-			if source:sub(open, open) ~= "(" then
-				i = open + 1
-				goto continue
-			end
-			local inner, after_paren = read_parens(source, open)
-			local a = 1
-			while a <= #inner and is_space(inner:sub(a, a)) do a = a + 1 end
-			local b = a
-			while b <= #inner and is_alnum(inner:sub(b, b)) do b = b + 1 end
-			local name = inner:sub(a, b - 1)
-
-			-- Look for atom_info(...) right after MipsAtom_(name).
-			local lookahead = skip_ws_and_cmt(source, after_paren)
-			local look_ident, look_after = read_ident(source, lookahead)
-			if look_ident == "atom_info" then
-				local info_open = skip_ws_and_cmt(source, look_after)
-				if source:sub(info_open, info_open) == "(" then
-					local info_inner, info_after = read_parens(source, info_open)
-					local args = parse_atom_annot_args(info_inner)
-					local entry = new_annot_entry(line_of(lookahead), "atom_info", name, "info")
-					ANNOT_ARG_HANDLERS.info(entry, args)
-					annots[#annots + 1] = entry
-					i = info_after
-				else
-					i = info_open + 1
-				end
-			else
-				-- No atom_info follows this MipsAtom_. Valid in new shape.
-				i = after_paren
-			end
-
-			-- Skip past the body { ... } if present.
-			local brace = scan_to_char(source, "{", i)
-			if brace then
-				local _, after_brace = read_braces(source, brace)
-				i = after_brace
-			end
-		else
-			i = after
-		end
-		::continue::
-	end
-	return annots
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Validation (ported from tape_atom_annotation_pass.lua:1193-1405)
 -- ════════════════════════════════════════════════════════════════════════════
+--
+-- Pure check: read from src.scan, run validations, emit findings.
+-- No source walking; no parsing. The scan was done once upstream.
 
+--- Validate one source against its pre-scanned SourceScan payload.
+--- @param ctx PassCtx
+--- @param src SourceFile
+--- @return AnnotatedResult
 local function validate(ctx, src)
-	local source = src.text
+	local scan = src.scan
 
-	local annots      = find_atom_annotations(source)
+	-- Project the pre-scanned atoms to the AtomEntry shape this pass needs.
-	local macros     = find_macro_word_annotations(source)
+	local atoms = {}
-	local binds      = find_binds_structs(source)
+	for _, a in ipairs(scan.atoms) do
-	local atoms      = find_atom_names(source)
+		if a.kind == "atom" then
+			atoms[#atoms + 1] = { line = a.line, name = a.raw_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 = {},
+		}
+	end
+
+	-- Index atoms by name for lookup.
 	local atom_index = {}
 	for _, a in ipairs(atoms) do atom_index[a.name] = a end
 
+	-- Index binds by name for lookup.
 	local binds_index = {}
-	for _, b in ipairs(binds) do binds_index[b.name] = b end
+	for _, b in ipairs(scan.binds) do binds_index[b.name] = b end
 
 	local errors   = {}
 	local warnings = {}
@@ -545,9 +133,7 @@ local function validate(ctx, src)
 
 	-- 1. Every annotated atom must exist as a real MipsAtom_ declaration.
 	for _, a in ipairs(annots) do
-		if a.error then
+		if not atom_index[a.name] then
-			errors[#errors + 1] = {line = a.line, msg = a.error}
-		elseif not atom_index[a.name] then
 			errors[#errors + 1] = {
 				line = a.line,
 				msg  = string.format("annotation for '%s' has no matching MipsAtom_(%s) { ... }", a.name, a.name),
@@ -561,10 +147,10 @@ local function validate(ctx, src)
 	end
 
 	-- 2. Every atom may have AT MOST ONE annotation (no duplicates).
-	--    (Atoms with ZERO annotations are valid in the new minimal shape.)
+	-- (Atoms with ZERO annotations are valid in the new minimal shape.)
 	local count_per_atom = {}
 	for _, a in ipairs(annots) do
-		if a.name and not a.error then
+		if a.name then
 			count_per_atom[a.name] = (count_per_atom[a.name] or 0) + 1
 		end
 	end
@@ -577,17 +163,19 @@ local function validate(ctx, src)
 		end
 	end
 
-	-- 3. (Phase validity check DROPPED. Phases were removed from the
+	-- 3. (Phase validity check DROPPED. Phases were removed from the annotation DSL.)
-	--    annotation DSL. They may be reintroduced later as sub-calls of
-	--    atom_info, at which point ordering checks will go here.)
 
 	-- 4. BIND atoms must reference a real Binds_* struct.
 	for _, a in ipairs(annots) do
 		if a.binds then
 			if not binds_index[a.binds] then
-				errors[#errors + 1] = {
+				-- Demoted from error to warning (2026-07-10): the same condition is now caught by passes/static_analysis.lua's
+				-- check_abi_handoff() as an error. Emitting a warning here keeps the annotation pass from being stop-on-error
+				-- for the common test-fixture case, while still surfacing the issue in the report.
+				-- The static-analysis report remains the source of truth for build-stopping errors.
+				warnings[#warnings + 1] = {
 					line = a.line,
-					msg  = string.format("'%s' binds '%s' but no Struct_(%s) { ... } declaration found", a.name, a.binds, a.binds),
+					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),
 				}
 			end
 		end
@@ -597,8 +185,6 @@ local function validate(ctx, src)
 	for _, a in ipairs(annots) do
 		if a.binds and binds_index[a.binds] then
 			local bs = binds_index[a.binds]
-			local field_names = {}
-			for _, f in ipairs(bs.fields) do field_names[f.name] = true end
 
 			for _, f in ipairs(bs.fields) do
 				local candidate = "R_" .. f.name
@@ -635,7 +221,6 @@ local function validate(ctx, src)
 
 	-- 7. TAPE_WORDS(mac_X, N) ↔ WORD_COUNT(mac_X, N) drift.
 	--    Three outcomes: missing (error), mismatch (error), match (info).
-	--    Flattened via early-return-style helper instead of 3-way elseif.
 	local function check_macro_drift(m, declared)
 		if not declared then
 			errors[#errors + 1] = {
@@ -656,31 +241,22 @@ local function validate(ctx, src)
 			msg  = string.format("OK: %s = %d words", m.name, m.words),
 		}
 	end
-	for _, m in ipairs(macros) do
+	for _, m in ipairs(scan.macros) do
 		check_macro_drift(m, ctx.shared.word_counts[m.name])
 	end
 
-	-- 8. (atom_<...> _Pragma validation DROPPED. The pragma macros
+	-- 8. Information summary.
-	--    atom_resource / atom_region / atom_group / atom_cadence /
-	--    atom_async were removed from atom_dsl.h. They may be
-	--    reintroduced later as sub-calls of atom_info.)
-
-	-- 9. (CADENCE_ONDEMAND requires async check DROPPED. Same reason
-	--    as #8.)
-
-	-- 10. Information summary.
 	info[#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, #macros, #binds),
+			#atoms, #annots, #scan.macros, #scan.binds),
 	}
 
 	return {
 		atoms    = atoms,
 		annots   = annots,
-		macros   = macros,
+		macros   = scan.macros,
-		pragmas  = pragmas,
+		binds    = scan.binds,
-		binds    = binds,
 		errors   = errors,
 		warnings = warnings,
 		info     = info,
@@ -688,44 +264,49 @@ local function validate(ctx, src)
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Per-source output: errors.h + annotations.txt
+-- Per-DIRECTORY (per-module) output: errors.h + annotations.txt
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Render <basename>.errors.h with #error directives for any structural issues.
+--- Render `<dir_basename>.errors.h` with `#error` directives for every error found across all sources in the directory.
-local function emit_errors_h(ctx, src, result)
+--- Empty directories (no errors, no atoms) produce no file.
-	local out_path = ctx.out_root .. "/" .. src.basename .. ".errors.h"
+local function emit_module_errors_h(ctx, dir_basename, atoms_count, errors, sources)
-	local lines = {
+	if ctx.dry_run then return nil end
+	if atoms_count == 0 and #errors == 0 then
+		return nil
+	end
+	local out_path = ctx.out_root .. "/" .. dir_basename .. ".errors.h"
+	local lines    = {
 		"// Auto-generated by ps1_meta.lua (passes/annotation.lua) — DO NOT EDIT",
+		string.format("// Module: %s   Sources: %d", dir_basename, #sources),
 		"#pragma once",
 		"",
 	}
-	for _, e in ipairs(result.errors) do
+	if #errors == 0 then
-		lines[#lines + 1] = string.format('#error "annotation: %s (line %d)"', e.msg, e.line)
-	end
-	if #result.errors == 0 then
 		lines[#lines + 1] = "// annotation pass OK"
+	else
+		for _, e in ipairs(errors) do
+			local src_tag = ""
+			if e.source then
+				local src_name = e.source:match("([^/\\]+)$") or e.source
+				src_tag = src_name .. ": "
+			end
+			lines[#lines + 1] = string.format('#error "%s%s (line %d)"', src_tag, e.msg, e.line)
+		end
 	end
-	if ctx.dry_run then return nil end
 	ensure_dir(ctx.out_root)
 	write_file(out_path, table.concat(lines, "\n") .. "\n")
 	return out_path
 end
 
---- Render <basename>.annotations.txt human-readable summary.
+--- Stash aggregated per-module results for the report pass to consume.
---- Implementation lives in passes/report.lua (extracted to keep this
+local function emit_module_annotations_stub(ctx, dir, dir_basename, atoms_count)
---- file focused on validation). We delegate via a callback set on ctx.
-local function emit_annotations_txt(ctx, src, result)
-	-- The annotation pass emits a structured result; the report pass
-	-- renders it. To avoid a circular dep, the M.run below packs the
-	-- result into ctx.upstream.annotation for the report pass to
-	-- consume via ctx.flags._annot_results.
 	ctx.flags         = ctx.flags or {}
 	ctx.flags._annot_results = ctx.flags._annot_results or {}
 	ctx.flags._annot_results[#ctx.flags._annot_results + 1] = {
-		source = src,
+		dir          = dir,
-		result = result,
+		dir_basename = dir_basename,
+		atoms_count  = atoms_count,
 	}
-	return nil  -- annotations.txt is written by report.lua
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -736,6 +317,9 @@ end
 
 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
+
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -743,21 +327,41 @@ function M.run(ctx)
 	local errors   = {}
 	local warnings = {}
 
-	for _, src in ipairs(ctx.sources) do
+	-- Per-DIRECTORY (per-module) aggregation. Group sources by `src.dir`,
-		local result = validate(ctx, src)
+	-- validate every source in the dir, then emit ONE errors.h per dir.
-		local err_path = emit_errors_h(ctx, src, result)
+	-- `ctx.by_dir` is pre-computed in build_ctx (shared across all passes).
+	local by_dir = ctx.by_dir or duffle.group_sources_by_dir(ctx.sources)
+
+	for dir, dir_sources in pairs(by_dir) do
+		local dir_basename = dir:match("([^/\\]+)$") or dir
+
+		local dir_atoms    = 0
+		local dir_errors   = {}
+		local dir_warnings = {}
+		-- Per-source validate() results, cached for the report pass (it reads from this instead of re-validating each source).
+		ctx.flags                       = ctx.flags or {}
+		ctx.flags._annot_source_results = ctx.flags._annot_source_results or {}
+		for _, src in ipairs(dir_sources) do
+			local result = validate(ctx, src)
+			result.source = src.path                                  -- tag for downstream rendering
+			ctx.flags._annot_source_results[src.path] = result          -- stash so report.lua reads from cache instead of re-running validate()
+			dir_atoms = dir_atoms + #result.atoms
+			for _, e in ipairs(result.errors) do
+				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
+				dir_warnings[#dir_warnings + 1] = { line = w.line, msg = w.msg }
+				warnings[#warnings + 1] = { line = w.line, msg = w.msg }
+			end
+		end
+
+		local err_path = emit_module_errors_h(ctx, dir_basename, dir_atoms, dir_errors, dir_sources)
 		if err_path then
 			table.insert(outputs, { errors_h = err_path })
 		end
-		-- Stash result for report pass.
-		emit_annotations_txt(ctx, src, result)
 
-		for _, e in ipairs(result.errors) do
+		emit_module_annotations_stub(ctx, dir, dir_basename, dir_atoms)
-			errors[#errors + 1] = { line = e.line, msg = e.msg }
-		end
-		for _, w in ipairs(result.warnings) do
-			warnings[#warnings + 1] = { line = w.line, msg = w.msg }
-		end
 	end
 
 	return { outputs = outputs, errors = errors, warnings = warnings }

scripts/passes/offsets.lua

@@ -1,286 +1,215 @@
--- passes/offsets.lua
+--- passes/offsets.lua — Branch-offset generator.
---
+---
--- Generate <module>/gen/<basename>.offsets.h with branch offset
+--- Reads the pre-scanned SourceScan payload (produced once upstream by `duffle.scan_source`)
--- immediates for every atom_offset(F, T) reference in atom bodies.
+--- for `MipsAtom_(name)` and `MipsCode code_<name>` declarations, computes the word offset
---
+--- from each `atom_offset(F, T)` marker to its target `atom_label(T)` declaration, and emits
--- The branch offset regression we just fixed in commit 98e27c2 must
+--- `<dir_basename>.offsets.h` with one `#define _atom_offset_F_T = N` per branch.
--- NOT return. The fix was in duffle.lua's split_top_level_commas +
+---
--- tape_atom_annotation_pass.lua's compute_component_word_count.
+--- The offset is `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding: branch_offset = relative_pc_in_words - 1).
--- word_count_eval.count_token_words preserves the fix.
+---
---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
--- THIS MODULE ALSO REQUIRES the recent fix to duffle.lua's
+--- Lua 5.3 compatible.
--- split_top_level_commas (the second-half of the 98e27c2 fix):
--- top-level comments must be appended to the previous token, not
--- stripped, so the emit path preserves `// trailing comment` text
--- for convert_line_comments_to_block to convert to `/* */`.
---
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
-local script_path = arg and arg[0] or "?"
+-- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
-local last_sep = 0
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
-for i = 1, #script_path do
+-- Uses `debug.getinfo` to find this file's own directory, so it works
-	local c = script_path:sub(i, i)
+-- both standalone and when require'd from the orchestrator.
-	if c == "/" or c == "\\" then last_sep = i end
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
-end
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
-package.path   = script_dir .. "../?.lua;" .. script_dir .. "../?/init.lua;" .. script_dir .. "?.lua;" .. package.path
+local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
-
+local word_count_eval = require("word_count_eval")
-local duffle              = require("duffle")
+local count_token_words = word_count_eval.count_token_words
-local trim                = duffle.trim
-local read_ident          = duffle.read_ident
-local is_space            = duffle.is_space
-local is_alpha            = duffle.is_alpha
-local is_alnum            = duffle.is_alnum
-local skip_ws_and_cmt     = duffle.skip_ws_and_cmt
-local skip_str_or_cmt     = duffle.skip_str_or_cmt
-local split_top_level_commas = duffle.split_top_level_commas
-local read_parens         = duffle.read_parens
-local read_braces         = duffle.read_braces
-local write_file          = duffle.write_file
-local dirname             = duffle.dirname
-local basename_no_ext     = duffle.basename_no_ext
-local ensure_dir          = duffle.ensure_dir
-
-local word_count_eval     = require("word_count_eval")
-local count_token_words   = word_count_eval.count_token_words
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Local helpers (ported from offset_gen.meta.lua lines 67-93)
+-- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
-local function starts_with(s, prefix)
+-- Marker-call identifiers inside atom bodies.
-	if #s < #prefix then return false end
+local LABEL_MARKER    = "atom_label"
-	for i = 1, #prefix do
+local OFFSET_MARKER   = "atom_offset"
-		if s:sub(i, i) ~= prefix:sub(i, i) then return false end
-	end
-	return true
-end
 
-local function to_upper(s) return s:upper() end
+-- Offset macro/enum naming prefixes (the emitted header uses these).
+local OFFSET_MACRO_PREFIX = "_atom_offset_"
+local OFFSET_ENUM_PREFIX  = "atom_offset_"
 
-local function to_alnum_underscore(s)
+-- Column width for the `#define _atom_offset_F_T = N` alignment.
-	local out = ""
+local OFFSET_MACRO_COL = 44
-	for i = 1, #s do
-		local c = s:sub(i, i)
-		if is_alnum(c) then out = out .. c
-		else out = out .. "_" end
-	end
-	return out
-end
-
-local function pad_right(s, w) return s .. string.rep(" ", w - #s) end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Marker-call helpers (ported from offset_gen.meta.lua lines 148-205)
+-- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Extract comma-separated identifier args from a parenthesized group
+--- @class SourceFile
---- after a function-like macro call.
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+
+--- @class PassCtx
+--- @field sources            SourceFile[]           -- all source files in the build
+--- @field metadata_path      string                 -- path to word_count.metadata.h
+--- @field shared             table                  -- cross-pass shared state
+--- @field shared.word_counts table                  -- macro name -> word count
+--- @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 dry_run            boolean                -- if true, compute but don't write
+--- @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 BranchOffset
+--- @field tag    string   -- the marker tag (e.g. "F" in `atom_offset(F, T)`)
+--- @field target string   -- the target label name (e.g. "T" in `atom_offset(F, T)`)
+--- @field pos    integer  -- the branch's word position within the atom body
+--- @field offset integer  -- computed `target_word - branch_word - 1`
+
+--- @class AtomData
+--- @field name        string         -- atom name
+--- @field total_words integer        -- total word count of the atom body
+--- @field offsets     BranchOffset[] -- per-branch offset list
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-token marker-call helpers (atom_label / atom_offset inside bodies)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Extract comma-separated identifier args from a parenthesized group after a function-like macro call.
+-- Returns (args, after_paren) where `after_paren` is the position just past the closing `)`, or nil if `token` did not start with `(`.
+-- @param token string
+-- @param after_ident integer
+-- @return string[], integer|nil
 local function extract_ident_args(token, after_ident)
-	local arg_start = skip_ws_and_cmt(token, after_ident)
+	local arg_start = duffle.skip_ws_and_cmt(token, after_ident)
 	if token:sub(arg_start, arg_start) ~= "(" then return {}, nil end
-	local inner, after_paren = read_parens(token, arg_start)
+	local inner, after_paren = duffle.read_parens(token, arg_start)
+	-- scan: <marker>(<args>)
 
-	local args = {}
+	local args      = {}
-	local n    = 1
+	local pos       = 1
-	local len  = #inner
+	local inner_len = #inner
-	while n <= len do
+	while pos <= inner_len do
-		n = skip_ws_and_cmt(inner, n)
+		pos = duffle.skip_ws_and_cmt(inner, pos)
-		if n > len then break end
+		if pos > inner_len then break end
-		local ident, after = read_ident(inner, n)
+		local ident, after = duffle.read_ident(inner, pos)
 		if ident and ident ~= "" then
 			table.insert(args, ident)
-			n = after
+			pos = after
 		else
-			n = n + 1
+			pos = pos + 1
 		end
-		n = skip_ws_and_cmt(inner, n)
+		pos = duffle.skip_ws_and_cmt(inner, pos)
-		if n <= len and inner:sub(n, n) == "," then n = n + 1 end
+		if pos <= inner_len and inner:sub(pos, pos) == "," then pos = pos + 1 end
 	end
 
 	return args, after_paren
 end
 
---- Scan a single token for atom_label/atom_offset markers, walking through
+-- (internal) Record a `atom_label(name)` marker — `at_pos` is the branch-free word position within the atom body.
---- balanced groups transparently (so nested calls are found).
+-- @param labels table<string, integer>
+-- @param args string[]
+-- @param at_pos integer
+local function record_label_marker(labels, args, at_pos)
+	if #args >= 1 then labels[args[1]] = at_pos end
+end
+
+-- (internal) Record a `atom_offset(tag, target)` marker.
+-- @param branches table[]  -- list of {pos=, target=, tag=}
+-- @param args string[]
+-- @param at_pos integer
+local function record_offset_marker(branches, args, at_pos)
+	if #args >= 2 then
+		table.insert(branches, { pos = at_pos, target = args[2], tag = args[1] })
+	end
+end
+
+--- Scan a single token for atom_label/atom_offset markers, walking through balanced groups transparently (so nested calls are found).
+--- @param token string
+--- @param at_pos integer    -- the branch-free word position of this token in the body
+--- @param labels table<string, integer>
+--- @param branches table[]
 local function scan_for_atom_markers(token, at_pos, labels, branches)
-	local i   = 1
+	local pos     = 1
-	local len = #token
+	local tok_len = #token
-	while i <= len do
+	while pos <= tok_len do
-		i = skip_ws_and_cmt(token, i)
+		pos = duffle.skip_ws_and_cmt(token, pos)
-		if i > len then break end
+		if pos > tok_len then break end
-		local c = token:sub(i, i)
+		local ch = token:sub(pos, pos)
-		if is_alpha(c) then
+		if duffle.is_alpha(ch) then
-			local ident, after = read_ident(token, i)
+			local ident, after = duffle.read_ident(token, pos)
-			if ident == "atom_label" then
+			if ident == LABEL_MARKER then
 				local args, after_paren = extract_ident_args(token, after)
-				if #args >= 1 then labels[args[1]] = at_pos end
+				record_label_marker(labels, args, at_pos)
-				if after_paren then i = after_paren else i = after end
+				pos = after_paren or after
-			elseif ident == "atom_offset" then
+			elseif ident == OFFSET_MARKER then
 				local args, after_paren = extract_ident_args(token, after)
-				if #args >= 2 then table.insert(branches, {pos = at_pos, target = args[2], tag = args[1]}) end
+				record_offset_marker(branches, args, at_pos)
-				if after_paren then i = after_paren else i = after end
+				pos = after_paren or after
 			else
-				i = after
+				pos = after
 			end
 		else
-			local nx = skip_str_or_cmt(token, i)
+			local nx = duffle.skip_str_or_cmt(token, pos)
-			if nx > i then i = nx else i = i + 1 end
+			pos = (nx > pos) and nx or (pos + 1)
 		end
 	end
 end
 
---- Find the end position (just past the closing ')') of the first
+-- (internal) Count words emitted by the rest of `tok` after a marker call
---- atom_label/atom_offset call in `tok`. Returns 0 if no such call.
+-- (the marker call itself emits 0 words, but the source pattern may bundle the marker with the next instruction on the same line,
-local function find_marker_call_end(tok)
+-- separated by no top-level comma).
-	local i   = 1
+-- Returns the word count contributed by that rest.
-	local len = #tok
+-- @param tok string
-	while i <= len do
+-- @param word_counts table
-		i = skip_ws_and_cmt(tok, i)
+-- @return integer
-		if i > len then break end
+local function count_marker_rest(tok, word_counts)
-		local c = tok:sub(i, i)
+	-- duffle.find_marker_call_end returns the position PAST the closing `)` of the marker call
-		if is_space(c) then
+	-- (or nil if `tok` isn't a marker call). Canonical impl in duffle.lua is faster than the
-			i = i + 1
+	-- file-local copy that used to live here (byte-indexed, no `tok:sub` per char).
-		elseif c == "/" then
+	local marker_end = duffle.find_marker_call_end(tok)
-			-- comment — skip past it (delegated to duffle.skip_str_or_cmt)
+	if not marker_end or marker_end >= #tok then return 0 end
-			local nx = skip_str_or_cmt(tok, i)
+	local rest = duffle.trim(tok:sub(marker_end))
-			if nx > i then i = nx else i = i + 1 end
+	if rest == "" then return 0 end
-		else
+	return count_token_words(rest, word_counts)
-			local ident, after = read_ident(tok, i)
-			if ident == "atom_label" or ident == "atom_offset" then
-				local j = skip_ws_and_cmt(tok, after)
-				if tok:sub(j, j) == "(" then
-					local _, end_paren = read_parens(tok, j)
-					return end_paren - 1
-				end
-				return 0
-			end
-			i = after or (i + 1)
-		end
-	end
-	return 0
 end
 
--- ════════════════════════════════════════════════════════════════════════════
+-- (internal) Is this token a marker call (`atom_label` or `atom_offset`)?
--- Atom scanner (ported from offset_gen.meta.lua lines 245-321)
+-- @param tok string
--- ════════════════════════════════════════════════════════════════════════════
+-- @return boolean
-
+local function is_marker_token(tok)
---- Skip C qualifier keywords (static, const, etc.) and return the position
+	local leading_ident = duffle.read_ident(tok, 1)
---- past the last qualifier.
+	return leading_ident == LABEL_MARKER or leading_ident == OFFSET_MARKER
-local function skip_qualifiers(source, i)
-	local keywords = {
-		["static"]  = true, ["const"]    = true, ["volatile"] = true,
-		["extern"]  = true, ["register"] = true, ["auto"]     = true,
-		["inline"]  = true, ["typedef"]  = true,
-		["internal"]= true, ["LP_"]      = true, ["global"]   = true, ["gkknown"] = true,
-	}
-	while true do
-		i = skip_ws_and_cmt(source, i)
-		local ident, after = read_ident(source, i)
-		if not ident       then                return i end
-		if keywords[ident] then i = after else return i end
-	end
 end
 
---- Find every MipsAtom_(name) { ... } in a source.
-local function find_atoms(source_text)
-	local atoms = {}
-	local len   = #source_text
-	local i     = 1
-
-	local function try_wrapped(after_pos)
-		local paren_pos = skip_ws_and_cmt(source_text, after_pos)
-		if source_text:sub(paren_pos, paren_pos) ~= "(" then return nil end
-		local inner, after_paren = read_parens(source_text, paren_pos)
-		local n = 1
-		while n <= #inner and is_space(inner:sub(n, n)) do n = n + 1 end
-		local ns = n
-		while n <= #inner and is_alnum(inner:sub(n, n)) do n = n + 1 end
-		local name = inner:sub(ns, n - 1)
-		if name == "" then return nil end
-		-- Find the brace after the parens.
-		local brace_pos = duffle.scan_to_char(source_text, "{", after_paren)
-		if not brace_pos then return nil end
-		local body, after_brace = read_braces(source_text, brace_pos)
-		return {name = name, body = body, after_brace = after_brace}
-	end
-
-	local function try_raw(after_pos)
-		local next_pos = skip_ws_and_cmt(source_text, after_pos)
-		local next_ident, next_after = read_ident(source_text, next_pos)
-		if not next_ident then return nil end
-		if not starts_with(next_ident, "code_") then return nil end
-		if #next_ident <= 5 then return nil end
-		local atom_name = next_ident:sub(6)
-		local brace_pos = duffle.scan_to_char(source_text, "{", next_after)
-		if not brace_pos then return nil end
-		local body, after_brace = read_braces(source_text, brace_pos)
-		return {name = atom_name, body = body, after_brace = after_brace}
-	end
-
-	while i <= len do
-		i = skip_ws_and_cmt(source_text, i); if i > len then break end
-		i = skip_qualifiers(source_text, i); if i > len then break end
-		local ident, after = read_ident(source_text, i)
-		if not ident then
-			i = i + 1
-		elseif ident == "MipsAtom_" then
-			local atom = try_wrapped(after)
-			if atom then
-				table.insert(atoms, {name = atom.name, body = atom.body})
-				i = atom.after_brace
-			else
-				i = i + 1
-			end
-		elseif ident == "MipsCode" then
-			local atom = try_raw(after)
-			if atom then
-				table.insert(atoms, {name = atom.name, body = atom.body})
-				i = atom.after_brace
-			else
-				i = after
-			end
-		else
-			i = after
-		end
-	end
-	return atoms
-end
-
--- ════════════════════════════════════════════════════════════════════════════
--- Per-atom body scan (ported from offset_gen.meta.lua lines 207-239)
--- ════════════════════════════════════════════════════════════════════════════
-
 --- Scan an atom body for labels + branches, count total words.
 --- Returns (labels, branches, total_words).
-local function scan_atom_body(body, word_counts)
+--- @param body string
+--- @param word_counts table
+--- @return table<string, integer>, table[], integer
+-- scan_atom_body: walk pre-tokenized body for atom_label/atom_offset markers + word counts.
+-- Uses `atom.body_tokens` from the SourceScan payload (pre-tokenized by scan-source pass).
+-- @param body_tokens table[]  -- {{tok=string, rel=integer}, ...} from duffle.tokenize_body
+-- @param word_counts table
+-- @return table, table, integer  -- labels, branches, total_words
+local function scan_atom_body(body_tokens, word_counts)
 	local pos      = 0
 	local labels   = {}
 	local branches = {}
-	for _, tok in ipairs(split_top_level_commas(body)) do
+	for _, t in ipairs(body_tokens) do
-		local k    = 1
+		local tok = t.tok
-		local tlen = #tok
+		if is_marker_token(tok) then
-		while k <= tlen and is_space(tok:sub(k, k)) do k = k + 1 end
-		local leading_ident = read_ident(tok, k)
-		if leading_ident == "atom_label" or leading_ident == "atom_offset" then
 			-- Marker call: record at the current pos, do NOT advance pos.
-			-- But the source pattern may bundle the marker with the next
-			-- instruction on a new line (no top-level comma between them).
-			-- In that case, the rest of `tok` after the marker call is
-			-- a real instruction that must still be counted.
 			scan_for_atom_markers(tok, pos, labels, branches)
-			local marker_end = find_marker_call_end(tok)
+			pos = pos + count_marker_rest(tok, word_counts)
-			if marker_end > 0 and marker_end < #tok then
-				local rest = trim(tok:sub(marker_end + 1))
-				if rest ~= "" then
-					local rest_words = count_token_words(rest, word_counts)
-					pos = pos + rest_words
-				end
-			end
 		else
 			local words = count_token_words(tok, word_counts)
 			scan_for_atom_markers(tok, pos, labels, branches)
@@ -291,10 +220,14 @@ local function scan_atom_body(body, word_counts)
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Offset computation + header generation (ported lines 327-383)
+-- Offset computation + header generation
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Compute branch offsets as (target_word - branch_word - 1).
+-- Compute branch offsets as `target_word - branch_word - 1`
+-- (the standard MIPS branch-immediate encoding).
+-- @param labels table<string, integer>
+-- @param branches table[]
+-- @return BranchOffset[]
 local function compute_offsets(labels, branches)
 	local results = {}
 	for _, br in ipairs(branches) do
@@ -302,17 +235,62 @@ local function compute_offsets(labels, branches)
 		if not target then
 			error("Branch target '" .. br.target .. "' has no atom_label (at word " .. br.pos .. ")")
 		end
-		table.insert(results, {target = br.target, tag = br.tag, offset = target - br.pos - 1})
+		results[#results + 1] = { target = br.target, tag = br.tag, offset = target - br.pos - 1 }
 	end
 	return results
 end
 
---- Generate the per-source .offsets.h header.
+-- Right-pad `s` with spaces to width `w`. If `s` is already `w` or wider, no padding is added.
+-- @param s string
+-- @param w integer
+-- @return string
+local function pad_right(s, w)
+	return s .. string.rep(" ", math.max(0, w - #s))
+end
+
+-- (internal) Build a constant-table entry `{macro_name, enum_name, value}` from a BranchOffset.
+-- @param r BranchOffset
+-- @return table
+local function make_offset_const(r)
+	return {
+		macro_name = OFFSET_MACRO_PREFIX .. r.tag .. "_" .. r.target,
+		enum_name  = OFFSET_ENUM_PREFIX  .. r.tag .. "_" .. r.target,
+		value      = r.offset,
+	}
+end
+
+-- (internal) Emit one atom's offset constants + enum into the lines buffer.
+-- @param add fun(s: string)
+-- @param atom AtomData
+local function emit_atom_offsets(add, atom)
+	if #atom.offsets == 0 then return end
+	add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
+	add("")
+	local consts = {}
+	for _, r in ipairs(atom.offsets) do
+		consts[#consts + 1] = make_offset_const(r)
+	end
+	for _, c in ipairs(consts) do
+		add("#define " .. pad_right(c.macro_name, OFFSET_MACRO_COL) .. "  " .. c.value)
+	end
+	add("")
+	add("enum {")
+	for _, c in ipairs(consts) do
+		add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
+	end
+	add("};")
+	add("")
+end
+
+-- Generate the per-source .offsets.h header.
+-- @param source_path string
+-- @param atoms_data AtomData[]
+-- @return string
 local function generate_header(source_path, atoms_data)
-	local basename = basename_no_ext(source_path)
+	local basename = duffle.basename_no_ext(source_path)
 
 	local lines = {}
-	local function add(s) table.insert(lines, s) end
+	local function add(s) lines[#lines + 1] = s end
 
 	add("// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT")
 	add("// Source: " .. source_path)
@@ -322,28 +300,7 @@ local function generate_header(source_path, atoms_data)
 	add("")
 	add("")
 	for _, atom in ipairs(atoms_data) do
-		if #atom.offsets > 0 then
+		emit_atom_offsets(add, atom)
-			add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
-			add("")
-			local consts = {}
-			for _, r in ipairs(atom.offsets) do
-				table.insert(consts, {
-					macro_name = "_atom_offset_" .. r.tag .. "_" .. r.target,
-					enum_name  = "atom_offset_"  .. r.tag .. "_" .. r.target,
-					value      = r.offset,
-				})
-			end
-			for _, c in ipairs(consts) do
-				add("#define " .. pad_right(c.macro_name, 44) .. "  " .. c.value)
-			end
-			add("")
-			add("enum {")
-			for _, c in ipairs(consts) do
-				add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
-			end
-			add("};")
-			add("")
-		end
 	end
 	add("#pragma endregion " .. basename)
 	add("")
@@ -351,13 +308,58 @@ local function generate_header(source_path, atoms_data)
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- M.run — orchestrator entry
+-- M — module exports
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class M
-
 local M = {}
 
+-- Project the pre-scanned SourceScan entries into the {name, body, body_tokens} shape this pass needs.
+-- MipsAtom_ entries have kind="atom"; MipsCode code_<name> entries have kind="raw_atom".
+-- `body_tokens` is set by scan-source on every `scan.atoms[i]` / `scan.raw_atoms[i]`; we carry it forward
+-- so `scan_atom_body` reads from the precomputed table directly (no per-atom tokenize_body fallback).
+-- @param scan table  -- SourceScan from duffle.scan_source
+-- @return table[]  -- list of {name=, body=, body_tokens=}
+local function project_atoms(scan)
+	local out = {}
+	for _, a in ipairs(scan.atoms) do
+		out[#out + 1] = { name = a.raw_name, body = a.body, body_tokens = a.body_tokens }
+	end
+	for _, a in ipairs(scan.raw_atoms) do
+		out[#out + 1] = { name = a.name, body = a.body, body_tokens = a.body_tokens }
+	end
+	return out
+end
+
+-- (internal) Process one source: project atoms from scan, scan bodies, write header.
+-- Returns the offsets_h path if a header was written, or nil.
+-- @param ctx PassCtx
+-- @param src SourceFile
+-- @return string|nil  -- the offsets_h path
+local function process_source(ctx, src)
+	local atoms = project_atoms(src.scan)
+	if #atoms == 0 then return nil end
+
+	local atoms_data = {}
+	for _, atom in ipairs(atoms) do
+		local labels, branches, total = scan_atom_body(atom.body_tokens, ctx.shared.word_counts)
+		atoms_data[#atoms_data + 1] = {
+			name        = atom.name,
+			total_words = total,
+			offsets     = compute_offsets(labels, branches),
+		}
+	end
+
+	local out_path = src.dir .. "/gen/" .. duffle.basename_no_ext(src.dir) .. ".offsets.h"
+	if not ctx.dry_run then
+		duffle.ensure_dir(duffle.dirname(out_path))
+		duffle.write_file(out_path, generate_header(src.path, atoms_data))
+	end
+	return out_path
+end
+
+--- Run the offsets pass.
+--- For each source, emits a per-module `<dir_basename>.offsets.h` containing `#define _atom_offset_F_T = N` constants 
+--- for every `atom_offset(F, T)` reference in the source's atoms.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -366,25 +368,9 @@ function M.run(ctx)
 	local warnings = {}
 
 	for _, src in ipairs(ctx.sources) do
-		local atoms = find_atoms(src.text)
+		local out_path = process_source(ctx, src)
-		if #atoms > 0 then
+		if out_path then
-			local atoms_data = {}
+			outputs[#outputs + 1] = { offsets_h = out_path }
-			for _, atom in ipairs(atoms) do
-				local labels, branches, total = scan_atom_body(atom.body, ctx.shared.word_counts)
-				local offsets = compute_offsets(labels, branches)
-				table.insert(atoms_data, {
-					name        = atom.name,
-					total_words = total,
-					offsets     = offsets,
-				})
-			end
-
-			local out_path = src.dir .. "/gen/" .. basename_no_ext(src.dir) .. ".offsets.h"
-			if not ctx.dry_run then
-				ensure_dir(dirname(out_path))
-				write_file(out_path, generate_header(src.path, atoms_data))
-			end
-			table.insert(outputs, { offsets_h = out_path })
 		end
 	end
 

scripts/passes/report.lua

@@ -1,111 +1,311 @@
--- passes/report.lua
+--- passes/report.lua — Per-MODULE annotation report renderer +
---
+--- project-wide summary writer.
--- Render the per-project summary (build/gen/annotation_validation.txt)
+---
--- + the per-source annotation reports (build/gen/<basename>.annotations.txt).
+--- Two output files per build:
--- Aggregates errors + warnings from upstream annotation pass results.
+---   - `build/gen/<dir_basename>.annotations.txt` — one per source-directory containing atoms; aggregates across all sources in the directory.
---
+---   - `build/gen/annotation_validation.txt` — the project summary.
--- The annotation pass stashes its per-source results in ctx.flags._annot_results
+---
--- (set by passes/annotation.lua). This report pass renders them.
+--- The annotation pass stashes per-MODULE summary entries in `ctx.flags._annot_results` (set by `passes/annotation.lua`). 
---
+--- This pass re-validates each source via `annotation.validate()` to get the detailed per-source results needed for the report. 
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex.
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
-local script_path = arg and arg[0] or "?"
+-- Resolve `arg[0]` to an absolute-ish script directory so that `require("duffle")` resolves against `scripts/` regardless of CWD.
-local last_sep = 0
+-- Note: this boilerplate is duplicated in 6 other entry scripts; a Phase-6 extraction target (`duffle.setup_package_path()`).
-for i = 1, #script_path do
+-- Bootstrap: see `ps1_meta.lua` for the rationale.
-	local c = script_path:sub(i, i)
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
-	if c == "/" or c == "\\" then last_sep = i end
+-- 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 duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Section separators used in the rendered text reports.
+-- The thin rules are hand-tuned to align with the per-section content width; do not change without also checking the section renderers below.
+local RULE_THICK = "========================================================"
+local SECTION_HEADER_ATOMS     = "── Atoms ────────────────────────────────────────────────"
+local SECTION_HEADER_ANNOTS    = "── Annotations ──────────────────────────────────────────"
+local SECTION_HEADER_BINDS     = "── Binds_* structs ──────────────────────────────────────"
+local SECTION_HEADER_MACROS    = "── Macro word-count declarations ─────────────────────────"
+local SECTION_HEADER_ERRORS    = "── Errors ──────────────────────────────────────────────"
+local SECTION_HEADER_WARNINGS  = "── Warnings ────────────────────────────────────────────"
+
+-- Lua pattern that captures the basename (last path segment) of a
+-- forward- or back-slash separated path.
+local BASENAME_PATTERN = "([^/\\]+)$"
+
+-- Debug flag name — set to truthy in `_G` to enable verbose logging.
+local DEBUG_FLAG = "_DEBUG_REPORT"
+
+-- Pass identifier for log messages.
+local PASS_NAME = "report"
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+
+--- @class PassCtx
+--- @field sources            SourceFile[]            -- all source files in the build
+--- @field metadata_path      string                  -- path to word_count.metadata.h
+--- @field shared             table                   -- cross-pass shared state
+--- @field out_root           string                  -- output root (e.g. "build/gen")
+--- @field project_root       string                  -- project root (e.g. "code/")
+--- @field upstream           table<string, table>    -- per-pass upstream outputs
+--- @field flags              table                   -- CLI flags + per-pass stash
+--- @field flags._annot_results ModuleEntry[]         -- stashed by annotation pass
+--- @field dry_run            boolean                 -- if true, compute but don't write
+--- @field verbose            boolean                 -- if true, log diagnostic info
+
+--- @class PassResult
+--- @field outputs  table[]  -- {kind=, path=} entries describing emit files
+--- @field errors   table[]  -- {line=, msg=} entries; build-stops
+--- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
+
+-- Shapes produced by `passes/annotation.lua`'s `M.validate()`.
+
+--- @class AtomEntry
+--- @field name string   -- atom name (e.g. "cube_g4_face")
+--- @field line integer  -- source line of the atom declaration
+
+--- @class AnnotEntry
+--- @field line    integer  -- source line
+--- @field macro   string   -- the macro name (e.g. "atom_reads")
+--- @field name    string   -- the atom name (if a `name(...)` was given)
+--- @field kind    string   -- "atom_info" | "atom_bind" | ...
+--- @field binds   string|nil  -- Binds_X name if any
+--- @field reads   string[]    -- R_* names (read targets)
+--- @field writes  string[]    -- R_* names (write targets)
+--- @field error   string|nil  -- error message if annotation was malformed
+
+--- @class BindsField
+--- @field name   string   -- field name
+--- @field offset integer  -- byte offset within the Binds_X struct
+
+--- @class BindsStruct
+--- @field name   string         -- struct name (e.g. "Binds_Floor")
+--- @field line   integer        -- source line of the typedef
+--- @field bytes  integer        -- total byte size
+--- @field fields BindsField[]   -- the field list
+
+--- @class MacroEntry
+--- @field name  string   -- macro name (e.g. "WORD_COUNT(my_macro, 4)")
+--- @field line  integer  -- source line
+--- @field words integer  -- declared word count
+
+--- @class Finding
+--- @field line integer  -- source line
+--- @field msg  string   -- finding message
+
+--- @class AnnotationResult
+--- @field source   string         -- set by this pass; original source path
+--- @field atoms    AtomEntry[]    -- atom declarations in this source
+--- @field annots   AnnotEntry[]   -- annotation entries
+--- @field macros   MacroEntry[]   -- macro word-count declarations
+--- @field binds    BindsStruct[]  -- Binds_* struct declarations
+--- @field errors   Finding[]      -- errors from validation
+--- @field warnings Finding[]      -- warnings from validation
+--- @field info     table          -- info summary (not rendered here)
+
+--- @class ModuleEntry
+--- @field dir          string   -- absolute directory path
+--- @field dir_basename string   -- basename (e.g. "duffle", "gte_hello")
+--- @field atoms_count  integer  -- pre-counted atoms for filtering
+
+--- @class ModuleReport
+--- @field dir       string             -- module directory
+--- @field sources   SourceFile[]       -- sources in this module
+--- @field results   AnnotationResult[] -- per-source validate() results
+
+--- @class ProjectReport
+--- @field results AnnotationResult[]  -- all per-source results
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-MODULE annotation report (aggregated across all sources in a dir)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Extract the basename (last path segment) of a forward- or back-slash separated path. Returns the input unchanged if no separator is found.
+-- @param path string
+-- @return string
+local function source_basename(path)
+	return path:match(BASENAME_PATTERN) or path
 end
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
-package.path   = script_dir .. "../?.lua;" .. script_dir .. "../?/init.lua;" .. script_dir .. "?.lua;" .. package.path
 
-local duffle        = require("duffle")
+-- (internal) Format a single annotation entry as one rendered line.
-local ensure_dir    = duffle.ensure_dir
+-- @param a AnnotEntry
-local write_file    = duffle.write_file
+-- @param src_name string
+-- @return string
+local function format_annot_line(a, src_name)
+	if a.error then
+		return string.format("  ✗ line %d  %s  [ERROR: %s]  [%s]", a.line, a.macro or "?", a.error, src_name)
+	end
+	local line = string.format("  ●  line %d  %s  [%s]", a.line, a.name, src_name)
+	if a.binds               then line = line .. "  binds=" .. a.binds end
+	if #a.reads > 0          then line = line .. "  reads={" .. table.concat(a.reads, ",") .. "}" end
+	if #a.writes > 0         then line = line .. "  writes={" .. table.concat(a.writes, ",") .. "}" end
+	return line
+end
 
--- ════════════════════════════════════════════════════════════════════════════
+-- (internal) Tally totals across all results in a module.
--- Per-source annotation report (ported from tape_atom_annotation_pass.lua:1411-1486)
+-- @param results AnnotationResult[]
--- ════════════════════════════════════════════════════════════════════════════
+-- @return integer, integer, integer, integer, integer, integer
+local function tally_module_totals(results)
+	local total_atoms, total_annots, total_binds, total_macros = 0, 0, 0, 0
+	local total_errors, total_warnings = 0, 0
+	for _, r in ipairs(results) do
+		total_atoms    = total_atoms    + #r.atoms
+		total_annots   = total_annots   + #r.annots
+		total_binds    = total_binds    + #r.binds
+		total_macros   = total_macros   + #r.macros
+		total_errors   = total_errors   + #r.errors
+		total_warnings = total_warnings + #r.warnings
+	end
+	return total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings
+end
 
-local function render_source_report(source_path, result)
+-- (internal) Section renderer: per-source atom declarations.
+local function render_module_atoms_section(add, results)
+	add(SECTION_HEADER_ATOMS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, a in ipairs(r.atoms) do
+			add(string.format("  MipsAtom_(%s)   line %d   [%s]", a.name, a.line, src_name))
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source annotation entries.
+local function render_module_annots_section(add, results)
+	add(SECTION_HEADER_ANNOTS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, a in ipairs(r.annots) do
+			add(format_annot_line(a, src_name))
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source Binds_* struct declarations.
+local function render_module_binds_section(add, results)
+	add(SECTION_HEADER_BINDS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, b in ipairs(r.binds) do
+			add(string.format("  %s   line %d   %d bytes   [%s]", b.name, b.line, b.bytes, src_name))
+			for _, f in ipairs(b.fields) do
+				add(string.format("    +%2d: %s", f.offset, f.name))
+			end
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source macro word-count declarations.
+local function render_module_macros_section(add, results)
+	add(SECTION_HEADER_MACROS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, m in ipairs(r.macros) do
+			add(string.format("  %s  line %d  words=%d  [%s]", m.name, m.line, m.words, src_name))
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source errors (one-line + "(none)" if empty).
+local function render_module_errors_section(add, results, total_errors)
+	add(SECTION_HEADER_ERRORS)
+	if total_errors == 0 then
+		add("  (none)")
+	else
+		for _, r in ipairs(results) do
+			local src_name = source_basename(r.source)
+			for _, e in ipairs(r.errors) do
+				add(string.format("  ✗ line %d  %s  [%s]", e.line, e.msg, src_name))
+			end
+		end
+	end
+	add("")
+end
+
+-- (internal) Section renderer: per-source warnings (one-line + "(none)" if empty).
+local function render_module_warnings_section(add, results, total_warnings)
+	add(SECTION_HEADER_WARNINGS)
+	if total_warnings == 0 then
+		add("  (none)")
+	else
+		for _, r in ipairs(results) do
+			local src_name = source_basename(r.source)
+			for _, w in ipairs(r.warnings) do
+				add(string.format("  ⚠ line %d  %s  [%s]", w.line, w.msg, src_name))
+			end
+		end
+	end
+	add("")
+end
+
+--- Render the per-MODULE annotation report (one `<dir_basename>.annotations.txt`).
+--- @param dir string                  -- module directory path
+--- @param sources SourceFile[]        -- sources in this module
+--- @param results AnnotationResult[]  -- per-source validate() results
+--- @return string                     -- the rendered report text
+local function render_module_report(dir, sources, results)
 	local lines = {}
 	local function add(s) lines[#lines + 1] = s end
 
-	add("========================================================")
+	add(RULE_THICK)
-	add("ANNOTATION PASS — " .. source_path)
+	add("ANNOTATION PASS — module " .. source_basename(dir))
-	add("========================================================")
+	add(RULE_THICK)
+	add(string.format("Sources: %d", #sources))
+	for _, s in ipairs(sources) do add("  " .. s.path) end
 	add("")
+
+	local total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings = tally_module_totals(results)
 	add(string.format("Atoms: %d   Annotations: %d   Binds structs: %d   Macro decls: %d",
-		#result.atoms, #result.annots,
+		total_atoms, total_annots, total_binds, total_macros))
-		#result.binds, #result.macros))
 	add("")
 
-	add("── Atoms ────────────────────────────────────────────────")
+	render_module_atoms_section(add, results)
-	for _, a in ipairs(result.atoms) do
+	render_module_annots_section(add, results)
-		add(string.format("  MipsAtom_(%s)   line %d", a.name, a.line))
+	render_module_binds_section(add, results)
-	end
+	render_module_macros_section(add, results)
-	add("")
+	render_module_errors_section(add, results, total_errors)
-
+	render_module_warnings_section(add, results, total_warnings)
-	add("── Annotations ──────────────────────────────────────────")
-	for _, a in ipairs(result.annots) do
-		if a.error then
-			add(string.format("  ✗ line %d  %s  [ERROR: %s]", a.line, a.macro or "?", a.error))
-		else
-			local line = string.format("  ●  line %d  %s", a.line, a.name)
-			if a.binds then line = line .. "  binds=" .. a.binds end
-			if #a.reads > 0 then line = line .. "  reads={" .. table.concat(a.reads, ",") .. "}" end
-			if #a.writes > 0 then line = line .. "  writes={" .. table.concat(a.writes, ",") .. "}" end
-			add(line)
-		end
-	end
-	add("")
-
-	add("── Binds_* structs ──────────────────────────────────────")
-	for _, b in ipairs(result.binds) do
-		add(string.format("  %s   line %d   %d bytes", b.name, b.line, b.bytes))
-		for _, f in ipairs(b.fields) do
-			add(string.format("    +%2d: %s", f.offset, f.name))
-		end
-	end
-	add("")
-
-	add("── Macro word-count declarations ─────────────────────────")
-	for _, m in ipairs(result.macros) do
-		add(string.format("  %s  line %d  words=%d", m.name, m.line, m.words))
-	end
-	add("")
-
-	add("── Errors ──────────────────────────────────────────────")
-	if #result.errors == 0 then add("  (none)") end
-	for _, e in ipairs(result.errors) do
-		add(string.format("  ✗ line %d  %s", e.line, e.msg))
-	end
-	add("")
-
-	add("── Warnings ────────────────────────────────────────────")
-	if #result.warnings == 0 then add("  (none)") end
-	for _, w in ipairs(result.warnings) do
-		add(string.format("  ⚠ line %d  %s", w.line, w.msg))
-	end
-	add("")
 
 	return table.concat(lines, "\n") .. "\n"
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- Per-project summary (ported from tape_atom_annotation_pass.lua:1488-1528)
+-- Per-project summary
 -- ════════════════════════════════════════════════════════════════════════════
 
+--- Render the per-project summary (`build/gen/annotation_validation.txt`).
+--- Aggregates totals across all sources; lists per-source error counts if any source has errors.
+--- @param all_results AnnotationResult[]
+--- @return string
 local function render_project_report(all_results)
 	local lines = {}
 	local function add(s) lines[#lines + 1] = s end
 
 	local total_atoms, total_annots, total_macros, total_binds = 0, 0, 0, 0
 	local total_errors, total_warnings = 0, 0
-
 	for _, r in ipairs(all_results) do
 		total_atoms    = total_atoms    + #r.atoms
 		total_annots   = total_annots   + #r.annots
@@ -115,9 +315,9 @@ local function render_project_report(all_results)
 		total_warnings = total_warnings + #r.warnings
 	end
 
-	add("========================================================")
+	add(RULE_THICK)
 	add("ANNOTATION VALIDATION — project summary")
-	add("========================================================")
+	add(RULE_THICK)
 	add("")
 	add(string.format("Atoms:        %d", total_atoms))
 	add(string.format("Annotations:  %d", total_annots))
@@ -132,7 +332,8 @@ local function render_project_report(all_results)
 		add("Per-source error counts:")
 		for _, r in ipairs(all_results) do
 			if #r.errors > 0 then
-				add(string.format("  %s : %d error(s)", r.source, #r.errors))
+				local src_name = source_basename(r.source)
+				add(string.format("  %s : %d error(s)", src_name, #r.errors))
 			end
 		end
 		add("")
@@ -142,13 +343,59 @@ local function render_project_report(all_results)
 end
 
 -- ════════════════════════════════════════════════════════════════════════════
--- M.run — orchestrator entry
+-- Orchestration helpers
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class M
+-- (internal) Pull per-source validate() results from the annotation pass's stash.
+-- The annotation pass runs first in the dep chain and caches results in `ctx.flags._annot_source_results`; we read from there instead of re-validating each source.
+-- Returns the list of module results + the flat list of all results (for the project-wide summary).
+-- @param ctx PassCtx
+-- @param dir_sources SourceFile[]
+-- @return AnnotationResult[], AnnotationResult[]
+local function lookup_module_results(ctx, dir_sources)
+	local src_cache      = (ctx.flags and ctx.flags._annot_source_results) or {}
+	local module_results = {}
+	local all_results    = {}
+	for _, src in ipairs(dir_sources) do
+		local result = src_cache[src.path]
+		if result then
+			result.source = src.path                                    -- defensive (annotation tags it too; this guards against cache misses from earlier iterations)
+			module_results[#module_results + 1] = result
+			all_results[#all_results + 1] = result
+		end
+	end
+	return module_results, all_results
+end
+
+-- (internal) Does this module's results contain anything worth emitting?
+-- @param module_results AnnotationResult[]
+-- @return boolean
+local function module_has_content(module_results)
+	for _, r in ipairs(module_results) do
+		if #r.atoms  > 0 or #r.annots > 0 or #r.binds    > 0
+		or #r.macros > 0 or #r.errors > 0 or #r.warnings > 0 then
+			return true
+		end
+	end
+	return false
+end
+
+-- (internal) Log a debug message if `_G[DEBUG_FLAG]` is truthy.
+-- @param fmt string
+local function debug_log(fmt, ...)
+	if _G[DEBUG_FLAG] then
+		io.stderr:write(string.format("[%s] " .. fmt, PASS_NAME, ...))
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M — module exports
+-- ════════════════════════════════════════════════════════════════════════════
 
 local M = {}
 
+--- Run the report pass. 
+--- Renders one `<dir_basename>.annotations.txt` per source-directory that has content, plus the project-wide `annotation_validation.txt` summary.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
@@ -156,37 +403,38 @@ function M.run(ctx)
 	local errors   = {}
 	local warnings = {}
 
-	-- The annotation pass stashes per-source results in ctx.flags._annot_results.
+	local module_entries = (ctx.flags and ctx.flags._annot_results) or {}
-	-- Render each as build/gen/<basename>.annotations.txt and aggregate into
+	local by_dir         = ctx.by_dir or duffle.group_sources_by_dir(ctx.sources)
-	-- build/gen/annotation_validation.txt.
-	local annot_results = (ctx.flags and ctx.flags._annot_results) or {}
 
-	-- Render per-source reports.
+	if not ctx.dry_run then duffle.ensure_dir(ctx.out_root) end
-	-- Hoist ensure_dir out of the loop (cache + hoisting = single mkdir).
+
-	if not ctx.dry_run then ensure_dir(ctx.out_root) end
+	local all_results_for_summary = {}
-	for _, entry in ipairs(annot_results) do
+	for _, entry in ipairs(module_entries) do
-		local src = entry.source
+		debug_log("entry: dir=%s basename=%s atoms_count=%d dir_sources=%d\n", entry.dir, entry.dir_basename, entry.atoms_count, #(by_dir[entry.dir] or {}))
-		local result = entry.result
+
-		local out_path = ctx.out_root .. "/" .. src.basename .. ".annotations.txt"
+		if entry.atoms_count > 0 or #(by_dir[entry.dir] or {}) > 0 then
-		if not ctx.dry_run then
+			local dir_sources                 = by_dir[entry.dir] or {}
-			write_file(out_path, render_source_report(src.path, result))
+			local module_results, all_results = lookup_module_results(ctx, dir_sources)
+			for _, r in ipairs(all_results) do
+				all_results_for_summary[#all_results_for_summary + 1] = r
+			end
+
+			if module_has_content(module_results) then
+				local out_path = ctx.out_root .. "/" .. entry.dir_basename .. ".annotations.txt"
+				if not ctx.dry_run then
+					duffle.write_file(out_path, render_module_report(entry.dir, dir_sources, module_results))
+				end
+				outputs[#outputs + 1] = { annotations_txt = out_path }
+			else
+				debug_log("  -> no content; skipping\n")
+			end
 		end
-		table.insert(outputs, { annotations_txt = out_path })
 	end
 
-	-- Render project summary.
+	if not ctx.dry_run and #all_results_for_summary > 0 then
-	if not ctx.dry_run then
-		-- The project report references each source by its absolute path.
-		-- Augment the entries with a .source field for the per-source error counts.
-		-- ensure_dir was already hoisted above; cache makes this a no-op.
-		local all_results = {}
-		for _, entry in ipairs(annot_results) do
-			entry.result.source = entry.source.path
-			table.insert(all_results, entry.result)
-		end
 		local summary_path = ctx.out_root .. "/annotation_validation.txt"
-		write_file(summary_path, render_project_report(all_results))
+		duffle.write_file(summary_path, render_project_report(all_results_for_summary))
-		table.insert(outputs, { summary_txt = summary_path })
+		outputs[#outputs + 1] = { summary_txt = summary_path }
 	end
 
 	return { outputs = outputs, errors = errors, warnings = warnings }

scripts/passes/scan_source.lua

@@ -0,0 +1,484 @@
+--- passes/scan_source.lua — Source pre-scan pass (the "mega entity" pass).
+---
+--- Single source-walk pass that produces the fat `SourceScan` payload consumed by all downstream passes. Walks each `ctx.sources` entry once, 
+--- extracting every construct type the metaprograms need:
+---
+---   MipsAtom_              (kind = "atom", with optional atom_info inner)
+---   MipsAtomComp_          (kind = "comp_bare")
+---   MipsAtomComp_Proc_     (kind = "comp_proc", body inside last {})
+---   MipsCode code_<name>   (kind = "raw_atom", offsets pass only)
+---   typedef Struct_(Binds_X) { fields }
+---   #pragma mac_X tape_atom words=N   +   _Pragma("...")
+---
+--- The result is attached to each `src.scan` so downstream passes can read from `src.scan.atoms` / `src.scan.binds` / etc. without re-walking the source.
+--- This is the first pass in the dep graph (no deps).
+--- Every other pass that reads source structure depends on this one — see `ps1_meta.lua :: PASSES`.
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+-- Bootstrap: same as entry scripts. See `ps1_meta.lua` for the rationale.
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
+-- 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 duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceScan
+--- @field atoms      AtomEntry[]     -- MipsAtom_ + MipsAtomComp_ + MipsAtomComp_Proc_
+--- @field raw_atoms  AtomEntry[]     -- MipsCode code_<name> { body } (offsets pass only)
+--- @field binds      BindsEntry[]    -- typedef Struct_(Binds_X) { fields } (fields pre-parsed)
+--- @field atom_infos AtomInfoEntry[] -- MipsAtom_(name) atom_info(...) (sub-calls pre-parsed)
+--- @field macros     MacroEntry[]    -- #pragma mac_X tape_atom words=N  +  _Pragma("...")
+--- @field line_of    fun(pos: integer): integer  -- shared LineIndex closure
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+--- @field scan     table   -- pre-scanned SourceScan payload (set by this pass)
+
+--- @class PassCtx
+--- @field sources            SourceFile[]
+--- @field metadata_path      string
+--- @field shared             table
+--- @field out_root           string
+--- @field project_root       string
+--- @field upstream           table<string, table>
+--- @field flags              table
+--- @field dry_run            boolean
+--- @field verbose            boolean
+
+--- @class PassResult
+--- @field outputs  table[]
+--- @field errors   table[]
+--- @field warnings table[]
+
+--- @class AtomEntry
+--- @field line       integer
+--- @field name       string         -- atom name (for components: without ac_ prefix)
+--- @field body       string         -- brace-delimited body (without the braces)
+--- @field body_off   integer        -- char offset of body[1] in source
+--- @field kind       string         -- "atom" | "comp_bare" | "comp_proc" | "raw_atom"
+--- @field raw_name   string         -- un-stripped name (for components: with ac_ prefix)
+--- @field ident_pos  integer        -- position of the MipsAtom_/MipsAtomComp_ ident start
+--- @field after_paren integer       -- position past the closing paren
+--- @field args       string|nil     -- populated by components pass (backward lookup)
+--- @field comment    string|nil     -- populated by components pass (backward lookup)
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Local helpers
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- C qualifier keywords that may precede a MipsAtom_ / MipsCode declaration.
+-- (typedef is NOT a qualifier here — it's a separate construct (`typedef Struct_(Binds_X) { ... };`)
+-- and must be read as an ident so the typedef check below can match it.)
+local QUALIFIER_KEYWORDS = {
+	["static"]   = true, ["const"] = true, ["volatile"] = true, ["extern"] = true,
+	["register"] = true, ["auto"]  = true, ["inline"]   = true,
+	["internal"] = true, ["LP_"]   = true, ["global"]   = true, ["gkknown"] = true,
+}
+
+-- Parse the U4 fields from a Binds_X body. Returns (fields, byte_count).
+local function scan_binds_fields(body)
+	local fields   = {}
+	local byte_off = 0
+	local body_pos = 1
+	while body_pos <= #body do
+		body_pos = duffle.skip_ws_and_cmt(body, body_pos)
+		if body_pos > #body then break end
+		local type_ident, type_end = duffle.read_ident(body, body_pos)
+		if not type_ident then
+			body_pos = body_pos + 1
+		elseif type_ident == "U4" then
+			local field_ident, field_end = duffle.read_ident(body, duffle.skip_ws_and_cmt(body, type_end))
+			if field_ident then
+				fields[#fields + 1] = { name = field_ident, offset = byte_off }
+				byte_off = byte_off + 4
+			end
+			body_pos = field_end or (type_end + 1)
+		else
+			body_pos = type_end + 1
+		end
+	end
+	return fields, byte_off
+end
+
+-- Parse the register list from inside `atom_reads(...)` or `atom_writes(...)`.
+local function scan_reg_list(sub_inner)
+	local regs = {}
+	local sub_inner_pos = 1
+	while sub_inner_pos <= #sub_inner do
+		sub_inner_pos = duffle.skip_ws_and_cmt(sub_inner, sub_inner_pos)
+		if sub_inner_pos > #sub_inner then break end
+		local reg_ident, reg_end = duffle.read_ident(sub_inner, sub_inner_pos)
+		if reg_ident then
+			regs[#regs + 1] = duffle.trim(reg_ident)
+			sub_inner_pos = reg_end
+		else
+			sub_inner_pos = sub_inner_pos + 1
+		end
+		if sub_inner_pos > #sub_inner then break end
+		if sub_inner:sub(sub_inner_pos, sub_inner_pos) == "," then sub_inner_pos = sub_inner_pos + 1 end
+	end
+	return regs
+end
+
+-- Parse the sub-calls inside `atom_info(atom_bind(...), atom_reads(...), atom_writes(...))`.
+-- Returns (binds, reads, writes).
+local function scan_atom_info_subcalls(info_inner)
+	local binds, reads, writes = nil, nil, nil
+	local sub_pos = 1
+	while sub_pos <= #info_inner do
+		sub_pos = duffle.skip_ws_and_cmt(info_inner, sub_pos)
+		if sub_pos > #info_inner then break end
+		local sub_ident, sub_end = duffle.read_ident(info_inner, sub_pos)
+		if not sub_ident then
+			sub_pos = sub_pos + 1
+		elseif sub_ident == "atom_bind" then
+			local sub_open = duffle.skip_ws_and_cmt(info_inner, sub_end)
+			if info_inner:sub(sub_open, sub_open) == "(" then
+				local sub_inner, sub_after2 = duffle.read_parens(info_inner, sub_open)
+				-- scan: atom_bind(<Binds_X>)
+				binds = duffle.trim(sub_inner)
+				sub_pos = sub_after2
+			else
+				sub_pos = sub_open + 1
+			end
+		elseif sub_ident == "atom_reads" or sub_ident == "atom_writes" then
+			local kind = sub_ident
+			local sub_open = duffle.skip_ws_and_cmt(info_inner, sub_end)
+			if info_inner:sub(sub_open, sub_open) == "(" then
+				local sub_inner, sub_after2 = duffle.read_parens(info_inner, sub_open)
+				-- scan: atom_reads(<regs>)  OR  atom_writes(<regs>)
+				local regs = scan_reg_list(sub_inner)
+				if kind == "atom_reads" then reads = regs else writes = regs end
+				sub_pos = sub_after2
+			else
+				sub_pos = sub_open + 1
+			end
+		else
+			sub_pos = sub_end
+		end
+	end
+	return binds, reads, writes
+end
+
+-- Skip C qualifier keywords and return the position past the last one.
+local function scan_skip_qualifiers(source, pos)
+	while true do
+		pos = duffle.skip_ws_and_cmt(source, pos)
+		local ident, after = duffle.read_ident(source, pos)
+		if not ident then return pos end
+		if QUALIFIER_KEYWORDS[ident] then pos = after else return pos end
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- The single source walker
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Single-pass source scan. Walks the source ONCE and extracts every construct type the metaprogram passes need.
+--- Returns a fat SourceScan table. Each pass filters from this payload instead of re-walking the source.
+--- @param source string
+--- @return table  -- SourceScan { atoms, raw_atoms, binds, atom_infos, macros, line_of }
+local function scan_source(source)
+	local line_of = duffle.LineIndex(source)
+	local atoms       = {}
+	local raw_atoms   = {}
+	local binds       = {}
+	local atom_infos  = {}
+	local macros      = {}
+	local pos         = 1
+	local src_len     = #source
+
+	while pos <= src_len do
+		pos = duffle.skip_ws_and_cmt(source, pos)
+		if pos > src_len then break end
+
+		-- Skip preprocessor directives (#define / #include / #pragma / etc).
+		-- _Pragma is an operator (not a directive) — it doesn't start with #.
+		local pp_pos = duffle.skip_preprocessor_line(source, pos)
+		if pp_pos then pos = pp_pos; goto continue end
+
+		-- Skip C qualifiers (static, const, etc.) that may precede a declaration.
+		pos = scan_skip_qualifiers(source, pos)
+		if pos > src_len then break end
+
+		local ident, ident_end = duffle.read_ident(source, pos)
+		-- scan: <ident>
+		if not ident then pos = pos + 1; goto continue end
+
+		-- ── MipsAtom_ / MipsAtomComp_ / MipsAtomComp_Proc_ ──
+		if ident == "MipsAtom_" or ident == "MipsAtomComp_" or ident == "MipsAtomComp_Proc_" then
+			local is_atom = ident == "MipsAtom_"
+			local is_comp = ident == "MipsAtomComp_"
+			local is_proc = ident == "MipsAtomComp_Proc_"
+			local kind = is_atom and "atom" or (is_comp and "comp_bare" or "comp_proc")
+			local open_paren = duffle.skip_ws_and_cmt(source, ident_end)
+			if source:sub(open_paren, open_paren) ~= "(" then pos = open_paren + 1; goto continue end
+
+			local inner, after_paren = duffle.read_parens(source, open_paren)
+			-- scan: <ident>(<args>)
+
+			if is_proc then
+				-- MipsAtomComp_Proc_(name, { body }) — body is inside the LAST { } in args.
+				local last_brace_pos
+				for search_pos = #inner, 1, -1 do
+					if inner:sub(search_pos, search_pos) == "{" then last_brace_pos = search_pos; break end
+				end
+				if last_brace_pos then
+					local depth = 1
+					local inner_pos = last_brace_pos + 1
+					while inner_pos <= #inner and depth > 0 do
+						local c = inner:byte(inner_pos)
+						if c == 123 then depth = depth + 1; inner_pos = inner_pos + 1
+						elseif c == 125 then depth = depth - 1; if depth == 0 then break end; inner_pos = inner_pos + 1
+						elseif c == 40 then local _, a = duffle.read_parens(inner, inner_pos); inner_pos = a
+						elseif c == 91 then local _, a = duffle.read_brackets(inner, inner_pos); inner_pos = a
+						elseif c == 34 or c == 39 then inner_pos = duffle.skip_str_or_cmt(inner, inner_pos) + 1
+						else inner_pos = inner_pos + 1 end
+					end
+					if depth == 0 then
+						-- scan: <ident>(<name>, { <body> })
+						local name_match = inner:match("^%s*([%w_]+)")
+						local raw_name = name_match or "?"
+						-- Strip "ac_" prefix for component names (components pass convention).
+						local name = raw_name
+						if #raw_name > 3 and raw_name:sub(1, 3) == "ac_" then
+							name = raw_name:sub(4)
+						end
+						local body = inner:sub(last_brace_pos + 1, inner_pos - 1)
+						local body_off = open_paren + 1 + last_brace_pos
+						atoms[#atoms + 1] = {
+							line = line_of(pos), name = name, body = body, body_off = body_off + 1,
+							kind = kind, raw_name = raw_name,
+							ident_pos = pos, after_paren = after_paren,
+							args = nil, comment = nil,
+						}
+					end
+				end
+				pos = after_paren
+			else
+				-- MipsAtom_(name) { body }  OR  MipsAtomComp_(name) { body }
+				local name_start = 1
+				while name_start <= #inner and inner:sub(name_start, name_start):match("[%s]") do name_start = name_start + 1 end
+				local name_end = name_start
+				while name_end <= #inner and inner:sub(name_end, name_end):match("[%w_]") do name_end = name_end + 1 end
+				local raw_name = inner:sub(name_start, name_end - 1)
+				-- scan: <ident>(<name>)
+				if raw_name ~= "" then
+					local brace = duffle.scan_to_char(source, "{", after_paren)
+					-- scan: <ident>(<name>) {
+					if brace then
+						local body, after_brace = duffle.read_braces(source, brace)
+						-- scan: <ident>(<name>) { <body> }
+						-- Strip "ac_" prefix for component names (components pass convention).
+						local disp_name = raw_name
+						if is_comp and #raw_name > 3 and raw_name:sub(1, 3) == "ac_" then
+							disp_name = raw_name:sub(4)
+						end
+						atoms[#atoms + 1] = {
+							line = line_of(pos), name = disp_name, body = body, body_off = brace + 1,
+							kind = kind, raw_name = raw_name,
+							ident_pos = pos, after_paren = after_paren,
+							args = nil, comment = nil,
+						}
+						pos = after_brace
+					else
+						pos = open_paren + 1
+					end
+				else
+					pos = open_paren + 1
+				end
+			end
+
+			-- For MipsAtom_ entries: check if atom_info(...) follows.
+			if is_atom then
+				local lookahead = duffle.skip_ws_and_cmt(source, after_paren)
+				local look_ident, look_end = duffle.read_ident(source, lookahead)
+				-- scan: MipsAtom_(<name>) <look_ident>
+				if look_ident == "atom_info" then
+					local info_open = duffle.skip_ws_and_cmt(source, look_end)
+					if source:sub(info_open, info_open) == "(" then
+						local info_inner, info_after = duffle.read_parens(source, info_open)
+						-- scan: MipsAtom_(<name>) atom_info(<binds>, <reads>, <writes>)
+						-- Find the atom name from the just-parsed atom entry (last one added).
+						local last_atom = atoms[#atoms]
+						local atom_name = last_atom and last_atom.raw_name or "?"
+						local ai_binds, ai_reads, ai_writes = scan_atom_info_subcalls(info_inner)
+						atom_infos[#atom_infos + 1] = {
+							atom_name = atom_name, binds = ai_binds,
+							reads = ai_reads or {}, writes = ai_writes or {},
+							info_line = line_of(lookahead),
+						}
+						-- Don't advance pos past info_after — the body { ... } still needs to be skipped
+						-- by the brace scan below. But if there's no body (forward decl), advance.
+						local body_brace = duffle.scan_to_char(source, "{", info_after)
+						if body_brace then
+							local _, after_body = duffle.read_braces(source, body_brace)
+							pos = after_body
+						else
+							pos = info_after
+						end
+					end
+				end
+			end
+			goto continue
+		end
+
+		-- ── MipsCode code_<name> { body } (raw atom form — offsets pass only) ──
+		if ident == "MipsCode" then
+			local next_pos = duffle.skip_ws_and_cmt(source, ident_end)
+			local next_ident, next_after = duffle.read_ident(source, next_pos)
+			-- scan: MipsCode <next_ident>
+			if next_ident and #next_ident > 5 and next_ident:sub(1, 5) == "code_" then
+				local atom_name = next_ident:sub(6)
+				-- scan: MipsCode code_<name>
+				local brace_pos = duffle.scan_to_char(source, "{", next_after)
+				-- scan: MipsCode code_<name> {
+				if brace_pos then
+					local body, after_brace = duffle.read_braces(source, brace_pos)
+					-- scan: MipsCode code_<name> { <body> }
+					raw_atoms[#raw_atoms + 1] = {
+						line = line_of(pos), name = atom_name, body = body, body_off = brace_pos + 1,
+						kind = "raw_atom", raw_name = atom_name,
+					}
+					pos = after_brace
+					goto continue
+				end
+			end
+			pos = ident_end
+			goto continue
+		end
+
+		-- ── typedef Struct_(Binds_X) { fields } ──
+		if ident == "typedef" then
+			local after_typedef = duffle.skip_ws_and_cmt(source, ident_end)
+			local id2, id2_end = duffle.read_ident(source, after_typedef)
+			-- scan: typedef <id2>
+			if id2 == "Struct_" then
+				local open_paren = duffle.skip_ws_and_cmt(source, id2_end)
+				if source:sub(open_paren, open_paren) == "(" then
+					local inner, after_paren = duffle.read_parens(source, open_paren)
+					-- scan: typedef Struct_(<name>)
+					local name = duffle.trim(inner)
+					local brace = duffle.scan_to_char(source, "{", after_paren)
+					-- scan: typedef Struct_(<name>) {
+					if brace then
+						local body, after_brace = duffle.read_braces(source, brace)
+						-- scan: typedef Struct_(<name>) { <fields> }
+						if name:sub(1, 6) == "Binds_" then
+							local fields, byte_off = scan_binds_fields(body)
+							binds[#binds + 1] = { line = line_of(pos), name = name, fields = fields, bytes = byte_off }
+						end
+						pos = after_brace
+						goto continue
+					end
+					pos = open_paren + 1
+					goto continue
+				end
+				pos = id2_end or (after_typedef + 1)
+				goto continue
+			end
+			pos = ident_end
+			goto continue
+		end
+
+		-- ── _Pragma("mac_X tape_atom words=N") (operator form) ──
+		if ident == "_Pragma" then
+			local open_paren = duffle.skip_ws_and_cmt(source, ident_end)
+			if source:sub(open_paren, open_paren) == "(" then
+				local str, str_end = duffle.read_parens(source, open_paren)
+				-- scan: _Pragma(<string>)
+				str = duffle.trim(str)
+				if str:sub(1, 1) == '"' and str:sub(-1) == '"' then
+					local inner = str:sub(2, -2)
+					local space = duffle.find_byte(inner, 32, 1)
+					if space then
+						local name = inner:sub(1, space - 1)
+						local rest = inner:sub(space + 1)
+						local eq = duffle.find_byte(rest, 61, 1)
+						if eq then
+							local key = duffle.trim(rest:sub(1, eq - 1))
+							local val = duffle.trim(rest:sub(eq + 1))
+							if key == "tape_atom words" or key == "words" then
+								macros[#macros + 1] = { line = line_of(pos), name = name, words = tonumber(val) or 0 }
+							end
+						end
+					end
+				end
+				pos = str_end
+				goto continue
+			end
+			pos = open_paren + 1
+			goto continue
+		end
+
+		-- ── #pragma mac_X tape_atom words=N (directive form) ──
+		-- (preprocessor skip above handles # lines, but pragma is an ident here
+		--  only if it appeared without a leading # — which happens when the
+		--  preprocessor skip didn't fire because the # was on a previous line.
+		--  The annotation pass handles this via its own skip_preprocessor_line,
+		--  but scan_source handles it here by checking the ident.)
+		if ident == "pragma" then
+			-- This shouldn't normally fire — #pragma lines are skipped by
+			-- skip_preprocessor_line above. If we get here, it's a _Pragma
+			-- variant or a non-#-prefixed pragma. Just advance.
+			pos = ident_end
+			goto continue
+		end
+
+		-- ── Unrecognized ident — advance past it ──
+		pos = ident_end
+
+		::continue::
+	end
+
+	return {
+		atoms      = atoms,
+		raw_atoms  = raw_atoms,
+		binds      = binds,
+		atom_infos = atom_infos,
+		macros     = macros,
+		line_of    = line_of,
+	}
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M — module exports
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class M
+
+local M = {}
+
+--- Walk each source once and attach the fat SourceScan payload to `src.scan`.
+--- No output files; this is a pure in-memory pre-processing pass.
+--- @param ctx PassCtx
+--- @return PassResult
+function M.run(ctx)
+	for _, src in ipairs(ctx.sources) do
+		src.scan = scan_source(src.text)
+		-- Pre-tokenize each atom body once (plex: single source of truth).
+		-- Downstream passes (offsets, word-counts, components, static-analysis) read from
+		-- `atom.body_tokens` instead of calling `split_top_level_commas` / `tokenize_body` independently.
+		-- The tokens are memoized in duffle.lua's cache, so re-access is O(1).
+		for _, atom in ipairs(src.scan.atoms) do
+			atom.body_tokens = duffle.tokenize_body(atom.body)
+		end
+		for _, atom in ipairs(src.scan.raw_atoms or {}) do
+			atom.body_tokens = duffle.tokenize_body(atom.body)
+		end
+	end
+	return { outputs = {}, errors = {}, warnings = {} }
+end
+
+return M

scripts/passes/word_count_eval.lua

@@ -0,0 +1,213 @@
+--- word_count_eval.lua — Word-counting logic for the tape-atom metaprogram pipeline.
+---
+--- Three responsibilities:
+---   1. **Public utilities** (used by `passes/components.lua`, `passes/offsets.lua`, `passes/annotation.lua`):
+---        - `M.count_token_words(token, wc)` — words emitted by one token
+---        - `M.scan_dir(dir, suffix)` — glob walk for *.macs.h
+---   2. **Pass entry** `M.run(ctx)` — loads metadata.h + *.macs.h into `ctx.shared.word_counts` for downstream passes.
+---   3. **Internal helpers** for the body scanner.
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module-scope requires + package.path setup
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Resolve `arg[0]` to an absolute-ish script directory so that `require("duffle")` resolves against `scripts/` regardless of CWD.
+-- Note: this boilerplate is duplicated in 6 other entry scripts; a Phase-6 extraction target (`duffle.setup_package_path()`).
+-- Bootstrap: see `ps1_meta.lua` for the rationale.
+-- Bootstrap: load `scripts/duffle_paths.lua` (sets package.path + package.cpath).
+-- Uses `debug.getinfo` to find this file's own directory, so it works both standalone and when require'd from the orchestrator.
+-- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
+-- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Windows separator chars — used to convert `dir` output (which uses `\`) into POSIX paths (which our scripts expect).
+local PATH_SEP_BACKSLASH = "\\"
+local PATH_SEP_FORWARD   = "/"
+
+-- Fallback glob command (subprocess). Used when `lfs` (LuaFileSystem) is not available.
+-- Scoped to `code\` to avoid walking `.git/`, `toolchain/`, `build/`, etc.
+local DIR_GLOB_CMD = 'dir /b /s "%s\\code\\%s" 2>nul'
+
+-- Try to load lfs (LuaFileSystem). If available, scan_dir uses native directory enumeration (~2ms)
+-- instead of spawning `dir /b /s` as a subprocess (~56ms). Built by update_deps.ps1 into toolchain/lfs/lfs.dll.
+local lfs = pcall(require, "lfs") and require("lfs") or nil
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class WordCounts
+--- @field [string] integer  -- macro name -> word count
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+
+--- @class PassCtx
+--- @field sources            SourceFile[]  -- all source files in the build
+--- @field metadata_path      string        -- path to word_count.metadata.h
+--- @field shared             table         -- cross-pass shared state
+--- @field shared.word_counts WordCounts    -- 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 dry_run            boolean       -- if true, compute but don't write
+--- @field verbose            boolean       -- if true, log diagnostic info
+
+--- @class PassResult
+--- @field outputs  table[]  -- {kind=, path=} entries describing emit files
+--- @field errors   table[]  -- {line=, msg=} entries; build-stops
+--- @field warnings table[]  -- {line=, msg=} entries; build-succeeds
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module exports
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+-- ┌────────────────────────────────────────────────────────────────────┐
+-- │ Shared utility: count_token_words                                  │
+-- └────────────────────────────────────────────────────────────────────┘
+
+--- Count words emitted by a single comma-separated token inside an atom body.
+--- For most tokens (regular MIPS instructions) this returns 1.
+--- For `mac_X(...)` calls, this returns the resolved word count from `wc` (recursively if needed). For `nop2` etc., returns wc[name].
+--- For unknown macros, returns 1 and (optionally) warns.
+---
+--- @param token string        -- a single token from split_top_level_commas
+--- @param wc WordCounts       -- the shared word-count table
+--- @return integer
+function M.count_token_words(token, wc)
+	local s = duffle.trim(token)
+	if    s == "" then return 0 end
+	local name, after = duffle.read_ident(s, 1)
+	if not name then return 1 end
+	if wc[name] then return wc[name] end
+	local paren_pos = duffle.skip_ws_and_cmt(s, after)
+	if s:sub(paren_pos, paren_pos) == "(" then
+		io.stderr:write("  warning: unknown macro '" .. name .. "', assuming 1 word\n")
+	end
+	return 1
+end
+
+-- ┌────────────────────────────────────────────────────────────────────┐
+-- │ Shared utility: scan_dir                                           │
+-- └────────────────────────────────────────────────────────────────────┘
+
+--- Recursively scan a directory for files matching a glob suffix.
+--- No regex per the no_regex constraint — uses plain byte matching via `dir /b /s` on Windows.
+---
+--- The `.macs.h` files produced by the components pass always live at `<project_root>/<module>/gen/`.
+--- We can shortcut the `dir /b /s` walk by listing modules first (one `dir /b /ad`), then walking each `<module>/gen/`
+--- (one `dir /b` per module, no recursion). 
+--- For projects with 2 modules and 0 .macs.h files, this drops the cost from ~52ms 
+--- (full recursive walk of the entire project tree) to ~5ms.
+---
+--- @param dir string        -- directory to scan (absolute or relative)
+--- @param suffix string     -- file pattern, e.g. "*.macs.h"
+--- @return string[]
+-- Cache the scan_dir result per (dir, suffix) in package.loaded. 
+-- Each `io.popen` call on Windows is ~50-100ms of subprocess overhead, so caching the result saves a fixed cost on every build.
+-- The cache persists for the lifetime of the Lua process (cleared when ps1_meta.lua exits).
+-- If a build removes/creates .macs.h files mid-process, the caller can invalidate by calling `M._invalidate_scan_cache()`.
+local SCAN_CACHE_KEY = "__word_count_eval_scan_cache__"
+
+--- Scan `code/` for files matching `suffix` (e.g. `*.macs.h`).
+--- Uses `lfs` (LuaFileSystem) when available — native directory enumeration at ~2ms.
+--- Falls back to `dir /b /s` subprocess (~56ms) when `lfs` is not compiled.
+---
+--- @param dir string        -- project root directory
+--- @param suffix string     -- file pattern, e.g. "*.macs.h"
+--- @return string[]
+function M.scan_dir(dir, suffix)
+	local key = dir .. "\0" .. suffix
+
+	local cache = package.loaded[SCAN_CACHE_KEY]
+	if    cache and cache[key] then return cache[key] end
+
+	local results = {}
+
+	if lfs then
+		-- Native walk: list code/<module>/gen/ for matching files. Zero subprocess spawns.
+		local code_dir = dir .. "/code"
+		if lfs.attributes(code_dir, "mode") == "directory" then
+			for mod_name in lfs.dir(code_dir) do
+				if mod_name ~= "." and mod_name ~= ".." then
+					local gen_path = code_dir .. "/" .. mod_name .. "/gen"
+					if lfs.attributes(gen_path, "mode") == "directory" then
+						for fname in lfs.dir(gen_path) do
+							if fname:match("%.macs%.h$") then
+								results[#results + 1] = gen_path .. "/" .. fname
+							end
+						end
+					end
+				end
+			end
+		end
+	else
+		-- Fallback: single `dir /b /s` subprocess scoped to code\.
+		local pipe = io.popen(DIR_GLOB_CMD:format(dir, suffix))
+		if pipe then
+			for raw_line in pipe:lines() do
+				results[#results + 1] = raw_line:gsub(PATH_SEP_BACKSLASH, PATH_SEP_FORWARD)
+			end
+			pipe:close()
+		end
+	end
+
+	-- Cache the result (including empty results).
+	cache      = cache or {}
+	cache[key] = results
+	package.loaded[SCAN_CACHE_KEY] = cache
+
+	return results
+end
+
+--- Invalidate the scan cache (call after creating new .macs.h files in the same Lua process — usually not needed).
+function M._invalidate_scan_cache() package.loaded[SCAN_CACHE_KEY] = nil end
+
+-- ┌────────────────────────────────────────────────────────────────────┐
+-- │ Pass entry: M.run(ctx) — "word-counts" pass                        │
+-- └────────────────────────────────────────────────────────────────────┘
+
+--- Load metadata.h + scan for existing *.macs.h files into ctx.shared.word_counts.
+--- Loading the .macs.h files is idempotent: entries from later (current-build) .macs.h files override metadata.h entries of the same name.
+---
+--- @param ctx PassCtx
+--- @return PassResult
+function M.run(ctx)
+	local wc = {}
+
+	-- 1. Load metadata.h (the encoding-macro source of truth).
+	local meta_counts = duffle.load_word_counts(ctx.metadata_path)
+	for name, count in pairs(meta_counts) do wc[name] = count end
+
+	-- 2. Scan project_root recursively for *.macs.h files (component-macro source).
+	local macs_files = M.scan_dir(ctx.project_root, "*.macs.h")
+	for _, macs_path in ipairs(macs_files) do
+		local ok, mc = pcall(duffle.load_word_counts, macs_path)
+		if not ok then
+			io.stderr:write(string.format("[word_count_eval] parse error in '%s': %s\n", macs_path, tostring(mc)))
+		elseif type(mc) ~= "table" then
+			io.stderr:write(string.format("[word_count_eval] '%s' did not return a table (got %s)\n", macs_path, type(mc)))
+		else
+			for name, count in pairs(mc) do wc[name] = count end
+		end
+	end
+
+	ctx.shared.word_counts = wc
+	return { outputs = {}, errors = {}, warnings = {} }
+end
+
+return M

scripts/ps1_meta.lua

@@ -1,84 +1,117 @@
--- ps1_meta.lua
+--- ps1_meta.lua — Orchestrator entry point for the tape-atom metaprogram pipeline.
---
+---
--- Orchestrator entry point for the tape-atom metaprogram pipeline.
+--- Dispatches to pass modules under `scripts/passes/`, resolving
--- Dispatches to pass modules under scripts/passes/, resolving dependencies
+--- dependencies topologically (Kahn's algorithm + cycle detection).
--- topologically. Single CLI surface (`--<pass>` flags + auto-dep + --dry-run).
+--- Single CLI surface (`--<pass>` flags + auto-dep expansion + --dry-run).
---
+---
--- Coding standard: tabs (1/level), EmmyLua annotations, no regex,
+--- **Architecture**:
--- Lua 5.3 compatible.
+---   - **PASSES table** — declarative dep graph (data, not code).
-
+---   - **FLAG_HANDLERS table** — per-flag CLI dispatchers (handler-map pattern; replaces an 8-way if/elseif chain).
+---   - **parse_args** → **build_ctx** (just opens + reads source files; no inline scanning) → **topo_sort** → **dispatch_passes**.
+---   - The first pass in the dep graph is `scan-source` (see `passes/scan_source.lua`). 
+---     It calls `duffle.scan_source` once per source to produce the fat `SourceScan` payload, which is attached to each `src.scan`. 
+---     Every other pass that reads source structure depends on `scan-source` and consumes `src.scan` as a read-only payload. 
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+---
 -- ════════════════════════════════════════════════════════════════════════════
 -- Module-scope requires + package.path setup
 -- ════════════════════════════════════════════════════════════════════════════
 
-local script_path = arg and arg[0] or "?"
+-- Bootstrap: load `duffle_paths.lua` via `arg[0]` (this script's own path).
-local last_sep = 0
+-- That single statement: (a) sets `package.path` + `package.cpath` (via cached `git rev-parse`),
-for i = 1, #script_path do
+-- (b) at the bottom returns `require("duffle")`. So the dofile's return value is the duffle module.
-	local c = script_path:sub(i, i)
+local duffle = dofile((arg[0]:match("(.*[/\\])") or "./") .. "duffle_paths.lua")
-	if c == "/" or c == "\\" then last_sep = i end
-end
-local script_dir = last_sep == 0 and "./" or script_path:sub(1, last_sep)
-package.path   = script_dir .. "?.lua;" .. script_dir .. "?/init.lua;" .. package.path
-package.cpath = "C:\\projects\\Pikuma\\ps1\\toolchain\\luajit-2.1\\lib\\lua\\5.1\\?.dll;" .. package.cpath
 
-local duffle = require("duffle")
+-- ════════════════════════════════════════════════════════════════════════════
-local dirname          = duffle.dirname
+-- Constants
-local basename_no_ext  = duffle.basename_no_ext
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Exit codes (per the --help text and the post-build summary convention).
+local EXIT_OK                  = 0
+local EXIT_VALIDATION_ERRORS   = 1
+local EXIT_INTERNAL_ERROR      = 2
+
+-- Default --out-root value if not provided.
+local DEFAULT_OUT_ROOT         = "build/gen"
+
+-- 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__"
+
+-- 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__"
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class PassDescriptor
---- @field module   string         -- module name passed to require()
+--- @field module string       -- module name passed to require()
---- @field kind     string         -- "shared" | "header-output" | "validation" | "report"
+--- @field kind   string       -- "shared" | "header-output" | "validation" | "report"
---- @field deps     string[]       -- names of upstream passes
+--- @field deps   string[]     -- names of upstream passes
---- @field desc     string         -- human description (used by --help + ASCII graph)
+--- @field desc   string       -- human description (used by --help + ASCII graph)
---- @field out      PassOutput[]   -- output paths (used by --dry-run + report)
+--- @field out    PassOutput[] -- output paths (used by --dry-run + report)
 
 --- @class PassOutput
 --- @field kind          string  -- "header" | "report"
 --- @field path_template string  -- e.g. "<source_dir>/gen/<basename>.macs.h"
 
 --- @class SourceFile
---- @field path     string
+--- @field path     string  -- absolute path to the source file
---- @field text     string
+--- @field text     string  -- the full source text
---- @field dir      string
+--- @field dir      string  -- the directory containing the source
---- @field basename string
+--- @field basename string  -- filename without extension
 
 --- @class PassCtx
---- @field sources            SourceFile[]
+--- @field sources            SourceFile[]           -- all source files in the build
---- @field metadata_path      string
+--- @field metadata_path      string                 -- path to word_count.metadata.h
---- @field shared             table
+--- @field shared             table                  -- cross-pass shared state
---- @field shared.word_counts table<string, integer>
+--- @field shared.word_counts table<string, integer> -- populated by word-counts pass
---- @field out_root           string
+--- @field out_root           string                 -- output root (e.g. "build/gen")
---- @field project_root       string
+--- @field project_root       string                 -- project root (e.g. "code/")
---- @field upstream           table<string, table>
+--- @field upstream           table<string, table>   -- per-pass output accumulator
---- @field flags              table
+--- @field flags              table                  -- CLI flags + per-pass stash
---- @field dry_run            boolean
+--- @field dry_run            boolean                -- if true, compute but don't write
---- @field verbose            boolean
+--- @field verbose            boolean                -- if true, log diagnostic info
+
+--- @class PassOutputEntry
+--- @field [string] string  -- dynamic shape; key is the output kind
+	-- (e.g. "macs_h", "offsets_h", "errors_h", "annotations_txt", "static_analysis_txt", "summary_txt"), value is the path
+
+--- @class Finding
+--- @field line integer  -- source line (or 0 for pass-level)
+--- @field msg  string   -- finding message
 
 --- @class PassResult
---- @field outputs  table[]
+--- @field outputs  PassOutputEntry[] -- emitted file paths
---- @field errors   table[]
+--- @field errors   Finding[]         -- build-stops (per-pass kind policy)
---- @field warnings table[]
+--- @field warnings Finding[]         -- informational
 
 --- @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[]    -- --source values
+--- @field sources       string[]  -- --source values
---- @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      -- --project-root value (default dirname(metadata))
+--- @field project_root  string    -- --project-root value (default dirname(metadata))
---- @field dry_run       boolean
+--- @field dry_run       boolean   -- if true, compute but don't write
---- @field verbose       boolean
+--- @field verbose       boolean   -- if true, log diagnostic info
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- PASSES table (data, not code) — the orchestrator's dep graph
 -- ════════════════════════════════════════════════════════════════════════════
 
 local PASSES = {
+	["scan-source"] = {
+		module = "passes.scan_source",
+		kind   = "shared",
+		deps   = {},
+		desc   = "Walk each source once; produce the fat SourceScan payload for downstream passes",
+		out    = {},
+	},
 	["word-counts"] = {
-		module = "word_count_eval",
+		module = "passes.word_count_eval",
 		kind   = "shared",
 		deps   = {},
 		desc   = "Build the shared metadata table (metadata.h + .macs.h)",
@@ -87,14 +120,14 @@ local PASSES = {
 	components = {
 		module = "passes.components",
 		kind   = "header-output",
-		deps   = {"word-counts"},
+		deps   = {"scan-source", "word-counts"},
 		desc   = "Emit mac_X macros from MipsAtomComp_ declarations",
 		out    = { { kind = "header", path_template = "<source_dir>/gen/<basename>.macs.h" } },
 	},
 	annotation = {
 		module = "passes.annotation",
 		kind   = "validation",
-		deps   = {"word-counts"},
+		deps   = {"scan-source", "word-counts"},
 		desc   = "Validate atom DSL usage; emit errors.h + annotations.txt",
 		out    = {
 			{ kind = "report", path_template = "<out_root>/<basename>.errors.h" },
@@ -104,14 +137,14 @@ local PASSES = {
 	offsets = {
 		module = "passes.offsets",
 		kind   = "header-output",
-		deps   = {"word-counts", "components"},
+		deps   = {"scan-source", "word-counts", "components"},
 		desc   = "Compute branch offsets for atom_label / atom_offset",
 		out    = { { kind = "header", path_template = "<source_dir>/gen/<basename>.offsets.h" } },
 	},
 	["static-analysis"] = {
 		module = "passes.static_analysis",
 		kind   = "validation",
-		deps   = {"word-counts", "components"},
+		deps   = {"scan-source", "word-counts", "components"},
 		desc   = "[FUTURE] GTE pipeline-fill, mac_yield uniformity, etc.",
 		out    = { { kind = "report", path_template = "<out_root>/<basename>.static_analysis.txt" } },
 	},
@@ -140,27 +173,26 @@ local PASS_FLAG_TO_NAME = {
 	["--offsets"]         = "offsets",
 	["--static-analysis"] = "static-analysis",
 	["--report"]          = "report",
-	["--all"]             = "__all__",
+	["--scan-source"]     = "scan-source",
+	["--all"]             = ALL_PASSES_SENTINEL,
 }
 
 local ALL_PASS_NAMES = {
-	"word-counts", "components", "annotation",
+	"scan-source", "word-counts", "components", "annotation",
 	"offsets", "static-analysis", "report",
 }
 
---- Append every pass name to args.requested_set. Used by --all and
+--- Append every pass name to args.requested_set. Used by --all and by the "default to --all if no pass flags were given" fallback.
---- by the "default to --all if no pass flags were given" fallback.
+--- @param args ParsedArgs
 local function request_all_passes(args)
 	for _, n in ipairs(ALL_PASS_NAMES) do
 		args.requested_set[#args.requested_set + 1] = n
 	end
 end
 
--- Per-flag handlers. Each handler takes (args, argv, i) and returns
+-- 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). 
--- the new i (so multi-arg flags like --source FILE advance it).
+-- Returning nil + os.exit() handles termination flags (--help). This replaces the 8-way `if/elseif/elseif...` chain that nested 4 levels deep 
--- Returning nil + os.exit() handles termination flags (--help).
+-- and made the dispatch logic hard to scan.
--- This replaces the 8-way `if/elseif/elseif...` chain that nested
--- 4 levels deep and made the dispatch logic hard to scan.
 local FLAG_HANDLERS = {}
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -203,53 +235,28 @@ EXAMPLE:
 ]])
 end
 
--- Per-flag handlers. Each takes (args, argv, i) and returns the new i
+-- Per-flag handlers. Each takes (args, argv, arg_idx) and returns the new arg_idx (so multi-arg flags like --source FILE advance it).
--- (so multi-arg flags like --source FILE advance it). Termination
+-- Termination flags like --help call os.exit() instead.
--- flags like --help call os.exit() instead. This replaces the 8-way
+-- This replaces the 8-way `if/elseif/elseif...` chain that nested 4 levels deep and made the dispatch logic hard to scan.
--- `if/elseif/elseif...` chain that nested 4 levels deep and made the
--- dispatch logic hard to scan.
 --
--- Populated AFTER print_help so the --help handler can reference it
+-- Populated AFTER print_help so the --help handler can reference it as an upvalue (Lua resolves locals at closure-call time, 
--- as an upvalue (Lua resolves locals at closure-call time, but if the
+-- but if the closure is defined before the local, it falls back to _G). 
--- closure is defined before the local, it falls back to _G).
 FLAG_HANDLERS["--help"] = function(args)
 	print_help()
 	os.exit(0)
 end
 
-FLAG_HANDLERS["--dry-run"] = function(args)
+FLAG_HANDLERS["--dry-run"]      = function(args) args.dry_run = true end
-	args.dry_run = true
+FLAG_HANDLERS["--verbose"]      = function(args) args.verbose = true end
-end
+FLAG_HANDLERS["--source"]       = function(args, argv, arg_idx) args.sources[#args.sources + 1] = argv[arg_idx + 1]; return arg_idx + 1 end
+FLAG_HANDLERS["--metadata"]     = function(args, argv, arg_idx) args.metadata                   = argv[arg_idx + 1]; return arg_idx + 1 end
+FLAG_HANDLERS["--out-root"]     = function(args, argv, arg_idx) args.out_root                   = argv[arg_idx + 1]; return arg_idx + 1 end
+FLAG_HANDLERS["--project-root"] = function(args, argv, arg_idx) args.project_root               = argv[arg_idx + 1]; return arg_idx + 1 end
 
-FLAG_HANDLERS["--verbose"] = function(args)
+-- Pass-flag handler. Reads the closed-set table, expands --all, appends to requested_set. Single-statement, no nesting.
-	args.verbose = true
+FLAG_HANDLERS[PASS_FLAG_DISPATCH_KEY] = function(args, a)
-end
-
-FLAG_HANDLERS["--source"] = function(args, argv, i)
-	args.sources[#args.sources + 1] = argv[i + 1]
-	return i + 1
-end
-
-FLAG_HANDLERS["--metadata"] = function(args, argv, i)
-	args.metadata = argv[i + 1]
-	return i + 1
-end
-
-FLAG_HANDLERS["--out-root"] = function(args, argv, i)
-	args.out_root = argv[i + 1]
-	return i + 1
-end
-
-FLAG_HANDLERS["--project-root"] = function(args, argv, i)
-	args.project_root = argv[i + 1]
-	return i + 1
-end
-
--- Pass-flag handler. Reads the closed-set table, expands --all,
--- appends to requested_set. Single-statement, no nesting.
-FLAG_HANDLERS["__pass__"] = function(args, a)
 	local name = PASS_FLAG_TO_NAME[a]
-	if name == "__all__" then
+	if name == ALL_PASSES_SENTINEL then
 		request_all_passes(args)
 		return
 	end
@@ -265,49 +272,47 @@ local function parse_args(argv)
 		requested_set = {},
 		sources       = {},
 		metadata      = nil,
-		out_root      = "build/gen",
+		out_root      = DEFAULT_OUT_ROOT,
 		project_root  = nil,
 		dry_run       = false,
 		verbose       = false,
 	}
 
-	local i = 1
+	local pos = 1
-	while i <= #argv do
+	while pos <= #argv do
-		local a = argv[i]
+		local a       = argv[pos]
 		local handler = FLAG_HANDLERS[a]
 		if handler then
-			i = handler(args, argv, i) or i
+			pos = handler(args, argv, pos) or pos
 		elseif PASS_FLAG_TO_NAME[a] then
-			FLAG_HANDLERS["__pass__"](args, a)
+			FLAG_HANDLERS[PASS_FLAG_DISPATCH_KEY](args, a)
 		else
 			io.stderr:write("ps1_meta: unknown flag '" .. a .. "'\n")
 			io.stderr:write("Run with --help for usage.\n")
-			os.exit(2)
+			os.exit(EXIT_INTERNAL_ERROR)
 		end
-		i = i + 1
+		pos = pos + 1
 	end
 
 	-- Default: --all if no explicit pass flags.
-	if #args.requested_set == 0 then
+	if #args.requested_set == 0 then request_all_passes(args) end
-		request_all_passes(args)
-	end
 
 	-- Defaults: project_root = dirname(metadata).
 	if args.metadata and not args.project_root then
-		local d = dirname(args.metadata)
+		local d = duffle.dirname(args.metadata)
-		if #d > 0 and (d:sub(-1) == "/" or d:sub(-1) == "\\") then
+		if   #d > 0 and (d:sub(-1) == "/" or d:sub(-1) == "\\") then
 			d = d:sub(1, -2)
 		end
-		args.project_root = dirname(d)
+		args.project_root = duffle.dirname(d)
 	end
 
 	if not args.metadata then
 		io.stderr:write("ps1_meta: --metadata PATH is required\n")
-		os.exit(2)
+		os.exit(EXIT_INTERNAL_ERROR)
 	end
 	if #args.sources == 0 then
 		io.stderr:write("ps1_meta: at least one --source FILE is required\n")
-		os.exit(2)
+		os.exit(EXIT_INTERNAL_ERROR)
 	end
 
 	return args
@@ -325,20 +330,23 @@ end
 local function build_ctx(args)
 	local sources = {}
 	for _, path in ipairs(args.sources) do
-		local f = io.open(path, "r")
+		local  f = io.open(path, "r")
 		if not f then
 			io.stderr:write("ps1_meta: cannot open --source " .. path .. "\n")
-			os.exit(2)
+			os.exit(EXIT_INTERNAL_ERROR)
 		end
 		local text = f:read("*a")
 		f:close()
 
-		local dir      = dirname(path)
+		local dir      = duffle.dirname(path)
-		local basename = basename_no_ext(path)
+		local basename = duffle.basename_no_ext(path)
 		if #dir > 0 and (dir:sub(-1) == "/" or dir:sub(-1) == "\\") then
 			dir = dir:sub(1, -2)
 		end
 
+		-- src.scan is populated by the "scan-source" pass (the first pass in the
+		-- dep graph). build_ctx just opens + reads the files; the scan itself
+		-- happens in the pass module, not inline in the orchestrator.
 		sources[#sources + 1] = {
 			path     = path,
 			text     = text,
@@ -347,8 +355,14 @@ local function build_ctx(args)
 		}
 	end
 
+	-- Pre-compute the per-directory grouping once (Fleury: expose structure).
+	-- Three passes (annotation, report, static-analysis) call group_sources_by_dir with the same ctx.sources;
+	-- computing it here and stashing on ctx.by_dir eliminates 2 redundant calls.
+	local by_dir = duffle.group_sources_by_dir(sources)
+
 	return {
 		sources       = sources,
+		by_dir        = by_dir,
 		metadata_path = args.metadata,
 		shared        = {},
 		upstream      = {},
@@ -364,14 +378,12 @@ end
 -- Topological sort (Kahn's algorithm + cycle detection)
 -- ════════════════════════════════════════════════════════════════════════════
 
---- Topologically sort the requested pass set, augmented with all transitive deps.
+--- Compute the dep-closure of `requested_set`: include every pass name transitively required by the requested set.
---- Detects cycles and errors out with details.
 ---
 --- @param passes table<string, PassDescriptor>
 --- @param requested_set string[]
---- @return string[]  -- execution order
+--- @return table<string, boolean>  -- set of pass names needed (including transitive deps)
-local function topo_sort(passes, requested_set)
+local function dep_closure(passes, requested_set)
-	-- Step 1: dep-closure.
 	local needed = {}
 	for _, name in ipairs(requested_set) do needed[name] = true end
 	local changed = true
@@ -390,55 +402,94 @@ local function topo_sort(passes, requested_set)
 			end
 		end
 	end
+	return needed
+end
 
-	-- Step 2: Kahn's algorithm.
+--- Count entries in a hash table (Lua's `#t` doesn't work for hash tables).
+--- @param t table
+--- @return integer
+local function count_entries(t)
+	local n = 0
+	for _ in pairs(t) do n = n + 1 end
+	return n
+end
+
+--- Compute in-degrees for the Kahn sort: for each pass in `needed`, the number of its deps that are also in `needed`.
+---
+--- @param passes table<string, PassDescriptor>
+--- @param needed table<string, boolean>
+--- @return table<string, integer>
+local function compute_in_degrees(passes, needed)
 	local in_degree = {}
 	for name, _ in pairs(needed) do in_degree[name] = 0 end
 	for name, _ in pairs(needed) do
 		for _, dep in ipairs(passes[name].deps) do
 			if needed[dep] then
-				in_degree[name] = (in_degree[name] or 0) + 1
+				in_degree[name] = in_degree[name] + 1
 			end
 		end
 	end
+	return in_degree
+end
 
-	-- Seed with passes that have no unmet deps. Sort for determinism.
+--- Seed the Kahn ready queue with passes whose in-degree is 0, sorted alphabetically for deterministic execution order.
+---
+--- @param in_degree table<string, integer>
+--- @return string[]
+local function seed_ready_queue(in_degree)
 	local ready = {}
 	for name, deg in pairs(in_degree) do
 		if deg == 0 then ready[#ready + 1] = name end
 	end
 	table.sort(ready)
+	return ready
+end
 
-	local order = {}
+-- (internal) Pop the next ready pass, decrement the in-degree of every remaining pass that depended on it
-	while #ready > 0 do
+-- (inserting newly-zero-degree passes back into the ready queue), and append to `order`. Keeps `ready` sorted.
-		local n = table.remove(ready, 1)
+-- @param passes table<string, PassDescriptor>
-		order[#order + 1] = n
+-- @param needed table<string, boolean>
-		for name, _ in pairs(needed) do
+-- @param in_degree table<string, integer>
-			if name ~= n then
+-- @param ready string[]
-				for _, dep in ipairs(passes[name].deps) do
+-- @param order string[]
-					if dep == n then
+local function process_next_ready(passes, needed, in_degree, ready, order)
-						in_degree[name] = in_degree[name] - 1
+	local just_finished = table.remove(ready, 1)
-						if in_degree[name] == 0 then
+	order[#order + 1] = just_finished
-							ready[#ready + 1] = name
+	for name, _ in pairs(needed) do
-							table.sort(ready)
+		if name ~= just_finished then
-						end
+			for _, dep in ipairs(passes[name].deps) do
+				if dep == just_finished then
+					in_degree[name] = in_degree[name] - 1
+					if in_degree[name] == 0 then
+						ready[#ready + 1] = name
+						table.sort(ready)
 					end
 				end
 			end
 		end
 	end
+end
 
-	-- Cycle detection: if order doesn't include all needed passes,
+--- Topologically sort the requested pass set, augmented with all transitive deps.
-	-- some are stuck with in_degree > 0 (the cycle closed on itself
+--- Detects cycles and errors out with details.
-	-- before Kahn could process them). Without this check, a fully-
+---
-	-- closed cycle (e.g. A -> B -> A) would silently return an empty
+--- @param passes table<string, PassDescriptor>
-	-- order list, leaving the orchestrator to dispatch nothing.
+--- @param requested_set string[]
-	--
+--- @return string[]  -- execution order
-	-- Note: `#needed` returns 0 for hash tables (needed is a set,
+local function topo_sort(passes, requested_set)
-	-- not a sequence), so we count entries explicitly.
+	local needed    = dep_closure(passes, requested_set)
-	local needed_count = 0
+	local in_degree = compute_in_degrees(passes, needed)
-	for _ in pairs(needed) do needed_count = needed_count + 1 end
+	local ready     = seed_ready_queue(in_degree)
-	if #order ~= needed_count then
+
+	local order = {}
+	while #ready > 0 do
+		process_next_ready(passes, needed, in_degree, ready, order)
+	end
+
+	-- 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 emspty order list, 
+	-- leaving the orchestrator to dispatch nothing.
+	if #order ~= count_entries(needed) then
 		for name, deg in pairs(in_degree) do
 			if deg > 0 then
 				error("dependency cycle detected involving pass '" .. name .. "'")
@@ -454,8 +505,7 @@ end
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- Render the dep graph as ASCII art. Output width capped at 78 columns.
---- Falls back to the simpler "Resolved dependency order" list only if
+--- Falls back to the simpler "Resolved dependency order" list only if graph width exceeds terminal width.
---- graph width exceeds terminal width.
 ---
 --- @param passes table<string, PassDescriptor>
 --- @param requested string[]  -- originally-requested passes (subset of closed)
@@ -466,50 +516,61 @@ local function render_dep_graph(passes, requested, closed)
 	local function add(s) lines[#lines + 1] = s end
 
 	add("[ps1_meta] Resolved dependency order (closed under deps):")
-	for i, name in ipairs(closed) do
+	for pass_idx, name in ipairs(closed) do
 		local p = passes[name]
 		local deps_str = (#p.deps == 0) and "(no deps)" or
 			"(deps: " .. table.concat(p.deps, ", ") .. ")"
 		add(string.format("  %d. %-22s %-45s [%s]",
-			i, name, deps_str, p.kind))
+			pass_idx, name, deps_str, p.kind))
 	end
 	add("")
 
-	add("[ps1_meta] Pass graph (read top-to-bottom):")
+	-- Data-driven ASCII graph built from the actual PASSES table.
+	-- Shows the source -> scan_source -> pass chain. Each pass is
+	-- shown once; edges are "feeds into" arrows based on deps.
+	add("[ps1_meta] Pass graph (read top-to-bottom; edges = 'feeds into'):")
 	add("")
-	add("                       metadata.h")
+
-	add("                           |")
+	-- Compute which passes feed which other passes (reverse of deps).
-	add("                           v")
+	local feeds = {}  -- feeds[X] = list of passes that X feeds into
-	add("   +-----------+   +-----------------+   +-----------------+")
+	for _, name in ipairs(closed) do feeds[name] = {} end
-	add("   |   word-   |-->|    components   |-->|     offsets     |")
+	for name, p in pairs(passes) do
-	add("   |   counts  |   +-----------------+   +-----------------+")
+		for _, dep in ipairs(p.deps) do
-	add("   |   (load)  |            |                      ^")
+			if feeds[dep] then feeds[dep][#feeds[dep] + 1] = name end
-	add("   +-----------+            |                      |")
+		end
-	add("        |                   v                      |")
+	end
-	add("        |  code/<module>/gen/<basename>.macs.h     |")
+
-	add("        |     (header - co-located for #include)   |")
+	-- Layout: source -> scan_source -> word-counts -> {components, annotation, offsets, static-analysis} -> report
-	add("        |                                            |")
+	-- Outputs are listed under each pass.
-	add("        |           +-----------------+              |")
+	local outputs_for = function(name)
-	add("        +---------->|    annotation   |--------------+")
+		local p = passes[name]
-	add("        |           +-----------------+              |")
+		if not p or not p.out or #p.out == 0 then return "" end
-	add("        |                   |                        |")
+		local outs = {}
-	add("        |                   v                        |")
+		for _, o in ipairs(p.out) do outs[#outs + 1] = o.path_template end
-	add("        |       build/gen/<basename>.errors.h        |")
+		return table.concat(outs, ", ")
-	add("        |       build/gen/<basename>.annotations.txt |")
+	end
-	add("        |         (report - NOT #included)            |")
+
-	add("        |                                            |")
+	add("   +-----------+   +-------------------+    +-----------------+")
-	add("        |           +-----------------+              |")
+	add("   |  source   |-->|  scan_source      |--->|   word-counts   |")
-	add("        +---------->| static-analysis |--------------+")
+	add("   |  files    |   | (scan_source.lua) |    |   (load)        |")
-	add("                    +-----------------+")
+	add("   +-----------+   +-------------------+    +-----------------+")
-	add("                            |")
+	add("                          (single walk)         |")
-	add("                            v")
+	add("                                                |")
-	add("                    +---------------+")
+	add("        +-------------------+-------------------+-----------+")
-	add("                    |    report     |")
+	add("        v                   v                   v           v")
-	add("                    +---------------+")
+	add("   +--------------+   +--------------+   +--------------+   +---------------+")
-	add("                            |")
+	add("   | components   |   | annotation   |   |   offsets    |   |static-analysis|")
-	add("                            v")
+	add("   +--------------+   +--------------+   +--------------+   +---------------+")
-	add("                    build/gen/annotation_validation.txt")
+	add("   |<src>/gen/    |   |build/gen/    |   |<src>/gen/    |   |build/gen/     |")
-	add("                      (project summary)")
+	add("   |<base>.macs.h |   |<base>.errors |   |<base>.offsets|   |<base>.static  |")
+	add("   |   (header)   |   |  .h          |   |  .h          |   |  _analysis    |")
+	add("   +------+-------+   |  +annot.txt  |   |  (header)    |   |  .txt         |")
+	add("          |           +------+-------+   +--------------+   +------+--------+")
+	add("          v                v                                       v")
+	add("   +------+----------------+  +------+-------+                     |")
+	add("   |offsets|static-analysis|  |report|       |<--------------------+")
+	add("   |       |               |  +------+-------+")
+	add("   +-------+---------------+")
 
 	return table.concat(lines, "\n") .. "\n"
 end
@@ -518,6 +579,59 @@ end
 -- Main orchestrator
 -- ════════════════════════════════════════════════════════════════════════════
 
+-- (internal) Push a pass's outputs + warnings into `ctx.upstream[name]` for downstream passes to consume.
+-- @param ctx PassCtx
+-- @param pass_name string
+-- @param result PassResult
+local function accumulate_pass_result(ctx, pass_name, result)
+	ctx.upstream[pass_name] = ctx.upstream[pass_name] or {}
+	for _, out in ipairs(result.outputs or {}) do
+		table.insert(ctx.upstream[pass_name], out)
+	end
+	for _, warn in ipairs(result.warnings or {}) do
+		table.insert(ctx.upstream[pass_name], warn)
+	end
+end
+
+-- (internal) If the pass's kind is in PASS_KIND_STOP_ON_ERROR and it reported errors, write each error to stderr.
+-- Returns true if any validation errors were reported.
+-- @param pass_name string
+-- @param pass PassDescriptor
+-- @param result PassResult
+-- @return boolean
+local function report_validation_errors(pass_name, pass, result)
+	local   has_errors = result.errors and #result.errors > 0
+	if not (has_errors and PASS_KIND_STOP_ON_ERROR[pass.kind]) then
+		return false
+	end
+	for _, e in ipairs(result.errors) do
+		io.stderr:write(string.format("[%s] line %d: %s\n",
+			pass_name, e.line or 0, e.msg or ""))
+	end
+	return true
+end
+
+-- (internal) Run each pass in `order` in topological sequence.
+--
+-- @param ctx PassCtx
+-- @param order string[]
+-- @return boolean  -- true if any validation errors were reported
+local function dispatch_passes(ctx, order)
+	ctx.shared = {}
+	local had_errors = false
+	for _, pass_name in ipairs(order) do
+		local pass   = PASSES[pass_name]
+		local mod    = require(pass.module)
+		local result = mod.run(ctx)
+
+		accumulate_pass_result(ctx, pass_name, result)
+		if report_validation_errors(pass_name, pass, result) then
+			had_errors = true
+		end
+	end
+	return had_errors
+end
+
 --- Main entry point. Runs the requested passes in dep-topological order.
 --- @param argv string[]
 local function main(argv)
@@ -525,49 +639,25 @@ local function main(argv)
 		local args = parse_args(argv)
 		local ctx  = build_ctx(args)
 
-		-- 1. Compute requested set + dep-closed set.
 		local requested = args.requested_set
 		local closed    = topo_sort(PASSES, requested)
 
-		-- 2. --dry-run: print dep order + ASCII graph, exit 0.
+		-- --dry-run: print dep order + ASCII graph, exit OK.
 		if args.dry_run then
 			io.write(render_dep_graph(PASSES, requested, closed))
-			os.exit(0)
+			os.exit(EXIT_OK)
 		end
 
-		-- 3. Run passes in topological order.
+		local had_errors = dispatch_passes(ctx, closed)
-		ctx.shared = {}
+		if had_errors then os.exit(EXIT_VALIDATION_ERRORS) end
-		for _, pass_name in ipairs(closed) do
-			local pass  = PASSES[pass_name]
-			local mod   = require(pass.module)
-			local result = mod.run(ctx)
-
-			-- Collect outputs + warnings into ctx.upstream.
-			ctx.upstream[pass_name] = ctx.upstream[pass_name] or {}
-			for _, out in ipairs(result.outputs or {}) do
-				table.insert(ctx.upstream[pass_name], out)
-			end
-			for _, warn in ipairs(result.warnings or {}) do
-				table.insert(ctx.upstream[pass_name], warn)
-			end
-
-			-- Stop on errors (unless this is a non-stopping pass like report).
-			if (result.errors and #result.errors > 0) and PASS_KIND_STOP_ON_ERROR[pass.kind] then
-				for _, e in ipairs(result.errors) do
-					io.stderr:write(string.format("[%s] line %d: %s\n",
-						pass_name, e.line or 0, e.msg or ""))
-				end
-				os.exit(1)
-			end
-		end
 	end)
 
 	if not ok then
 		io.stderr:write("[ps1_meta] internal error: " .. tostring(err) .. "\n")
-		os.exit(2)
+		os.exit(EXIT_INTERNAL_ERROR)
 	end
 
-	os.exit(0)
+	os.exit(EXIT_OK)
 end
 
 main({...})

scripts/update_deps.ps1

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

scripts/word_count_eval.lua

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