eliminated most lag (runs in ms)

script running is slow need to fix.

.editorconfig

@@ -36,3 +36,7 @@ charset = utf-8
 [*.{natvis, natstepfilter}]
 indent_style = tab
 indent_size  = 4
+
+[*.lua]
+indent_style = tab
+indent_size = 2

.gitignore

@@ -1,8 +1,9 @@
 build
 toolchain/armips
+toolchain/luajit-2.1
 toolchain/pcsx-redux
-# toolchain/psyq_iwyu
-# toolchain/PSn00bSDK
+toolchain/psyq_iwyu
+toolchain/PSn00bSDK
 
 *.exe
 *.elf
@@ -14,3 +15,5 @@ toolchain/pcsx-redux
 *.a
 .sentry-native
 .vscode/settings.json
+toolchain/lfs
+toolchain/lpeg

code/duffle/atom_dsl.h

@@ -0,0 +1,201 @@
+/*
+ * atom_dsl.h
+ * ============================================================================
+ *
+ * ATOM DSL: Annotation layer for tape atoms (lottes_tape.h).
+ *
+ *   WHAT THIS HEADER IS
+ *   -------------------
+ *   The metaprogram (scripts/passes/annotation.lua) reads source-as-written
+ *   and validates:
+ *     - atom_info(...) shape: up to three sub-calls (atom_bind(Binds_X),
+ *       atom_reads(...), atom_writes(...)) in any order. All optional.
+ *       (No phase token for now; phases may be reintroduced later.)
+ *     - rbind atoms (atom_info(..., atom_bind(Binds_X), ...)) reference a
+ *       real Binds_* struct declaration.
+ *     - wave-context positions only reference the canonical 4-register
+ *       set: R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase.
+ *     - atom word-counts in word_counts.metadata.h agree with the body's
+ *       actual .word count.
+ *
+ *   WHY A PURE MACRO (atom_info, atom_bind, atom_reads, atom_writes, atom_label)
+ *   -----------------------------------------------------------------
+ *   Each of these expands to a C comment or to nothing. The C preprocessor
+ *   strips them to whitespace. The metaprogram reads the literal token from
+ *   source-as-written, NOT from the preprocessed output. This means:
+ *     - the C compiler does no work for them (no __attribute__, no
+ *       _Pragma, no asm side-effects)
+ *     - they can never silently drift from the metaprogram's view
+ *       (the metaprogram re-reads the source on every build)
+ *     - the annotation is invisible to the linker, debugger, and IDE
+ *
+ * ============================================================================
+ *
+ *  Usage:
+ *      MipsAtom_(cube_tri) atom_info(
+ *         atom_reads (R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor)
+ *      ){
+ *          atom_label(culling),
+ *          // ... atom body ...
+ *          atom_offset(culling, bounds_chk)         // branch target, validated
+ *          // ... atom body ...
+ *          atom_label(bounds_chk),
+ *      };
+ *
+ *
+ *  Data Binding pattern -- atom_bind as a sub-call of atom_info
+ *
+ *      // Wave-context register layout (declarative):
+ *      typedef Struct_(Binds_TrackFaceBatch) { 
+ * 					U4 PrimCursor; 
+ * 					U4 FaceCursor;
+ *          U4 VertBase;
+ * 					U4 OtBase;
+ *      };
+ *      MipsAtom_(rbind_track_face_batch) atom_info(
+ *         atom_bind(Binds_TrackFaceBatch)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+ *      ){ ... };
+ *
+ *  Annotation rules
+ *  ----------------
+ *      1. atom_info(...) is OPTIONAL. Most atoms have no annotation.
+ *         Atoms without atom_info are silently skipped by the metaprogram.
+ *
+ *      2. If present, atom_info takes up to three sub-calls, all
+ *         order-independent within the arg list:
+ *           - atom_bind(Binds_X) (optional; only for rbind atoms)
+ *           - atom_reads(...) (optional; wave-context registers)
+ *           - atom_writes(...) (optional; wave-context registers)
+ *
+ *      3. atom_bind(Binds_X) pins the ABI-struct shape -- the metaprogram
+ *         cross-references Binds_X against the
+ *         `typedef struct Binds_X { ... } Binds_X;` declaration.
+ *
+ *      4. atom_reads(...) and atom_writes(...) args are wave-context
+ *         registers: R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase.
+ *         Closed set. GTE / SP / DMA / I/O state is declared in source
+ *         comments, not in atom_reads/atom_writes.
+ *
+ *      5. atom_label(name) is an anchor -- the macro is empty in C; the
+ *         metaprogram records the marker at the current pos for offset
+ *         calculation.
+ *
+ *      6. atom_offset(F, T) is resolved by gen/atom_offsets.h, generated
+ *         from the atom_label markers.
+ */
+
+#ifdef INTELLISENSE_DIRECTIVES
+#pragma once
+// #include <stdint.h>
+#endif
+
+/* ============================================================================
+ * WAVE-CONTEXT REGISTERS -- canonical register set for the tape wave model.
+ *
+ *   R_PrimCursor  output pointer into the prim arena (next OT entry to write)
+ *   R_FaceCursor  input pointer into the face array (next face to consume)
+ *   R_VertBase    base pointer into the vertex arena (this wave's vertices)
+ *   R_OtBase      base pointer into the ordering table (this wave's OT slot)
+ *
+ * Closed set. If your atom needs to touch GTE / SP / DMA / other side state,
+ * declare it at the source level as you normally would -- but DO NOT put
+ * those registers in atom_reads/atom_writes.
+ *
+ * ============================================================================*/
+
+/* ============================================================================
+ * atom_reads(...) / atom_writes(...) -- wave-context register list
+ *
+ *   atom_reads(R_PrimCursor, R_FaceCursor)
+ *         ->  (R_PrimCursor, R_FaceCursor)   // comma-evaluated, discarded
+ *
+ * The macro produces a comma-evaluated expression that the C compiler
+ * silently discards (it sits in an unused arg position -- the result is
+ * never bound). The Lua tool pattern-matches the "atom_reads(...)" /
+ * "atom_writes(...)" token to extract the list.
+ *
+ * You can have at most one atom_reads(...) and at most one atom_writes(...)
+ * in an atom_info(...) call. To declare multiple disjoint sets (rare), just
+ * declare the union -- the metaprogram doesn't track which reads need which
+ * writes at this granularity.
+ *
+ * ============================================================================*/
+#define atom_reads(...)  (__VA_ARGS__)
+#define atom_writes(...) (__VA_ARGS__)
+
+/* ============================================================================
+ * ATOM ANNOTATION MACROS
+ *
+ *   atom_info -- single unified annotation. OPTIONAL. Most atoms have none.
+ *
+ *      MipsAtom_(cube_tri) atom_info(
+ *         atom_reads (R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor)
+ *      ){ ... };
+ *
+ *   Shape (sub-args order-independent; all optional):
+ *     - atom_bind(Binds_X):  at most one; pins the ABI-struct shape
+ *     - atom_reads(...):     at most one; comma-list of wave-context registers
+ *     - atom_writes(...):    at most one; comma-list of wave-context registers
+ *
+ *   No phase token for now. The metaprogram doesn't check ordering across
+ *   atoms -- phases (init / bind / setup / work / commit / terminate) will
+ *   be reintroduced when ordering checks are added.
+ *
+ *   The macro expands to a C comment (or to nothing). The C compiler does
+ *   no work. The metaprogram reads the source-as-written directly.
+ *
+ * ============================================================================*/
+#define atom_info(...)  /* atom_info(__VA_ARGS__) */
+
+/* ----------------------------------------------------------------------------
+ * atom_bind(Binds_X) -- rbind sub-call of atom_info
+ *
+ *   MipsAtom_(rbind_cube_tri) atom_info(
+ *         atom_bind(Binds_CubeTri)
+ *       , atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+ *   ){ ... };
+ *
+ * The Binds_X MUST be a typedef'd type (declared via
+ * `typedef struct Binds_X { ... } Binds_X;` somewhere in the source).
+ * The Lua tool cross-references this. Missing struct = error.
+ *
+ * atom_bind is a SUB-CALL of atom_info, not a standalone annotation macro.
+ *
+ * The macro expands to a C comment. The metaprogram reads source-as-written.
+ * ----------------------------------------------------------------------------*/
+#define atom_bind(binds_struct)  /* atom_bind(binds_struct) */
+
+/* ============================================================================
+ * atom_label / atom_offset — branch target machinery
+ *
+ *   atom_label(culling)                      ← nothing in C; anchor only
+ *   ... body ...
+ *   atom_label(bounds_chk)                   ← another anchor
+ *
+ *   atom_offset(culling, bounds_chk)         ← resolved by gen/.offsets.h
+ *
+ * The metaprogram generates gen/atom_offsets.h with one
+ *   #define atom_offset__culling__bounds_chk  ((target - branch_pos - 1))
+ * per atom_offset(F, T) call. The preprocessor then expands your call to
+ * the right immediate value.
+ *
+ * If gen/atom_offsets.h is stale (or atom_label(name) is undefined),
+ * `atom_offset__F__T` becomes an undefined macro and the C build fails.
+ * This catches:
+ *   - typo in atom_label (no anchor → metaprogram doesn't emit the macro)
+ *   - .offsets.h not regenerated after body edits
+ *   - body edit that broke the offset math (recompile + retest picks it up
+ *     in CPU emulator)
+ *
+ * ============================================================================*/
+
+#define atom_offset(F, T) atom_offset_ ## F ## _ ## T
+/* atom_label is a pure annotation for the metaprogram's offset calculations.
+ * The macro expands to a C comment, so the C preprocessor strips it to
+ * whitespace — NO instruction word is emitted in the asm. The metaprogram
+ * still recognises the literal `atom_label(name)` token in source and
+ * records the marker at the current pos. */
+#define atom_label(name) /* atom_label anchor: name */

code/duffle/dsl.h

@@ -87,7 +87,7 @@
 #define PtrSet_(type)  TypeR_(type); typedef TypeV_(type)
 #define TSet_(type)    type; typedef PtrSet_(type)
 
-#define array_len(a)                   (U8)(sizeof(a) / sizeof(typeof((a)[0])))
+#define array_len(a)                   (U4)(sizeof(a) / sizeof(typeof((a)[0])))
 #define array_decl(type, ...)          (type[]){__VA_ARGS__}
 #define Array_sym(type,len)            A ## len ## _ ## type
 #define Array_expand(type,len)         type Array_sym(type, len)[len]; typedef PtrSet_(Array_sym(type, len))
@@ -95,13 +95,14 @@
 #define Bit_(id,b)                     id = (1 << b), tmpl(id,pos) = b
 #define Enum_(underlying_type, symbol) underlying_type TSet_(symbol); enum   symbol
 #define Proc_(symbol)                  symbol
+#define Relative_(symbol)              // Does nothing but annotate that a symbol is associated with another.
 #define Struct_(symbol)                struct symbol   TSet_(symbol); struct symbol
 #define Union_(symbol)                 union  symbol   TSet_(symbol); union  symbol
 
-#define Opt_(proc)                    Struct_(tmpl(Opt,proc))
-#define opt_(symbol, ...)             (tmpl(Opt,symbol)){__VA_ARGS__}
-#define Ret_(proc)                    Struct_(tmpl(Ret,proc))
-#define ret_(proc)                    tmpl(Ret,proc) proc
+#define Opt_(proc)                     Struct_(tmpl(Opt,proc))
+#define opt_(symbol, ...)              (tmpl(Opt,symbol)){__VA_ARGS__}
+#define Ret_(proc)                     Struct_(tmpl(Ret,proc))
+#define ret_(proc)                     tmpl(Ret,proc) proc
 
 // Using Byte-Width convention for the fundamental types.
 typedef __UINT8_TYPE__  TSet_(U1); 
@@ -140,7 +141,9 @@ typedef void Proc_(VoidFn) (void);
 #define tera(n)         (C_(U4, n) << 40)
 #define null             C_(U4,    0)
 #define nullptr          C_(void*, 0)
-#define O_(type,member)  C_(U4,__builtin_offsetof(type,member))
+#define O_(type, field) (C_(U4, & C_(type*,0)->field))
+ 
+#define OT_(field)       O_(typeof_ptr(& field), filed))
 #define S_(data)         C_(U4, sizeof(data))
 
 #define sop_1(op,a,b) C_(U1, s1_(a) op s1_(b))
@@ -171,8 +174,6 @@ def_signed_ops(le, <=)
 #define le_s(a,b)  def_generic_sop(le, a,b)
 #undef def_generic_sop
 
-#define o_(field)                           offset_of(typeof_ptr(& field), filed))
-
 #define alignas                             _Alignas
 #define alignof                             _Alignof
 #define byte_pad(amount, ...)               B1 glue(_PAD_, __VA_ARGS__) [amount]

code/duffle/gcc_asm.h

@@ -66,14 +66,15 @@
  *   register V3_S2* p0 rgcc(R_T4) = ...;                    // bundled
  *
  *   asm volatile("nop" : : : reg_str(R_RA), "memory");      // clobber list */
-#define rlit_impl(n)  "$" #n
-#define rlit(n)       rlit_impl(n)
+#define rlit_stringfy(n)  "$" stringify(n)
+#define rlit_tmpl(n)      rlit_stringfy(tmpl(n,Code))
+#define rlit(n)           rlit_tmpl(n)
 
 /* ------------------------------------------------------------------------ *
  *  rgcc(n) — GCC-specific bundle for register-variable declarations.
  *
- *  Produces `__asm__(reg_str(tmpl(n, Code)))` at expansion time. 
- *  The `tmpl(n, Code)` indirection derives the preprocessor-visible `_Code`
+ *  Produces `__asm__(reg_str(tmpl(n, MipsCode)))` at expansion time. 
+ *  The `tmpl(n, MipsCode)` indirection derives the preprocessor-visible `_Code`
  *  form from the enum name (which the preprocessor can't expand on its own). 
  *  So a call is:                register V3_S2* p rgcc(R_T4)               = verts[0].ptr;
  *  expands (via tmpl) to:       register V3_S2* p __asm__(rlit(R_T4_Code)) = verts[0].ptr;
@@ -91,8 +92,7 @@
  *
  *  For clobber lists and asm-template strings, use the bare `rlit(R_T4_Code)`.
  * ------------------------------------------------------------------------ */
-#define rgcc_(n)       __asm__(rlit(tmpl(n, Code)))
-#define rgcc(n)        rgcc_(n)
+#define rgcc(n) __asm__(rlit(n))
 
 /* rgcc_ref(n) — GCC operand-reference form "%N". Not currently used
  * by the placeholder-pun macros (the .word bodies are fully baked

code/duffle/gen/duffle.macs.h

@@ -0,0 +1,126 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#pragma once
+#endif
+// Auto-generated by ps1_meta.lua — DO NOT EDIT
+// Source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
+// Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)
+
+#ifndef WORD_COUNT
+#define WORD_COUNT(name, count)  enum { words_##name = (count) };
+#endif
+
+#define mac_yield(...) \
+	load_word(R_AtomJmp, R_TapePtr, 0) \
+,	add_ui_self(         R_TapePtr, S_(MipsCode)) \
+,	jump_reg( R_AtomJmp) \
+,	nop
+WORD_COUNT(mac_yield, 4)
+
+/* Words: 3; Loads 3 S2 indices from the face array */
+#define mac_load_tri_indices(...) \
+	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)) \
+,	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)) \
+,	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2))
+WORD_COUNT(mac_load_tri_indices, 3)
+
+/* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
+#define mac_gte_load_tri_verts(...) \
+	shift_lleft(R_AT, R_T0, v3s2_byteoff) \
+,	add_u_self(R_AT, R_VertBase) \
+,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
+,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
+,	gte_mv_to_data_r(R_V0, C2_VXY0) \
+,	gte_mv_to_data_r(R_V1, C2_VZ0) \
+,	shift_lleft(R_AT, R_T1, v3s2_byteoff) \
+,	add_u_self(R_AT, R_VertBase) \
+,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
+,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
+,	gte_mv_to_data_r(R_V0, C2_VXY1) \
+,	gte_mv_to_data_r(R_V1, C2_VZ1) \
+,	shift_lleft(R_AT, R_T2, v3s2_byteoff) \
+,	add_u_self(R_AT, R_VertBase) \
+,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
+,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
+,	gte_mv_to_data_r(R_V0, C2_VXY2) \
+,	gte_mv_to_data_r(R_V1, C2_VZ2)
+WORD_COUNT(mac_gte_load_tri_verts, 18)
+
+/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
+ * Hardcoded for Poly_F3 (5 words). For Poly_G4, use ac_insert_ot_tag_g4. */
+#define mac_insert_ot_tag_f3(...) \
+	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
+,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
+,	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (5 - 1) << 24 = 4 << 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
+WORD_COUNT(mac_insert_ot_tag_f3, 11)
+
+/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
+ * Hardcoded for Poly_G4 (9 words). For Poly_F3, use ac_insert_ot_tag_f3. */
+#define mac_insert_ot_tag_g4(...) \
+	shift_lleft( R_T1, R_T1, S_(U4)/2)                        /* T1 = otz * S_(U4) (otz arg is implicit R_T1) */ \
+,	add_u_self(  R_T1, R_OtBase)                              /* T1 = & OrderingTable[OTZ] */ \
+,	load_word(   R_AT, R_T1,         O_(PolyTag,code))        /* AT = old_ot_head */ \
+,	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits) /* V0 = (9 - 1) << 24 = 8 << 24 */ \
+,	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits))    /* Strip upper 8 bits (length from prev cell) → keep only low 24 */ \
+,	or_u(        R_AT, R_AT, R_V0)                            /* Merge length */ \
+,	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code))        /* prim->tag = packed(prim_length, old_addr) */ \
+,	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits))    /* AT = (prim_length << 24) | old_addr */ \
+,	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)) \
+,	store_word(  R_AT, R_T1,         O_(PolyTag,code))        /* OrderingTable[OTZ] = PrimCursor */
+WORD_COUNT(mac_insert_ot_tag_g4, 11)
+
+#define mac_pack_color_word(off, cmd, r, g, b) \
+	load_upper_i(R_AT, (cmd) << 8  | (b)) \
+,	or_i_self(   R_AT, ((g)   << 8) | (r)) \
+,	store_word(  R_AT, R_PrimCursor, (off))
+WORD_COUNT(mac_pack_color_word, 3)
+
+#define mac_format_f3_color(r, g, b) \
+	mac_pack_color_word(O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b)
+WORD_COUNT(mac_format_f3_color, 3)
+
+/* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices to the F3.
+ * PIPELINE: post-RTPT (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). */
+#define mac_gte_store_f3_post_rtpt(...) \
+	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_F3,p0)) \
+,	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_F3,p1)) \
+,	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_F3,p2))
+WORD_COUNT(mac_gte_store_f3_post_rtpt, 3)
+
+#define mac_format_g4_color(r0, g0, b0, r1, g1, b1, r2, g2, b2, r3, g3, b3) \
+	mac_pack_color_word(O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0) \
+,	mac_pack_color_word(O_(Poly_G4,c1), 0,               r1,g1,b1) \
+,	mac_pack_color_word(O_(Poly_G4,c2), 0,               r2,g2,b2) \
+,	mac_pack_color_word(O_(Poly_G4,c3), 0,               r3,g3,b3)
+WORD_COUNT(mac_format_g4_color, 12)
+
+/* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
+ * G4 triangle portion to p0/p1/p2.
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
+ * three registers aligned with v0/v1/v2 you must store before RTPS).
+ * The macro name declares the pipeline position; check #6 (GTE state-
+ * machine validation) verifies the call site matches the declaration. */
+#define mac_gte_store_g4_p012_post_rtpt_pre_rtps(...) \
+	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_G4,p0)) \
+,	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_G4,p1)) \
+,	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p2))
+WORD_COUNT(mac_gte_store_g4_p012_post_rtpt_pre_rtps, 3)
+
+/* Words: 1; Stores the V3 screen coord to the G4's p3 slot.
+ * PIPELINE: post-RTPS (SXY2 holds v3.screen because RTPS writes its
+ * single-vertex result to SXY2; SXY0 still holds v0.screen from the
+ * earlier RTPT — DO NOT read SXY0 here, that's the bug this name
+ * prevents).
+ */
+#define mac_gte_store_g4_p3_post_rtps(...) \
+	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3))
+WORD_COUNT(mac_gte_store_g4_p3_post_rtps, 1)
+

code/duffle/gen/duffle.offsets.h

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

code/duffle/gp.h

@@ -1,122 +1,693 @@
+/* ============================================================================
+ *  duffle DSL Suffix Conventions
+ *  ============================================================================
+ *
+ *  Every mnemonic in this header follows the same suffix grammar:
+ *
+ *  Primitive commands: gp0_cmd_poly_f3 = 0x20    (byte opcode)
+ *  Packed 32-bit cmd:  gp0_word_poly_f3(r, g, b) (32-bit, shifted)
+ *
+ *  Type ordering: domain?_(direction)?_action_target_modifier_type?
+ *  Examples: add_ui             (add + unsigned + immediate)
+ *            add_s              (add + signed, R-type implicit)
+ *            shift_lleft        (shift + logical + left)
+ *            shift_aright       (shift + arithmetic + right)
+ *            call_reg(rs)       (call + register, $ra implicit)
+ *            gte_mv_to_data_r   (gte + mv + to + data + register)
+ *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
+ *            load_upper_i       (load-upper + immediate, unique verb)
+ *
+ *  --- GPU-domain layer cake ---
+ *  Every gp.h macro follows the same 4-layer composition as mips.h and gte.h:
+ *    4. Semantic encoders      gp0_word_poly_f3(r,g,b)
+ *    3. Composite encoders     enc_color_word(cmd, r, g, b)
+ *    2. Per-field encoders     enc_gp0_color_r(r), enc_gp0_color_g(g), ...
+ *    1. Bitfield layout consts gp0_color_red_shift = 0, gp0_color_red_mask = 0xFF
+ *    0. Opcode IDs             gp0_cmd_poly_f3 = 0x20
+ *
+ *  Vendor mnemonics (gte_mtc2, gte_mfc2, etc.) are NOT in this header.
+ *  They live in the opt-in `gp_vendor_sym.h` for users who prefer the
+ *  PSYQ-style names.
+ * ============================================================================ */
+
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
 #	include "dsl.h"
 #	include "math.h"
+#	include "mips.h"
 #endif
 
-typedef Enum_(U4, gp_Commands) {
-	gcmd_Reset       = 0b000,
-	gcmd_Polygon     = 0b001,
-	gcmd_Line        = 0b010,
-	gcmd_Rect        = 0b011,
-	gcmd_VM_to_VM    = 0b100,
-	gcmd_CPU_to_VM   = 0b101,
-	gcmd_VM_to_CPU   = 0b110,
-	gcmd_Environment = 0b111,
-
-	gcmd_SetDrawMode          = 0xE1,
-	gcmd_SetTextureWindow     = 0xE2,
-	gcmd_SetDrawArea_TopLeft  = 0xE3,
-	gcmd_SetDrawArea_BotRight = 0xE4,
-	gcmd_SetDrawOffset        = 0xE5,
-	gcmd_SetMaskBit           = 0xE6,
-
-	gcmd_ResetCommandBuffer      = 0x01,
-	gcmd_AcknowledgeGPUInterrupt = 0x02,
-	gcmd_DisplayEnable           = 0x03,
-	gcmd_DMA_Request             = 0x04,
-	gcmd_DispArea_Start          = 0x05,
-	gcmd_HorizontalDisplayRange  = 0x06,
-	gcmd_VerticalDisplayRange    = 0x07,
-	gcmd_DisplayMode             = 0x08,
-
-	gcmd_SetVramSize             = 0x09,
-};
-
+#pragma region GPU Ports & Commands
+/* ============================================================================
+ *  Hardware MMIO Addresses
+ *  ============================================================================
+ *
+ *  PSX GPU has two 32-bit ports in the I/O register region at KSEG2
+ *  0x1F800000+. GP0 (offset 0x10) is the data port (commands + params).
+ *  GP1 (offset 0x14) is the control port (status, ctrl writes).
+ * ============================================================================ */
+/* IO base address (KSEG2 0x1F800000+ for the I/O register region).
+ * The 16-bit upper half `IO_BASE_ADDR_HI16` is the form used by
+ * 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, GPIO_PORT*_OFFSET($reg)` (1 word). 
+ * Mirrors the `IO_BASE_ADDR equ 0x1F80` + `gpio_port0 equ 0x1810` pattern from graphics_hello/gp.s. */
 enum {
-	gpio_port_0 = 0x1810,
-	gpio_port_1 = 0x1814,
+    IO_BASE_ADDR      = 0x1F800000,  /* full 32-bit I/O region base */
+    IO_BASE_ADDR_HI16 = 0x1F80,      /* fits in a single `lui $reg, 0x1F80` */
 
-	gcmd_offset = 24,
+    /* Offsets from IO_BASE_ADDR to each port. Used by tape-side macros
+     * that pin a register to IO_BASE_ADDR and access ports via offsets:
+     *   sw $data, GPIO_PORT0_OFFSET($io_base)   ; write GP0
+     *   sw $data, GPIO_PORT1_OFFSET($io_base)   ; write GP1 */
+    GPIO_PORT0_OFFSET = 0x1810,
+    GPIO_PORT1_OFFSET = 0x1814,
 
-	gp_Reset = (gcmd_Reset << gcmd_offset),
-
-	gp_DisplayEnabled  = (gcmd_DisplayEnable << gcmd_offset | 0x0),
-	gp_DisplayDisabled = (gcmd_DisplayEnable << gcmd_offset | 0x1),
-
-	gp_DMA_FIFO       = 1,
-	gp_DMA_CPU_to_GPU = 2,
-	gp_DMA_GPU_to_CPU = 3,
-	gp_DMA_Request    = (gcmd_DMA_Request << gcmd_offset),
-
-	gp_HorizontalDisplayRange_3168_608 = (gcmd_HorizontalDisplayRange << gcmd_offset | 0xC60 << 12 | 0x260),
-
-	gp_VerticalDiplayRange         = (gcmd_VerticalDisplayRange << gcmd_offset),
-	gp_VerticalDisplayRange_264_24 = (gp_VerticalDiplayRange | 264 << 10 | 24),
-	gp_VerticalDisplayRange_504_24 = (gp_VerticalDiplayRange | 504 << 10 | 24),
-
-	gp_DisplayMode                    = (gcmd_DisplayMode << gcmd_offset),
-	gp_Disp_HRes_256                  = (0x0),
-	gp_Disp_HRes_320                  = (0x1),
-	gp_Disp_HRes_512                  = (0x2),
-	gp_Disp_HRes_640                  = (0x3),
-	gp_Disp_VRes_240                  = (0x0 << 2),
-	gp_Disp_VRes_480                  = (0x1 << 2),
-	gp_Disp_Color15                   = (0x0 << 4),
-	gp_Disp_Color24                   = (0x1 << 4),
-	gp_Disp_VInterlace                = (0x1 << 5),
-	gp_DisplayMode_320x240_15bit_NTSC = (gp_DisplayMode | gp_Disp_HRes_320 | gp_Disp_VRes_240 | gp_Disp_Color15),
-	gp_DisplayMOde_640x480_24bbp_NTSC = (gp_DisplayMode | gp_Disp_HRes_640 | gp_Disp_VRes_480 | gp_Disp_Color24 | gp_Disp_VInterlace),
-	
-	gp_DrawMode_DrawAllowed    = 10,
-	gp_SetDrawMode_DrawAllowed = (gcmd_SetDrawMode << gcmd_offset | 0x1 << gp_DrawMode_DrawAllowed),
-
-	gp_SetArea_TopLeft     = (gcmd_SetDrawArea_TopLeft  << gcmd_offset),
-	gp_SetArea_BottomRight = (gcmd_SetDrawArea_BotRight << gcmd_offset),
+    HW_GP0_ADDR = (IO_BASE_ADDR_HI16 << 16) | GPIO_PORT0_OFFSET,
+    HW_GP1_ADDR = (IO_BASE_ADDR_HI16 << 16) | GPIO_PORT1_OFFSET,
 };
 
+#define HW_GP0 C_(U4 V_*, HW_GP0_ADDR)
+#define HW_GP1 C_(U4 V_*, HW_GP1_ADDR)
+
+#define gp0_send(word) (HW_GP0[0] = (word))
+#define gp1_send(word) (HW_GP1[0] = (word))
+
+/* ============================================================================
+ *  GP0 command byte constants + Layer 1 (GPU bitfield shifts)
+ *  ============================================================================
+ *
+ *  8-bit GP0 opcodes (the upper byte of a primitive's first word). These are the BYTE only.
+ *  The layer-1 bitfield-layout constants live in the same enum block
+ *  so the encoder can reference them by name. 
+ *  NO macro body past this point uses a raw shift or raw mask. 
+ *  Every shift/width/mask is named here, named once. 
+ *  Mirrors the OPCODE_SHIFT / RS_SHIFT / REG_MASK convention from mips.h.
+ * ============================================================================ */
+enum {
+    gp0_cmd_Nop             = 0x00,
+
+    /* Cache management */
+    gp0_cmd_ClearCache      = 0x01,
+    gp0_cmd_FillVram        = 0x02,
+    gp0_cmd_CopyVram        = 0x80,
+    gp0_cmd_CopyVramChained = 0x81,
+    gp0_cmd_ReadVram        = 0xC0,
+
+    /* Polygons */
+    gp0_cmd_poly_f3         = 0x20,  /* Flat Triangle           */
+    gp0_cmd_poly_ft3        = 0x24,  /* Flat Textured Triangle  */
+    gp0_cmd_poly_g3         = 0x30,  /* Gouraud Triangle        */
+    gp0_cmd_poly_gt3        = 0x34,  /* Gouraud Textured Tri    */
+    gp0_cmd_poly_f4         = 0x28,  /* Flat Quad               */
+    gp0_cmd_poly_ft4        = 0x2C,  /* Flat Textured Quad      */
+    gp0_cmd_poly_g4         = 0x38,  /* Gouraud Quad            */
+    gp0_cmd_poly_gt4        = 0x3C,  /* Gouraud Textured Quad   */
+
+    /* Lines */
+    gp0_cmd_line_f2         = 0x40,
+    gp0_cmd_line_g2         = 0x50,
+
+    /* Sprites + Tiles + Rects */
+    gp0_cmd_sprt_1          = 0x64,
+    gp0_cmd_sprt_8          = 0x74,
+    gp0_cmd_sprt_16         = 0x7C,
+    gp0_cmd_tile_1          = 0x60,
+    gp0_cmd_tile_8          = 0x68,
+    gp0_cmd_tile_16         = 0x70,
+
+    /* State setters (not drawing primitives; set render context). */
+    gp0_cmd_DrawModeSetting      = 0xE1,  /* TPage / draw-mode (semi-trans, dither, etc.) */
+    gp0_cmd_SetTextureWindow     = 0xE2,
+    gp0_cmd_SetDrawArea_TopLeft  = 0xE3,
+    gp0_cmd_SetDrawArea_BotRight = 0xE4,
+    gp0_cmd_SetDrawOffset        = 0xE5,
+    gp0_cmd_SetMaskBit           = 0xE6,
+
+    /* bitfield shifts / widths / masks ----
+     * Generic GP0/GP1 command byte (upper 8 bits of every word sent to either port). */
+    gp0_cmd_shift = 24,
+    gp0_cmd_width =  8,
+    gp0_cmd_mask  = 0xFF,
+
+    /* Color word layout (lives in Poly_F3.color, Poly_G4.c0..c3, etc.):
+     *   bits 31..24 = command byte
+     *   bits 23..16 = BLUE
+     *   bits 15..08 = GREEN
+     *   bits 07..00 = RED     (PSX GPU is BGR, NOT RGB) */
+    gp0_color_cmd_shift   = 24, gp0_color_cmd_width   = 8, gp0_color_cmd_mask   = 0xFF,
+    gp0_color_blue_shift  = 16, gp0_color_blue_width  = 8, gp0_color_blue_mask  = 0xFF,
+    gp0_color_green_shift =  8, gp0_color_green_width = 8, gp0_color_green_mask = 0xFF,
+    gp0_color_red_shift   =  0, gp0_color_red_width   = 8, gp0_color_red_mask   = 0xFF,
+};
+
+/* ============================================================================
+ *  Layer 1.5 (per-field encoders) + Layer 2 (composite) + Layer 3 (semantic GP0 word builders)
+ *  ============================================================================
+ *
+ *  Layer 1.5 encoders take one field's value, mask it to its own width,
+ *  and shift it to its own position. 
+ *  Mirrors `enc_op` / `enc_rs` / `enc_rt` in mips.h and `enc_gte_sf` / `enc_gte_mx` in gte.h. 
+ *  Layer-2 composite encoders OR the per-field encoders together; layer-3 semantic macros delegate to the composites.
+ *  No raw shifts or magic numbers in any macro body below this point.
+ * ============================================================================ */
+
+/* ---- Layer 1.5: per-field encoders ---- */
+#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_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_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))
+
+#define enc_gp0_cmd_word(cmd) (enc_gp0_cmd(cmd))
+
+/* ---- Layer 3: semantic GP0 word builders ---- */
+
+/* Pre-baked color+command words for all 8 polygon variants.
+ * Mirrors `load_word` / `add_ui` / `jump_reg` style in mips.h. */
+#define gp0_word_poly_f3(r,g,b)  enc_color_word(gp0_cmd_poly_f3,  (r),(g),(b))
+#define gp0_word_poly_ft3(r,g,b) enc_color_word(gp0_cmd_poly_ft3, (r),(g),(b))
+#define gp0_word_poly_g3(r,g,b)  enc_color_word(gp0_cmd_poly_g3,  (r),(g),(b))
+#define gp0_word_poly_gt3(r,g,b) enc_color_word(gp0_cmd_poly_gt3, (r),(g),(b))
+#define gp0_word_poly_f4(r,g,b)  enc_color_word(gp0_cmd_poly_f4,  (r),(g),(b))
+#define gp0_word_poly_ft4(r,g,b) enc_color_word(gp0_cmd_poly_ft4, (r),(g),(b))
+#define gp0_word_poly_g4(r,g,b)  enc_color_word(gp0_cmd_poly_g4,  (r),(g),(b))
+#define gp0_word_poly_gt4(r,g,b) enc_color_word(gp0_cmd_poly_gt4, (r),(g),(b))
+
+/* Cache management — bare-cmd words (no color/range payload). */
+#define gp0_word_clear_cache() enc_gp0_cmd_word(gp0_cmd_ClearCache)
+#define gp0_word_fill_vram()   enc_gp0_cmd_word(gp0_cmd_FillVram)
+#define gp0_word_copy_vram()   enc_gp0_cmd_word(gp0_cmd_CopyVram)
+#define gp0_word_read_vram()   enc_gp0_cmd_word(gp0_cmd_ReadVram)
+
+/* ============================================================================
+ *  GP1 command byte constants + Layer 1 (display-mode + range + draw-area bitfield shifts)
+ *  ============================================================================
+ *
+ *  GP1 status bits are read from HW_GP1; ctrl writes use GP1 commands
+ *  packed into 32-bit words (cmd byte in the upper 8 bits via
+ *  `enc_gp0_cmd(cmd)` — never a raw shift).
+ * ============================================================================ */
+enum {
+    gp1_cmd_Reset                  = 0x00,
+    gp1_cmd_ResetCmdBuffer         = 0x01,
+    gp1_cmd_AcknowledgeIRQ         = 0x02,
+    gp1_cmd_DisplayEnable          = 0x03,
+    gp1_cmd_DMADirection           = 0x04,
+    gp1_cmd_StartDisplayArea       = 0x05,
+    gp1_cmd_HorizontalDisplayRange = 0x06,
+    gp1_cmd_VerticalDisplayRange   = 0x07,
+    gp1_cmd_DisplayMode            = 0x08,
+    /* Note: GP1 only has commands 0x00..0x08. 
+		 * The state-setter commands (SetTextureWindow, * SetDrawArea*, 
+		 * SetDrawOffset, SetMaskBit) live in the GP0 enum as * 0xE1..0xE6. 
+		 * DrawArea word builders are below as GP0s * macros 
+		 * (since they emit GP0 commands). */
+
+    /* ---- Display-mode payload flags (per PSX-SPX §"GP1 Display Mode").
+     * Bit positions match the encoder shifts below; values are the
+     * *payload* bits only (the cmd byte is OR'd in by enc_gp1_disp_mode_word). */
+    gp1_disp_HRes_256   = 0x0,
+    gp1_disp_HRes_320   = 0x1,
+    gp1_disp_HRes_512   = 0x2,
+    gp1_disp_HRes_640   = 0x3,
+    gp1_disp_VRes_240   = 0x0,
+    gp1_disp_VRes_480   = 0x1,
+    gp1_disp_Color15    = 0x0,
+    gp1_disp_Color24    = 0x1,
+    gp1_disp_VInterlace = 0x1,
+
+    /* ---- Layer 1: GP1 display-mode + range + draw-area shifts/masks ---- */
+    gp1_disp_hres_shift      =  0, gp1_disp_hres_width      = 2, gp1_disp_hres_mask      = 0x3,
+    gp1_disp_vres_shift      =  2, gp1_disp_vres_width      = 1, gp1_disp_vres_mask      = 0x1,
+    gp1_disp_color_shift     =  4, gp1_disp_color_width     = 1, gp1_disp_color_mask     = 0x1,
+    gp1_disp_interlace_shift =  5, gp1_disp_interlace_width = 1, gp1_disp_interlace_mask = 0x1,
+
+    /* GP1 horizontal display range: bits 0..11 = X2, bits 12..23 = X1 */
+    gp1_hrange_x1_shift = 12, gp1_hrange_x1_width = 12, gp1_hrange_x1_mask = 0xFFF,
+    gp1_hrange_x2_shift =  0, gp1_hrange_x2_width = 12, gp1_hrange_x2_mask = 0xFFF,
+
+    /* GP1 vertical display range: bits 0..9 = Y2, bits 10..19 = Y1 */
+    gp1_vrange_y1_shift = 10, gp1_vrange_y1_width = 10, gp1_vrange_y1_mask = 0x3FF,
+    gp1_vrange_y2_shift =  0, gp1_vrange_y2_width = 10, gp1_vrange_y2_mask = 0x3FF,
+
+    /* GP1 draw area (top-left or bottom-right): bits 0..9 = X, bits 10..19 = Y
+     * (10-bit signed — caller pre-signs and masks with the named mask) */
+    gp1_draw_x_shift =  0, gp1_draw_x_width = 10, gp1_draw_x_mask = 0x3FF,
+    gp1_draw_y_shift = 10, gp1_draw_y_width = 10, gp1_draw_y_mask = 0x3FF,
+};
+
+/* ---- Layer 1.5: GP1 per-field encoders ---- */
+#define enc_gp1_disp_hres(h)      (((h) & gp1_disp_hres_mask)     << gp1_disp_hres_shift)
+#define enc_gp1_disp_vres(v)      (((v) & gp1_disp_vres_mask)     << gp1_disp_vres_shift)
+#define enc_gp1_disp_color(c)     (((c) & gp1_disp_color_mask)    << gp1_disp_color_shift)
+#define enc_gp1_disp_interlace(i) (((i) & gp1_disp_interlace_mask << gp1_disp_interlace_shift)
+
+#define enc_gp1_hrange_x1(x1) (((x1) & gp1_hrange_x1_mask) << gp1_hrange_x1_shift)
+#define enc_gp1_hrange_x2(x2) (((x2) & gp1_hrange_x2_mask) << gp1_hrange_x2_shift)
+#define enc_gp1_vrange_y1(y1) (((y1) & gp1_vrange_y1_mask) << gp1_vrange_y1_shift)
+#define enc_gp1_vrange_y2(y2) (((y2) & gp1_vrange_y2_mask) << gp1_vrange_y2_shift)
+#define enc_gp1_draw_x(x)     (((x)  & gp1_draw_x_mask)    << gp1_draw_x_shift)
+#define enc_gp1_draw_y(y)     (((y)  & gp1_draw_y_mask)    << gp1_draw_y_shift)
+
+/* ---- Layer 2: GP1 composite encoders ---- */
+#define enc_gp1_disp_mode_word(h, v, c, i) (enc_gp0_cmd(gp1_cmd_DisplayMode)            | enc_gp1_disp_hres(h)  | enc_gp1_disp_vres(v) | enc_gp1_disp_color(c) | enc_gp1_disp_interlace(i))
+#define enc_gp1_hrange_word(x1, x2)        (enc_gp0_cmd(gp1_cmd_HorizontalDisplayRange) | enc_gp1_hrange_x1(x1) | enc_gp1_hrange_x2(x2))
+#define enc_gp1_vrange_word(y1, y2)        (enc_gp0_cmd(gp1_cmd_VerticalDisplayRange)   | enc_gp1_vrange_y1(y1) | enc_gp1_vrange_y2(y2))
+
+/* ---- Layer 2: GP0 state-setter composite encoders ----
+ * GP0(0xE3) SetDrawArea top-left and GP0(0xE4) SetDrawArea bottom-right
+ * both use the same X/Y 10-bit signed payload as GP1 DisplayRange. */
+#define enc_gp0_draw_area_tl_word(x, y)    (enc_gp0_cmd(gp0_cmd_SetDrawArea_TopLeft)  | enc_gp1_draw_x(x) | enc_gp1_draw_y(y))
+#define enc_gp0_draw_area_br_word(x, y)    (enc_gp0_cmd(gp0_cmd_SetDrawArea_BotRight) | enc_gp1_draw_x(x) | enc_gp1_draw_y(y))
+
+/* ---- Layer 3: GP1 semantic word builders ---- */
+#define gp1_word_display_enable(on)                         (enc_gp0_cmd(gp1_cmd_DisplayEnable) | ((on) & 1))
+#define gp1_word_display_disable()                          gp1_word_display_enable(0)
+#define gp1_word_display_mode_320x240_15bit_ntsc            enc_gp1_disp_mode_word(gp1_disp_HRes_320, gp1_disp_VRes_240, gp1_disp_Color15, 0)
+#define gp1_word_display_mode_640x480_24bit_ntsc_interlaced enc_gp1_disp_mode_word(gp1_disp_HRes_640, gp1_disp_VRes_480, gp1_disp_Color24, gp1_disp_VInterlace)
+
+#define gp1_word_horizontal_range(x1, x2) enc_gp1_hrange_word((x1), (x2))
+#define gp1_word_vertical_range(y1, y2)   enc_gp1_vrange_word((y1), (y2))
+
+/* ---- Layer 3: GP0 state-setter semantic word builders ---- */
+/* DrawArea: top-left = (X, Y), bottom-right = (X, Y) — X/Y in 10-bit signed.
+ * Caller is responsible for sign-conversion before passing in. */
+#define gp0_word_draw_area_top_left(x, y)     enc_gp0_draw_area_tl_word((x), (y))
+#define gp0_word_draw_area_bottom_right(x, y) enc_gp0_draw_area_br_word((x), (y))
+
+/* ============================================================================
+ *  Pre-baked GPU state words
+ *  ============================================================================
+ *
+ *  Common command words for boot-time GPU init and standard display configurations.
+ * ============================================================================ */
+
+/* ---- Display enable (1-bit payload on DisplayEnable cmd) ---- */
+#define gp1_word_display_enabled   enc_gp0_cmd_word(gp1_cmd_DisplayEnable)
+#define gp1_word_display_disabled (enc_gp0_cmd_word(gp1_cmd_DisplayEnable) | 1)
+
+/* ---- DMA direction (2-bit payload on DMADirection cmd 0x04) ---- */
+enum {
+    gp1_dma_dir_Off            = 0,
+    gp1_dma_dir_FIFO           = 1,
+    gp1_dma_dir_CPU_to_GPU     = 2,
+    gp1_dma_dir_GPUREAD_to_CPU = 3,
+};
+#define gp1_word_dma_direction(dir) (enc_gp0_cmd(gp1_cmd_DMADirection) | ((dir) & 0x3))
+
+/* ---- Standard display ranges (NTSC + PAL pre-baked) ---- */
+/* Horizontal range values are in video clock units (8 units/pixel); vertical range values are scanline numbers. */
+enum {
+    /* NTSC horizontal range: X1=608, X2=3168 */
+    gp1_hrange_NTSC_x1 = 0x260,
+    gp1_hrange_NTSC_x2 = 0xC60,
+    /* PAL horizontal range (same as NTSC for most CRTs) */
+    gp1_hrange_PAL_x1  = 0x260,
+    gp1_hrange_PAL_x2  = 0xC60,
+
+    /* NTSC vertical range: Y1=24, Y2=264 */
+    gp1_vrange_NTSC_y1 = 24,
+    gp1_vrange_NTSC_y2 = 264,
+    /* PAL vertical range: Y1=24, Y2=504 */
+    gp1_vrange_PAL_y1  = 24,
+    gp1_vrange_PAL_y2  = 504,
+};
+
+#define gp1_word_horizontal_range_ntsc enc_gp1_hrange_word(gp1_hrange_NTSC_x1, gp1_hrange_NTSC_x2)
+#define gp1_word_horizontal_range_pal  enc_gp1_hrange_word(gp1_hrange_PAL_x1,  gp1_hrange_PAL_x2)
+#define gp1_word_vertical_range_ntsc   enc_gp1_vrange_word(gp1_vrange_NTSC_y1, gp1_vrange_NTSC_y2)
+#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 "drawing enabled" word is the standard post-init state. */
+enum {
+    gp0_DrawMode_DrawToDispBit = 10,
+};
+#define gp0_word_draw_mode_drawing_allowed (enc_gp0_cmd(gp0_cmd_DrawModeSetting) | (1 << gp0_DrawMode_DrawToDispBit))
+
+/* ---- DrawArea pre-baked at origin (0,0) and full screen (320x240) ---- */
+#define gp0_word_draw_area_top_left_origin      enc_gp0_draw_area_tl_word(0, 0)
+#define gp0_word_draw_area_bottom_right_320x240 enc_gp0_draw_area_br_word(320, 240)
+#define gp0_word_draw_area_bottom_right_640x480 enc_gp0_draw_area_br_word(640, 480)
+
+#pragma endregion GPU Ports & Commands
+
+#pragma region GPU Status
+/* ============================================================================
+ *  GPU status register bits
+ *  ============================================================================
+ *  Read from HW_GP1; the lower bits are DMA-block-size (variable-width).
+ * ============================================================================ */
+enum {
+    gp1_Status_BitReady          = 31,
+    gp1_Status_BitSendingDMA     = 25,
+    gp1_Status_DMABlockSizeShift =  0,
+};
+
+#define gp1_status_is_ready()       ((HW_GP1[0] >> gp1_Status_BitReady)      & 1)
+#define gp1_status_is_sending_dma() ((HW_GP1[0] >> gp1_Status_BitSendingDMA) & 1)
+#pragma endregion GPU Status
+
+#pragma region Primitives
+/* ============================================================================
+ *  Primitive structs (8 polygon variants + tag)
+ *  ============================================================================
+ *
+ *  Each struct follows the GPU-documented memory layout for the corresponding primitive command. 
+ *  The PolyTag is the OT-link header; the rest of the struct is the primitive's body.
+ *
+ *  The current working layouts match the existing demo 
+ *  (floor_tri uses Poly_F3; cube_tri uses Poly_G4). 
+ *  They are NOT necessarily byte-identical to the PSX-SPX reference layout. 
+ *  The demo layout uses color+vertex interleaving that doesn't match the standard PSX SDK file format. 
+ *  For PSX-SDK file compatibility, the textured variants (FT*, GT*) would need layout adjustments.
+ * ============================================================================ */
+
+/* ---------- RGB8 (3-byte packed color) ---------- */
 typedef Struct_(RGB8) { B1 r; B1 g; B1 b; };
-#define rgb8(r, g, b) (RGB8){ r, g, b }
-
-typedef B1 gp_Pixel16[1];
-typedef B1 gp_Pixel24[3];
+#define rgb8(r,g,b) ((RGB8){r,g,b})
 
+/* ---------- PolyTag (the OT-link header; 1 word) ---------- */
 enum {
-	gp_b10_X = 0,
-	gp_b10_Y = 10,
-	gp_b16_X = 0,
-	gp_b16_Y = 16,
+    PolyTag_len_bits  =  8,
+    PolyTag_addr_bits = 24,
+};
+typedef Struct_(PolyTag) {
+	union {
+		U4 code;
+		struct {
+			U4 addr: 24;
+			U4 len:  8;
+		};
+	};
 };
 
-typedef Struct_(gp_Vec2) { U2 y; U2 x; };
+/* DSL cast convention: every cast uses `C_()`, every pointer qualifier is `R_` (restrict) or `V_` (volatile).
+ * No raw C-style casts. RHS values 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 `set_poly_*` setters, 
+ *  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)
 
-#if 1
-void gp_screen_init(void) __asm__("gp_screen_init_asm");
-#else
-#define gp_screen_init() gp_screen_init_c11()
-#endif
+/* ---------- Poly_F3 (Flat Triangle; 5 words) ---------- */
+typedef Struct_(Poly_F3) {
+    U4   tag;
+    RGB8 color;
+    B1   code;
+    union {
+        struct { V2_S2 p0; V2_S2 p1; V2_S2 p2; };
+        A3_V2_S2 points;
+    };
+};
 
+/* ---------- Poly_F4 (Flat Quad; 6 words) ---------- */
+typedef Struct_(Poly_F4) {
+    U4   tag;
+    RGB8 color;
+    B1   code;
+    union {
+        struct { V2_S2 p0; V2_S2 p1; V2_S2 p2; V2_S2 p3; };
+        A4_V2_S2 points;
+    };
+};
 
+/* ---------- Poly_G3 (Gouraud Triangle; 7 words) ---------- */
+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;
+};
 
-// TODO REVIEW:
+/* ---------- Poly_G4 (Gouraud Quad; 9 words) ---------- */
+typedef Struct_(Poly_G4) {
+    U4    tag; RGB8 c0; B1 code;
+    V2_S2 p0;  RGB8 c1; B1 pad1;
+    V2_S2 p1;  RGB8 c2; B1 pad2;
+    V2_S2 p2;  RGB8 c3; B1 pad3;
+    V2_S2 p3;
+};
 
-/* --- GPU Command Semantics (GP0) --- */
+/* ---------- Poly_FT3 (Flat Textured Triangle; placeholder layout) ---------- */
+/* TODO(Ed): verify the textured-variant layout against PSX-SPX when needed. */
+typedef Struct_(Poly_FT3) {
+    U4   tag;
+    RGB8 color;
+    B1   code;
+    U4   tpage;
+    U4   clut;
+    V2_S2 p0; U1 u0; U1 v0;
+    V2_S2 p1; U1 u1; U1 v1;
+    V2_S2 p2; U1 u2; U1 v2;
+};
 
-#define GPU_CMD_CLEAR_CACHE 0x01
-#define GPU_CMD_VRAM_FILL   0x02
-#define GPU_CMD_VRAM_COPY   0x80
-#define GPU_CMD_VRAM_READ   0xC0
-#define GPU_CMD_POLY_F3     0x20 /* Flat Triangle */
-#define GPU_CMD_POLY_FT3    0x24 /* Flat Textured Triangle */
-#define GPU_CMD_POLY_G3     0x30 /* Gouraud Triangle */
-#define GPU_CMD_POLY_GT3    0x34 /* Gouraud Textured Triangle */
-#define GPU_CMD_POLY_F4     0x28 /* Flat Quad */
-#define GPU_CMD_POLY_FT4    0x2C /* Flat Textured Quad */
-#define GPU_CMD_POLY_G4     0x38 /* Gouraud Quad */
-#define GPU_CMD_POLY_GT4    0x3C /* Gouraud Textured Quad */
+/* ---------- Poly_FT4 (Flat Textured Quad) ---------- */
+typedef Struct_(Poly_FT4) {
+    U4   tag;
+    RGB8 color;
+    B1   code;
+    U4   tpage;
+    U4   clut;
+    V2_S2 p0; U1 u0; U1 v0;
+    V2_S2 p1; U1 u1; U1 v1;
+    V2_S2 p2; U1 u2; U1 v2;
+    V2_S2 p3; U1 u3; U1 v3;
+};
 
-/* --- Hardware MMIO Addresses --- */
+/* ---------- Poly_GT3 (Gouraud Textured Triangle) ---------- */
+typedef Struct_(Poly_GT3) {
+    U4    tag; RGB8 c0; B1 code;
+    V2_S2 p0;  RGB8 c1; B1 pad1;
+    V2_S2 p1;  RGB8 c2; B1 pad2;
+    V2_S2 p2;
+    U4    tpage;
+    U4    clut;
+    V2_S2 tp0; U1 u0; U1 v0;
+    V2_S2 tp1; U1 u1; U1 v1;
+    V2_S2 tp2; U1 u2; U1 v2;
+};
 
-#define HW_GP0_ADDR       0x1F801810 /* GPU Data Port */
-#define HW_GP1_ADDR       0x1F801814 /* GPU Status/Control Port */
+/* ---------- Poly_GT4 (Gouraud Textured Quad) ---------- */
+typedef Struct_(Poly_GT4) {
+    U4    tag; RGB8 c0; B1 code;
+    V2_S2 p0;  RGB8 c1; B1 pad1;
+    V2_S2 p1;  RGB8 c2; B1 pad2;
+    V2_S2 p2;  RGB8 c3; B1 pad3;
+    V2_S2 p3;
+    U4    tpage;
+    U4    clut;
+    V2_S2 tp0; U1 u0; U1 v0;
+    V2_S2 tp1; U1 u1; U1 v1;
+    V2_S2 tp2; U1 u2; U1 v2;
+    V2_S2 tp3; U1 u3; U1 v3;
+};
 
+/* ---------- 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
+#define set_poly_g3(p)  set_len(p, 6),  C_(Poly_G3_R, p)->code = gp0_cmd_poly_g3
+#define set_poly_gt3(p) set_len(p, 9),  C_(Poly_GT3_R,p)->code = gp0_cmd_poly_gt3
+#define set_poly_f4(p)  set_len(p, 5),  C_(Poly_F4_R, p)->code = gp0_cmd_poly_f4
+#define set_poly_ft4(p) set_len(p, 9),  C_(Poly_FT4_R,p)->code = gp0_cmd_poly_ft4
+#define set_poly_g4(p)  set_len(p, 8),  C_(Poly_G4_R, p)->code = gp0_cmd_poly_g4
+#define set_poly_gt4(p) set_len(p, 12), C_(Poly_GT4_R,p)->code = gp0_cmd_poly_gt4
+
+/* ---------- Ordering table ops ---------- */
+#define orderingtbl_add_primitive(ot, p)       set_addr(p,  get_addr(ot)), set_addr(ot, p)
+#define orderingtbl_add_primitives(ot, p0, p1) set_addr(p1, get_addr(ot)), set_addr(ot, p0)
+
+#pragma endregion Primitives
+
+#pragma region TPage
+/* ============================================================================
+ *  Texture Page (TPage) bit layout
+ *  ============================================================================
+ *
+ *  The TPage data word sent via GP0(0x2X) has:
+ *    bits  0..3   = texture page X    (4 bits, 64-px units, 0..16)
+ *    bit   4      = texture page Y    (1 bit,  64-px units, 0/1)
+ *    bits  5..6   = semi-transparency (2 bits, 0..3)
+ *    bits  7..8   = texture page colors (2 bits, 4bpp/8bpp/16bpp/2bpp-mixed)
+ *    bit   9      = dither            (1 bit,  0/1)
+ *    bit  10      = drawing to display area (1 bit)
+ *    bit  11      = texture disable   (1 bit)
+ *    bits 12..31  = reserved (zero)
+ * ============================================================================ */
+enum {
+    /* ---- Layer 1: TPage bitfield shifts / widths / masks ---- */
+    gp0_tpage_x_shift            =  0, gp0_tpage_x_width            =  4, gp0_tpage_x_mask            = 0xF,
+    gp0_tpage_y_shift            =  4, gp0_tpage_y_width            =  1, gp0_tpage_y_mask            = 0x1,
+    gp0_tpage_semi_trans_shift   =  5, gp0_tpage_semi_trans_width   =  2, gp0_tpage_semi_trans_mask   = 0x3,
+    gp0_tpage_color_depth_shift  =  7, gp0_tpage_color_depth_width  =  2, gp0_tpage_color_depth_mask  = 0x3,
+    gp0_tpage_dither_shift       =  9, gp0_tpage_dither_width       =  1, gp0_tpage_dither_mask       = 0x1,
+    gp0_tpage_draw_to_disp_shift = 10, gp0_tpage_draw_to_disp_width =  1, gp0_tpage_draw_to_disp_mask = 0x1,
+    gp0_tpage_tex_disable_shift  = 11, gp0_tpage_tex_disable_width  =  1, gp0_tpage_tex_disable_mask  = 0x1,
+
+    /* TPage color-depth payload values (NOT bit positions — these go in
+     * the 2-bit field at gp0_tpage_color_depth_shift). */
+    gp0_tpage_color_4bpp  = 0x0,
+    gp0_tpage_color_8bpp  = 0x1,
+    gp0_tpage_color_16bpp = 0x2,
+
+    /* TPage semi-transparency mode payload values (NOT bit positions). */
+    gp0_tpage_semi_trans_none  = 0x0,
+    gp0_tpage_semi_trans_alpha = 0x1,
+    gp0_tpage_semi_trans_add   = 0x2,
+    gp0_tpage_semi_trans_sub   = 0x3,
+};
+
+/* ---- Layer 1.5: TPage per-field encoders. Mirrors enc_gte_sf/mx/v in gte.h. ---- */
+#define enc_gp0_tpage_x(x)            (((x) & gp0_tpage_x_mask)            << gp0_tpage_x_shift)
+#define enc_gp0_tpage_y(y)            (((y) & gp0_tpage_y_mask)            << gp0_tpage_y_shift)
+#define enc_gp0_tpage_semi_trans(s)   (((s) & gp0_tpage_semi_trans_mask)   << gp0_tpage_semi_trans_shift)
+#define enc_gp0_tpage_color_depth(c)  (((c) & gp0_tpage_color_depth_mask)  << gp0_tpage_color_depth_shift)
+#define enc_gp0_tpage_dither(d)       (((d) & gp0_tpage_dither_mask)       << gp0_tpage_dither_shift)
+#define enc_gp0_tpage_draw_to_disp(d) (((d) & gp0_tpage_draw_to_disp_mask) << gp0_tpage_draw_to_disp_shift)
+#define enc_gp0_tpage_tex_disable(t)  (((t) & gp0_tpage_tex_disable_mask)  << gp0_tpage_tex_disable_shift)
+
+/* ---- Layer 2: TPage composite encoder. Mirrors enc_gte_cmdw in gte.h ---- */
+#define enc_gp0_tpage_word(x, y, semi_trans, color_depth, dither, draw_to_disp, tex_disable) \
+    (enc_gp0_tpage_x(x)                       \
+   | enc_gp0_tpage_y(y)                       \
+   | enc_gp0_tpage_semi_trans(semi_trans)     \
+   | enc_gp0_tpage_color_depth(color_depth)   \
+   | enc_gp0_tpage_dither(dither)             \
+   | enc_gp0_tpage_draw_to_disp(draw_to_disp) \
+   | enc_gp0_tpage_tex_disable(tex_disable))
+
+typedef Struct_(TexturePage) { U4 raw; };
+
+/* ---- Layer 3: TPage semantic word builder ---- */
+#define gp0_word_tpage(x, y, semi_trans, color_depth, dither, draw_to_disp, tex_disable) \
+    enc_gp0_tpage_word((x), (y), (semi_trans), (color_depth), (dither), (draw_to_disp), (tex_disable))
+#pragma endregion TPage
+
+#pragma region CLUT
+/* ============================================================================
+ *  CLUT (Color Look-Up Table) semantics
+ *  ============================================================================
+ * 
+ *  CLUT is loaded into VRAM by sending a GP0 command whose payload is:
+ *    bits  0..5   = Y in 16-px units (palette row)
+ *    bits  6..14  = X in 16-px units (palette column)
+ *    bits 15..23  = reserved (zero)
+ *    bits 24..31  = command byte — 0x20 (4bpp load) or 0x25 (8bpp load)
+ * ============================================================================ */
+enum {
+    /* ---- Layer 1: CLUT bitfield shifts / widths / masks ---- */
+    gp0_clut_y_shift = 0, gp0_clut_y_width = 6, gp0_clut_y_mask = 0x3F,
+    gp0_clut_x_shift = 6, gp0_clut_x_width = 9, gp0_clut_x_mask = 0x1FF,
+    /* CLUT-load cmd-byte variants — the upper byte of the GP0 word. */
+    gp0_clut_cmd_Load4bpp = 0x20,
+    gp0_clut_cmd_Load8bpp = 0x25,
+};
+
+/* ---- Layer 1.5: CLUT per-field encoders ---- */
+#define enc_gp0_clut_x(x) (((x) & gp0_clut_x_mask) << gp0_clut_x_shift)
+#define enc_gp0_clut_y(y) (((y) & gp0_clut_y_mask) << gp0_clut_y_shift)
+
+/* ---- Layer 2: CLUT composite encoder ---- */
+#define enc_gp0_clut_word(cmd, x, y) (enc_gp0_cmd(cmd) | enc_gp0_clut_x(x) | enc_gp0_clut_y(y))
+
+/* ---- Layer 3: CLUT semantic word builders — one per depth variant,
+ * named cmd-byte (no opaque ternary). ---- */
+#define gp0_word_clut_load_4bpp(x, y) enc_gp0_clut_word(gp0_clut_cmd_Load4bpp, (x), (y))
+#define gp0_word_clut_load_8bpp(x, y) enc_gp0_clut_word(gp0_clut_cmd_Load8bpp, (x), (y))
+#pragma endregion CLUT
+
+#pragma region TIM File Format
+/* ============================================================================
+ *  TIM file format constants and headers
+ *  ============================================================================
+ *
+ *  TIM (Sony .TIM texture image) file structure:
+ *    +0x00  U4 file_id (always 0x10 = TIM magic)
+ *    +0x04  U4 version (always 0x00 for v1)
+ *    +0x08  U4 flags   (bits 0..2 = type, bit 3 = has_CLUT)
+ *    +0x0C  ... CLUT section (if flags & 0x8)
+ *         +0x00 U4 clut_section_length
+ *         +0x04 U2 clut_org_x
+ *         +0x06 U2 clut_org_y
+ *         +0x08 U2 num_colors
+ *         +0x0A U2 depth_bpp
+ *         +0x0C ... palette data
+ *    ...   ... Pixel section
+ *         +0x00 U4 px_section_length
+ *         +0x04 U2 px_width
+ *         +0x06 U2 px_height
+ *         +0x08 ... pixel data
+ *
+ *  Future?: add `tim_load_to_vram(tim_ptr, vram_addr)` that
+ *  emits the necessary GP0 commands. Stoppped for now at the
+ *  struct + enum level.
+ * ============================================================================ */
+enum {
+    tim_file_id_magic = 0x10,
+    tim_type_4bpp     = 0x00,
+    tim_type_8bpp     = 0x01,
+    tim_type_16bpp    = 0x02,
+    tim_type_32bpp    = 0x03,
+    tim_type_mixed    = 0x04,
+    tim_flag_has_clut = 0x08,
+};
+
+typedef Struct_(TIM_Header) {
+    U4 file_id;       /* always 0x10 = "TIM" magic */
+    U4 version;       /* ignored; always 0 */
+    U4 flags;         /* bits 0..2 = type, bit 3 = has_clut */
+};
+typedef Struct_(TIM_SectionHeader) {
+    U4 section_length;  /* bytes in this section including this header */
+    U2 org_x;           /* origin in VRAM */
+    U2 org_y;
+    U2 width;           /* width in pixels */
+    U2 height;          /* height in pixels */
+};
+#pragma endregion TIM File Format
+
+#pragma region Tape-Side Macros
+/* ============================================================================
+ *  Tape-side GPU operations (NOT in this header)
+ *  ============================================================================
+ *
+ *  No `mac_gp0_send` or related macros live in gp.h. Rationale: the
+ *  Lottes tape model uses OT-DMA for primitive submission, so atom bodies
+ *  write to main RAM (the OT/primitive buffer) and to GTE state — never
+ *  directly to the GPU ports at 0x1F801810 / 0x1F801814. See
+ *  `mac_format_f3_color`, `mac_insert_ot_tag`, `mac_gte_store_f3` in
+ *  lottes_tape.h for the patterns atom bodies actually use.
+ *
+ *  If a feature need arises requires tape-side GPU port writes (e.g. DMA-kick to
+ *  start GPU consumption of the OT, VBlank sync via GP1 status poll),
+ *  the right home is `lottes_tape.h` alongside the rest of the `mac_*`
+ *  family — the encoder infrastructure is already in place:
+ *
+ *    1. The caller pins a register to hold the IO base, e.g.
+ *         register U4 r_io rgcc(R_T4) = IO_BASE_ADDR;
+ *       The compiler emits `lui R_T4, IO_BASE_ADDR_HI16` outside the
+ *       atom body (in the C prologue before tape_run).
+ *
+ *    2. The atom body uses `store_word(R_data, R_T4, GPIO_PORT0_OFFSET)`
+ *       to write to GP0, and `store_word(R_data, R_T4, GPIO_PORT1_OFFSET)`
+ *       to write to GP1. Both are preprocessor-encodable because R_T4 is
+ *       a fixed register and the GPIO_PORT*_OFFSET constants fit in the
+ *       `sw`'s 16-bit signed offset field. No placeholder-pun, no asm
+ *       constraints, no hidden register choice. Same pattern as the
+ *       old graphics_hello/hello_gp_routines.s `reg_io_offset`/`gcmd_push`
+ *       convention.
+ *
+ *  This mirrors the existing tape-side wave-context discipline: the
+ *  caller binds the IO-base register via `rgcc()`, the macro assumes
+ *  the binding is in effect, and the encoding falls out at preprocessor
+ *  time. No additional GPU-domain macro layer required.
+ * ============================================================================ */
+#pragma endregion Tape-Side Macros

code/duffle/gp_vendor_sym.h

@@ -0,0 +1,58 @@
+/* ============================================================================
+ *  duffle DSL — GPU Vendor Mnemonics (opt-in)
+ *  ============================================================================
+ *
+ *  Provides the PSYQ-style CamelCase aliases for the canonical duffle GPU
+ *  primitive setters and OT operations. The duffle snake_case names are
+ *  primary; this header is for users who prefer the PSYQ SDK function
+ *  names from the legacy C API.
+ *
+ *  USAGE:   #include "duffle/gp_vendor_sym.h"   // after gp.h
+ *
+ *  Mapping (vendor -> duffle):
+ *    Primitive setters (PSYQ SDK-style):
+ *      setPolyF3  -> set_poly_f3
+ *      setPolyF4  -> set_poly_f4
+ *      setPolyG3  -> set_poly_g3
+ *      setPolyG4  -> set_poly_g4
+ *      setPolyFT3 -> set_poly_ft3
+ *      setPolyFT4 -> set_poly_ft4
+ *      setPolyGT3 -> set_poly_gt3
+ *      setPolyGT4 -> set_poly_gt4
+ *
+ *    OT operations:
+ *      AddPrim(ot, p)  -> orderingtbl_add_primitive(ot, p)
+ *
+ *  The gp0_cmd_* / gp1_cmd_* byte constants are already short and
+ *  descriptive; no vendor alias is provided for them.
+ *
+ *  The vendor mnemonics are NOT registered with the duffle word-count
+ *  metadata (word_counts.metadata.h). They expand to the duffle canonical
+ *  macros which DO have word-count entries (the ones emitted by
+ *  mac_format_f3_color / mac_gte_store_f3 / etc.). Verification: V13
+ *  (objdump byte-identical) holds.
+ *
+ * ============================================================================ */
+
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "gp.h"
+#endif
+
+#ifndef DUFFLE_GP_VENDOR_SYM_H
+#define DUFFLE_GP_VENDOR_SYM_H
+
+/* Primitive setters (PSYQ SDK-style) */
+#define setPolyF3(p)    set_poly_f3(p)
+#define setPolyF4(p)    set_poly_f4(p)
+#define setPolyG3(p)    set_poly_g3(p)
+#define setPolyG4(p)    set_poly_g4(p)
+#define setPolyFT3(p)   set_poly_ft3(p)
+#define setPolyFT4(p)   set_poly_ft4(p)
+#define setPolyGT3(p)   set_poly_gt3(p)
+#define setPolyGT4(p)   set_poly_gt4(p)
+
+/* OT operations */
+#define AddPrim(ot, p)  orderingtbl_add_primitive((ot), (p))
+
+#endif

code/duffle/gte.h

@@ -1,3 +1,27 @@
+/* ============================================================================
+ *  duffle DSL Suffix Conventions
+ *  ============================================================================
+ *
+ *  Every mnemonic in this header follows the same suffix grammar:
+ *
+ *  Primitive commands: gp0_cmd_poly_f3 = 0x20    (byte opcode)
+ *  Packed 32-bit cmd:  gp0_word_poly_f3(r, g, b) (32-bit, shifted)
+ *
+ *  Type ordering: domain?_(direction)?_action_target_modifier_type?
+ *  Examples: add_ui             (add + unsigned + immediate)
+ *            add_s              (add + signed, R-type implicit)
+ *            shift_lleft        (shift + logical + left)
+ *            shift_aright       (shift + arithmetic + right)
+ *            call_reg(rs)       (call + register, $ra implicit)
+ *            gte_mv_to_data_r   (gte + mv + to + data + register)
+ *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
+ *            load_upper_i       (load-upper + immediate, unique verb)
+ *
+ *  Vendor mnemonics (gte_mtc2, gte_mfc2, gte_lwc2, gte_swc2, etc.) are
+ *  NOT in this header. They live in the opt-in `gte_vendor_sym.h` for
+ *  users who prefer the textbook MIPS assembly mnemonics.
+ * ============================================================================ */
+
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
 #	include "dsl.h"
@@ -5,6 +29,7 @@
 #	include "mips.h"
 #endif
 
+#pragma region ASM DSL
 /* ============================================================================
  *  gte.h — Geometry Transformation Engine (COP2) for the PS1
  * ============================================================================
@@ -12,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( clb_system )
- *      );
- *
- *      // 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 __asm__("$12") = verts[0].ptr;
- *      register V3_S2* p1 __asm__("$13") = verts[1].ptr;
- *      register V3_S2* p2 __asm__("$14") = 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
@@ -69,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 */
@@ -132,7 +113,7 @@ enum {
 	gte_in_v1_z      = C2_VZ1,  /* Input Vector 1 (Z) */
 	gte_in_v2_xy     = C2_VXY2, /* Input Vector 2 (X, Y) */
 	gte_in_v2_z      = C2_VZ2,  /* Input Vector 2 (Z) */
-	gte_in_rgb       = C2_RGB,  /* Input Color (R, G, B, Code) */
+	gte_in_rgb       = C2_RGB,  /* Input Color (R, G, B, MipsCode) */
 	gte_out_scr_xy0  = C2_SXY0, /* Output Screen Coord 0 (X, Y) */
 	gte_out_scr_xy1  = C2_SXY1, /* Output Screen Coord 1 (X, Y) */
 	gte_out_scr_xy2  = C2_SXY2, /* Output Screen Coord 2 (X, Y) */
@@ -197,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
- * OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
+ * configurable field, used by the ENC_GTE_CMD encoder. 
+ * Mirrors the OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
  */
 
 	gte_shift_sf  = 19,  gte_width_sf  = 1,  gte_mask_sf  = 0x1,
@@ -216,17 +197,17 @@ enum {
  * Same pattern as the GPR `_Code` set in mips.h. Note: indices 21-23
  * are reserved/unused on real hardware, so there's a gap. */
 #define gte_cr_RT11_Code  0
-#define gte_cr_RT12_Code  1
-#define gte_cr_RT13_Code  2
-#define gte_cr_RT21_Code  3
-#define gte_cr_RT22_Code  4
-#define gte_cr_RT23_Code  5
-#define gte_cr_RT31_Code  6
-#define gte_cr_RT32_Code  7
-#define gte_cr_RT33_Code  8
-#define gte_cr_TRX_Code   9
-#define gte_cr_TRY_Code  10
-#define gte_cr_TRZ_Code  11
+#define gte_cr_RT12_Code  1  /* packed with RT13 in bits 16..31 */
+#define gte_cr_RT13_Code  2  /* packed with RT22 in bits 16..31 */
+#define gte_cr_RT21_Code  3  /* packed with RT31 in bits 16..31 */
+#define gte_cr_RT22_Code  4  /* RT33 alone (low 16 bits used) */
+// #define gte_cr_RT23_Code  5
+// #define gte_cr_RT31_Code  6
+// #define gte_cr_RT32_Code  7
+// #define gte_cr_RT33_Code  8
+#define gte_cr_TRX_Code   5   /* PSX SDK convention: C2 r5 = TRX (alone, 32-bit) */
+#define gte_cr_TRY_Code   6   /* PSX SDK convention: C2 r6 = TRY (alone, 32-bit) */
+#define gte_cr_TRZ_Code   7   /* PSX SDK convention: C2 r7 = TRZ (alone, 32-bit) */
 #define gte_cr_L11_Code  12
 #define gte_cr_L12_Code  13
 #define gte_cr_L13_Code  14
@@ -247,8 +228,8 @@ enum {
 
 enum {
 	gte_cr_RT11 = gte_cr_RT11_Code, gte_cr_RT12 = gte_cr_RT12_Code, gte_cr_RT13 = gte_cr_RT13_Code,
-	gte_cr_RT21 = gte_cr_RT21_Code, gte_cr_RT22 = gte_cr_RT22_Code, gte_cr_RT23 = gte_cr_RT23_Code,
-	gte_cr_RT31 = gte_cr_RT31_Code, gte_cr_RT32 = gte_cr_RT32_Code, gte_cr_RT33 = gte_cr_RT33_Code,
+	gte_cr_RT21 = gte_cr_RT21_Code, gte_cr_RT22 = gte_cr_RT22_Code, //gte_cr_RT23 = gte_cr_RT23_Code,
+	// gte_cr_RT31 = gte_cr_RT31_Code, gte_cr_RT32 = gte_cr_RT32_Code, gte_cr_RT33 = gte_cr_RT33_Code,
 	gte_cr_TRX  = gte_cr_TRX_Code,  gte_cr_TRY  = gte_cr_TRY_Code,  gte_cr_TRZ  = gte_cr_TRZ_Code,
 	gte_cr_L11  = gte_cr_L11_Code,  gte_cr_L12  = gte_cr_L12_Code,  gte_cr_L13  = gte_cr_L13_Code,
 	gte_cr_L21  = gte_cr_L21_Code,  gte_cr_L22  = gte_cr_L22_Code,  gte_cr_L23  = gte_cr_L23_Code,
@@ -259,26 +240,64 @@ enum {
 };
 
 enum { _C2_OPS_ = 0
-
 	, op_lwc2    = 0x32 /* Load Word  to   Coprocessor 2 (GTE) */
 	, op_swc2    = 0x3A /* Store Word from Coprocessor 2 (GTE) */
 };
 
-/* COP2 (GTE) Transfer Format: ctc2 rt, rd or cfc2 rt, rd
+/* COP2 transfer sub-opcodes (5-bit field in the `rs` slot of enc_gte_tx).
+ *
+ * Spans the 2x2 {From, To} × {Data, Control} register classes that the
+ * GTE exposes:
+ *
+ *   bit 1 (0x02): register class — 0 = data,  1 = control
+ *   bit 2 (0x04): direction      — 0 = read,  1 = write
+ *
+ * The values 0x00 (sub_mfc2) and 0x04 (sub_mtc2) are the same 5-bit
+ * numbers as the general MIPS `cop_mf` / `cop_mt` defined in mips.h
+ * (which target the data register file on any coprocessor). They are
+ * re-aliased here so the four-way table reads like the spec mnemonics
+ * (MFC2 / CFC2 / MTC2 / CTC2) and so the encoding lives next to its
+ * only consumer (this header).
+ *
+ * Vendor mnemonic aliases (gte_mfc2 / gte_mtc2 / gte_cfc2 / gte_ctc2)
+ * live in gte_vendor_sym.h. */
+enum { _C2_TX_SUBS_ = 0
+	, sub_mfc2 = 0x00 /* MFC2: Move From Coprocessor 2 data   reg */
+	, sub_cfc2 = 0x02 /* CFC2: Copy From Coprocessor 2 ctrl   reg */
+	, sub_mtc2 = 0x04 /* MTC2: Move To   Coprocessor 2 data   reg */
+	, sub_ctc2 = 0x06 /* CTC2: Copy To   Coprocessor 2 ctrl   reg */
+};
+
+/* COP2 (GTE) Transfer Format: mfc2 / cfc2 / mtc2 / ctc2 rt, rd
  * Layout: [op_cop2:6][sub:5][rt:5][rd:5][0:11]
- *   - sub: cop_mf (0x00) for cfc2, cop_mt (0x04) for ctc2
+ *   - sub: one of sub_mfc2 / sub_cfc2 / sub_mtc2 / sub_ctc2
  *   - rt:  GPR source/dest
- *   - rd:  COP2 control register index (0..31) */
+ *   - rd:  COP2 register index (0..31):
+ *            data class → C2_VXY0_Code..C2_LZCR_Code (gte_in_v0_xy..gte_math_accum2 aliases)
+ *            ctrl class → gte_cr_RT11_Code..gte_cr_OFY_Code */
 #define enc_gte_tx(sub, rt, rd) (enc_op(op_cop2) | enc_rs(sub) | enc_rt(rt) | enc_rd(rd))
 
-// #define gte_mt(rt, rd) enc_gte_tx(cop_mt, (rt), (rd)) /* Move GPR (rt) to GTE Control Register (rd) */
-// #define gte_mf(rt, rd) enc_gte_tx(cop_mf, (rt), (rd)) /* Move GTE Control Register (rd) to GPR (rt) */
 
-/* Explicit GTE Data vs Control Register Transfers */
-#define gte_mf(rt, rd) enc_gte_tx(0x00, (rt), (rd)) /* Move from GTE Data Reg (e.g. MAC0, OTZ) */
-#define gte_cf(rt, rd) enc_gte_tx(0x02, (rt), (rd)) /* Move from GTE Control Reg */
-#define gte_mt(rt, rd) enc_gte_tx(0x04, (rt), (rd)) /* Move to GTE Data Reg (e.g. VXY0) */
-#define gte_ct(rt, rd) enc_gte_tx(0x06, (rt), (rd)) /* Move to GTE Control Reg (e.g. Matrices) */
+// #define gte_mv_to_data_r(rt, rd)   enc_gte_tx(cop_mt, (rt), (rd)) /* Move GPR (rt) to GTE Control Register (rd) */
+// #define gte_mv_from_data_r(rt, rd) enc_gte_tx(cop_mf, (rt), (rd)) /* Move GTE Control Register (rd) to GPR (rt) */
+
+/* GTE Data vs Control Register Transfers
+ *
+ * Each macro emits a single .word constant for one of MFC2/CFC2/MTC2/CTC2.
+ *
+ * `rd` is the C2 register index in the file the sub-opcode names:
+ *   gte_mv_from_data_r / gte_mv_to_data_r  →  C2 data register file
+ *   gte_mv_from_ctrl_r / gte_mv_to_ctrl_r  →  C2 ctrl register file
+ *
+ * Common pairs:
+ *   gte_mv_from_data_r(R_T0, C2_MAC0)       — read MAC0 into a GPR
+ *   gte_mv_to_data_r  (R_V0, C2_VXY0)       — write GPR into VXY0
+ *   gte_mv_to_ctrl_r  (R_T0, gte_cr_RT11)   — write GPR into rotation matrix
+ *   gte_mv_from_ctrl_r(R_T0, gte_cr_OFX)    — read screen-X offset */
+#define gte_mv_from_data_r(rt, rd) enc_gte_tx(sub_mfc2, (rt), (rd)) /* Move From data reg */
+#define gte_mv_from_ctrl_r(rt, rd) enc_gte_tx(sub_cfc2, (rt), (rd)) /* Copy From ctrl reg */
+#define gte_mv_to_data_r(rt, rd)   enc_gte_tx(sub_mtc2, (rt), (rd)) /* Move To   data reg */
+#define gte_mv_to_ctrl_r(rt, rd)   enc_gte_tx(sub_ctc2, (rt), (rd)) /* Copy To   ctrl reg */
 
 /* COP2 Data Load (lwc2): `lwc2 rt, off(rs)`
  * Layout: [op_lwc2:6][rs:5][rt:5][imm:16]
@@ -300,7 +319,7 @@ enum { _C2_OPS_ = 0
 #define gte_lw(rt, base, off) enc_gte_lw(rt, base, off)
 #define gte_sw(rt, base, off) enc_gte_sw(rt, base, off)
 
-/* GTE Command Format (The math engine trigger)
+/* GTE Command Format
  * Opcode is always MIPS_OP_COP2, RS is always 1 (CO).
  * The lower 25 bits are the GTE-specific command payload.
  *
@@ -332,7 +351,7 @@ enum { _C2_OPS_ = 0
    | enc_gte_cmd(cmd) \
 )
 
-/* Pre-baked GTE command words for the common cases.
+/* GTE command words for the common cases.
  *
  * These are pure compile-time integer constants — the C compiler
  * constant-folds them into `.word` directives in .rodata. Use them
@@ -377,8 +396,28 @@ enum { _C2_OPS_ = 0
 #define gte_cmdw_rtpt   (gte_cmd_base | enc_gte_cmd(gte_cmd_rtpt ) | gte_cmdw_psyq_compat)
 #define gte_cmdw_nclip  (gte_cmd_base | enc_gte_cmd(gte_cmd_nclip))
 #define gte_cmdw_op     (gte_cmd_base | enc_gte_cmd(gte_cmd_op   ))
+#define gte_cmdw_outer_product gte_cmdw_op      /* "outer product" -- NOCASH/Sdk terminology */
+#define gte_cmdw_wedge        gte_cmdw_op      /* "wedge product"  -- geometric-algebra terminology */
 #define gte_cmdw_mvmva  (gte_cmd_base | enc_gte_cmd(gte_cmd_mvmva))
 
+#define gte_cmdw_rotate_translate_perspective_single gte_cmdw_rtps
+#define gte_cmdw_rotate_translate_perspective_triple gte_cmdw_rtpt
+
+/* PsyQ compatibility bits for AVSZ3 (Bits 20, 22, 24 must be set) */
+#define gte_cmdw_psyq_avsz3_compat (0x15 << 20)
+#define gte_cmd_avsz3               0x2D
+
+#define gte_cmdw_avsz3 (gte_cmd_base | enc_gte_cmd(gte_cmd_avsz3) | gte_cmdw_psyq_avsz3_compat)
+
+// Takes the three screen-space Z values of the triangle → averages them → writes the result into the OTZ register.
+#define gte_avg_sort_z3 gte_cmdw_avsz3
+
+/* AVSZ4 — average Z of 4 vertices (for quads) */
+#define gte_cmd_avsz4 0x2E
+#define gte_cmdw_avsz4 (gte_cmd_base | enc_gte_cmd(gte_cmd_avsz4) | gte_cmdw_psyq_avsz3_compat)
+
+#define gte_cmdw_avg_sort_z4 gte_cmdw_avsz4
+
 /**
  * @brief Loads a single SVECTOR to GTE vector register V0
  *
@@ -393,14 +432,14 @@ enum { _C2_OPS_ = 0
  *   asm_gte_load_v0(svector_ptr);
  */
 
-/* Pre-baked lwc2 encoding helpers parameterized on the base GPR.
+/* lwc2 encoding helpers parameterized on the base GPR.
  *
- * gte_lwc2_v0(base)  → lwc2 $0,  0(base)   ; C2_VXY0
- * gte_lwc2_v0z(base) → lwc2 $1,  4(base)   ; C2_VZ0
- * gte_lwc2_v1(base)  → lwc2 $2,  0(base)   ; C2_VXY1
- * gte_lwc2_v1z(base) → lwc2 $3,  4(base)   ; C2_VZ1
- * gte_lwc2_v2(base)  → lwc2 $4,  0(base)   ; C2_VXY2
- * gte_lwc2_v2z(base) → lwc2 $5,  4(base)   ; C2_VZ2
+ * gte_lw_v0_xy(base)  → lwc2 $0,  0(base)   ; C2_VXY0
+ * gte_lw_v0_z(base)   → lwc2 $1,  4(base)   ; C2_VZ0
+ * gte_lw_v1_xy(base)  → lwc2 $2,  0(base)   ; C2_VXY1
+ * gte_lw_v1_z(base)   → lwc2 $3,  4(base)   ; C2_VZ1
+ * gte_lw_v2_xy(base)  → lwc2 $4,  0(base)   ; C2_VXY2
+ * gte_lw_v2_z(base)   → lwc2 $5,  4(base)   ; C2_VZ2
  *
  * `base` is the GPR number to bake into the .word constant's `rs` field.
  * These are pure compile-time integers; the C compiler constant-folds
@@ -410,12 +449,12 @@ enum {
 	GTE_Z_Offset = 4
 };
 
-#define gte_lw_v0(base)   enc_gte_lw(gte_in_v0_xy, (base), 0)
-#define gte_lw_v0z(base)  enc_gte_lw(gte_in_v0_z,  (base), GTE_Z_Offset)
-#define gte_lw_v1(base)   enc_gte_lw(gte_in_v1_xy, (base), 0)
-#define gte_lw_v1z(base)  enc_gte_lw(gte_in_v1_z,  (base), GTE_Z_Offset)
-#define gte_lw_v2(base)   enc_gte_lw(gte_in_v2_xy, (base), 0)
-#define gte_lw_v2z(base)  enc_gte_lw(gte_in_v2_z,  (base), GTE_Z_Offset)
+#define gte_lw_v0_xy(base)  enc_gte_lw(gte_in_v0_xy, (base), 0)
+#define gte_lw_v0_z(base)   enc_gte_lw(gte_in_v0_z,  (base), GTE_Z_Offset)
+#define gte_lw_v1_xy(base)  enc_gte_lw(gte_in_v1_xy, (base), 0)
+#define gte_lw_v1_z(base)   enc_gte_lw(gte_in_v1_z,  (base), GTE_Z_Offset)
+#define gte_lw_v2_xy(base)  enc_gte_lw(gte_in_v2_xy, (base), 0)
+#define gte_lw_v2_z(base)   enc_gte_lw(gte_in_v2_z,  (base), GTE_Z_Offset)
 
 /* gte_load_vN(r_ptr, base) — placeholder-punned lwc2 loaders
  *
@@ -424,7 +463,6 @@ enum {
  * (typically one of R_T4..R_T9 for the standard "3-pointer" pattern).
  *
  * The caller MUST bind `r_ptr` to that same GPR via a register variable:
- *
  *     register V3_S2* p_in_12 __asm__("$12") = my_ptr;
  *     gte_load_v0(p_in_12, R_T4);   // R_T4 = 12, base is $12
  *
@@ -454,22 +492,22 @@ enum {
  *
  * The `asm_clobber(...)` helper from gcc_asm.h prepends the colon that
  * starts the clobbers section. */
-#define gte_load_v0(r_ptr, base) asm volatile( \
-	asm_words( gte_lw_v0(base), gte_lw_v0z(base) ) \
-	asm_rpins,   r_use(r_ptr)                                    \
-	asm_clobber: rlit(R_V0_Code), rlit(R_T0_Code), rlit(R_T1_Code), rlit(R_RA_Code), clb_mem_drain \
+#define gte_load_v0(r_ptr, base) asm volatile(       \
+	asm_words( gte_lw_v0_xy(base), gte_lw_v0_z(base) ) \
+	asm_rpins,   r_use(r_ptr)                          \
+	asm_clobber: rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain \
 )
 
-#define gte_load_v1(r_ptr, base) asm volatile( \
-	asm_words( gte_lw_v1(base), gte_lw_v1z(base) ) \
-	asm_rpins,   r_use(r_ptr)                                    \
-	asm_clobber: rlit(R_V0_Code), rlit(R_T0_Code), rlit(R_T1_Code), rlit(R_RA_Code), clb_mem_drain \
+#define gte_load_v1(r_ptr, base) asm volatile(       \
+	asm_words( gte_lw_v1_xy(base), gte_lw_v1_z(base) ) \
+	asm_rpins,   r_use(r_ptr)                          \
+	asm_clobber: rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain \
 )
 
-#define gte_load_v2(r_ptr, base) asm volatile( \
-	asm_words( gte_lw_v2(base), gte_lw_v2z(base) ) \
-	asm_rpins,   r_use(r_ptr)                                    \
-	asm_clobber: rlit(R_V0_Code), rlit(R_T0_Code), rlit(R_T1_Code), rlit(R_RA_Code), clb_mem_drain \
+#define gte_load_v2(r_ptr, base) asm volatile(       \
+	asm_words( gte_lw_v2_xy(base), gte_lw_v2_z(base) ) \
+	asm_rpins,   r_use(r_ptr)                          \
+	asm_clobber: rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain \
 )
 
 /* gte_load_v0v1v2(p0, p1, p2, b0, b1, b2) — the canonical prelude to gte_cmd_rtpt.
@@ -486,12 +524,12 @@ enum {
  */
 #define gte_load_v0v1v2(p0, p1, p2, b0, b1, b2) asm volatile( \
 	asm_words( \
-		gte_lw_v0(b0), gte_lw_v0z(b0),  \
-		gte_lw_v1(b1), gte_lw_v1z(b1),  \
-		gte_lw_v2(b2), gte_lw_v2z(b2) ) \
+		gte_lw_v0_xy(b0), gte_lw_v0_z(b0),  \
+		gte_lw_v1_xy(b1), gte_lw_v1_z(b1),  \
+		gte_lw_v2_xy(b2), gte_lw_v2_z(b2) ) \
 	asm_rpins                             \
 		, r_use(p0), r_use(p1), r_use(p2)   \
-	asm_clobber: rlit(R_V0_Code), rlit(R_T0_Code), rlit(R_T1_Code), rlit(R_RA_Code), clb_mem_drain \
+	asm_clobber: rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain \
 )
 
 /**
@@ -514,7 +552,7 @@ enum {
  *      zero (standard rotation, no scaling, V0 vector, translation
  *      vector, no clamp).
  *
- * Clobbers the caller-saved GPRs via `clb_system` (per the kernel
+ * Clobbers the caller-saved GPRs via `clbr_volatile_gprs` (per the kernel
  * ABI) plus the standard "memory" barrier. Does not clobber any COP2
  * data/control register — those have to be saved by the caller if
  * they need to survive across the call (RTPT writes SXY0..2, SZ0..3,
@@ -523,10 +561,10 @@ enum {
 #define gte_rtpt()                        \
 	asm volatile(                           \
 		asm_words( nop, nop, gte_cmdw_rtpt )  \
-		asm_clobber: clb_system               \
+		asm_clobber: clbr_volatile_gprs       \
 	)
 
-#define gte_rtpt_ori() \
+#define gte_rtpt_asm_str() \
 	__asm__ volatile( \
 		"nop;"          \
 		"nop;"          \
@@ -555,7 +593,7 @@ enum {
  *      (unlike RTPS/RTPT which carry the `gte_cmdw_psyq_compat`
  *      quirk), so `gte_cmdw_nclip` does NOT OR in any reserved bits.
  *
- * Clobbers the caller-saved GPRs via `clb_system` (per the kernel
+ * Clobbers the caller-saved GPRs via `clbr_volatile_gprs` (per the kernel
  * ABI) plus the standard "memory" barrier. Does not clobber any COP2
  * data/control register - those have to be saved by the caller if
  * they need to survive across the call (NCLIP writes MAC0 only; it
@@ -564,7 +602,7 @@ enum {
 #define gte_nclip()                       \
 	asm volatile(                           \
 		asm_words( nop, nop, gte_cmdw_nclip ) \
-		asm_clobber: clb_system               \
+		asm_clobber: clbr_volatile_gprs               \
 	)
 
 #define gte_stotz(r0) __asm__ volatile("swc2   $7, 0( %0 )" : : "r"(r0) : "memory")
@@ -595,7 +633,6 @@ enum {
  * [RT_xx, RT_xy] | [RT_xz, pad] | ...).
  *
  * Generated MIPS (mirrors the source macro):
- *
  *   lw   $12,  0( %0 )    ; word 0
  *   lw   $13,  4( %0 )    ; word 1
  *   ctc2 $12,  $0         ; → C2_RT11
@@ -634,16 +671,23 @@ enum {
 		asm_words(                          \
 			  load_word(R_T5, R_T4,  0)       \
 			, load_word(R_T6, R_T4,  4)       \
-			, gte_mt(   R_T5,        0)       \
-			, gte_mt(   R_T6,        1)       \
+			, gte_mv_to_data_r(   R_T5,  0)   \
+			, gte_mv_to_data_r(   R_T6,  1)   \
 			, load_word(R_T5, R_T4,  8)       \
 			, load_word(R_T6, R_T4, 12)       \
 			, load_word(R_T4, R_T4, 16)       \
-			, gte_mt(   R_T5,  2)             \
-			, gte_mt(   R_T6,  3)             \
-			, gte_mt(   R_T4,  4)             \
+			, gte_mv_to_data_r(   R_T5,  2)   \
+			, gte_mv_to_data_r(   R_T6,  3)   \
+			, gte_mv_to_data_r(   R_T4,  4)   \
 		)                                   \
 		, r_use(r0)                         \
-		asm_clobber: clb_system, rlit(R_T4_Code), rlit(R_T5_Code), rlit(R_T6_Code) \
+		asm_clobber: clbr_volatile_gprs, rlit(R_T4), rlit(R_T5), rlit(R_T6) \
 	)
 
+#pragma endregion ASM DSL
+
+#pragma region Reserved
+
+
+
+#pragma endregion Reserved

code/duffle/gte_vendor_sym.h

@@ -0,0 +1,44 @@
+/* ============================================================================
+ *  duffle DSL — GTE Vendor Mnemonics (opt-in)
+ *  ============================================================================
+ *
+ *  Provides the textbook MIPS assembly mnemonics for the GTE/COP2
+ *  instructions as thin aliases to the canonical duffle macros in gte.h.
+ *  The duffle names are primary; this header is for users who prefer
+ *  the textbook mnemonics.
+ *
+ *  USAGE:   #include "duffle/gte_vendor_sym.h"   // after gte.h
+ *
+ *  Mapping (vendor -> duffle):
+ *    Transfers (move GPR <-> GTE control/data register):
+ *      gte_mfc2  -> gte_mv_from_data_r   (move from coprocessor 2 data reg)
+ *      gte_mtc2  -> gte_mv_to_data_r     (move to coprocessor 2 data reg)
+ *      gte_cfc2  -> gte_mv_from_ctrl_r   (move from coprocessor 2 control reg)
+ *      gte_ctc2  -> gte_mv_to_ctrl_r     (move to coprocessor 2 control reg)
+ *
+ *    Data load/store (load/store word to coprocessor 2 data register):
+ *      gte_lwc2(rt, base, off)  -> gte_lw(rt, base, off)
+ *      gte_swc2(rt, base, off)  -> gte_sw(rt, base, off)
+ *      (the lower-level vector variants gte_lw_v0_xy etc. don't have
+ *      vendor mnemonics; they're already gte_-prefixed and short)
+ * ============================================================================ */
+
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "gte.h"
+#endif
+
+#ifndef DUFFLE_GTE_VENDOR_SYM_H
+#define DUFFLE_GTE_VENDOR_SYM_H
+
+/* Transfers (move GPR <-> GTE control/data register) */
+#define gte_mfc2(rt, rd)  gte_mv_from_data_r((rt), (rd))
+#define gte_mtc2(rt, rd)  gte_mv_to_data_r((rt), (rd))
+#define gte_cfc2(rt, rd)  gte_mv_from_ctrl_r((rt), (rd))
+#define gte_ctc2(rt, rd)  gte_mv_to_ctrl_r((rt), (rd))
+
+/* Data load/store (load/store word to coprocessor 2 data register) */
+#define gte_lwc2(rt, base, off)  gte_lw((rt), (base), (off))
+#define gte_swc2(rt, base, off)  gte_sw((rt), (base), (off))
+
+#endif

code/duffle/lottes_tape.h

@@ -5,144 +5,360 @@
 # include "mips.h"
 # include "gte.h"
 # include "memory.h"
+#	include "atom_dsl.h"
+#	include "gen/duffle.macs.h"
+#	include "gen/duffle.offsets.h"
 #endif
 
-/* R_T8 is our dedicated Tape Pointer (TP) */
-#define R_TP      R_T8
-#define R_TP_Code R_T8_Code
+typedef U4 const MipsCode;
+typedef Slice_(MipsCode);
+typedef Slice_MipsCode MipsAtom;
 
-/* The 'Yield' sequence for CodeBlobs */
-#define mips_yield \
-      load_word(R_T9, R_TP, 0) \
-    , add_ui(R_TP, R_TP, 4)    \
-    , jump_reg(R_T9)           \
-    , nop
+#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 identifier-args (hardcoded register names).
+//   MipsAtomComp_(ac_X) { body }
+// expands to:
+//   MipsCode ac_X[] align_(4) = { body };
+#define MipsAtomComp_(sym) MipsCode sym [] align_(4) =
+
+// Function form: function-body block that returns a MipsAtom slice.
+// Used for components with value-args (e.g., ac_format_f3_color).
+//   FI_ MipsAtom ac_X(args) MipsAtomComp_Proc_(ac_X, { body })
+// expands to:
+//   FI_ MipsAtom ac_X(args) { MipsCode ac_X[] align_(4) = { body }; return slice_from_array(MipsCode, ac_X); }
+#define MipsAtomComp_Proc_(sym, ...) { MipsCode sym [] align_(4) = __VA_ARGS__; return slice_from_array(MipsCode, sym); }
+
+// Auto-generated component macros (<module>/gen/<dir>/<dir>.macs.h) are included manually by the unity build.
+
+/* Register aliases */
+enum {
+	R_AtomJmp    = R_T9,
+	R_TapePtr    = R_T8,  /* The Instruction Stream Pointer */
+	R_InCursor   = R_T4,  /* Input data cursor */
+
+	R_PrimCursor = R_T7,  /* VRAM output cursor (primitive buffer) */
+	R_FaceCursor = R_T4,  /* Input data cursor (indices/faces) */
+	R_VertBase   = R_T5,  /* Base address of the vertex array */
+	R_OtBase     = R_T6,  /* Base address of the Ordering Table */
+
+/* Stringification codes for the GCC inline assembler clobber lists */
+#define R_TapePtr_Code     R_T8_Code
+#define R_InCursor_Code    R_T4_Code
+
+#define R_PrimCursor_Code  R_T7_Code
+#define R_FaceCursor_Code  R_T4_Code
+#define R_VertBase_Code    R_T5_Code
+#define R_OtBase_Code      R_T6_Code
+};
+
+#pragma region Tape Drive
+/* ---------------------------------------------------------------------------
+ *  TAPE DRIVE ABI & REGISTER ALIASES (the enum moved earlier; see below)
+ * ---------------------------------------------------------------------------*/
 
 /* The 'Exit' Atom */
-internal Code CodeBlob_(tape_exit) { jump_reg(rret_addr), nop };
+MipsAtom_(tape_exit) { jump_reg(rret_addr), nop };
 
-typedef Slice_(U4);
+/* Generalized Tape Engine Runner */
+FI_ void tape_run(Slice_U4 tape) { register U4* tp rgcc(R_TapePtr) = tape.ptr; asm volatile(
+	asm_words(
+			add_ui(     R_SP, R_SP, -MipsStackAlignment) /* Allocate stack space */
+		, store_word( R_RA, R_SP,           0)         /* Safely backup $ra to the stack */
+		, load_word(  R_AtomJmp, R_TapePtr, 0)         /* Bootstrap the first jump */
+		, add_ui_self(R_TapePtr, S_(MipsCode))         /* Advance tape */
+		, call_reg(   R_AtomJmp)                       /* jalr $t9 */
+		, nop                                          /* Branch delay slot */
+		, load_word(  R_RA, R_SP, 0)                   /* Restore $ra from stack */
+		, add_ui_self(R_SP, MipsStackAlignment)        /* Deallocate stack space */
+	)
+	asm_rpins, r_use(tp)
+	asm_clobber: 
+			rlit(R_AT)
+		, rlit(R_V0), rlit(R_V1)
+		, rlit(R_T0), rlit(R_T1), rlit(R_T2), rlit(R_T3)
+		/* Tell GCC the tape engine owns and destroys the workspace registers */
+		, rlit(R_PrimCursor), rlit(R_FaceCursor), rlit(R_VertBase), rlit(R_OtBase)
+		, rlit(R_T9)
+		, clb_mem_drain 
+); }
 
-FI_ void tape_run(Slice_U4 tape, B1** r_prim_cursor, void* face_cursor, void* vert_base, void* ot_base) {
-    register U4*   tp   rgcc(R_TP) = tape.ptr;
-    register B1*   pcur rgcc(R_T7) = *r_prim_cursor;
-    register void* r_t4 rgcc(R_T4) = face_cursor;
-    register void* r_t5 rgcc(R_T5) = vert_base;
-    register void* r_t6 rgcc(R_T6) = ot_base;
+typedef Relative_(FArena) Struct_(TapeBuilder) { U4 ptr; U4 capacity; U4 used; };
+FI_ void        tb_init(TapeBuilder* tb, FArena* arena) { tb->ptr = arena->start; tb->used = 0; }
+FI_ TapeBuilder tb_make_old(             FArena* arena) { return (TapeBuilder){ arena->start, 0 }; }
+FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ mem.ptr, mem.len, 0 }; }
 
-    asm volatile(
-        "lw    $25, 0(%0);"   
-        "addiu %0, %0, 4;"    
-        "jalr  $25;"          
-        "nop;"                
-        : "+r"(tp), "+r"(pcur), "+r"(r_t4), "+r"(r_t5), "+r"(r_t6)
-        : 
-        : "at", "v0", "v1", "t0", "t1", "t2", "t3", "t9", "ra", "memory" 
-    );
-    
-    *r_prim_cursor = pcur; 
-}
+#define tb_emit_(tb, atom) tb_emit(tb, tmpl(code,atom))
+FI_ void tb_emit(TapeBuilder* tb, MipsCode* atom) { u4_r(tb->ptr)[tb->used] = u4_(atom); ++ tb->used; }
+FI_ void tb_data(TapeBuilder* tb, U4        data) { u4_r(tb->ptr)[tb->used] = u4_(data); ++ tb->used; }
 
-typedef Struct_(TapeBuilder) {FArena* arena;};
-FI_ TapeBuilder tb_begin(FArena* arena) {return (TapeBuilder){ arena };}
+FI_ Slice_U4 tb_end  (TapeBuilder* tb) { tb_emit(tb,code_tape_exit); return (Slice_U4){ C_(U4*,tb->ptr), tb->used }; }
+FI_ Slice_U4 tb_slice(TapeBuilder  tb) {                             return (Slice_U4){ C_(U4*,tb.ptr),  tb.used }; }
+#define tb_scope(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,code_tape_exit))
 
-I_ void tb_emit(TapeBuilder* tb, Code* atom) {
-	U4* slot = farena_push_type(tb->arena, U4); 
-	slot[0] = (U4)atom;
-}
+#pragma endregion Tape Drive
 
-I_ Slice_U4 tb_end(TapeBuilder* tb) {
-	tb_emit(tb, code_tape_exit);
-	return (Slice_U4){ (U4*)tb->arena->start, tb->arena->used / 4 };
-}
+#pragma region Macro Mips Atom Components
+/* ---------------------------------------------------------------------------
+ *  MACRO ATOM Components (Reusable Assembly Components)
+ *  These do NOT yield. They are expanded inline inside Tape Atoms.
+ * ---------------------------------------------------------------------------*/
 
-internal Code CodeBlob_(atom_set_gte_world) {
-    /* Pop matrix address from tape into R_T3 ($11) */
-    load_word(R_T3, R_TP, 0),
-    add_ui(R_TP, R_TP, 4),
-
-    /* Load 3x3 Rotation + 3x1 Translation from R_T3 into GTE CONTROL Regs (ctc2) */
-    load_word(R_T0, R_T3,  0), load_word(R_T1, R_T3,  4),
-    gte_ct(R_T0, gte_cr_RT11), gte_ct(R_T1, gte_cr_RT12),
-    
-    load_word(R_T0, R_T3,  8), load_word(R_T1, R_T3, 12), load_word(R_T2, R_T3, 16),
-    gte_ct(R_T0, gte_cr_RT13), gte_ct(R_T1, gte_cr_RT21), gte_ct(R_T2, gte_cr_RT22),
-    
-    load_word(R_T0, R_T3, 20), load_word(R_T1, R_T3, 24), load_word(R_T2, R_T3, 28),
-    gte_ct(R_T0, gte_cr_TRX),  gte_ct(R_T1, gte_cr_TRY),  gte_ct(R_T2, gte_cr_TRZ),
-    
-    mips_yield
+// The 'Yield' sequence for Tape Atoms (mac_yield). 
+MipsAtomComp_(ac_yield) {
+	load_word(R_AtomJmp, R_TapePtr, 0),
+	add_ui_self(         R_TapePtr, S_(MipsCode)),
+	jump_reg( R_AtomJmp),
+	nop,
 };
 
-internal Code CodeBlob_(atom_floor_tri) {
-    /* 1. Load 3 indices from $t4 */
-    load_half_u(R_T0, R_T4, 0),
-    load_half_u(R_T1, R_T4, 2),
-    load_half_u(R_T2, R_T4, 4),
-
-    /* 2. Load Vertices: Addr = Base + (idx * 8). Write to GTE DATA Regs (mtc2) */
-    shift_ll(R_AT, R_T0, 3), add_u(R_AT, R_AT, R_T5),
-    load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-    gte_mt(R_V0, C2_VXY0), gte_mt(R_V1, C2_VZ0),
-
-    shift_ll(R_AT, R_T1, 3), add_u(R_AT, R_AT, R_T5),
-    load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-    gte_mt(R_V0, C2_VXY1), gte_mt(R_V1, C2_VZ1),
-
-    shift_ll(R_AT, R_T2, 3), add_u(R_AT, R_AT, R_T5),
-    load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
-    gte_mt(R_V0, C2_VXY2), gte_mt(R_V1, C2_VZ2),
-
-    /* 3. RTPT + NCLIP */
-    nop, nop, gte_cmdw_rtpt,
-    nop, nop, gte_cmdw_nclip,
-    nop, nop, /* Wait for NCLIP to finish */
-
-    /* 4. Check NCLIP. 
-       If MAC0 <= 0 (Backface), branch to end.
-       Target is 28 instructions past the delay slot. */
-    gte_mf(R_T0, C2_MAC0),
-    branch_le_zero(R_T0, 28), 
-    nop, /* <--- DELAY SLOT (Index 0) */
-
-    /* 5. Store Primitive Data */
-    /*  1 */ store_word(R_0, R_T7, 0), 
-    /*  2 */ load_ui(R_AT, 0x20FF),     /* High: Code 0x20 + Color R:FF */
-    /*  3 */ or_i(R_AT, R_AT, 0xFFFF),  /* Low: Color G:FF, B:FF */
-    /*  4 */ store_word(R_AT, R_T7, 4),
-    /*  5 */ enc_gte_sw(C2_SXY0, R_T7, 8),
-    /*  6 */ enc_gte_sw(C2_SXY1, R_T7, 12),
-    /*  7 */ enc_gte_sw(C2_SXY2, R_T7, 16),
-
-    /* 6. OT Insertion with Bounds Checking */
-    /*  8 */ nop, 
-    /*  9 */ nop, 
-    /* 10 */ enc_gte_cmd(0x2D),         /* AVSZ3 */
-    /* 11 */ nop,                       /* Wait for AVSZ3 */
-    /* 12 */ nop,                       /* Wait for AVSZ3 */
-    /* 13 */ gte_mf(R_T1, C2_OTZ),      /* T1 = Depth index */
-    
-    /* Bounds Check: OTZ < 2048 */
-    /* 14 */ load_ui(R_AT, 2048),
-    /* 15 */ slt_u(R_AT, R_T1, R_AT),   /* AT = (OTZ < 2048) ? 1 : 0 */
-    /* 16 */ branch_equal(R_AT, R_0, 11), /* If AT == 0, skip to end (11 instrs past delay) */
-    /* 17 */ nop, /* <--- DELAY SLOT (Index 0 for Bounds branch) */
-    
-    /*  18 (1)  */ shift_ll(R_T1, R_T1, 2), 
-    /*  19 (2)  */ add_u(R_T1, R_T1, R_T6),         /* T1 = &OrderingTable[OTZ] */
-    /*  20 (3)  */ load_word(R_AT, R_T1, 0),        /* AT = current head */
-    /*  21 (4)  */ store_word(R_AT, R_T7, 0),       /* prim->next = head */
-    
-    /* Create Tag in AT: Len 4 (0x04) in top 8 bits, T7 in bottom 24 */
-    /*  22 (5)  */ shift_ll(R_AT, R_T7, 8),
-    /*  23 (6)  */ shift_lr(R_AT, R_AT, 8),         /* AT = T7 & 0x00FFFFFF */
-    /*  24 (7)  */ load_ui(R_V0, 0x0400),           /* V0 = 0x04000000 */
-    /*  25 (8)  */ or_u(R_AT, R_AT, R_V0),          /* AT = Tag */
-    
-    /*  26 (9)  */ store_word(R_AT, R_T1, 0),       /* OrderingTable[OTZ] = Tag */
-    /*  27 (10) */ add_ui(R_T7, R_T7, 20),          /* Advance Prim Cursor (5 words) */
-
-    /* 7. Yield */
-    /*  28 (11) */ add_ui(R_T4, R_T4, 8),           /* Advance Face Cursor (4 * S2 = 8 bytes) */
-    mips_yield
+/* Words: 3; Loads 3 S2 indices from the face array */
+MipsAtomComp_(ac_load_tri_indices) {
+	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
+	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)),
+	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
 };
+
+/* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
+MipsAtomComp_(ac_gte_load_tri_verts) {
+	shift_lleft(R_AT, R_T0, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
+	shift_lleft(R_AT, R_T1, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
+	shift_lleft(R_AT, R_T2, v3s2_byteoff), add_u_self(R_AT, R_VertBase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
+};
+
+/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
+ * Hardcoded for Poly_F3 (5 words). For Poly_G4, use ac_insert_ot_tag_g4. */
+MipsAtomComp_(ac_insert_ot_tag_f3) {
+	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
+	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (5 - 1) << 24 = 4 << 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	or_u(        R_AT, R_AT, R_V0),                            // Merge length
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
+};
+
+/* Words: 11; Correctly inserts a primitive into the Ordering Table linked list.
+ * Hardcoded for Poly_G4 (9 words). For Poly_F3, use ac_insert_ot_tag_f3. */
+MipsAtomComp_(ac_insert_ot_tag_g4) {
+	shift_lleft( R_T1, R_T1, S_(U4)/2),                        // T1 = otz * S_(U4) (otz arg is implicit R_T1)
+	add_u_self(  R_T1, R_OtBase),                              // T1 = & OrderingTable[OTZ]
+	load_word(   R_AT, R_T1,         O_(PolyTag,code)),        // AT = old_ot_head
+	load_upper_i(R_V0, (S_(Poly_G4)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits), // V0 = (9 - 1) << 24 = 8 << 24
+	mask_upper(  R_AT, R_AT,         S_(PolyTag_len_bits)),    // Strip upper 8 bits (length from prev cell) → keep only low 24
+	or_u(        R_AT, R_AT, R_V0),                            // Merge length
+	store_word(  R_AT, R_PrimCursor, O_(PolyTag,code)),        // prim->tag = packed(prim_length, old_addr)
+	shift_lleft( R_AT, R_PrimCursor, S_(PolyTag_len_bits)),    // AT = (prim_length << 24) | old_addr
+	shift_lright(R_AT, R_AT,         S_(PolyTag_len_bits)),
+	store_word(  R_AT, R_T1,         O_(PolyTag,code)),        // OrderingTable[OTZ] = PrimCursor
+};
+
+/* Words: 3; Emits one (cmd|color) word to R_PrimCursor at the given
+ * byte offset. Internal helper used by the *_format_*_color macros. */
+FI_ MipsAtom ac_pack_color_word(U4 off, U4 cmd, U1 r, U1 g, U1 b)
+MipsAtomComp_Proc_(ac_pack_color_word, {
+	load_upper_i(R_AT, (cmd) << 8  | (b)),
+	or_i_self(   R_AT, ((g)   << 8) | (r)),
+	store_word(  R_AT, R_PrimCursor, (off)),
+})
+
+/* Words: 3; Emits the F3 command+color word (cmd byte | BLUE | GREEN | RED)
+ * Args: _r, _g, _b are 8-bit RGB byte values (not raw 16-bit fields).
+ * Migrated from hello_gte_tape.c; takes RGB form per the Phase 3 convention. */
+FI_ MipsAtom ac_format_f3_color(U1 r, U1 g, U1 b)
+MipsAtomComp_Proc_(ac_format_f3_color, { mac_pack_color_word(O_(Poly_F3,color), gp0_cmd_poly_f3, r, g, b) })
+
+/* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices to the F3.
+ * PIPELINE: post-RTPT (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). */
+MipsAtomComp_(ac_gte_store_f3_post_rtpt) {
+	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_F3,p0)),
+	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_F3,p1)),
+	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_F3,p2)),
+};
+
+/* Words: 12; Emits the four (code|color) words of a Poly_G4.
+ * Args: rN,gN,bN are 8-bit RGB byte values for each of the 4 vertices. */
+FI_ MipsAtom ac_format_g4_color(
+	U1 r0, U1 g0, U1 b0,
+  U1 r1, U1 g1, U1 b1,
+  U1 r2, U1 g2, U1 b2,
+  U1 r3, U1 g3, U1 b3)
+MipsAtomComp_Proc_(ac_format_g4_color, {
+	mac_pack_color_word(O_(Poly_G4,c0), gp0_cmd_poly_g4, r0,g0,b0),
+	mac_pack_color_word(O_(Poly_G4,c1), 0,               r1,g1,b1),
+	mac_pack_color_word(O_(Poly_G4,c2), 0,               r2,g2,b2),
+	mac_pack_color_word(O_(Poly_G4,c3), 0,               r3,g3,b3),
+})
+
+/* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
+ * G4 triangle portion to p0/p1/p2.
+ * PIPELINE: post-RTPT, pre-RTPS (SXY0=v0.screen, SXY1=v1.screen, SXY2=v2.screen). 
+ * MUST be called BEFORE V3-RTPS, otherwise SXY0/1/2
+ * get overwritten with v3 (RTPS writes only to SXY2, but to keep the
+ * three registers aligned with v0/v1/v2 you must store before RTPS).
+ * The macro name declares the pipeline position; check #6 (GTE state-
+ * machine validation) verifies the call site matches the declaration. */
+MipsAtomComp_(ac_gte_store_g4_p012_post_rtpt_pre_rtps) {
+	gte_sw(C2_SXY0, R_PrimCursor, O_(Poly_G4,p0)),
+	gte_sw(C2_SXY1, R_PrimCursor, O_(Poly_G4,p1)),
+	gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p2)),
+};
+
+/* Words: 1; Stores the V3 screen coord to the G4's p3 slot.
+ * PIPELINE: post-RTPS (SXY2 holds v3.screen because RTPS writes its
+ * single-vertex result to SXY2; SXY0 still holds v0.screen from the
+ * earlier RTPT — DO NOT read SXY0 here, that's the bug this name
+ * prevents).
+ */
+MipsAtomComp_(ac_gte_store_g4_p3_post_rtps) { gte_sw(C2_SXY2, R_PrimCursor, O_(Poly_G4,p3)) };
+
+#pragma endregion Macro Atom Components
+
+#pragma region Mips Atom Builder
+// This allows for runtime procedural authoring of mips atoms.
+
+typedef Struct_(FMipsAtom512) { U4 data[512]; U4 used; };
+
+// FArena Related
+typedef Relative_(FArena) Struct_(MipsAtomBuilder) { U4 start; U4 capacity; U4 used; };
+// Whatever the builder is writting to should most likely coresspond
+// to something that can fit within instruction cache?
+
+FI_ void atombuilder_unroll(MipsAtomBuilder_R ab, Slice_MipsCode_R code) {
+	assert(ab->capacity - ab->used - code->len);
+	mem_copy(ab->start, u4_(code->ptr), code->len);
+	mem_bump(ab->start, ab->capacity, & ab->used, code->len);
+}
+#define atombuilder_unroll_mac(ab, mac) atombuilder_unroll(ab, slice_arg_from_array(Slice_MipsCode, mac))
+
+// When done authoring, utilize this to cap-off the atom
+FI_ void atombuilder_end(MipsAtomBuilder_R ab) {
+	LP_ MipsAtom_(yield) { mac_yield() };
+	mem_copy(ab->start, u4_(code_yield), S_(code_yield));
+	mem_bump(ab->start, ab->capacity, & ab->used, S_(code_yield));
+}
+
+#define mipsatom_from_builder(ab) (MipsAtom){ab.start, ab.used}
+
+#pragma endregion Mips Atom Builder
+
+#pragma region Baked Mips Atoms
+// These atoms are resolved at compile time and are (usually) statically linked readonly data.
+
+enum {
+	bios_flushcache = 0x44,
+	bios_table_addr = 0xA0,
+};
+
+/* Flushes the Instruction Cache (PSX A-function 0x44 via BIOS stub at 0xA0).
+ * Sequence (per MIPS ABI; arguments in arg registers, RA pushed to stack):
+ *   1. sp -= 8;  sw $ra, 4($sp)        ; save RA
+ *   2. $a0 = bios_flushcache (arg0)
+ *   3. $t0 = bios_table_addr           ; t0 = &BIOS A-function table
+ *   4. jalr $t0, $ra                   ; call BIOS(flushcache)
+ *      nop                             ; branch delay slot
+ *   5. lw $ra, 4($sp);  jr $ra         ; restore & return
+ *   6. sp += 8
+ */
+internal MipsAtom_(mips_flush_icache) {
+	add_ui(rstack_ptr, rstack_ptr, -MipsStackAlignment), // sp -= 8
+	store_word(rret_addr, rstack_ptr, S_(U4)),           // sw  $ra,   4($sp) 
+	add_ui(rret_0, rdiscard, bios_flushcache),           // addiu $a0, $0, 0x44 
+	add_ui(rtmp_0, rdiscard, bios_table_addr),           // addiu $t0, $0, 0xA0 
+	jump_link(rtmp_0, rret_addr),                        // jalr  $t0, $ra 
+	nop,                                                 // BD slot 
+	load_word(rret_addr, rstack_ptr, S_(U4)),            // lw   $ra, 4($sp) 
+	jump_reg(rret_addr),                                 // jr   $ra 
+	add_ui(rstack_ptr, rstack_ptr, MipsStackAlignment),  // sp += 8 (BD) 
+	mac_yield(),
+};
+
+typedef Struct_(Binds_SetGteWorld) {
+	M3_S2* transform;
+};
+internal MipsAtom_(set_gte_world) atom_info(
+		atom_bind(Binds_SetGteWorld)
+	,	atom_reads(R_TapePtr)
+){
+	/* Pop matrix address from tape into R_T3 ($11) */
+	load_word(R_T3, R_TapePtr, O_(Binds_SetGteWorld,transform)),
+	add_ui_self(    R_TapePtr, S_(Binds_SetGteWorld)),
+	/* Load 3x3 Rotation + 3x1 Translation from R_T3 into GTE CONTROL Regs (ctc2) */
+	load_word(R_T0, R_T3, 0),  load_word(R_T1, R_T3,  4),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_RT11), gte_mv_to_ctrl_r(R_T1, gte_cr_RT12),
+	load_word(R_T0, R_T3, 8),  load_word(R_T1, R_T3, 12), load_word(R_T2, R_T3, 16),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_RT13), gte_mv_to_ctrl_r(R_T1, gte_cr_RT21), gte_mv_to_ctrl_r(R_T2, gte_cr_RT22),
+	load_word(R_T0, R_T3, 20), load_word(R_T1, R_T3, 24), load_word(R_T2, R_T3, 28),
+	gte_mv_to_ctrl_r(R_T0, gte_cr_TRX),  gte_mv_to_ctrl_r(R_T1, gte_cr_TRY),  gte_mv_to_ctrl_r(R_T2, gte_cr_TRZ),
+	mac_yield()
+};
+
+/* DIAGNOSTIC 1: Pure tape loop test */
+internal MipsAtom_(diag_yield) { mac_yield() };
+
+// TODO(Ed): Reduce magic numbers/offsets
+/* DIAGNOSTIC 2: Pure memory test (No GTE). Draws a fixed cyan triangle. */
+internal MipsAtom_(diag_color) {
+	store_word(  R_0, R_T7, 0), 
+	load_upper_i(R_AT, gp0_cmd_poly_f3 << 8 | 0xFF), /* High: MipsCode Poly_F3(0x20) + Color B:FF */
+	or_i_self(   R_AT, 0xFF00),                      /* Low:  Color G:FF, R:00 (Cyan) */
+	store_word(  R_AT, R_T7, 4),
+	
+	/* Fake coordinates - Swapped winding order to prevent GPU culling! */
+	load_upper_i(R_AT, 0x0010), or_i_self(R_AT, 0x0010), store_word(R_AT, R_T7, 8),  /* (16, 16) */
+	load_upper_i(R_AT, 0x0050), or_i_self(R_AT, 0x0010), store_word(R_AT, R_T7, 12), /* (80, 16) */
+	load_upper_i(R_AT, 0x0010), or_i_self(R_AT, 0x0050), store_word(R_AT, R_T7, 16), /* (16, 80) */
+
+	add_ui(          R_T1, R_0,  10),
+	shift_lleft_self(R_T1,       S_(U4)/2), 
+	add_u_self(      R_T1,       R_T6),         
+	
+	load_word(   R_AT, R_T1, 0),        
+	load_upper_i(R_V0, (S_(Poly_F3)/S_(U4) - S_(PolyTag)/S_(U4)) << PolyTag_len_bits),
+	store_word(  R_AT, R_T7, 0),       
+	shift_lleft(R_AT, R_T7, S_(PolyTag_len_bits)), shift_lright(R_AT, R_AT, S_(PolyTag_len_bits)),         
+	or_u_self(  R_AT, R_V0),          
+	store_word( R_AT, R_T1, 0),       
+
+	add_ui(R_T7, R_T7, 20),          
+
+	mac_yield()
+};
+
+// TODO(Ed): Reduce magic numbers/offsets
+/* DIAGNOSTIC 3: Pure GTE test (No Memory Writes) */
+internal MipsAtom_(diag_gte) {
+	/* Load 3 indices */
+	load_half_u(R_T0, R_T4, 0),
+	load_half_u(R_T1, R_T4, 2),
+	load_half_u(R_T2, R_T4, 4),
+
+	/* Load Vertices into GTE */
+	shift_lleft( R_AT, R_T0, 3), add_u(    R_AT, R_AT, R_T5),
+	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
+	gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
+
+	shift_lleft( R_AT, R_T1, 3), add_u(R_AT, R_AT, R_T5),
+	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
+	gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
+
+	shift_lleft(R_AT, R_T2, 3), add_u(R_AT, R_AT, R_T5),
+	load_word(R_V0, R_AT, 0), load_word(R_V1, R_AT, 4),
+	gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
+
+	/* Run Math */
+	nop2, gte_cmdw_rtpt,
+	nop2, gte_cmdw_nclip,
+	nop2,
+
+	/* Advance Face Cursor and Yield */
+	add_ui(R_T4, R_T4, 8),
+
+	mac_yield()
+};
+
+#pragma endregion Baked Mips Atoms

code/duffle/math.h

@@ -7,6 +7,10 @@
 #define max(A, B)       (((A) > (B)) ? (A) : (B))
 #define clamp_bot(X, B) max(X, B)
 
+enum { 
+	v3s2_byteoff = 3, // log2(8), used with shift_left_logical op for index via byte offset.
+};
+
 typedef Array_(U4, 2);
 typedef Array_(S2, 2);
 typedef Array_(S2, 3);

code/duffle/memory.h

@@ -3,7 +3,7 @@
 #	include "dsl.h"
 #endif
 
-#define MEM_ALIGNMENT_DEFAULT  (2 * S_(void*))
+#define MEM_ALIGNMENT_DEFAULT  4
 
 #define assert_bounds(point, start, end) for(;0;){ \
 	assert((start) <= (point)); \
@@ -73,6 +73,7 @@ typedef Slice_(B1);
 
 #define slice_iter(container, iter)     (T_((container).ptr) iter = (container).ptr; iter != slice_end(container); ++ iter)
 #define slice_arg_from_array(type, ...) & (tmpl(Slice,type)) { .ptr = array_decl(type,__VA_ARGS__), .len = array_len( array_decl(type,__VA_ARGS__)) }
+#define slice_from_array(type, array)     (tmpl(Slice,type)) { .ptr = array, .len = S_(array) }
 
 FI_ void slice_zero_(Slice s) { slice_assert(s); mem_zero(s.ptr, s.len); }
 #define  slice_zero(s)        slice_zero_(slice_to_ut(s))
@@ -88,6 +89,8 @@ FI_ void slice_copy_(Slice dest, Slice src) {
 	slice_copy_(slice_to_ut(dest), slice_to_ut(src)); \
 } while(0)
 
+typedef Slice_(U4);
+
 #pragma endregion Slice
 
 #pragma region FArena
@@ -100,14 +103,15 @@ FI_ void farena_init(FArena_R arena, Slice mem) {  assert(arena != nullptr);
 	arena->used     = 0;
 }
 FI_ FArena farena_make(Slice mem) { FArena a; farena_init(& a, mem); return a; }
-I_ Slice farena_push(FArena_R arena, U4 amount, Opt_farena o) {
+I_ Slice   farena_push(FArena_R arena, U4 amount, Opt_farena o) {
 	if (amount == 0) { return (Slice){}; }
 	U4 desired   = amount * (o.type_width == 0 ? 1 : o.type_width);
 	U4 to_commit = align_pow2(desired, o.alignment ?  o.alignment : MEM_ALIGNMENT_DEFAULT);
+	U4 ptr       = arena->start + arena->used;
 	mem_bump(arena->start, arena->capacity, & arena->used, to_commit);
-	return (Slice){ arena->start + arena->used, to_commit };
+	return (Slice){ ptr, to_commit };
 }
-FI_ void farena_reset(FArena_R arena) { arena->used = 0; }
+FI_ void farena_reset (FArena_R arena) { arena->used = 0; }
 FI_ void farena_rewind(FArena_R arena, U4 save_point) {
 	U4 end       = arena->start + arena->used; assert_bounds(save_point, arena->start, end);
 	arena->used -= save_point - arena->start;

code/duffle/mips.h

@@ -1,9 +1,100 @@
+/* ============================================================================
+ *  duffle DSL Suffix Conventions
+ *  ============================================================================
+ *
+ *  Every mnemonic in this header follows the same suffix grammar:
+ *
+ *    _i        Immediate value (16-bit constant operand). Combine with
+ *              _u or _s (single-letter modifier + type combined): add_ui,
+ *              add_si. Examples: add_ui, add_si, and_i, or_i, xor_i,
+ *              load_upper_i. and_i is sign-agnostic (andi zero-extends).
+ *              load_upper_i is a unique verb; _i is the immediate marker,
+ *              not a modifier+type combination.
+ *
+ *    _u        Unsigned (no-overflow, no-sign-extension). R-type
+ *              arithmetic examples: add_u, sub_u, mult_u, div_u. I-type
+ *              (combined with _i): add_ui.
+ *
+ *    _s        Signed (overflow-traps, sign-extends). R-type: add_s,
+ *              sub_s, mult_s, div_s, set_lt_s. I-type (combined with _i):
+ *              add_si.
+ *
+ *  --- Shift family (R-type): verb-modifier-direction ---
+ *    The shift macros use `shift_<modifier><direction>`. Modifier is
+ *    the single letter `l` (logical) or `a` (arithmetic). Direction
+ *    is the word `left` or `right`. Combined: `_lleft`, `_lright`,
+ *    `_aright`. Examples: shift_lleft( rd, rt, shamt) (= sll)
+ *                         shift_lright(rd, rt, shamt) (= srl)
+ *                         shift_aright(rd, rt, shamt) (= sra)
+ *    (no `_aleft`; MIPS has no `sla` — arithmetic-left is bit-identical
+ *    to logical-left, so use shift_lleft for that case)
+ *
+ *  --- Jump/Call family ---
+ *    Simple jumps keep the original short names: jump (j), jump_reg
+ *    (jr), jump_link (jalr rs, rd). The jump-and-link-to variants
+ *    (jal, jalr rs with default $ra) get the `call_` verb instead:
+ *    call_addr (jal), call_reg (jalr rs, default $ra).
+ *    Examples: jump(off)         (= j)
+ *              jump_reg(rs)      (= jr)
+ *              jump_link(rs, rd) (= jalr rs, rd)
+ *              call_reg(rs)      (= jalr rs, default $ra)
+ *              call_addr(off)    (= jal)
+ *
+ *    _r        Register marker — used only when the register type needs
+ *              disambiguation (e.g., GTE data register vs control
+ *              register). NOT used in plain R-type arithmetic (the
+ *              R-type is implicit). Examples: gte_mv_to_data_r,
+ *              gte_mv_to_ctrl_r.
+ *
+ *    _self     Destination equals one source operand.
+ *              Examples: add_ui_self (I-type, to self),
+ *                        add_u_self (R-type, to self).
+ *
+ *    _mv_to_   Direction: data flows into X.
+ *              Example: gte_mv_to_data_r, gte_mv_to_ctrl_r.
+ *
+ *    _mv_from_ Direction: data flows out of X.
+ *              Example: gte_mv_from_data_r, gte_mv_from_ctrl_r.
+ *
+ *    _str      String-form — emits inline-asm string instead of `.word`.
+ *              Example: gte_rtpt_asm_str.
+ *
+ *    _2w / _1w Word count of the emitted sequence.
+ *              Example: load_imm_2w.
+ *
+ *    _cop2     RESERVED — DO NOT USE in macro names. The `gte_` namespace
+ *              prefix already implies coprocessor 2. Use `c2` only in:
+ *                (a) integer opcode enums (op_lwc2 = 0x32, op_swc2 = 0x3A)
+ *                (b) vendor-mnemonic macro aliases (gte_mtc2, gte_mfc2)
+ *
+ *  Primitive commands: gp0_cmd_poly_f3 = 0x20 (byte opcode)
+ *  Packed 32-bit cmd:  gp0_word_poly_f3(r, g, b) (32-bit, shifted)
+ *
+ *  Type ordering: domain?_(direction)?_action_target_modifier_type?
+ *  Examples: add_ui             (add + unsigned + immediate)
+ *            add_s              (add + signed, R-type implicit)
+ *            shift_lleft        (shift + logical + left)
+ *            shift_aright       (shift + arithmetic + right)
+ *            call_reg(rs)       (call + register, $ra implicit)
+ *            gte_mv_to_data_r   (gte + mv + to + data + register)
+ *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
+ *            load_upper_i       (load-upper + immediate, unique verb)
+ *
+ *  Vendor mnemonics (sll, srl, sra, jr, j, jal, jalr) are NOT in this
+ *  header. They live in the opt-in `mips_vendor_sym.h` for users who
+ *  prefer the textbook MIPS assembly mnemonics.
+ * ============================================================================ */
+
 #ifdef INTELLISENSE_DIRECTIVES
 #	pragma once
 #	include "dsl.h"
 # include "gcc_asm.h"
 #endif
 
+enum {
+	MipsStackAlignment = 8,
+};
+
 /* ============================================================================
  *  REGISTER INTEGER IDS (preprocessor-visible)
  * ============================================================================
@@ -69,6 +160,7 @@ enum {
 /* Semantic Aliases for MIPS Registers (O32 ABI) */
 
 	, rdiscard      = R_0  /* Hardwired to 0 */
+	, rasm_tmp      = R_AT /* Assembler temporary (destroyed by some assembler pseudoinstructions!) */
 	, rret_0        = R_V0 /* Function return value */
 	, rret_1        = R_V1 /* Second return value (e.g., 64-bit) */
 	, rarg_0        = R_A0 /* First function argument */
@@ -112,21 +204,30 @@ enum {
 	, op_xori    = 0x0E /* XOR Immediate */
 	, op_lui     = 0x0F /* Load Upper Immediate */
 	, op_cop0    = 0x10 /* Coprocessor 0 (System) */
+	, op_cop1    = 0x11 /* Coprocessor 1 (Reserved, FP Unit, Omitted by Sony) */
 	, op_cop2    = 0x12 /* Coprocessor 2 (GTE) */
-	, op_la      = 0
-	, op_li      = 0
+	, op_cop3    = 0x13 /* Coprocessor 3 (Reserved, Unused)*/
+	/* 14-1F: N/A */
 	, op_lb      = 0x20 /* Load Byte */
 	, op_lh      = 0x21 /* Load Halfword */
+	, op_lwl     = 0x22 /* Load Word (Left Bits) */
 	, op_lw      = 0x23 /* Load Word */
 	, op_lbu     = 0x24 /* Load Byte Unsigned */
 	, op_lhu     = 0x25 /* Load Halfword Unsigned */
+	, op_lwr     = 0x26 /* Load Word (Right Bits) */
+	/* 27: N/A */
 	, op_sb      = 0x28 /* Store Byte */
 	, op_sh      = 0x29 /* Store Halfword */
+	, op_swl     = 0x2A /* Store Word (Left Bits) */
 	, op_sw      = 0x2B /* Store Word */
+	/* 2C-2D: N/A */
+	, op_swr     = 0x2E /* Store Word (Right Bits) */
+	/* 2F: N/A */
+	// , op_lwc0
 
 
-	, op_load_addr  = op_la
-	, op_load_imm   = op_li
+	// , op_load_addr  = op_la
+	// , op_load_imm   = op_li
 	, op_jump       = op_j
 	, op_jump_nlink = op_jal
 
@@ -229,7 +330,9 @@ enum { _BitOffsets = 0
  *   load_word(rt, base, off)   → lw   rt, off(base)
  *   store_word(rt, base, off)  → sw   rt, off(base)
  *   add_ui(rt, rs, imm)        → addiu rt, rs, imm
- *   shift_ll(rd, rt, shamt)    → sll   rd, rt, shamt
+ *   shift_lleft(rd, rt, shamt)   → sll   rd, rt, shamt
+ *   shift_lright(rd, rt, shamt)  → srl   rd, rt, shamt
+ *   shift_aright(rd, rt, shamt)  → sra   rd, rt, shamt
  *   jump_reg(rs)               → jr    rs
  *   jump_link(rs, rd)          → jalr  rs        (link in rd, default $ra)
  *   nop                        → sll   $0, $0, 0
@@ -241,10 +344,19 @@ enum { _BitOffsets = 0
 #define load_half_u(rt, base, off) enc_i(op_lhu,   (base), (rt), (off))
 #define store_word(rt, base, off)  enc_i(op_sw,    (base), (rt), (off))
 #define add_ui(rt, rs, imm)        enc_i(op_addiu, (rs),   (rt), (imm))
-#define and_si(rt, rs, imm)        enc_i(op_andi,  (rs),   (rt), (imm))
+#define and_i(rt, rs, imm)         enc_i(op_andi,  (rs),   (rt), (imm))
+// #define and_si                     and_i
 #define or_i(rt, rs, imm)          enc_i(op_ori,   (rs),   (rt), (imm))
 #define xor_i(rt, rs, imm)         enc_i(op_xori,  (rs),   (rt), (imm))
-#define load_ui(rt, imm)           enc_i(op_lui,   R_0,    (rt), (imm))
+#define load_upper_i(rt, imm)      enc_i(op_lui,   R_0,    (rt), (imm))
+
+#define load_u1 load_byte_u
+#define load_u2 load_half_u
+#define load_u4 load_word
+
+// Ergonomic add to the same register.
+#define or_i_self(rt_rs, imm)      enc_i(op_ori,   (rt_rs), (rt_rs), (imm))
+#define add_ui_self(rt_rs, imm)    enc_i(op_addiu, (rt_rs), (rt_rs), (imm))
 
 /* Logic Opcodes */
 
@@ -253,10 +365,16 @@ enum { _BitOffsets = 0
 #define xor_u(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_xor)
 #define nor_u(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_nor)
 
-/* Shift family (R-type). shift_ll/lr/ra: `sll rd, rt, shamt` */
-#define shift_ll(rd, rt, shamt)    enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_sll)
-#define shift_lr(rd, rt, shamt)    enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_srl)
-#define shift_ra(rd, rt, shamt)    enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_sra)
+#define or_u_self(rd_rs, rt)       enc_r(op_special, (rd_rs), (rt), (rd_rs), 0, fc_or)
+
+/* Shift family (R-type). shift_lleft/lright/aright: `sll/srl/sra rd, rt, shamt` */
+#define shift_lleft(rd, rt, shamt)  enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_sll)
+#define shift_lright(rd, rt, shamt) enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_srl)
+#define shift_aright(rd, rt, shamt) enc_r(op_special, R_0,  (rt), (rd), (shamt), fc_sra)
+
+#define shift_lleft_self(rd_rt, shamt) enc_r(op_special, R_0, (rd_rt), (rd_rt), (shamt), fc_sll)
+
+#define mask_upper(rd, rt, shamt) shift_lleft(rd, rt, shamt), shift_lright(rd, rt, shamt)
 
 /* jr rs — jump to address in rs. */
 #define jump_reg(rs)               enc_r(op_special, (rs), R_0, R_0, 0, fc_jr)
@@ -265,14 +383,14 @@ enum { _BitOffsets = 0
  * Layout: [op_special][rs:5][rt=0:5][rd:5][shamt=0:5][fc_jalr=0x09] */
 #define jump_link(rs, rd)          enc_r(op_special, (rs), R_0, (rd), 0, fc_jalr)
 
-/* jalr rs — link in $ra and jump to address in rs (most common form). */
-#define jump_nreg(rs)              jump_link((rs), R_RA)
+/* call_reg rs — jump-and-link to register-held address; link in $ra. */
+#define call_reg(rs)               jump_link((rs), R_RA)
 
 /* j target — absolute jump within the current 256MB region. */
 #define jump(off)                  enc_i(op_j,     R_0, R_0, (off))
 
-/* jal target — absolute call within the current 256MB region. */
-#define jump_nlink(off)            enc_i(op_jal,   R_0, R_0, (off))
+/* call_addr off — jump-and-link to immediate address. */
+#define call_addr(off)             enc_i(op_jal,   R_0, R_0, (off))
 
 /* --- Store family (mirrors the load family) --- */
 #define store_byte(rt, base, off)  enc_i(op_sb,    (base), (rt), (off))
@@ -304,15 +422,17 @@ enum { _BitOffsets = 0
 #define div_s(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_div)
 #define div_u(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_divu)
 
+#define add_u_self(rd_rs, rt)      add_u(rd_rs, rd_rs, rt)
+
 /* --- Arithmetic I-type (immediate) --- */
 #define add_si(rt, rs, imm)        enc_i(op_addi,  (rs), (rt), (imm))
 /* add_ui already exists above as add_ui */
 
 /* --- Set on less than (R-type and I-type) --- */
-#define slt_s(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_slt)
-#define slt_u(rd, rs, rt)          enc_r(op_special, (rs), (rt), (rd), 0, fc_sltu)
-#define slt_si(rt, rs, imm)        enc_i(op_slti,  (rs), (rt), (imm))
-#define slt_ui(rt, rs, imm)        enc_i(op_sltiu, (rs), (rt), (imm))
+#define set_lt_s(rd, rs, rt)       enc_r(op_special, (rs), (rt), (rd), 0, fc_slt)
+#define set_lt_u(rd, rs, rt)       enc_r(op_special, (rs), (rt), (rd), 0, fc_sltu)
+#define set_lt_si(rt, rs, imm)     enc_i(op_slti,  (rs), (rt), (imm))
+#define set_lt_ui(rt, rs, imm)     enc_i(op_sltiu, (rs), (rt), (imm))
 
 /* --- Move from/to HI/LO (mult/div results) --- */
 #define mov_from_high(rd)          enc_r(op_special, R_0, R_0, (rd), 0, fc_mfhi)
@@ -341,10 +461,11 @@ enum { _BitOffsets = 0
 #define breakpoint()                enc_r(op_special, R_0, R_0, R_0, 0, fc_break)
 
 /* --- Shift-amount alias (matches the gas convention `\p3 = shamt`) --- */
-#define shift_amount(rd, rt, n)     shift_ll(rd, rt, n)
+#define shift_amount(rd, rt, n)     shift_lleft(rd, rt, n)
 
 /* nop — canonical sll $0, $0, 0 */
-#define nop shift_ll(rdiscard, rdiscard, 0)
+#define nop  shift_lleft(rdiscard, rdiscard, 0)
+#define nop2 nop, nop
 
 #define load_imm_1w(rt, imm)    add_ui((rt),  R_0, (imm))
 #define load_imm_1w_s0(rt, imm) add_si((rt)), R_0, (imm))
@@ -365,7 +486,7 @@ enum { _BitOffsets = 0
  *
  * For situations where you need to bypass even this choice (e.g. to
  * force a specific encoding for a known discontiguous high/low pair),
- * see `load_imm_2w_ori` and `load_imm_2w_addi` below.
+ * see `load_imm_2w_ori_forced` and `load_imm_2w_addi_forced` below.
  *
  * Statement-level (not expression-level): emits its own `asm volatile(...)`.
  */
@@ -374,38 +495,38 @@ enum { _BitOffsets = 0
 		asm volatile(                                         \
 			asm_words(load_ui((rt), u4_hi(imm),                 \
 			          add_si((rt), (rt), (S2)C_(U2,u4_lo(imm))) \
-			asm_clobber: rlit(R_AT_Code), clb_mem_drain         \
+			asm_clobber: rlit(R_AT), clb_mem_drain              \
 		);                                                    \
 	}                                                       \
 	else {                                                  \
 		asm volatile(asm_words(                               \
 			load_ui((rt), u4_hi(imm)),                          \
 			or_i((rt), (rt), C_(U2,u4_lo(imm))                  \
-			asm_clobber: rlit(R_AT_Code), clb_mem_drain         \
+			asm_clobber: rlit(R_AT), clb_mem_drain              \
 		);                                                    \
 	}                                                       \
 } while (0)
 
-/* load_imm_2w_ori — force the `lui` + `ori` form regardless of lo16 sign.
+/* load_imm_2w_ori_forced — force the `lui` + `ori` form regardless of lo16 sign.
  * Use when you specifically need zero-extension in the lo half. */
-#define load_imm_2w_ori(rt, imm) do {                 \
+#define load_imm_2w_ori_forced(rt, imm) do {          \
 	asm volatile(                                       \
 		asm_words(load_ui((rt), u4_lo(imm)),              \
 		          or_i((rt), (rt), C_(U2,u4_hi(imm))) )   \
-		asm_clobber: rlit(R_AT_Code), clb_mem_drain       \
+		asm_clobber: rlit(R_AT), clb_mem_drain            \
 	);                                                  \
 } while (0)
 
-/* load_imm_2w_addi — force the `lui` + `addi` form regardless of lo16 sign.
+/* load_imm_2w_addi_forced — force the `lui` + `addi` form regardless of lo16 sign.
  * Use when you know sign-extension is fine (e.g. lo16 is treated as
  * signed downstream) and you want a smaller effective instruction
  * (the assembler/MIPS hardware will sign-extend the imm16). */
-#define load_imm_2w_addi(rt, imm) do {          \
+#define load_imm_2w_addi_forced(rt, imm) do {   \
 	/*U4 _li2a_imm_ = (U4)(imm);*/                \
 	asm volatile(asm_words(                       \
 		lui_op((rt), u4_lo(imm)),                   \
 		add_si((rt), (rt), (S2)C_(U2,u4_hi(imm))) ) \
-		asm_clobber: rlit(R_AT_Code), clb_mem_drain \
+		asm_clobber: rlit(R_AT), clb_mem_drain      \
 	);                                            \
 } while (0)
 
@@ -433,14 +554,14 @@ enum { _BitOffsets = 0
 		/* Small positive: addi rt, $0, imm */                         \
 		asm volatile(                                                  \
 			asm_words(add_si((rt), R_0, (imm)))                          \
-			asm_clobber: rlit(R_AT_Code), clb_mem_drain                  \
+			asm_clobber: rlit(R_AT), clb_mem_drain                       \
 		);                                                             \
 	}                                                                \
 	else if (cexpr_(imm) && ((U4)(imm) <= 0xFFFFU)) {                \
 			/* 0x8000..0xFFFF: ori rt, $0, imm (zero-extends) */         \
 			asm volatile(                                                \
 				asm_words(or_i((rt), R_0, (imm)))                          \
-				asm_clobber: rlit(R_AT_Code), clb_mem_drain                \
+				asm_clobber: rlit(R_AT), clb_mem_drain                     \
 			);                                                           \
 	}                                                                \
 	else                                                             \
@@ -452,62 +573,28 @@ enum { _BitOffsets = 0
 			asm volatile(asm_words(                                      \
 				load_ui((rt), u4_hi(imm)),                                 \
 				add_si((rt), (rt), (S2)C_(U2,u4_lo(imm)))                  \
-				asm_clobber: rlit(R_AT_Code), clb_mem_drain                \
+				asm_clobber: rlit(R_AT), clb_mem_drain                     \
 			);                                                           \
 		}                                                              \
 		else {                                                         \
 			asm volatile(asm_words(                                      \
 				load_ui((rt),             u4_hi(imm)),                     \
 				or_i((rt), (rt), C_(U2,u4_lo(imm))                         \
-				asm_clobber: rlit(R_AT_Code), clb_mem_drain                \
+				asm_clobber: rlit(R_AT), clb_mem_drain                     \
 			);                                                           \
 		}                                                              \
 	}                                                                \
 } while (0                                                         )
 
-// Binary Metaprogramming
-
-typedef U4 const Code;
-#define CodeBlob_(sym) tmpl(code,sym) [] align_(4) =
-
-enum {
-	bios_flushcache = 0x44,
-	bios_table_addr = 0xA0,
-};
-
-/* Flushes the Instruction Cache (PSX A-function 0x44 via BIOS stub at 0xA0).
- *
- * Sequence (per MIPS ABI; arguments in arg registers, RA pushed to stack):
- *   1. sp -= 8;  sw $ra, 4($sp)        ; save RA
- *   2. $a0 = bios_flushcache (arg0)
- *   3. $t0 = bios_table_addr           ; t0 = &BIOS A-function table
- *   4. jalr $t0, $ra                    ; call BIOS(flushcache)
- *      nop                              ; branch delay slot
- *   5. lw $ra, 4($sp);  jr $ra          ; restore & return
- *   6. sp += 8
- */
-internal
-Code CodeBlob_(mips_flush_icache) {
-	  add_ui(rstack_ptr, rstack_ptr, -8)        /* sp -= 8             */
-	, store_word(rret_addr, rstack_ptr, 4)      /* sw  $ra,   4($sp)   */
-	, add_ui(rret_0, rdiscard, bios_flushcache) /* addiu $a0, $0, 0x44 */
-	, add_ui(rtmp_0, rdiscard, bios_table_addr) /* addiu $t0, $0, 0xA0 */
-	, jump_link(rtmp_0, rret_addr)              /* jalr  $t0, $ra      */
-	, nop                                       /* BD slot             */
-	, load_word(rret_addr, rstack_ptr, 4)       /* lw   $ra, 4($sp)    */
-	, jump_reg(rret_addr)                       /* jr   $ra            */
-	, add_ui(rstack_ptr, rstack_ptr, 8)         /* sp += 8 (BD)        */
-};
-I_ void mips_flush_icache(void) { C_(VoidFn*, code_mips_flush_icache)(); }
 
 /* Standard clobber list for pure-MIPS asm volatile blocks: caller-saved
  * GPRs that the kernel treats as volatile (v0/v1/t0/t1/ra) plus the
  * "memory" barrier. The register ids are passed through `rlit` so
  * the R_*_Code `#define`s are stringified into "$N" at expansion time. */
-#define clb_system rlit(R_V0_Code), rlit(R_T0_Code), rlit(R_T1_Code), rlit(R_RA_Code), clb_mem_drain
+#define clbr_volatile_gprs rlit(R_V0), rlit(R_T0), rlit(R_T1), rlit(R_RA), clb_mem_drain
 
 #define asm_mips_flush_icache() asm volatile( asm_words( \
-		add_ui(rstack_ptr, rstack_ptr, -8)        \
+		add_ui(rstack_ptr, rstack_ptr, -MipsStackAlignment) \
 	, store_word(rret_addr, rstack_ptr, 4)      \
 	, add_ui(rret_0, rdiscard, bios_flushcache) \
 	, add_ui(rtmp_0, rdiscard, bios_table_addr) \
@@ -515,9 +602,5 @@ I_ void mips_flush_icache(void) { C_(VoidFn*, code_mips_flush_icache)(); }
 	, nop                                       \
 	, load_word(rret_addr, rstack_ptr, 4)       \
 	, jump_reg(rret_addr)                       \
-	, add_ui(rstack_ptr, rstack_ptr, 8)         \
-) asm_clobber: clb_system )
-
-void test_mips_asm() {
-	asm_mips_flush_icache();
-}
+	, add_ui(rstack_ptr, rstack_ptr, MipsStackAlignment) \
+) asm_clobber: clbr_volatile_gprs )

code/duffle/mips_vendor_sym.h

@@ -0,0 +1,45 @@
+/* ============================================================================
+ *  duffle DSL — MIPS Vendor Mnemonics (opt-in)
+ *  ============================================================================
+ *
+ *  Provides the textbook MIPS assembly mnemonics as thin aliases to the
+ *  canonical duffle macros in mips.h. The duffle names are primary; this
+ *  header is for users who prefer the textbook mnemonics.
+ *
+ *  USAGE:   #include "duffle/mips_vendor_sym.h"   // after mips.h
+ *
+ *  Mapping (vendor -> duffle):
+ *    Shift family:
+ *      sll  -> shift_lleft      (shift left logical)
+ *      srl  -> shift_lright     (shift right logical)
+ *      sra  -> shift_aright     (shift right arithmetic)
+ *      (no sllv/srlv/srav; the shift macros take a literal shamt)
+ *
+ *    Jump family (1-arg / implicit-rd forms):
+ *      jr   -> jump_reg         (jump register)
+ *      j    -> jump              (jump to immediate address)
+ *      jal  -> call_addr         (jump-and-link to immediate address)
+ *      jalr -> call_reg          (jump-and-link to register, default $ra)
+ *      (for the 2-arg `jalr rs, rd`, use `jump_link(rs, rd)` directly)
+ * ============================================================================ */
+
+#ifdef INTELLISENSE_DIRECTIVES
+#	pragma once
+#	include "mips.h"
+#endif
+
+#ifndef DUFFLE_MIPS_VENDOR_SYM_H
+#define DUFFLE_MIPS_VENDOR_SYM_H
+
+/* Shift family */
+#define sll  shift_lleft
+#define srl  shift_lright
+#define sra  shift_aright
+
+/* Jump family (1-arg / implicit-$ra forms) */
+#define jr   jump_reg
+#define j    jump
+#define jal  call_addr
+#define jalr call_reg
+
+#endif

code/duffle/word_count.metadata.h

@@ -0,0 +1,57 @@
+// word_count.metadata.h
+// Single source of truth for instruction-word counts.
+// Used by C (to define compile-time constants) AND Python (to count positions).
+//
+// Format: WORD_COUNT(MACRO_NAME, COUNT)
+// One line per macro that appears in your atom sources.
+//
+// This file is encoding-macros-only. The auto-generated component
+// macros (mac_X) live in duffle/gen/<dir>.macs.h (included separately
+// by the unity build). The unity build should include THIS file and
+// the .macs.h file in the same TU, with both wrapped (or the
+// include guard order handled) to avoid WORD_COUNT redeclaration.
+//
+// To regenerate: hand-count the instructions in each macro definition.
+// (You'll only need to do this once per macro — they don't change often.)
+#define WORD_COUNT(name, count)  enum { words_##name = (count) };
+
+WORD_COUNT(nop,                              1)
+WORD_COUNT(load_upper_i,                     1)
+WORD_COUNT(jump_reg,                         1)
+WORD_COUNT(jump_link,                        1)
+WORD_COUNT(call_reg,                         1)
+WORD_COUNT(call_addr,                        1)
+WORD_COUNT(branch_le_zero,                   1)
+WORD_COUNT(branch_equal,                     1)
+WORD_COUNT(add_ui,                           1)
+WORD_COUNT(set_lt_u,                         1)
+WORD_COUNT(set_lt_s,                         1)
+WORD_COUNT(set_lt_si,                        1)
+WORD_COUNT(set_lt_ui,                        1)
+WORD_COUNT(load_word,                        1)
+WORD_COUNT(load_half_u,                      1)
+WORD_COUNT(store_word,                       1)
+WORD_COUNT(add_ui_self,                      1)
+WORD_COUNT(add_u_self,                       1)
+WORD_COUNT(add_u,                            1)
+WORD_COUNT(or_i,                             1)
+WORD_COUNT(or_i_self,                        1)
+WORD_COUNT(or_u,                             1)
+WORD_COUNT(or_u_self,                        1)
+WORD_COUNT(shift_lleft,                      1)
+WORD_COUNT(shift_lleft_self,                 1)
+WORD_COUNT(shift_lright,                     1)
+WORD_COUNT(shift_aright,                     1)
+WORD_COUNT(mask_upper,                       2)
+WORD_COUNT(gte_mv_from_data_r,               1)
+WORD_COUNT(gte_mv_from_ctrl_r,               1)
+WORD_COUNT(gte_mv_to_data_r,                 1)
+WORD_COUNT(gte_mv_to_ctrl_r,                 1)
+WORD_COUNT(gte_sw,                           1)
+WORD_COUNT(gte_cmdw_rtpt,                    1)
+WORD_COUNT(gte_cmdw_nclip,                   1)
+WORD_COUNT(gte_avg_sort_z3,                  1)
+WORD_COUNT(sub_u,                            1)
+WORD_COUNT(nop2,                             2)
+
+#undef WORD_COUNT

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 def_struct(PrimitiveArena) {
+typedef Array_(PrimitiveBuffer, 2);
+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 def_struct(DrawEnv) {
+typedef Struct_(DrawEnv_Packed) { U4 tag; U4 code[15]; };
+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 def_farray(DisplayEnv, 2);
-typedef def_struct(DoubleBuffer) {
+typedef Array_(DrawEnv,    2);
+typedef Array_(DisplayEnv, 2);
+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),
-		cast(S4*R_, pp),  cast(S4*R_, otz), cast(S4*R_, flag)
+		C_(S4*R_, xy0), C_(S4*R_, xy1), C_(S4*R_, xy2),
+		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),
-		cast(S4*R_, pp),  cast(S4*R_, otz), cast(S4*R_, flag)
+		C_(S4*R_, xy0), C_(S4*R_, xy1), C_(S4*R_, xy2), C_(S4*R_, xy3),
+		C_(S4*R_, pp),  C_(S4*R_, otz), C_(S4*R_, flag)
 	);
 }
 

code/gte_hello/gen/gte_hello.offsets.h

@@ -0,0 +1,29 @@
+// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT
+// Source: C:\projects\Pikuma\ps1\code\gte_hello\hello_gte_tape.c
+#pragma once
+
+#pragma region hello_gte_tape
+
+
+// --- atom: cube_g4_face (87 words) ---
+
+#define _atom_offset_cull_cube_g4_face_exit           48
+#define _atom_offset_bounds_chk_cube_g4_face_exit     12
+
+enum {
+    atom_offset_cull_cube_g4_face_exit = _atom_offset_cull_cube_g4_face_exit,
+    atom_offset_bounds_chk_cube_g4_face_exit = _atom_offset_bounds_chk_cube_g4_face_exit,
+};
+
+// --- atom: floor_f3_face (66 words) ---
+
+#define _atom_offset_culling_floor_f3_face_exit       29
+#define _atom_offset_bounds_chk_floor_f3_face_exit    13
+
+enum {
+    atom_offset_culling_floor_f3_face_exit = _atom_offset_culling_floor_f3_face_exit,
+    atom_offset_bounds_chk_floor_f3_face_exit = _atom_offset_bounds_chk_floor_f3_face_exit,
+};
+
+#pragma endregion hello_gte_tape
+

code/gte_hello/hello_gte.c

@@ -8,17 +8,22 @@
 #include "duffle/dsl.h"
 #include "duffle/memory.h"
 #include "duffle/math.h"
+
 #include "duffle/gcc_asm.h"
 #include "duffle/mips.h"
 #include "duffle/gp.h"
 #include "duffle/gte.h"
+
+#	include "duffle/gen/duffle.macs.h"
+#	include "duffle/gen/duffle.offsets.h"
+#include "duffle/atom_dsl.h"
 #include "duffle/lottes_tape.h"
+#include "duffle/word_count.metadata.h"
+
+#	include "gen/gte_hello.offsets.h"
 #include "hello_gte.h"
 
-enum {
-	PrimitiveBuff_Len = 4096,
-	OrderingTbl_Len   = 2048
-};
+#include "hello_gte_tape.c"
 
 typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
 typedef Array_(OrderingTable_Buffer, 2);
@@ -94,31 +99,39 @@ typedef Struct_(Ent_Floor) {
 	A2_V3_S2 faces;
 };
 
+enum { scratchpad_size = 1024, };
 typedef Struct_(SMemory) {
 	DoubleBuffer            screen_buf;
 	A2_OrderingTable_Buffer ordering_tbl;
 	PrimitiveArena          primitives;
-	S2                      active_buf_id;
+	S4                      active_buf_id;
 
 	M3_S2 tform_world;
 
 	Ent_Cube  cube;
 	Ent_Floor floor;
+
+	U4_V scratchpad; // d-cache
 };
-global SMemory static_mem;
-extern SMemory static_mem;
+global SMemory smem;
+extern SMemory smem;
+
+// TODO(Ed):
+FI_ U4* spad_warm(MipsAtom atom) {
+	return nullptr;
+}
 
 I_ B1* prim__alloc(U4 type_width, Str8 type_name) {
-	gknown PrimitiveArena* pa  = & static_mem.primitives;
-	gknown B1*             buf = (B1*) r_(static_mem.primitives.buf)[static_mem.active_buf_id];
+	gknown PrimitiveArena* pa  = & smem.primitives;
+	gknown B1*             buf = (B1*) r_(smem.primitives.buf)[smem.active_buf_id];
 	assert(pa->used + type_width < PrimitiveBuff_Len);
-	B1* next = buf + pa->used;
+	B1* next  = buf + pa->used;
 	pa->used += type_width;
 	return next;
 }
 #define prim_alloc(type) (type*)prim__alloc(S_(type), slit( stringify(type)))
 
-void gp_screen_init_c11(DoubleBuffer* screen_buf, S2* active_buf_id)
+void gp_screen_init_c11(DoubleBuffer* screen_buf, S4* active_buf_id)
 {
 	reset_graph(0);
 
@@ -144,13 +157,17 @@ void gp_screen_init_c11(DoubleBuffer* screen_buf, S2* active_buf_id)
 
 	// Initialize and setup the GTE geometry offsets
 	geom_init();
+	// NOTE: geom_set_offset/geom_set_screen are kept as-is (the libgte versions
+	// are known to be broken in this PSYQ 4.7 build — see report 2026-07-09).
+	// The user's research wants the C-side non-tape reference to work as a
+	// known-good baseline for comparison against the tape.
 	geom_set_offset(ScreenRes_CenterX, ScreenRes_CenterY);
 	geom_set_screen(ScreenZ);
 
 	set_display_enabled(1); // gp_DisplayEnabled
 }
 
-void gp_display_frame(DoubleBuffer* screen_buf, S2* active_buf_id, U4* ordering_buf, PrimitiveArena* pa) {
+void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_buf, PrimitiveArena* pa) {
 	draw_sync(0);
 	vsync(0);
 	displayenv_put(& r_(screen_buf->display)[active_buf_id[0] ]);
@@ -170,9 +187,9 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	orderingtbl_clear_reverse(ordering_buf, OrderingTbl_Len);
 
 	// Update the position based on acceleration and velocity
-	gknown V3_S4_R pos = & static_mem.cube.pos;
-	gknown V3_S4_R vel = & static_mem.cube.vel;
-	gknown V3_S4_R acc = & static_mem.cube.accel;
+	gknown V3_S4_R pos = & smem.cube.pos;
+	gknown V3_S4_R vel = & smem.cube.vel;
+	gknown V3_S4_R acc = & smem.cube.accel;
 	add_v3s4(vel, acc[0]);
 	add_v3s4_fp(pos, vel[0]);
 	// vel->x += acc->x;
@@ -182,7 +199,7 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	// pos->y += vel->y;
 	// pos->z += vel->z;
 
-	if (pos->y + 150 > static_mem.floor.pos.y) vel->y *= -1;
+	if (pos->y + 150 > smem.floor.pos.y) vel->y *= -1;
 
 	// Prep
 	S4 nclip = 0;
@@ -191,12 +208,13 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	S4 flag; //????
 
 	// Draw Cube
+	if (0)
 	{
-		m3s2_rotation   (& static_mem.cube.rot,    & static_mem.tform_world);
-		m3s2_translation(& static_mem.tform_world, & static_mem.cube.pos);
-		m3s2_scale      (& static_mem.tform_world, & static_mem.cube.scale);
-		gte_matrix_set_rotation   (& static_mem.tform_world);
-		gte_matrix_set_translation(& static_mem.tform_world);
+		m3s2_rotation   (& smem.cube.rot,    & smem.tform_world);
+		m3s2_translation(& smem.tform_world, & smem.cube.pos);
+		m3s2_scale      (& smem.tform_world, & smem.cube.scale);
+		// gte_matrix_set_rotation   (& smem.tform_world);
+		gte_matrix_set_translation(& smem.tform_world);
 		for (U4 face_id = 0; face_id < Cube_num_faces; face_id += 1)
 		{
 			Poly_G4* quad = prim_alloc(Poly_G4); set_poly_g4(quad);
@@ -205,11 +223,11 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 			quad->c2 = rgb8(  0, 255, 255);
 			quad->c3 = rgb8(  0, 255,   0);
 
-			V4_S2* face = & static_mem.cube.faces[face_id];
-			V3_S2* p0   = & static_mem.cube.verts[face->x];
-			V3_S2* p1   = & static_mem.cube.verts[face->y];
-			V3_S2* p2   = & static_mem.cube.verts[face->z];
-			V3_S2* p3   = & static_mem.cube.verts[face->w];
+			V4_S2* face = & smem.cube.faces[face_id];
+			V3_S2* p0   = & smem.cube.verts[face->x];
+			V3_S2* p1   = & smem.cube.verts[face->y];
+			V3_S2* p2   = & smem.cube.verts[face->z];
+			V3_S2* p3   = & smem.cube.verts[face->w];
 
 			nclip = rtp_avg_nclip_a4_v3s2(
 				p0, p1, p2, p3,
@@ -224,30 +242,62 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 				orderingtbl_add_primitive(ordering_buf[orderingtbl_z], quad);
 			}
 		}
-		// static_mem.cube.rot.x +=  6;
-		// static_mem.cube.rot.y +=  8;
-		// static_mem.cube.rot.z += 12;
-		static_mem.cube.rot.y += 30;
+		// smem.cube.rot.x +=  6;
+		// smem.cube.rot.y +=  8;
+		// smem.cube.rot.z += 12;
+		smem.cube.rot.y += 30;
+	}
+	// Draw cube (tape method) - two triangles per face
+	if (1)
+	{
+		m3s2_rotation   (& smem.cube.rot,    & smem.tform_world);
+		m3s2_translation(& smem.tform_world, & smem.cube.pos);
+		m3s2_scale      (& smem.tform_world, & smem.cube.scale);
+		gte_matrix_set_rotation   (& smem.tform_world);
+		gte_matrix_set_translation(& smem.tform_world);
+
+		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
+		U4 prim_cursor = prim_base + pa->used;
+
+		LP_ U4 mem_temp_tape[512]; FArena tape_arena; farena_init(& tape_arena, slice_ut_arr(mem_temp_tape));
+		TapeBuilder tb = tb_make_old(&tape_arena); tb_scope(& tb) {
+			tb_emit(& tb, code_rbind_cube_g4_face);
+				tb_data(& tb, prim_cursor);
+				tb_data(& tb, u4_(smem.cube.faces));
+				tb_data(& tb, u4_(smem.cube.verts));
+				tb_data(& tb, u4_(ordering_buf));
+
+			for (U4 i = 0; i < Cube_num_faces; i++) {
+				// Two triangles per quad face: (x,y,z) and (x,z,w)
+				tb_emit(& tb, code_cube_g4_face);
+			}
+
+			tb_emit(& tb, code_sync_primitive_arena);
+				tb_data(& tb, u4_(& pa->used));
+				tb_data(& tb, prim_base);
+		}
+		tape_run(tb_slice(tb));
+
+		smem.cube.rot.y += 30;
 	}
 	// Draw Floor
 	if (0)
 	{
-		m3s2_rotation   (& static_mem.floor.rot,   & static_mem.tform_world);
-		m3s2_translation(& static_mem.tform_world, & static_mem.floor.pos);
-		m3s2_scale      (& static_mem.tform_world, & static_mem.floor.scale);
-		gte_matrix_set_rotation   (& static_mem.tform_world);
-		gte_matrix_set_translation(& static_mem.tform_world);
+		m3s2_rotation   (& smem.floor.rot,   & smem.tform_world);
+		m3s2_translation(& smem.tform_world, & smem.floor.pos);
+		m3s2_scale      (& smem.tform_world, & smem.floor.scale);
+		gte_matrix_set_rotation   (& smem.tform_world);
+		gte_matrix_set_translation(& smem.tform_world);
 		for (U4 face_id = 0; face_id < Floor_num_faces; face_id += 1)
 		{
 			Poly_F3* tri = prim_alloc(Poly_F3); set_poly_f3(tri);
 			tri->color   = rgb8(255, 255, 255);
 
-			V3_S2* face = & static_mem.floor.faces[face_id];
-			register V3_S2* p0 rgcc(R_T4) = & static_mem.floor.verts[face->x];
-			register V3_S2* p1 rgcc(R_T5) = & static_mem.floor.verts[face->y];
-			register V3_S2* p2 rgcc(R_T6) = & static_mem.floor.verts[face->z];
+			V3_S2* face = & smem.floor.faces[face_id];
+			register V3_S2* p0 rgcc(R_T4) = & smem.floor.verts[face->x];
+			register V3_S2* p1 rgcc(R_T5) = & smem.floor.verts[face->y];
+			register V3_S2* p2 rgcc(R_T6) = & smem.floor.verts[face->z];
 
-			// Three independent bases — full register discretion at the call site
 			gte_load_v0(p0, R_T4);
 			/*
 			asm volatile( ".word " "%0" ", %1" : : 
@@ -282,72 +332,100 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 				}
 			}
 		}
-		static_mem.floor.rot.y += 5;
+		smem.floor.rot.y += 5;
 	}
 	// Draw floor tape method
 	if (1)
 	{
-    LP_ U4 mem_temp_tape[512]; // Buffer for function addresses
-    FArena tape_arena; 
-    farena_init(&tape_arena, slice_ut(mem_temp_tape, S_(mem_temp_tape)));
-    
-    TapeBuilder tb = tb_begin(&tape_arena); {
-        // Setup state atoms
-        m3s2_rotation(&static_mem.floor.rot, &static_mem.tform_world);
-        m3s2_translation(&static_mem.tform_world, &static_mem.floor.pos);
-        
-        // Push "Protocol" to tape
-        tb_emit(&tb, code_atom_set_gte_world);
-				tb_emit(&tb, (Code*)&static_mem.tform_world);
-        for (U4 i = 0; i < Floor_num_faces; i++) {
-            tb_emit(&tb, code_atom_floor_tri);
-        }
-    }
-    Slice_U4 tape = tb_end(&tb);
+		m3s2_rotation   (& smem.floor.rot,   & smem.tform_world);
+		m3s2_translation(& smem.tform_world, & smem.floor.pos);
+		m3s2_scale      (& smem.tform_world, & smem.floor.scale);
 
-    // 1. Setup Argument Registers (The Workspace)
-    register V3_S2* face_cursor rgcc(R_T4) = static_mem.floor.faces;
-    register V3_S2* vert_base   rgcc(R_T5) = static_mem.floor.verts;
-    register U4*    ot_base     rgcc(R_T6) = ordering_buf;
-		// --- EXECUTION ---
-		B1* prim_cursor = (B1*)r_(pa->buf)[static_mem.active_buf_id] + pa->used;
-		// 2. Fire the Tape Drive (Explicitly bind the workspace variables)
-		tape_run(tape, &prim_cursor, static_mem.floor.faces, static_mem.floor.verts, ordering_buf);
+		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
+		U4 prim_cursor = prim_base + pa->used;
 
-    // 3. Update C-side state
-    pa->used = (U4)prim_cursor - (U4)r_(pa->buf)[static_mem.active_buf_id];
-    static_mem.floor.rot.y += 5;
+		// TODO(Ed): We should do a bounds check beforehand to confirm pa can hold all tris.
+		// The tape atoms in-flight should not need to care.
+
+		// Prepare the tape. (Push protocol to tape)
+		LP_ U4 mem_temp_tape[512];
+		TapeBuilder tb = tb_make(slice_ut_arr(mem_temp_tape)); tb_scope(& tb) {
+			tb_emit(& tb, code_set_gte_world);
+				tb_data(& tb, u4_(& smem.tform_world));
+
+			tb_emit(& tb, code_rbind_floor_f3_face);
+			// TODO(Ed): Just use a single context struct ref
+				tb_data(& tb, prim_cursor);
+				tb_data(& tb, u4_(smem.floor.faces));
+				tb_data(& tb, u4_(smem.floor.verts));
+				tb_data(& tb, u4_(ordering_buf));
+			for (U4 i = 0; i < Floor_num_faces; i++) {
+				tb_emit(& tb, code_floor_f3_face);
+			}
+			// After code_floor_f3_face iterations complete, the primitive arena's used counter needs updating.
+			tb_emit(& tb, code_sync_primitive_arena);
+				tb_data(& tb, u4_(& pa->used));
+				tb_data(& tb, prim_base);
+		}
+
+		tape_run(tb_slice(tb));// Fire off the tape.
+
+		// C-side state (pa->used) has already been updated by the tape!
+		smem.floor.rot.y += 5;
+	}
+	// --- TAPE DIAGNOSTICS ---
+	if (1)
+	{
+		LP_ U4 mem_temp_tape[512]; FArena tape_arena; farena_init(& tape_arena, slice_ut_arr(mem_temp_tape));
+		TapeBuilder tb = tb_make_old(& tape_arena); tb_scope(& tb) {
+			// Skip set_gte_world atom for diagnostics to isolate the triangle loop
+			for (U4 i = 0; i < Floor_num_faces; i++) {
+				// =======================================================
+				// SWAP EMIT TO TEST DIFFERENT PARTS OF THE PIPELINE:
+				// =======================================================
+				// 1. code_diag_yield -> Tests Tape Engine jump logic
+				// 2. code_diag_color -> Tests OT and Prim Arena memory
+				// 3. code_diag_gte   -> Tests Vertex arrays and GTE Math
+				// tb_emit(& tb, code_diag_yield);
+				// tb_emit(& tb, code_diag_color);
+				// tb_emit(& tb, code_diag_gte); 
+			}
+		}
+		B1* prim_cursor = (B1*)r_(pa->buf)[smem.active_buf_id] + pa->used;
+		tape_run(tb_slice(tb));
+		pa->used = (U4)prim_cursor - (U4)r_(pa->buf)[smem.active_buf_id];
+		smem.floor.rot.y += 5;
 	}
 }
 
 int main(void)
 {
-	static_mem = (SMemory){0};
-	static_mem.primitives.used = 0;
-	ent_cube128_init(& static_mem.cube.verts, & static_mem.cube.faces); {
-		Ent_Cube* cube = & static_mem.cube;
+	smem = (SMemory){0};
+	smem.scratchpad = C_(U4_V, 0x1F800000);
+	smem.primitives.used = 0;
+	ent_cube128_init(& smem.cube.verts, & smem.cube.faces); {
+		Ent_Cube* cube = & smem.cube;
 		cube->rot    = v3s2(0, 0, 0);
 		// cube->pos    = v3s4(0, 0, 900);
 		cube->scale  = v3s4_fp_one();
 		cube->accel  = v3s4(0, 1, 0);
 		cube->pos    = v3s4(0, -400, 1800);
 	}
-	ent_floor_init(& static_mem.floor.verts, & static_mem.floor.faces); {
-		Ent_Floor* floor = & static_mem.floor;
+	ent_floor_init(& smem.floor.verts, & smem.floor.faces); {
+		Ent_Floor* floor = & smem.floor;
 		floor->rot   = v3s2(0, 0, 0);
 		floor->pos   = v3s4(0, 450, 1800);
 		floor->scale = v3s4_fp_one();
 	}
 	// gknown gp_screen_init();
-	gp_screen_init_c11(& static_mem.screen_buf, & static_mem.active_buf_id);
-	while (1) 
-	{
-		gknown S2* active_buf_id  = & static_mem.active_buf_id;
-		gknown U4* ordering_buf   = r_(static_mem.ordering_tbl)[active_buf_id[0]];
-		gknown PrimitiveArena* pa = & static_mem.primitives;
+	gp_screen_init_c11(& smem.screen_buf, & smem.active_buf_id);
+	while (1) {
+		gknown S4* active_buf_id  = & smem.active_buf_id;
+		gknown U4* ordering_buf   = r_(smem.ordering_tbl)[active_buf_id[0]];
+		gknown PrimitiveArena* pa = & smem.primitives;
 		update(pa, ordering_buf);
 		render();
-		gp_display_frame(& static_mem.screen_buf, active_buf_id, ordering_buf, pa);
+		gp_display_frame(& smem.screen_buf, active_buf_id, ordering_buf, pa);
 	};
 	return 0;
 }

code/gte_hello/hello_gte.h

@@ -5,6 +5,11 @@
 #	include "duffle/gp.h"
 #endif
 
+enum {
+	PrimitiveBuff_Len = 4096,
+	OrderingTbl_Len   = 2048
+};
+
 typedef Struct_(DrawEnv_Packed) { U4 tag; U4 code[15]; };
 typedef Struct_(DrawEnv) {
 	Rect_S2 clip_area;
@@ -58,98 +63,6 @@ U4 vsync(U4 mode)     __asm__("VSync");
 
 void draw_orderingtbl(U4* buf) __asm__("DrawOTag");
 
-typedef Struct_(PolyTag) {
-	U4   addr: 24;
-	U4   len:  8;
-	RGB8 color;
-	B1   code;
-};
-
-/*
- * Primitive Handling Macros
- */
-
-#define set_len( p, _len) 	(((PolyTag*R_)(p))->len  = (B1)(_len))
-#define set_addr(p, _addr)	(((PolyTag*R_)(p))->addr = (U4)(_addr))
-#define set_code(p, _code)	(((PolyTag*R_)(p))->code = (B1)(_code))
-
-#define get_len(p)    	    (B1)(((PolyTag*R_)(p))->len)
-#define get_code(p)   	    (B1)(((PolyTag*R_)(p))->code)
-#define get_addr(p)   	    (U4)(((PolyTag*R_)(p))->addr)
-
-#define orderingtbl_add_primitive(ot, p)		    set_addr(p,  get_addr(ot)), set_addr(ot, p)
-#define orderingtbl_add_primitives(ot, p0, p1)	set_addr(p1, get_addr(ot)), set_addr(ot, p0)
-
-/* Primitive 	Length		Code */
-
-#define set_poly_f3(p)	set_len(p, 4),  set_code(p, 0x20)
-#define set_poly_ft3(p)	set_len(p, 7),  set_code(p, 0x24)
-#define set_poly_g3(p)  set_len(p, 6),  set_code(p, 0x30)
-#define set_poly_gt3(p)	set_len(p, 9),  set_code(p, 0x34)
-#define set_poly_f4(p)	set_len(p, 5),  set_code(p, 0x28)
-#define set_poly_ft4(p)	set_len(p, 9),  set_code(p, 0x2c)
-#define set_poly_g4(p)  set_len(p, 8),  set_code(p, 0x38)
-#define set_poly_gt4(p)	set_len(p, 12), set_code(p, 0x3c)
-
-// #define setSprt8(p)	setlen(p, 3),  setcode(p, 0x74)
-// #define setSprt16(p)	setlen(p, 3),  setcode(p, 0x7c)
-// #define setSprt(p)	setlen(p, 4),  setcode(p, 0x64)
-
-// #define setTile1(p) 	set_len(p, 2),  set_code(p, 0x68)
-// #define setTile8(p) 	set_len(p, 2),  set_code(p, 0x70)
-// #define setTile16(p)	set_len(p, 2),  set_code(p, 0x78)
-#define set_tile(p) 	set_len(p, 3),  set_code(p, 0x60)
-// #define setLineF2(p)	set_len(p, 3),  set_code(p, 0x40)
-// #define setLineG2(p)	set_len(p, 4),  set_code(p, 0x50)
-// #define setLineF3(p)	set_len(p, 5),  set_code(p, 0x48),(p)->pad = 0x55555555
-// #define setLineG3(p)	set_len(p, 7),  set_code(p, 0x58),(p)->pad = 0x55555555, (p)->p2 = 0
-// #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 Struct_(Poly_F3) {
-	U4   tag;
-	RGB8 color;
-	B1   code;
-	union {
-		struct {
-			V2_S2 p0;
-			V2_S2 p1;
-			V2_S2 p2;
-		};
-		A3_V2_S2 points;
-	};
-};
-
-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 Struct_(Poly_F4) {
-	U4   tag;
-	RGB8 color;
-	B1   code;
-	union {
-		struct {
-			V2_S2 p0;
-			V2_S2 p1;
-			V2_S2 p2;
-			V2_S2 p3;
-		};
-		A4_V2_S2 points;
-	};
-};
-
-typedef Struct_(Poly_G4) {
-	U4    tag; RGB8 c0; B1 code;
-	V2_S2 p0;  RGB8 c1; B1 pad1;
-	V2_S2 p1;  RGB8 c2; B1 pad2;
-	V2_S2 p2;  RGB8 c3; B1 pad3;
-	V2_S2 p3;
-};
-
 typedef Struct_(Tile) {
 	U4      tag;
 	RGB8    color;
@@ -157,7 +70,6 @@ typedef Struct_(Tile) {
 	Rect_S2 rect;
 };
 
-
 /*
 	Linear Algebra
 */

code/gte_hello/hello_gte_tape.c

@@ -0,0 +1,161 @@
+#ifdef INTELLISENSE_DIRECTIVES
+#	include "duffle/gen/duffle.macs.h"
+#	include "duffle/gen/duffle.offsets.h"
+#	include "duffle/atom_dsl.h"
+#	include "duffle/lottes_tape.h"
+#	include "duffle/word_count.metadata.h"
+#	include "gen/gte_hello.offsets.h"
+#	include "hello_gte.h"
+#endif
+
+#pragma region MACs (Mips Atom components)
+
+
+
+#pragma endregion MACs
+
+#pragma region Baked Atoms
+
+typedef Struct_(Binds_CubeTri) {
+	U4     PrimCursor;
+	V4_S2* FaceCursor;
+	V3_S2* VertBase;
+	U4*    OtBase;
+};
+internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri)
+,	atom_reads(R_TapePtr)
+,	atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+){
+	/* Pop 4 arguments from the tape directly into the workspace registers */
+	load_word(R_PrimCursor, R_TapePtr, O_(Binds_CubeTri,PrimCursor)), 
+	load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,FaceCursor)), 
+	load_word(R_VertBase,   R_TapePtr, O_(Binds_CubeTri,VertBase)), 
+	load_word(R_OtBase,     R_TapePtr, O_(Binds_CubeTri,OtBase)), 
+	add_ui_self(            R_TapePtr, S_(Binds_CubeTri)),
+	mac_yield()
+};
+
+/* ============================================================================
+ *  cube_g4_face — Draw one cube face (Gouraud-shaded quad) via the GTE tape pipeline
+ * ============================================================================
+ *  Reads 4 indices from R_FaceCur (V4_S2 = 8 bytes), loads 4 vertices into
+ *  the GTE, runs the PsyQ RotAverageNclip4 sequence, and renders a Poly_G4.
+ */
+internal 
+MipsAtom_(cube_g4_face) atom_info(
+		atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
+		atom_writes(R_PrimCursor, R_FaceCursor)
+){
+	load_half_u(R_T0, R_FaceCursor, 0 * S_(S2)),
+	load_half_u(R_T1, R_FaceCursor, 1 * S_(S2)),
+	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
+	load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)),
+
+	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
+	nop2, gte_cmdw_rotate_translate_perspective_triple,
+	nop2, gte_cmdw_nclip,
+
+	nop2,  gte_mv_from_data_r(R_T0, C2_MAC0),
+	nop,
+	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)), nop,
+
+	store_word(R_0, R_PrimCursor, O_(Poly_G4, tag)),
+	mac_format_g4_color(
+		/* c0 magenta */ 0xFF, 0x00, 0xFF,
+		/* c1 yellow  */ 0xFF, 0xFF, 0x00,
+		/* c2 cyan    */ 0x00, 0xFF, 0xFF,
+		/* c3 green   */ 0x00, 0xFF, 0x00),
+	mac_gte_store_g4_p012_post_rtpt_pre_rtps(),
+
+	shift_lleft(R_AT, R_T3, v3s2_byteoff), add_u(R_AT, R_AT, R_VertBase),
+	load_word(R_V0, R_AT, O_(V3_S2, x)),   load_word(R_V1, R_AT, O_(V3_S2, z)),
+	gte_mv_to_data_r(R_V0, C2_VXY0),       gte_mv_to_data_r(R_V1, C2_VZ0),
+
+	nop2, gte_cmdw_rotate_translate_perspective_single,
+	mac_gte_store_g4_p3_post_rtps(),
+
+	nop2, gte_cmdw_avg_sort_z4,
+	nop2, gte_mv_from_data_r(R_T1, C2_OTZ),
+
+	add_ui(      R_AT, R_0,  OrderingTbl_Len),
+	set_lt_u(    R_AT, R_T1, R_AT),
+	branch_equal(R_AT, R_0,  atom_offset(bounds_chk, cube_g4_face_exit)), nop,
+	mac_insert_ot_tag_g4(),
+
+atom_label(cube_g4_face_exit)
+	add_ui_self(R_PrimCursor, S_(Poly_G4)),     /* 9 words = Poly_G4 */
+	add_ui_self(R_FaceCursor, S_(S2) * 4),      /* 4 × S2 = 8 bytes */
+	mac_yield()
+};
+
+typedef Struct_(Binds_FloorTri) {
+	U4     PrimCursor;
+	V3_S2* FaceCursor;
+	V3_S2* VertBase;
+	U4*    OtBase;
+};
+internal 
+MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri)
+	, atom_reads(R_TapePtr)
+	, atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+){
+	/* Pop 4 arguments from the tape directly into the workspace registers */
+	load_word(R_PrimCursor, R_TapePtr, O_(Binds_FloorTri,PrimCursor)), 
+	load_word(R_FaceCursor, R_TapePtr, O_(Binds_FloorTri,FaceCursor)), 
+	load_word(R_VertBase,   R_TapePtr, O_(Binds_FloorTri,VertBase)), 
+	load_word(R_OtBase,     R_TapePtr, O_(Binds_FloorTri,OtBase)), 
+	add_ui_self(            R_TapePtr, S_(Binds_FloorTri)),
+	mac_yield()
+};
+
+internal 
+MipsAtom_(floor_f3_face) atom_info(
+	, atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
+	, atom_writes(R_PrimCursor, R_FaceCursor)
+) {
+	mac_load_tri_indices(  R_T0, R_T1, R_T2),
+	mac_gte_load_tri_verts(R_T0, R_T1, R_T2),
+	nop2, gte_cmdw_rotate_translate_perspective_triple,
+	nop2, gte_cmdw_nclip,
+ 
+	/* Culling (Branch forward if Backface) */
+	nop2, gte_mv_from_data_r(R_T0, C2_MAC0),
+	nop,
+	branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop,
+	/* Format Primitive */
+	mac_format_f3_color(0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
+	mac_gte_store_f3_post_rtpt(),
+	
+	/* Calculate Depth */
+	nop2, gte_avg_sort_z3,            
+	nop2, gte_mv_from_data_r(R_T1, C2_OTZ),      
+	/* Bounds Check OTZ < 2048 (Branch forward to skip insertion) */
+	add_ui(      R_AT, R_0,  OrderingTbl_Len),   
+	set_lt_u(    R_AT, R_T1, R_AT), 
+	branch_equal(R_AT, R_0,  atom_offset(bounds_chk, floor_f3_face_exit)), nop, 
+	/* Insert into Ordering Table Linked List */
+	mac_insert_ot_tag_f3(),
+	add_ui_self(R_PrimCursor, S_(Poly_F3)), /* Advance Prim Cursor (5 words) */
+		// Note(Ed): No bounds checking, should be checked before atom runs.
+
+/* Advance Input Cursor & Yield (Both branch targets land here) */
+atom_label(floor_f3_face_exit) 
+	add_ui_self(R_FaceCursor, S_(S2) * 4),  /* Advance Face Cursor (4 * S2 = 8 bytes) */
+	mac_yield()
+};
+
+typedef Struct_(Binds_SyncPrimitiveArena) { U4 used; U4 cursor; };
+internal MipsAtom_(sync_primitive_arena) atom_info(atom_bind(Binds_SyncPrimitiveArena)
+	, atom_reads( R_TapePtr, R_PrimCursor)
+	, atom_writes(R_TapePtr)
+){
+	load_word(R_AT, R_TapePtr, O_(Binds_SyncPrimitiveArena,used)),
+	load_word(R_T0, R_TapePtr, O_(Binds_SyncPrimitiveArena,cursor)),      
+	add_ui_self(    R_TapePtr, S_(Binds_SyncPrimitiveArena)),
+	/* Calculate byte offset and store directly back to RAM */
+	sub_u(     R_T0, R_PrimCursor, R_T0), // R_T0    = R_PrimCursor - binds.cursor
+	store_word(R_T0, R_AT, 0),            // R_AT[0] = R_T0
+	mac_yield()
+};
+
+#pragma endregion Baked Atoms

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/bin2exe.lua

@@ -7,123 +7,123 @@ Converts a raw binary file to PlayStation 1 (PS-X) executable format.
 ]]
 
 function file_size(filename)
-    local file = io.open(filename, "rb")
-    if not file then return nil end
-    local size = file:seek("end")
-    file:close()
-    return size
+	local file = io.open(filename, "rb")
+	if not file then return nil end
+	local size = file:seek("end")
+	file:close()
+	return size
 end
 
 function main(args)
-    if #args ~= 2 then
-        io.stderr:write(usage)
-        os.exit(1)
-    end
+	if #args ~= 2 then
+		io.stderr:write(usage)
+		os.exit(1)
+	end
 
-    -- print(string.format("Input file:  %s", args[1]))
-    -- print(string.format("Output file: %s", args[2]))
-    
-    -- PS1 executables have a maximum size limit of 2MB
-    local max_size = 0x200000
-    -- print(string.format("\nChecking input file size (max: %d bytes)...", max_size))
-    
-    local infile_size = file_size(args[1])
-    if not infile_size then
-        io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
-        os.exit(1)
-    end
-    
-    -- print(string.format("Input file size: %d bytes", infile_size))
-    
-    if infile_size > max_size then
-        io.stderr:write(string.format("Error: Input file %s longer than %d bytes\n", args[1], max_size))
-        os.exit(1)
-    end
+	-- print(string.format("Input file:  %s", args[1]))
+	-- print(string.format("Output file: %s", args[2]))
+	
+	-- PS1 executables have a maximum size limit of 2MB
+	local max_size = 0x200000
+	-- print(string.format("\nChecking input file size (max: %d bytes)...", max_size))
+	
+	local infile_size = file_size(args[1])
+	if not infile_size then
+		io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
+		os.exit(1)
+	end
+	
+	-- print(string.format("Input file size: %d bytes", infile_size))
+	
+	if infile_size > max_size then
+		io.stderr:write(string.format("Error: Input file %s longer than %d bytes\n", args[1], max_size))
+		os.exit(1)
+	end
 
-    -- print("\nOpening files...")
-    local ofile = io.open(args[2], "wb")
-    if not ofile then
-        io.stderr:write("Error: Cannot open output file " .. args[2] .. "\n")
-        os.exit(1)
-    end
-    
-    local ifile = io.open(args[1], "rb")
-    if not ifile then
-        io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
-        os.exit(1)
-    end
+	-- print("\nOpening files...")
+	local ofile = io.open(args[2], "wb")
+	if not ofile then
+		io.stderr:write("Error: Cannot open output file " .. args[2] .. "\n")
+		os.exit(1)
+	end
+	
+	local ifile = io.open(args[1], "rb")
+	if not ifile then
+		io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
+		os.exit(1)
+	end
 
-    -- PS1 executables start with "PS-X EXE" magic string
-    -- print("Writing PS-X executable header...")
-    ofile:write("PS-X EXE")
-    
-    -- Write entry point address (where the PS1 will jump to start execution)
-    -- 0x80010000 is a standard entry point in PS1 RAM
-    ofile:seek("set", 0x10)
-    ofile:write(string.pack("<I4", 0x80010000))
-    -- print("  Entry point:   0x80010000")
-    
-    -- Initial GP/R28 register value (Global Pointer for data addressing)
-    -- 0xFFFFFFFF means it will be set by crt0.S startup code
-    ofile:write(string.pack("<I4", 0xFFFFFFFF))
-    
-    -- Destination address in RAM where the executable will be loaded
-    ofile:write(string.pack("<I4", 0x80010000))
-    -- print("  Load address:  0x80010000")
-    
-    -- Initial stack pointer (SP/R29) and frame pointer (FP/R30)
-    -- 0x801FFF00 points near the top of the 2MB main RAM
-    ofile:seek("set", 0x30)
-    ofile:write(string.pack("<I4", 0x801FFF00))
-    -- print("  Stack pointer: 0x801FFF00")
-    
-    -- PS1 executables have an 0x800 (2048) byte header
-    -- Zero fill the rest of the header
-    ofile:seek("set", 0x800)
-    -- print("  Header padding complete (2048 bytes)")
+	-- PS1 executables start with "PS-X EXE" magic string
+	-- print("Writing PS-X executable header...")
+	ofile:write("PS-X EXE")
+	
+	-- Write entry point address (where the PS1 will jump to start execution)
+	-- 0x80010000 is a standard entry point in PS1 RAM
+	ofile:seek("set", 0x10)
+	ofile:write(string.pack("<I4", 0x80010000))
+	-- print("  Entry point:   0x80010000")
+	
+	-- Initial GP/R28 register value (Global Pointer for data addressing)
+	-- 0xFFFFFFFF means it will be set by crt0.S startup code
+	ofile:write(string.pack("<I4", 0xFFFFFFFF))
+	
+	-- Destination address in RAM where the executable will be loaded
+	ofile:write(string.pack("<I4", 0x80010000))
+	-- print("  Load address:  0x80010000")
+	
+	-- Initial stack pointer (SP/R29) and frame pointer (FP/R30)
+	-- 0x801FFF00 points near the top of the 2MB main RAM
+	ofile:seek("set", 0x30)
+	ofile:write(string.pack("<I4", 0x801FFF00))
+	-- print("  Stack pointer: 0x801FFF00")
+	
+	-- PS1 executables have an 0x800 (2048) byte header
+	-- Zero fill the rest of the header
+	ofile:seek("set", 0x800)
+	-- print("  Header padding complete (2048 bytes)")
 
-    -- Copy the actual program binary data after the header
-    -- print("\nCopying program data...")
-    local buffer_size = 0x2000  -- 8KB chunks for efficient copying
-    local bytes_copied = 0
-    
-    for i = 0, math.ceil(infile_size / buffer_size) - 1 do
-        local buffer = ifile:read(buffer_size)
-        if buffer then
-            ofile:write(buffer)
-            bytes_copied = bytes_copied + #buffer
-            -- Show progress every 64KB
-            if bytes_copied % 0x10000 == 0 or bytes_copied == infile_size then
-                print(string.format("  Copied %d/%d bytes (%.1f%%)", 
-                    bytes_copied, infile_size, (bytes_copied / infile_size) * 100))
-            end
-        end
-    end
+	-- Copy the actual program binary data after the header
+	-- print("\nCopying program data...")
+	local buffer_size = 0x2000  -- 8KB chunks for efficient copying
+	local bytes_copied = 0
+	
+	for i = 0, math.ceil(infile_size / buffer_size) - 1 do
+		local buffer = ifile:read(buffer_size)
+		if buffer then
+			ofile:write(buffer)
+			bytes_copied = bytes_copied + #buffer
+			-- Show progress every 64KB
+			if bytes_copied % 0x10000 == 0 or bytes_copied == infile_size then
+				print(string.format("  Copied %d/%d bytes (%.1f%%)", 
+					bytes_copied, infile_size, (bytes_copied / infile_size) * 100))
+			end
+		end
+	end
 
-    -- PS1 executables must be padded to 0x800 (2048) byte boundaries
-    print("\nAligning to 2048-byte boundary...")
-    local exe_size = ofile:seek()
-    if exe_size % 0x800 ~= 0 then
-        local padding = 0x800 - (exe_size % 0x800)
-        exe_size = exe_size + padding
-        ofile:seek("set", exe_size - 1)
-        ofile:write(string.pack("B", 0))
-        print(string.format("  Added %d bytes of padding", padding))
-    else
-        print("  No padding needed")
-    end
+	-- PS1 executables must be padded to 0x800 (2048) byte boundaries
+	print("\nAligning to 2048-byte boundary...")
+	local exe_size = ofile:seek()
+	if exe_size % 0x800 ~= 0 then
+		local padding = 0x800 - (exe_size % 0x800)
+		exe_size = exe_size + padding
+		ofile:seek("set", exe_size - 1)
+		ofile:write(string.pack("B", 0))
+		print(string.format("  Added %d bytes of padding", padding))
+	else
+		print("  No padding needed")
+	end
 
-    -- Write the size of the executable (excluding the 0x800 byte header)
-    -- This goes at offset 0x1C in the header
-    ofile:seek("set", 0x1C)
-    ofile:write(string.pack("<I4", exe_size - 0x800))
-    -- print(string.format("\nProgram size field set to: %d bytes", exe_size - 0x800))
+	-- Write the size of the executable (excluding the 0x800 byte header)
+	-- This goes at offset 0x1C in the header
+	ofile:seek("set", 0x1C)
+	ofile:write(string.pack("<I4", exe_size - 0x800))
+	-- print(string.format("\nProgram size field set to: %d bytes", exe_size - 0x800))
 
-    ifile:close()
-    ofile:close()
-    
-    -- print(string.format("\nSuccess! PS1 executable created: %s", args[2]))
-    print(string.format("Total file size: %d bytes\n", exe_size))
+	ifile:close()
+	ofile:close()
+	
+	-- print(string.format("\nSuccess! PS1 executable created: %s", args[2]))
+	print(string.format("Total file size: %d bytes\n", exe_size))
 end
 
 -- Run main with command line arguments

scripts/build_psyq.ps1

@@ -81,21 +81,34 @@ $path_psyq          = join-path $path_toolchain  'psyq-4_7'
 $path_psyq_iwyu     = join-path $path_toolchain  'psyq_iwyu'
 $path_psyq_imyu_inc = join-path $path_psyq_iwyu  'include'
 
-function assemble-unit { param( 
+function Get-SourceFiles { param([Parameter(Mandatory=$true)] [string[]]$paths, [Parameter(Mandatory=$true)] [string[]]$extensions)
+	$files = @()
+	foreach ($p in $paths) {
+		if (-not (test-path $p)) { continue }
+		foreach ($ext in $extensions) {
+			Get-ChildItem -Path $p -File -Recurse -Filter "*$ext" -ErrorAction SilentlyContinue | ForEach-Object {
+				$files += $_.FullName
+			}
+		}
+	}
+	return ($files | Sort-Object -Unique)
+}
+
+function assemble-unit { param(
 	[string]  $unit,
 	[string]  $link_module,
 	[string[]]$include_paths,
 	[string[]]$user_assemble_args
 )
 	$assemble_args = @(
-		$f_arch_mips1, 
-		$f_arch_abi32, 
+		$f_arch_mips1,
+		$f_arch_abi32,
 		$f_arch_fp32,
-		$f_arch_little_endian, 
+		$f_arch_little_endian,
 		$f_arch_no_abicalls,
-		$f_arch_no_pic, 
-		$f_arch_no_llsc, 
-		$f_arch_no_shared, 
+		$f_arch_no_pic,
+		$f_arch_no_llsc,
+		$f_arch_no_shared,
 		$f_arch_no_stack_prot
 	)
 	$assemble_args += $f_no_stdlib
@@ -130,14 +143,14 @@ function compile-unit { param(
 	$compile_args += $f_no_strict_alias
 	$compile_args += @(
 		$f_arch_mips1,
-		$f_arch_abi32, 
+		$f_arch_abi32,
 		$f_arch_fp32,
 		$f_arch_little_endian,
-		$f_arch_no_abicalls, 
-		$f_arch_no_gpopt,  
-		$f_arch_no_pic, 
-		$f_arch_no_llsc,  
-		$f_arch_no_shared, 
+		$f_arch_no_abicalls,
+		$f_arch_no_gpopt,
+		$f_arch_no_pic,
+		$f_arch_no_llsc,
+		$f_arch_no_shared,
 		$f_arch_no_stack_prot
 	)
 	# $compile_args    += $f_std_c23
@@ -154,11 +167,7 @@ function compile-unit { param(
 		& $Compiler $compile_args
     if ($LASTEXITCODE -ne 0) { write-error "Compilation failed for $unit. Aborting."; exit 1 }
 }
-function link-modules { param(
-	[string[]]$link_modules,
-	[string]  $elf,
-	[string[]]$user_link_args
-)
+function link-modules { param([string[]]$link_modules, [string]  $elf, [string[]]$user_link_args)
 	$link_args = @()
 
 	$link_args += $f_no_stdlib
@@ -185,19 +194,19 @@ function link-modules { param(
 
 	$link_args += ($f_link_pass_through_prefix + $f_link_start_group)
 	$libraries = @(
-		"api", 
-		"c", 
-		"c2", 
-		"card", 
-		"cd", 
-		"comb", 
-		"ds", 
-		"etc", 
-		"gpu", 
-		"gs", 
-		"gte", 
-		"gun", 
-		"hmd", 
+		"api",
+		"c",
+		"c2",
+		"card",
+		"cd",
+		"comb",
+		"ds",
+		"etc",
+		"gpu",
+		"gs",
+		"gte",
+		"gun",
+		"hmd",
 		"math",
 		"mcrd",
 		"mcx",
@@ -226,10 +235,7 @@ function link-modules { param(
 		& mipsel-none-elf-objdump.exe -W $elf >> $dasm
 	if ($LASTEXITCODE -ne 0) { write-error "Linking failed. Aborting."; exit 1 }
 }
-function make-binary { param(
-	[string]$elf,
-	[string]$exe
-)
+function make-binary { param([string]$elf, [string]$exe)
 	Write-Host "--- Creating Binary ---" -ForegroundColor Cyan
 	write-host "Converting $elf to PS-EXE -> '$exe'"
 	$objcopy_args = ($f_objcopy_format + "binary"), $elf, $exe
@@ -281,7 +287,7 @@ function build-graphis_hello {
 
 	$src_asm_crt    = join-path $path_nugget_common 'crt0/crt0.s'
 	$module_asm_crt = join-path $path_build         'crt0.o'
-	# assemble-unit $src_asm_crt $module_asm_crt $includes $assemble_args
+	assemble-unit $src_asm_crt $module_asm_crt $includes $assemble_args
 
 	$src_asm    = join-path $path_module 'hello_gpu.s'
 	$module_asm = join-path $path_build  'hello_gpu.o'
@@ -311,10 +317,33 @@ function build-graphis_hello {
 }
 # build-graphis_hello
 
+function ps1-meta { param(
+		[Parameter(Mandatory=$true)][string[]]$sources,
+		[Parameter(Mandatory=$true)][string]$metadata,
+		[string]$out_root = (join-path $path_build 'gen'),
+		[string[]]$passes = @('--all')
+	)
+	$script = join-path $path_scripts 'ps1_meta.lua'
+	write-host "ps1-meta  $($sources.Count) source(s), passes=$($passes -join ',')" ` -ForegroundColor Magenta
+	$arg_list = @($passes) + @('--metadata', $metadata) + @('--out-root', $out_root)
+	foreach ($s in $sources) { $arg_list += @('--source', $s) }
+	& luajit $script @arg_list
+	if ($LASTEXITCODE -ne 0) {
+		write-error "ps1-meta failed (exit $LASTEXITCODE). Aborting."
+		exit $LASTEXITCODE
+	}
+}
+
 function build-gte_hello {
 	$includes += @()
 
-	$path_module = join-path $path_code 'gte_hello'
+	$path_module        = join-path $path_code   'gte_hello'
+	$path_duffle        = join-path $path_code   'duffle'
+	$path_atom_metadata = join-path $path_duffle 'word_count.metadata.h'
+
+	$source_dirs  = @($path_duffle, $path_module)
+	$atom_sources = Get-SourceFiles -paths $source_dirs -extensions @('.h', '.c')
+	ps1-meta -sources $atom_sources -metadata $path_atom_metadata -out_root (join-path $path_build 'gen')
 
 	$assemble_args = @()
 	$assemble_args += $f_debug
@@ -323,7 +352,7 @@ function build-gte_hello {
 
 	$src_asm_crt    = join-path $path_nugget_common 'crt0/crt0.s'
 	$module_asm_crt = join-path $path_build         'crt0.o'
-	# assemble-unit $src_asm_crt $module_asm_crt $includes $assemble_args
+	assemble-unit $src_asm_crt $module_asm_crt $includes $assemble_args
 
 	# $src_asm    = join-path $path_module 'hello_gte.s'
 	# $module_asm = join-path $path_build  'hello_gte.o'
@@ -348,23 +377,25 @@ function build-gte_hello {
 	$link_args = @()
 	$link_args += $f_debug
 	# $link_args += $f_optimize_size
-	link-modules @($module_asm_crt, $module_c) $elf $link_args
+	$link_modules = @(
+		$module_asm_crt, 
+		$module_c
+	)
+	link-modules $link_modules $elf $link_args
 	make-binary $elf $exe
 }
 build-gte_hello
 
-function Send-ToEmulator { param(
-    [string]$exePath
-)
+
+# NO idea if this works yet...
+function Send-ToEmulator { param( [string]$exePath )
     $uri = "http://localhost:8080/api/v1/load-exec"
-    
+
     # Absolute path is safest for the emulator web server
     $absolutePath = [System.IO.Path]::GetFullPath($exePath)
-    
+
     # Create JSON payload pointing to your compiled .ps-exe
-    $body = @{
-        filename = $absolutePath
-    } | ConvertTo-Json
+    $body = @{ filename = $absolutePath } | ConvertTo-Json
 
     Write-Host "Pushing hot-reload to PCSX-Redux..." -ForegroundColor Magenta
     try {

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

@@ -0,0 +1,370 @@
+--- passes/annotation.lua — Atom-annotation DSL validator.
+---
+--- Validates `MipsAtom_(name) atom_info(atom_bind(Binds_X), atom_reads(...), atom_writes(...)) { ... }` declarations in source files.
+--- Also reads: `Binds_*` struct declarations (`typedef Struct_(Binds_X) { ... };`)
+---
+--- Source scanning: done ONCE upstream by `duffle.scan_source()` (ps1_meta.lua pre-scans each
+--- source and stashes the result in `src.scan`). This pass is pure: read from the scan, run
+--- checks, emit findings. No source re-walking.
+---
+--- Writes:
+---   - `<ctx.out_root>/<dir_basename>.errors.h` — one per module, with `#error` directives on findings (the C compile will surface the error)
+---   - The annotations.txt report is rendered by `passes/report.lua` from the per-module results stashed in `ctx.flags._annot_results`
+---
+--- **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")
+local write_file          = duffle.write_file
+local ensure_dir          = duffle.ensure_dir
+
+-- Domain tables (single source of truth in duffle.lua).
+local WAVE_CONTEXT_REGS = duffle.WAVE_CONTEXT_REGS
+local TAPE_ATOM_MACROS  = duffle.TAPE_ATOM_MACROS
+
+local function is_wave_context_reg(n) return WAVE_CONTEXT_REGS[n] ~= nil  end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+
+--- @class PassCtx
+--- @field sources            SourceFile[]
+--- @field metadata_path      string
+--- @field shared             table
+--- @field shared.word_counts table<string, integer>
+--- @field out_root           string
+--- @field project_root       string
+--- @field upstream           table<string, table>
+--- @field flags              table
+--- @field flags._annot_results table[]   -- stashed by annotation pass; consumed by report.lua
+--- @field dry_run            boolean
+--- @field verbose            boolean
+
+--- @class PassResult
+--- @field outputs  table[]
+--- @field errors   table[]
+--- @field warnings table[]
+
+--- @class AtomAnnotation
+--- @field line    integer       -- source line of the atom_info call
+--- @field macro   string        -- 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[]
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Validation
+-- ════════════════════════════════════════════════════════════════════════════
+--
+-- 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 scan = src.scan
+
+	-- Project the pre-scanned atoms to the AtomEntry shape this pass needs.
+	local atoms = {}
+	for _, a in ipairs(scan.atoms) do
+		if a.kind == "atom" 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(scan.binds) do binds_index[b.name] = b end
+
+	local errors   = {}
+	local warnings = {}
+	local info     = {}
+
+	-- 1. Every annotated atom must exist as a real MipsAtom_ declaration.
+	for _, a in ipairs(annots) do
+		if 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),
+			}
+		end
+		if a.errors then
+			for _, msg in ipairs(a.errors) do
+				errors[#errors + 1] = {line = a.line, msg = string.format("'%s': %s", a.name, msg)}
+			end
+		end
+	end
+
+	-- 2. Every atom may have AT MOST ONE annotation (no duplicates).
+	-- (Atoms with ZERO annotations are valid in the new minimal shape.)
+	local count_per_atom = {}
+	for _, a in ipairs(annots) do
+		if a.name then
+			count_per_atom[a.name] = (count_per_atom[a.name] or 0) + 1
+		end
+	end
+	for name, n in pairs(count_per_atom) do
+		if n > 1 then
+			errors[#errors + 1] = {
+				line = atom_index[name] and atom_index[name].line or 0,
+				msg  = string.format("MipsAtom_(%s) has %d annotations (expected at most 1)", name, n),
+			}
+		end
+	end
+
+	-- 3. (Phase validity check DROPPED. Phases were removed from the annotation DSL.)
+
+	-- 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
+				-- 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 (also flagged as an error by check_abi_handoff in the static-analysis pass)", a.name, a.binds, a.binds),
+				}
+			end
+		end
+	end
+
+	-- 5. BIND writes must be wave-context registers that match Binds_ fields.
+	for _, a in ipairs(annots) do
+		if a.binds and binds_index[a.binds] then
+			local bs = binds_index[a.binds]
+
+			for _, f in ipairs(bs.fields) do
+				local candidate = "R_" .. f.name
+				if not is_wave_context_reg(candidate) then
+					warnings[#warnings + 1] = {
+						line = bs.line,
+						msg  = string.format("%s field '%s' doesn't match a known wave-context register (candidate '%s')", a.binds, f.name, candidate),
+					}
+				end
+			end
+
+			for _, w in ipairs(a.writes) do
+				if not is_wave_context_reg(w) then
+					warnings[#warnings + 1] = {
+						line = a.line,
+						msg  = string.format("%s writes '%s' which is not a known wave-context register", a.name, w),
+					}
+				end
+			end
+		end
+	end
+
+	-- 6. INFO reads should be wave-context registers (or R_TapePtr for rbind).
+	for _, a in ipairs(annots) do
+		for _, r in ipairs(a.reads) do
+			if not is_wave_context_reg(r) and r ~= "R_TapePtr" then
+				warnings[#warnings + 1] = {
+					line = a.line,
+					msg  = string.format("atom '%s' reads '%s' which is not a known wave-context register", a.name, r),
+				}
+			end
+		end
+	end
+
+	-- 7. TAPE_WORDS(mac_X, N) ↔ WORD_COUNT(mac_X, N) drift.
+	--    Three outcomes: missing (error), mismatch (error), match (info).
+	local function check_macro_drift(m, declared)
+		if not declared then
+			errors[#errors + 1] = {
+				line = m.line,
+				msg  = string.format("TAPE_WORDS(%s, %d) but '%s' is not in metadata.h", m.name, m.words, m.name),
+			}
+			return
+		end
+		if declared ~= m.words then
+			errors[#errors + 1] = {
+				line = m.line,
+				msg  = string.format("DRIFT: TAPE_WORDS(%s, %d) but metadata.h declares WORD_COUNT(%s, %d)", m.name, m.words, m.name, declared),
+			}
+			return
+		end
+		info[#info + 1] = {
+			line = m.line,
+			msg  = string.format("OK: %s = %d words", m.name, m.words),
+		}
+	end
+	for _, m in ipairs(scan.macros) do
+		check_macro_drift(m, ctx.shared.word_counts[m.name])
+	end
+
+	-- 8. 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, #scan.macros, #scan.binds),
+	}
+
+	return {
+		atoms    = atoms,
+		annots   = annots,
+		macros   = scan.macros,
+		binds    = scan.binds,
+		errors   = errors,
+		warnings = warnings,
+		info     = info,
+	}
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-DIRECTORY (per-module) output: errors.h + annotations.txt
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Render `<dir_basename>.errors.h` with `#error` directives for every error found across all sources in the directory.
+--- Empty directories (no errors, no atoms) produce no file.
+local function emit_module_errors_h(ctx, dir_basename, atoms_count, errors, sources)
+	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",
+		"",
+	}
+	if #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
+	ensure_dir(ctx.out_root)
+	write_file(out_path, table.concat(lines, "\n") .. "\n")
+	return out_path
+end
+
+--- Stash aggregated per-module results for the report pass to consume.
+local function emit_module_annotations_stub(ctx, dir, dir_basename, atoms_count)
+	ctx.flags         = ctx.flags or {}
+	ctx.flags._annot_results = ctx.flags._annot_results or {}
+	ctx.flags._annot_results[#ctx.flags._annot_results + 1] = {
+		dir          = dir,
+		dir_basename = dir_basename,
+		atoms_count  = atoms_count,
+	}
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M.run — orchestrator entry
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class M
+
+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)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	-- Per-DIRECTORY (per-module) aggregation. Group sources by `src.dir`,
+	-- validate every source in the dir, then emit ONE errors.h per dir.
+	-- `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
+
+		emit_module_annotations_stub(ctx, dir, dir_basename, dir_atoms)
+	end
+
+	return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/components.lua

@@ -0,0 +1,710 @@
+--- passes/components.lua — Component-macro header generator.
+---
+--- Reads the pre-scanned SourceScan payload (produced once upstream by `duffle.scan_source`)
+--- for `MipsAtomComp_(ac_X)` and `MipsAtomComp_Proc_(ac_X, { body })` declarations, then does
+--- per-source backward lookups for the function-args string (from the preceding `FI_ MipsAtom ac_X(...)`
+--- function declaration) and the preceding comment block (for LSP/IntelliSense signature docs).
+---
+--- Emits a per-directory `<dir_basename>.macs.h` containing one `#define mac_X(sig) \` macro per component
+--- + `WORD_COUNT(mac_X, N)` entries for downstream offset computation.
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+--- @class Component
+--- @field name    string
+--- @field body    string
+--- @field args    string|nil
+--- @field line    integer
+--- @field comment string|nil
+
+--- @class M
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module-scope requires + package.path setup
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- 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")
+local word_count_eval = require("word_count_eval")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Atom component declaration identifiers.
+local ATOM_COMP_PROC  = "MipsAtomComp_Proc_"
+local MIPS_ATOM       = "MipsAtom"  -- prefix on the function declaration that wraps an AtomComp_Proc_
+
+-- Component-name prefixes.
+local AC_PREFIX       = "ac_"        -- arg to MipsAtomComp_(ac_X); the X is the atom name
+local AC_PREFIX_LEN   = 3
+local MAC_PREFIX      = "mac_"       -- prefix on generated macros; the rest is the atom name
+local MAC_PREFIX_LEN  = 4
+
+-- ASCII byte values used in tokenization.
+local BYTE_NEWLINE    = 10
+local BYTE_SLASH      = 47
+
+-- Source dir basename used as the output `.macs.h` filename.
+local GEN_SUBDIR      = "gen"
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+
+--- @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<string, integer> -- populated by word-counts + components
+--- @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 Component
+--- @field name    string        -- atom name (without `ac_` prefix)
+--- @field body    string        -- brace-delimited body (without the braces)
+--- @field args    string|nil    -- function-args string (function form only)
+--- @field line    integer       -- source line of the declaration
+--- @field comment string|nil    -- preceding `/* */` or `//` comment block (signature doc)
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Local helpers (file I/O + path normalization)
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Function-args extraction (precedes MipsAtomComp_Proc_ invocations)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Find the LAST occurrence of `name + "("` in `source[1..before_pos]`.
+-- Returns the position of the open paren, or nil if not found.
+-- @param source string
+-- @param name string
+-- @param before_pos integer
+-- @return integer|nil
+local function find_last_name_open_paren(source, name, before_pos)
+	local search     = source:sub(1, before_pos)
+	local name_open  = name .. "("
+	local last_idx   = nil
+	local scan_pos   = 1
+	while true do
+		local found = search:find(name_open, scan_pos, true)  -- plain (no regex)
+		if not found then break end
+		last_idx = found
+		scan_pos = found + #name_open
+	end
+	return last_idx
+end
+
+--- Find the args of the function declaration that immediately precedes a `MipsAtomComp_Proc_` invocation of the given name.
+--- Returns the args string (e.g., `"U4 off, U4 code, U1 r, U1 g, U1 b"`) or nil if no function declaration is found.
+---
+--- Convention: function form is
+---   `FI_ MipsAtom ac_X(args) MipsAtomComp_Proc_(ac_X, { body })`
+--- We find the LAST occurrence of `"ac_X("` before `before_pos` and extract the args from inside the parens.
+--- We then verify the preceding context ends with `MipsAtom` (the function-decl keyword
+--- with possible qualifiers between).
+---
+--- @param source string
+--- @param name string
+--- @param before_pos integer
+--- @return string|nil
+local function find_function_args_for(source, name, before_pos)
+	local last_idx = find_last_name_open_paren(source, name, before_pos)
+	if not last_idx then return nil end
+
+	-- Verify the preceding context ends with "MipsAtom" (with possible qualifiers between).
+	local before   = source:sub(1, last_idx - 1)
+	local trimmed  = duffle.trim(before)
+	if trimmed:sub(-#MIPS_ATOM) ~= MIPS_ATOM then
+		-- Preceding context is not a function declaration.
+		return nil
+	end
+
+	local open_paren = last_idx + #name  -- position of "("
+	-- scan: MipsAtom ac_X(
+	local inner      = duffle.read_parens(source, open_paren)
+	-- scan: MipsAtom ac_X(<args>)
+	if not inner then return nil end
+	return inner
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Preceding-comment-block extraction
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Skip whitespace (space/tab/newline/CR) backward from `pos`, returning the position of the first non-whitespace char.
+-- @param source string
+-- @param pos integer
+-- @return integer
+local function skip_ws_backward(source, pos)
+	local back = pos - 1
+	while back > 0 do
+		local ch = source:sub(back, back)
+		if ch == " " or ch == "\t" or ch == "\n" or ch == "\r" then
+			back = back - 1
+		else
+			break
+		end
+	end
+	return back
+end
+
+-- Find the opening `/*` for a block comment whose `*/` ends at `close_pos`.
+-- Returns the position of `/`, or nil if not found.
+-- @param source string
+-- @param close_pos integer  -- position of the closing `*` of `*/`
+-- @return integer|nil
+local function find_block_comment_open(source, close_pos)
+	local prefix  = source:sub(1, close_pos - 1)
+	local open_at = nil
+	for scan = #prefix - 1, 1, -1 do
+		if prefix:sub(scan, scan + 1) == "/*" then
+			open_at = scan
+			break
+		end
+	end
+	return open_at
+end
+
+-- Walk back from `open_at` over leading spaces + tabs to include the indentation before the `/*` in the captured comment.
+-- @param source string
+-- @param open_at integer
+-- @return integer
+local function extend_left_over_indent(source, open_at)
+	local start = open_at
+	while start > 1 do
+		local ch = source:sub(start - 1, start - 1)
+		if ch == " " or ch == "\t" then
+			start = start - 1
+		else
+			break
+		end
+	end
+	return start
+end
+
+-- Walk back from `line_end` to the start of the source line (the most recent `\n` or position 1).
+-- @param source string
+-- @param line_end integer
+-- @return integer
+local function find_line_start(source, line_end)
+	local start = line_end
+	while start > 1 and source:sub(start - 1, start - 1) ~= "\n" do
+		start = start - 1
+	end
+	return start
+end
+
+-- (internal) Capture one `/* ... */` block comment whose closing `*/`
+-- ends at `close_end_pos`. Returns (block_text, new_scan_pos) where `new_scan_pos`
+-- is where to continue scanning for more comments, or nil if no block comment was found.
+local function capture_block_comment(source, close_end_pos)
+	local open_at = find_block_comment_open(source, close_end_pos)
+	if not open_at then return nil end
+	local block_start = extend_left_over_indent(source, open_at)
+	return source:sub(block_start, close_end_pos), block_start
+end
+
+-- (internal) Capture one `// ...` line comment ending at `line_end_pos`.
+-- Returns (comment_text, new_scan_pos) or nil if the line is not a `//` comment.
+local function capture_line_comment(source, line_end_pos)
+	local line_start = find_line_start(source, line_end_pos)
+	local line       = source:sub(line_start, line_end_pos)
+	if line:sub(1, 2) == "//" then
+		return line, line_start - 1
+	end
+	return nil
+end
+
+--- Find the contiguous comment block immediately preceding `pos` in `source`.
+--- Returns the comment text (with the `/* */` or `//` markers preserved) or an empty string if no comment is adjacent.
+---
+--- Used to copy signature comments from the source declaration (`MipsAtomComp_` / `MipsAtomComp_Proc_` / function decl)
+--- over to the generated `mac_X` macro, so LSP/IntelliSense displays the args doc.
+---
+--- @param source string
+--- @param pos integer
+--- @return string
+local function preceding_comment_block(source, pos)
+	local scan_pos = pos
+	local pieces   = {}
+	while true do
+		local non_ws = skip_ws_backward(source, scan_pos)
+		if non_ws == 0 then break end
+
+		local is_block_close = non_ws >= 2 and source:sub(non_ws - 1, non_ws) == "*/"
+		local is_line_end    = source:sub(non_ws, non_ws) == "\n" or source:sub(non_ws, non_ws) == "\r"
+
+		if is_block_close then
+			local block_text, new_scan_pos = capture_block_comment(source, non_ws)
+			if not block_text then break end
+			table.insert(pieces, 1, block_text)
+			scan_pos = new_scan_pos
+		elseif is_line_end then
+			local line_text, new_scan_pos = capture_line_comment(source, non_ws)
+			if not line_text then break end
+			table.insert(pieces, 1, line_text)
+			scan_pos = new_scan_pos
+		else
+			break
+		end
+	end
+	if #pieces == 0 then return "" end
+	return table.concat(pieces, "\n")
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Argument-name extraction
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Walk `trimmed` backward from `pos` over trailing whitespace / asterisks / brackets, returning the position of the first
+-- non-trailer character (i.e. the end of the identifier).
+-- @param trimmed string
+-- @param pos integer
+-- @return integer
+local function trim_trailer_back(trimmed, pos)
+	local back = pos
+	while back > 0 do
+		local ch = trimmed:sub(back, back)
+		if ch == " " or ch == "\t" or ch == "*" or ch == "]" or ch == "[" then
+			back = back - 1
+		else
+			break
+		end
+	end
+	return back
+end
+
+-- Walk `trimmed` backward from `pos` over identifier chars (alnum + `_`),
+-- returning the position just before the identifier starts.
+-- @param trimmed string
+-- @param pos integer
+-- @return integer
+local function trim_ident_back(trimmed, pos)
+	local back = pos
+	while back > 0 do
+		local ch = trimmed:sub(back, back)
+		if duffle.is_alnum(ch) or ch == "_" then
+			back = back - 1
+		else
+			break
+		end
+	end
+	return back
+end
+
+--- Extract just the parameter NAMES from a function-args string (stripping type annotations). E.g.,
+---   `"U4 off, U4 code, U1 r, U1 g, U1 b"`  ->  `{"off", "code", "r", "g", "b"}`
+---   `"U4 *ptr"`                            ->  `{"ptr"}`
+---   `""`                                   ->  nil
+---
+--- No regex — uses `duffle.is_alnum` + plain string ops.
+---
+--- @param args_str string|nil
+--- @return string[]|nil
+local function extract_arg_names(args_str)
+	if not args_str or args_str == "" then return nil end
+	local names  = {}
+	local tokens = duffle.split_top_level_commas(args_str)
+	for _, tok in ipairs(tokens) do
+		local trimmed = duffle.trim(tok)
+		if trimmed ~= "" then
+			local ident_end = trim_trailer_back(trimmed, #trimmed)
+			local ident_start = trim_ident_back(trimmed, ident_end) + 1
+			local name = trimmed:sub(ident_start, ident_end)
+			if name ~= "" then names[#names + 1] = name end
+		end
+	end
+	if #names == 0 then return nil end
+	return names
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Component projection (read from pre-scanned SourceScan)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Project pre-scanned MipsAtomComp_ / MipsAtomComp_Proc_ entries into Component shape.
+-- Does per-source backward lookups for args (preceding function decl) and comment (preceding comment block).
+-- Carries `body_tokens` forward from scan-source so word_count_rec reads from the precomputed table
+-- instead of calling duffle.tokenize_body again.
+-- @param source string  -- the full source text (needed for backward lookups)
+-- @param scan  table   -- SourceScan from duffle.scan_source
+-- @return Component[]
+local function project_components(source, scan)
+	local out = {}
+	for _, a in ipairs(scan.atoms) do
+		if a.kind == "comp_bare" or a.kind == "comp_proc" then
+			local args    = find_function_args_for(source, a.raw_name, a.ident_pos)
+			local comment = preceding_comment_block(source, a.ident_pos)
+			out[#out + 1] = {
+				line        = a.line,
+				name        = a.name,
+				body        = a.body,
+				body_tokens = a.body_tokens,
+				args        = args,
+				comment     = comment,
+			}
+		end
+	end
+	return out
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Line-comment → block-comment conversion
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Convert `//` line comments to `/* */` block comments in a token.
+--
+-- C macros use `\` line-continuations; a `//` comment before `\` would consume the continuation,
+-- breaking the macro. We convert `//` to `/* */` so the multi-line macro structure is preserved.
+--
+-- Skips `//` sequences that are inside string or character literals
+-- (a rough heuristic — sufficient for component bodies which don't have those constructs).
+--
+--- @param s string
+--- @return string
+local function convert_line_comments_to_block(s)
+	local result = s
+	local pos    = 1
+	local len    = #result
+	while pos <= len do
+		local is_double_slash = result:byte(pos) == BYTE_SLASH
+			and pos + 1 <= len and result:byte(pos + 1) == BYTE_SLASH
+		if not is_double_slash then
+			pos = pos + 1
+		else
+			-- Find end of line.
+			local eol = pos
+			while eol <= len and result:byte(eol) ~= BYTE_NEWLINE do
+				eol = eol + 1
+			end
+			local before   = result:sub(1, pos - 1)
+			local comment  = result:sub(pos + 2, eol - 1)  -- skip the `//`
+			local after
+			if eol <= len and result:byte(eol) == BYTE_NEWLINE then
+				after = " */" .. result:sub(eol)  -- keep the newline
+			else
+				after = " */"
+			end
+			result = before .. "/*" .. comment .. after
+			pos = #before + 2 + #comment + 3  -- skip past converted comment
+		end
+	end
+	return result
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Word-count computation (memoized recursive lookup)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Strip the `mac_` prefix from a component-call ident so we can look it up against the components-by-name table. Returns the ident unchanged
+-- if it doesn't start with the prefix (so a non-component ident like `mask_upper` falls through to the wc-table branch).
+-- @param ident string|nil
+-- @return string|nil
+local function strip_mac_prefix(ident)
+	if not ident then return nil end
+	if ident:sub(1, MAC_PREFIX_LEN) == MAC_PREFIX then
+		return ident:sub(MAC_PREFIX_LEN + 1)
+	end
+	return ident
+end
+
+-- (internal) Recursive word-count lookup. `cache` is the memoization table shared across all components
+-- in a single source's `count_all_components` pass; the in-progress -1 sentinel detects cycles (A -> B -> A).
+-- @param name string -- the component name (without `mac_`)
+-- @param comp_by_name table<string, Component>
+-- @param wc table<string, integer>
+-- @param cache table<string, integer>
+-- @return integer
+local function word_count_rec(name, comp_by_name, wc, cache)
+	if cache[name] ~= nil then return cache[name] end
+	cache[name] = -1  -- mark in-progress (cycle detection)
+	local cc = comp_by_name[name]
+	local n
+	if cc then
+		n = 0
+		local tokens = cc.body_tokens
+		for _, t in ipairs(tokens) do
+			local trimmed = t.tok
+			if trimmed ~= "" then
+				local lookup = strip_mac_prefix(duffle.read_ident(trimmed, 1))
+				if lookup and comp_by_name[lookup] then
+					-- It's a `mac_X(...)` call. Recurse.
+					n = n + word_count_rec(lookup, comp_by_name, wc, cache)
+				elseif lookup and wc and wc[lookup] then
+					-- Encoding macro or pseudo-instruction (e.g. mask_upper = 2, nop2 = 2).
+					n = n + wc[lookup]
+				else
+					-- Unrecognized token. Fall back to 1 word.
+					n = n + 1
+				end
+			end
+		end
+	else
+		-- Not a known component: assume 1 word (regular instruction).
+		n = 1
+	end
+	cache[name] = n
+	return n
+end
+
+--- Compute word counts for every component in `components` in a single pass.
+--- The name-lookup table + memoization cache are built ONCE (per source) instead of per-component,
+--- so the cache survives across siblings and a component's recursive `mac_Y(...)` references hit memoized values
+--- instead of re-walking the body. Previously each call rebuilt both tables (O(N) tables per call → O(N^2)).
+---
+--- Cycle detection (A -> B -> A) is preserved via the in-progress `-1` sentinel in `cache`.
+---
+--- @param components Component[]
+--- @param wc table<string, integer>
+--- @return table<string, integer>  -- map of component name (without `mac_`) -> word count
+local function count_all_components(components, wc)
+	local comp_by_name = {}
+	for _, cc in ipairs(components) do comp_by_name[cc.name] = cc end
+	local cache        = {}
+	local counts       = {}
+	for _, c in ipairs(components) do
+		counts[c.name] = word_count_rec(c.name, comp_by_name, wc, cache)
+	end
+	return counts
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-component emit logic
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Split a (possibly multi-line) comment into per-line entries.
+--- Hand-rolled (no regex patterns used).
+--- @param s string
+--- @return string[]
+local function split_comment_lines(s)
+	local out  = {}
+	local pos  = 1
+	local s_len = #s
+	while pos <= s_len do
+		local nl = s:find("\n", pos, true)
+		if not nl then
+			out[#out + 1] = s:sub(pos)
+			break
+		end
+		out[#out + 1] = s:sub(pos, nl - 1)
+		pos = nl + 1
+	end
+	return out
+end
+
+--- Split an atom body by top-level commas; drop empty tokens.
+--- @param body string
+--- @return string[]
+local function tokens_from_body(body)
+	return duffle.tokenize_body_simple(body)
+end
+
+--- Determine the macro signature: function-args list (function form) or variadic-ignored (bare form).
+--- @param args_str string|nil
+--- @return string
+local function signature_from_args(args_str)
+	local arg_names = extract_arg_names(args_str)
+	if arg_names and #arg_names > 0 then
+		return table.concat(arg_names, ", ")
+	end
+	return "..."
+end
+
+--- Strip the trailing `" \"` (space + backslash) line continuation from the last body line.
+--- The last 2 chars are always that pair.
+local function strip_trailing_continuation(lines)
+	local last = lines[#lines]
+	if last:sub(-2) == " \\" then
+		lines[#lines] = last:sub(1, -3)
+	end
+end
+
+--- Emit the `#define mac_X(sig) \<newline>\t<tok1> \<newline>,\t<tok2> ...` block.
+--- Converts `//` line comments to `/* */` block comments in each token so they don't break the C macro `\` line continuations.
+local function emit_macro_body(lines, c, sig, tokens)
+	for tok_idx = 1, #tokens do
+		tokens[tok_idx] = convert_line_comments_to_block(tokens[tok_idx])
+	end
+	lines[#lines + 1] = "#define mac_" .. c.name .. "(" .. sig .. ") \\"
+	lines[#lines + 1] = "\t" .. tokens[1] .. " \\"
+	for tok_idx = 2, #tokens do
+		lines[#lines + 1] = ",\t" .. tokens[tok_idx] .. " \\"
+	end
+	strip_trailing_continuation(lines)
+end
+
+--- Build the list of lines for one component
+--- (signature comment, `#define mac_X(...)` line with backslash-continued tokens, then `WORD_COUNT(mac_X, N)` entry).
+--- @param c Component
+--- @param components Component[]
+--- @param wc table<string, integer>
+--- @return string[]  -- list of lines for this component
+local function build_component_lines(c, counts)
+	local lines = {}
+
+	if c.comment and c.comment ~= "" then
+		for _, line in ipairs(split_comment_lines(c.comment)) do
+			lines[#lines + 1] = line
+		end
+	end
+
+	local tokens = tokens_from_body(c.body)
+	local sig    = signature_from_args(c.args)
+	-- Direct lookup against the per-source precomputed `counts` table (built once by count_all_components).
+	local n      = counts[c.name]
+
+	if n > 0 then
+		emit_macro_body(lines, c, sig, tokens)
+	end
+
+	-- Emit the WORD_COUNT(mac_<X>, N) entry.
+	lines[#lines + 1] = "WORD_COUNT(mac_" .. c.name .. ", " .. n .. ")"
+	lines[#lines + 1] = ""
+
+	return lines
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Per-source emit logic
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Build the boilerplate header lines (the `#ifdef INTELLISENSE_DIRECTIVES` block,
+-- the `// Auto-generated` comment, the `// Source:` line, and the self-contained `WORD_COUNT` macro definition).
+-- @param src SourceFile
+-- @return string[]
+local function header_boilerplate(src)
+	return {
+		-- #pragma once wrapped in #ifdef INTELLISENSE_DIRECTIVES, matching the convention in lottes_tape.h.
+		-- The build does manual unity includes (the user controls include order), so the pragma is only active for IDE/tooling.
+		"#ifdef INTELLISENSE_DIRECTIVES",
+		"#pragma once",
+		"#endif",
+		"// Auto-generated by ps1_meta.lua — DO NOT EDIT",
+		"// Source: " .. duffle.to_absolute_path(src.path),
+		"// Component atoms (MipsAtomComp_(ac_*)) -> macro variants (mac_*)",
+		"",
+		-- Self-contained: define WORD_COUNT if not already defined.
+		-- We use the same definition here so the auto-generated entries below expand to compile-time constants whether
+		-- the metadata file is included first or not.
+		"#ifndef WORD_COUNT",
+		"#define WORD_COUNT(name, count)  enum { words_##name = (count) };",
+		"#endif",
+		"",
+	}
+end
+
+-- Compute the output path for one source's `.macs.h` file.
+-- The pre-rework convention uses the *directory* basename
+-- (not the source file basename) — e.g. `code/duffle/lottes_tape.h` produces `code/duffle/gen/duffle.macs.h`.
+-- This matches what the C codebase #includes.
+-- @param src SourceFile
+-- @return string  -- the output directory
+-- @return string  -- the full output path
+local function compute_macs_h_path(src)
+	local out_dir  = src.dir .. "/" .. GEN_SUBDIR
+	local out_path = out_dir .. "/" .. duffle.basename_no_ext(src.dir) .. ".macs.h"
+	return out_dir, out_path
+end
+
+--- Emit a per-source `.macs.h` header with the `mac_X` macros + `WORD_COUNT` entries. Writes in BINARY mode so LF line endings are
+--- preserved (the git blob is LF; Windows text-mode would emit CRLF and break the byte-identical diff).
+---
+--- Honors `ctx.dry_run`: prints the intended path but does not write the file.
+---
+--- @param ctx PassCtx
+--- @param src SourceFile
+--- @param components Component[]
+--- @param counts table<string, integer>  -- precomputed word counts (from count_all_components)
+--- @return string|nil  -- path to the written file (nil if no components)
+local function emit_component_macros_h(ctx, src, components, counts)
+	if #components == 0 then return nil end
+
+	local out_dir, out_path = compute_macs_h_path(src)
+	local lines             = header_boilerplate(src)
+
+	for _, c in ipairs(components) do
+		for _, l in ipairs(build_component_lines(c, counts)) do
+			lines[#lines + 1] = l
+		end
+	end
+
+	local content = table.concat(lines, "\n") .. "\n"
+
+	if ctx.dry_run then
+		print(string.format("  -> %s (dry-run)", out_path))
+		return out_path
+	end
+
+	duffle.ensure_dir(out_dir)
+	duffle.write_file_lf(out_path, content)
+	print(string.format("  -> %s", out_path))
+	return out_path
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Pass entry
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- (internal) Extend `ctx.shared.word_counts` with this source's component macros
+-- so offsets sees them without re-reading the file.
+-- @param ctx PassCtx
+-- @param components Component[]
+-- @param counts table<string, integer>  -- precomputed word counts (from count_all_components)
+local function update_shared_word_counts(ctx, components, counts)
+	local wc = ctx.shared.word_counts
+	for _, c in ipairs(components) do
+		wc["mac_" .. c.name] = counts[c.name]
+	end
+end
+
+--- @param ctx PassCtx
+--- @return PassResult
+function M.run(ctx)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	for _, src in ipairs(ctx.sources) do
+		-- project_components reads from src.scan + does backward lookups on src.text
+		local components = project_components(src.text, src.scan)
+		if #components > 0 then
+			-- Compute word counts for ALL components once (was: rebuilt per call inside the helpers).
+			local counts = count_all_components(components, ctx.shared.word_counts)
+			local macs_path = emit_component_macros_h(ctx, src, components, counts)
+			if macs_path then
+				outputs[#outputs + 1] = { macs_h = macs_path }
+				update_shared_word_counts(ctx, components, counts)
+			end
+		end
+	end
+
+	return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/offsets.lua

@@ -0,0 +1,380 @@
+--- passes/offsets.lua — Branch-offset generator.
+---
+--- Reads the pre-scanned SourceScan payload (produced once upstream by `duffle.scan_source`)
+--- for `MipsAtom_(name)` and `MipsCode code_<name>` declarations, computes the word offset
+--- from each `atom_offset(F, T)` marker to its target `atom_label(T)` declaration, and emits
+--- `<dir_basename>.offsets.h` with one `#define _atom_offset_F_T = N` per branch.
+---
+--- The offset is `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding: branch_offset = relative_pc_in_words - 1).
+---
+--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex,
+--- Lua 5.3 compatible.
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Module-scope requires + package.path setup
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- 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")
+local word_count_eval = require("word_count_eval")
+local count_token_words = word_count_eval.count_token_words
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Marker-call identifiers inside atom bodies.
+local LABEL_MARKER    = "atom_label"
+local OFFSET_MARKER   = "atom_offset"
+
+-- Offset macro/enum naming prefixes (the emitted header uses these).
+local OFFSET_MACRO_PREFIX = "_atom_offset_"
+local OFFSET_ENUM_PREFIX  = "atom_offset_"
+
+-- Column width for the `#define _atom_offset_F_T = N` alignment.
+local OFFSET_MACRO_COL = 44
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Type declarations
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- @class SourceFile
+--- @field path     string  -- absolute path to the source file
+--- @field text     string  -- the full source text
+--- @field dir      string  -- the directory containing the source
+--- @field basename string  -- filename without extension
+--- @field scan     table   -- pre-scanned SourceScan payload (from duffle.scan_source)
+
+--- @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 = duffle.skip_ws_and_cmt(token, after_ident)
+	if token:sub(arg_start, arg_start) ~= "(" then return {}, nil end
+	local inner, after_paren = duffle.read_parens(token, arg_start)
+	-- scan: <marker>(<args>)
+
+	local args      = {}
+	local pos       = 1
+	local inner_len = #inner
+	while pos <= inner_len do
+		pos = duffle.skip_ws_and_cmt(inner, pos)
+		if pos > inner_len then break end
+		local ident, after = duffle.read_ident(inner, pos)
+		if ident and ident ~= "" then
+			table.insert(args, ident)
+			pos = after
+		else
+			pos = pos + 1
+		end
+		pos = duffle.skip_ws_and_cmt(inner, pos)
+		if pos <= inner_len and inner:sub(pos, pos) == "," then pos = pos + 1 end
+	end
+
+	return args, after_paren
+end
+
+-- (internal) Record a `atom_label(name)` marker — `at_pos` is the branch-free word position within the atom body.
+-- @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 pos     = 1
+	local tok_len = #token
+	while pos <= tok_len do
+		pos = duffle.skip_ws_and_cmt(token, pos)
+		if pos > tok_len then break end
+		local ch = token:sub(pos, pos)
+		if duffle.is_alpha(ch) then
+			local ident, after = duffle.read_ident(token, pos)
+			if ident == LABEL_MARKER then
+				local args, after_paren = extract_ident_args(token, after)
+				record_label_marker(labels, args, at_pos)
+				pos = after_paren or after
+			elseif ident == OFFSET_MARKER then
+				local args, after_paren = extract_ident_args(token, after)
+				record_offset_marker(branches, args, at_pos)
+				pos = after_paren or after
+			else
+				pos = after
+			end
+		else
+			local nx = duffle.skip_str_or_cmt(token, pos)
+			pos = (nx > pos) and nx or (pos + 1)
+		end
+	end
+end
+
+-- (internal) Count words emitted by the rest of `tok` after a marker call
+-- (the marker call itself emits 0 words, but the source pattern may bundle the marker with the next instruction on the same line,
+-- separated by no top-level comma).
+-- Returns the word count contributed by that rest.
+-- @param tok string
+-- @param word_counts table
+-- @return integer
+local function count_marker_rest(tok, word_counts)
+	-- duffle.find_marker_call_end returns the position PAST the closing `)` of the marker call
+	-- (or nil if `tok` isn't a marker call). Canonical impl in duffle.lua is faster than the
+	-- file-local copy that used to live here (byte-indexed, no `tok:sub` per char).
+	local marker_end = duffle.find_marker_call_end(tok)
+	if not marker_end or marker_end >= #tok then return 0 end
+	local rest = duffle.trim(tok:sub(marker_end))
+	if rest == "" then return 0 end
+	return count_token_words(rest, word_counts)
+end
+
+-- (internal) Is this token a marker call (`atom_label` or `atom_offset`)?
+-- @param tok string
+-- @return boolean
+local function is_marker_token(tok)
+	local leading_ident = duffle.read_ident(tok, 1)
+	return leading_ident == LABEL_MARKER or leading_ident == OFFSET_MARKER
+end
+
+--- Scan an atom body for labels + branches, count total words.
+--- Returns (labels, branches, total_words).
+--- @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 _, t in ipairs(body_tokens) do
+		local tok = t.tok
+		if is_marker_token(tok) then
+			-- Marker call: record at the current pos, do NOT advance pos.
+			scan_for_atom_markers(tok, pos, labels, branches)
+			pos = pos + count_marker_rest(tok, word_counts)
+		else
+			local words = count_token_words(tok, word_counts)
+			scan_for_atom_markers(tok, pos, labels, branches)
+			pos = pos + words
+		end
+	end
+	return labels, branches, pos
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Offset computation + header generation
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- 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
+		local target = labels[br.target]
+		if not target then
+			error("Branch target '" .. br.target .. "' has no atom_label (at word " .. br.pos .. ")")
+		end
+		results[#results + 1] = { target = br.target, tag = br.tag, offset = target - br.pos - 1 }
+	end
+	return results
+end
+
+-- Right-pad `s` with spaces to width `w`. If `s` is already `w` or wider, no padding is added.
+-- @param s string
+-- @param w integer
+-- @return string
+local function pad_right(s, w)
+	return s .. string.rep(" ", math.max(0, w - #s))
+end
+
+-- (internal) Build a constant-table entry `{macro_name, enum_name, value}` from a BranchOffset.
+-- @param 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 = duffle.basename_no_ext(source_path)
+
+	local lines = {}
+	local function add(s) lines[#lines + 1] = s end
+
+	add("// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT")
+	add("// Source: " .. source_path)
+	add("#pragma once")
+	add("")
+	add("#pragma region " .. basename)
+	add("")
+	add("")
+	for _, atom in ipairs(atoms_data) do
+		emit_atom_offsets(add, atom)
+	end
+	add("#pragma endregion " .. basename)
+	add("")
+	return table.concat(lines, "\n") .. "\n"
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- M — module exports
+-- ════════════════════════════════════════════════════════════════════════════
+
+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)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	for _, src in ipairs(ctx.sources) do
+		local out_path = process_source(ctx, src)
+		if out_path then
+			outputs[#outputs + 1] = { offsets_h = out_path }
+		end
+	end
+
+	return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/report.lua

@@ -0,0 +1,443 @@
+--- passes/report.lua — Per-MODULE annotation report renderer +
+--- project-wide summary writer.
+---
+--- Two output files per build:
+---   - `build/gen/<dir_basename>.annotations.txt` — one per source-directory containing atoms; aggregates across all sources in the directory.
+---   - `build/gen/annotation_validation.txt` — the project summary.
+---
+--- The annotation pass 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. 
+---
+--- **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
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- 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
+
+-- (internal) Format a single annotation entry as one rendered line.
+-- @param a AnnotEntry
+-- @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.
+-- @param results AnnotationResult[]
+-- @return integer, integer, integer, integer, integer, integer
+local function tally_module_totals(results)
+	local total_atoms, total_annots, total_binds, total_macros = 0, 0, 0, 0
+	local total_errors, total_warnings = 0, 0
+	for _, r in ipairs(results) do
+		total_atoms    = total_atoms    + #r.atoms
+		total_annots   = total_annots   + #r.annots
+		total_binds    = total_binds    + #r.binds
+		total_macros   = total_macros   + #r.macros
+		total_errors   = total_errors   + #r.errors
+		total_warnings = total_warnings + #r.warnings
+	end
+	return total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings
+end
+
+-- (internal) Section renderer: per-source atom declarations.
+local function render_module_atoms_section(add, results)
+	add(SECTION_HEADER_ATOMS)
+	for _, r in ipairs(results) do
+		local src_name = source_basename(r.source)
+		for _, a in ipairs(r.atoms) do
+			add(string.format("  MipsAtom_(%s)   line %d   [%s]", a.name, a.line, src_name))
+		end
+	end
+	add("")
+end
+
+-- (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(RULE_THICK)
+	add("ANNOTATION PASS — module " .. source_basename(dir))
+	add(RULE_THICK)
+	add(string.format("Sources: %d", #sources))
+	for _, s in ipairs(sources) do add("  " .. s.path) end
+	add("")
+
+	local total_atoms, total_annots, total_binds, total_macros, total_errors, total_warnings = tally_module_totals(results)
+	add(string.format("Atoms: %d   Annotations: %d   Binds structs: %d   Macro decls: %d",
+		total_atoms, total_annots, total_binds, total_macros))
+	add("")
+
+	render_module_atoms_section(add, results)
+	render_module_annots_section(add, results)
+	render_module_binds_section(add, results)
+	render_module_macros_section(add, results)
+	render_module_errors_section(add, results, total_errors)
+	render_module_warnings_section(add, results, total_warnings)
+
+	return table.concat(lines, "\n") .. "\n"
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- 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
+		total_macros   = total_macros   + #r.macros
+		total_binds    = total_binds    + #r.binds
+		total_errors   = total_errors   + #r.errors
+		total_warnings = total_warnings + #r.warnings
+	end
+
+	add(RULE_THICK)
+	add("ANNOTATION VALIDATION — project summary")
+	add(RULE_THICK)
+	add("")
+	add(string.format("Atoms:        %d", total_atoms))
+	add(string.format("Annotations:  %d", total_annots))
+	add(string.format("Macros:       %d", total_macros))
+	add(string.format("Binds:        %d", total_binds))
+	add("")
+	add(string.format("Errors:       %d", total_errors))
+	add(string.format("Warnings:     %d", total_warnings))
+	add("")
+
+	if total_errors > 0 then
+		add("Per-source error counts:")
+		for _, r in ipairs(all_results) do
+			if #r.errors > 0 then
+				local src_name = source_basename(r.source)
+				add(string.format("  %s : %d error(s)", src_name, #r.errors))
+			end
+		end
+		add("")
+	end
+
+	return table.concat(lines, "\n") .. "\n"
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Orchestration helpers
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- (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)
+	local outputs  = {}
+	local errors   = {}
+	local warnings = {}
+
+	local module_entries = (ctx.flags and ctx.flags._annot_results) or {}
+	local by_dir         = ctx.by_dir or duffle.group_sources_by_dir(ctx.sources)
+
+	if not ctx.dry_run then duffle.ensure_dir(ctx.out_root) end
+
+	local all_results_for_summary = {}
+	for _, entry in ipairs(module_entries) do
+		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 {}))
+
+		if entry.atoms_count > 0 or #(by_dir[entry.dir] or {}) > 0 then
+			local dir_sources                 = by_dir[entry.dir] or {}
+			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
+	end
+
+	if not ctx.dry_run and #all_results_for_summary > 0 then
+		local summary_path = ctx.out_root .. "/annotation_validation.txt"
+		duffle.write_file(summary_path, render_project_report(all_results_for_summary))
+		outputs[#outputs + 1] = { summary_txt = summary_path }
+	end
+
+	return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

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

@@ -0,0 +1,663 @@
+--- ps1_meta.lua — Orchestrator entry point for the tape-atom metaprogram pipeline.
+---
+--- Dispatches to pass modules under `scripts/passes/`, resolving
+--- dependencies topologically (Kahn's algorithm + cycle detection).
+--- Single CLI surface (`--<pass>` flags + auto-dep expansion + --dry-run).
+---
+--- **Architecture**:
+---   - **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
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Bootstrap: load `duffle_paths.lua` via `arg[0]` (this script's own path).
+-- That single statement: (a) sets `package.path` + `package.cpath` (via cached `git rev-parse`),
+-- (b) at the bottom returns `require("duffle")`. So the dofile's return value is the duffle module.
+local duffle = dofile((arg[0]:match("(.*[/\\])") or "./") .. "duffle_paths.lua")
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Constants
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- 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 kind   string       -- "shared" | "header-output" | "validation" | "report"
+--- @field deps   string[]     -- names of upstream passes
+--- @field desc   string       -- human description (used by --help + ASCII graph)
+--- @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  -- 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 table<string, integer> -- populated by word-counts 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 output accumulator
+--- @field flags              table                  -- CLI flags + per-pass stash
+--- @field dry_run            boolean                -- if true, compute but don't write
+--- @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  PassOutputEntry[] -- emitted file paths
+--- @field errors   Finding[]         -- build-stops (per-pass kind policy)
+--- @field warnings Finding[]         -- informational
+
+--- @class ParsedArgs
+--- @field requested_set string[]  -- pass names to run (explicit --all expanded)
+--- @field sources       string[]  -- --source values
+--- @field metadata      string    -- --metadata value
+--- @field out_root      string    -- --out-root value (default "build/gen")
+--- @field project_root  string    -- --project-root value (default dirname(metadata))
+--- @field dry_run       boolean   -- if true, compute but don't write
+--- @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 = "passes.word_count_eval",
+		kind   = "shared",
+		deps   = {},
+		desc   = "Build the shared metadata table (metadata.h + .macs.h)",
+		out    = {},
+	},
+	components = {
+		module = "passes.components",
+		kind   = "header-output",
+		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   = {"scan-source", "word-counts"},
+		desc   = "Validate atom DSL usage; emit errors.h + annotations.txt",
+		out    = {
+			{ kind = "report", path_template = "<out_root>/<basename>.errors.h" },
+			{ kind = "report", path_template = "<out_root>/<basename>.annotations.txt" },
+		},
+	},
+	offsets = {
+		module = "passes.offsets",
+		kind   = "header-output",
+		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   = {"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" } },
+	},
+	report = {
+		module = "passes.report",
+		kind   = "report",
+		deps   = {"annotation", "static-analysis"},
+		desc   = "Render the per-project summary",
+		out    = { { kind = "report", path_template = "<out_root>/annotation_validation.txt" } },
+	},
+}
+
+-- Pass-kind taxonomy: which kinds stop the build on errors?
+local PASS_KIND_STOP_ON_ERROR = {
+	["shared"]        = false,
+	["header-output"] = true,
+	["validation"]    = true,
+	["report"]        = false,
+}
+
+-- Closed set of CLI flags -> pass names.
+local PASS_FLAG_TO_NAME = {
+	["--word-counts"]     = "word-counts",
+	["--components"]      = "components",
+	["--validate"]        = "annotation",
+	["--offsets"]         = "offsets",
+	["--static-analysis"] = "static-analysis",
+	["--report"]          = "report",
+	["--scan-source"]     = "scan-source",
+	["--all"]             = ALL_PASSES_SENTINEL,
+}
+
+local ALL_PASS_NAMES = {
+	"scan-source", "word-counts", "components", "annotation",
+	"offsets", "static-analysis", "report",
+}
+
+--- Append every pass name to args.requested_set. Used by --all and 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, arg_idx) and returns the new arg_idx (so multi-arg flags like --source FILE advance it). 
+-- Returning nil + os.exit() handles termination flags (--help). 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 = {}
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- CLI parsing
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Print the CLI usage to stdout and exit 0.
+local function print_help()
+	io.write([[
+ps1_meta.lua - Tape-atom metaprogram orchestrator
+
+USAGE:
+  ps1_meta.lua [PASS_FLAGS] [COMMON_FLAGS]
+
+PASS_FLAGS (pick one or more, or use --all):
+  --word-counts         Load metadata.h + scan for existing .macs.h
+  --components          Generate <module>/gen/<basename>.macs.h
+  --validate            Run atom annotation DSL validation
+  --offsets             Generate <module>/gen/<basename>.offsets.h
+  --static-analysis     [FUTURE] GTE pipeline-fill, mac_yield uniformity
+  --report              Render per-project summary
+  --all                 Equivalent to all 6 flags above (default)
+
+COMMON_FLAGS:
+  --source FILE         Source file to process (repeatable)
+  --metadata PATH       Path to metadata.h (required)
+  --out-root DIR        Output root for reports (default: build/gen)
+  --project-root DIR    Project root for .macs.h scan (default: dirname(metadata))
+  --dry-run             Print dep order + ASCII graph; exit 0 without running
+  --verbose             Print per-pass debug output
+  --help                Show this help and exit
+
+EXIT CODES:
+  0  All requested passes succeeded
+  1  Validation errors found
+  2  Metaprogram internal error
+
+EXAMPLE:
+  ps1_meta.lua --all --metadata metadata.h --source code/foo.c --source code/bar.c
+]])
+end
+
+-- Per-flag handlers. Each takes (args, argv, arg_idx) and returns the new arg_idx (so multi-arg flags like --source FILE advance it).
+-- Termination flags like --help call os.exit() instead.
+-- This replaces the 8-way `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 as an upvalue (Lua resolves locals at closure-call time, 
+-- but if the closure is defined before the local, it falls back to _G). 
+FLAG_HANDLERS["--help"] = function(args)
+	print_help()
+	os.exit(0)
+end
+
+FLAG_HANDLERS["--dry-run"]      = function(args) args.dry_run = true end
+FLAG_HANDLERS["--verbose"]      = function(args) args.verbose = true 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
+
+-- Pass-flag handler. Reads the closed-set table, expands --all, appends to requested_set. Single-statement, no nesting.
+FLAG_HANDLERS[PASS_FLAG_DISPATCH_KEY] = function(args, a)
+	local name = PASS_FLAG_TO_NAME[a]
+	if name == ALL_PASSES_SENTINEL then
+		request_all_passes(args)
+		return
+	end
+	args.requested_set[#args.requested_set + 1] = name
+end
+
+--- Parse argv into a structured table. Validates against a closed enum.
+---
+--- @param argv string[]
+--- @return ParsedArgs
+local function parse_args(argv)
+	local args = {
+		requested_set = {},
+		sources       = {},
+		metadata      = nil,
+		out_root      = DEFAULT_OUT_ROOT,
+		project_root  = nil,
+		dry_run       = false,
+		verbose       = false,
+	}
+
+	local pos = 1
+	while pos <= #argv do
+		local a       = argv[pos]
+		local handler = FLAG_HANDLERS[a]
+		if handler then
+			pos = handler(args, argv, pos) or pos
+		elseif PASS_FLAG_TO_NAME[a] then
+			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(EXIT_INTERNAL_ERROR)
+		end
+		pos = pos + 1
+	end
+
+	-- Default: --all if no explicit pass flags.
+	if #args.requested_set == 0 then request_all_passes(args) end
+
+	-- Defaults: project_root = dirname(metadata).
+	if args.metadata and not args.project_root then
+		local d = duffle.dirname(args.metadata)
+		if   #d > 0 and (d:sub(-1) == "/" or d:sub(-1) == "\\") then
+			d = d:sub(1, -2)
+		end
+		args.project_root = duffle.dirname(d)
+	end
+
+	if not args.metadata then
+		io.stderr:write("ps1_meta: --metadata PATH is required\n")
+		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(EXIT_INTERNAL_ERROR)
+	end
+
+	return args
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Build ctx from parsed args
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Build the PassCtx from parsed args. Reads each source file once at startup;
+--- passes consume `src.text`, not the path (path is preserved for error reporting).
+---
+--- @param args ParsedArgs
+--- @return PassCtx
+local function build_ctx(args)
+	local sources = {}
+	for _, path in ipairs(args.sources) do
+		local  f = io.open(path, "r")
+		if not f then
+			io.stderr:write("ps1_meta: cannot open --source " .. path .. "\n")
+			os.exit(EXIT_INTERNAL_ERROR)
+		end
+		local text = f:read("*a")
+		f:close()
+
+		local dir      = duffle.dirname(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,
+			dir      = dir,
+			basename = basename,
+		}
+	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      = {},
+		out_root      = args.out_root,
+		project_root  = args.project_root,
+		flags         = {},
+		dry_run       = args.dry_run,
+		verbose       = args.verbose,
+	}
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Topological sort (Kahn's algorithm + cycle detection)
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Compute the dep-closure of `requested_set`: include every pass name transitively required by the requested set.
+---
+--- @param passes table<string, PassDescriptor>
+--- @param requested_set string[]
+--- @return table<string, boolean>  -- set of pass names needed (including transitive deps)
+local function dep_closure(passes, requested_set)
+	local needed = {}
+	for _, name in ipairs(requested_set) do needed[name] = true end
+	local changed = true
+	while changed do
+		changed = false
+		for name, _ in pairs(needed) do
+			local pass = passes[name]
+			if not pass then
+				error("unknown pass '" .. name .. "' requested")
+			end
+			for _, dep in ipairs(pass.deps) do
+				if not needed[dep] then
+					needed[dep] = true
+					changed = true
+				end
+			end
+		end
+	end
+	return needed
+end
+
+--- 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] + 1
+			end
+		end
+	end
+	return in_degree
+end
+
+--- 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
+
+-- (internal) Pop the next ready pass, decrement the in-degree of every remaining pass that depended on it
+-- (inserting newly-zero-degree passes back into the ready queue), and append to `order`. Keeps `ready` sorted.
+-- @param passes table<string, PassDescriptor>
+-- @param needed table<string, boolean>
+-- @param in_degree table<string, integer>
+-- @param ready string[]
+-- @param order string[]
+local function process_next_ready(passes, needed, in_degree, ready, order)
+	local just_finished = table.remove(ready, 1)
+	order[#order + 1] = just_finished
+	for name, _ in pairs(needed) do
+		if name ~= just_finished then
+			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
+
+--- Topologically sort the requested pass set, augmented with all transitive deps.
+--- Detects cycles and errors out with details.
+---
+--- @param passes table<string, PassDescriptor>
+--- @param requested_set string[]
+--- @return string[]  -- execution order
+local function topo_sort(passes, requested_set)
+	local needed    = dep_closure(passes, requested_set)
+	local in_degree = compute_in_degrees(passes, needed)
+	local ready     = seed_ready_queue(in_degree)
+
+	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 .. "'")
+			end
+		end
+	end
+
+	return order
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- ASCII dep graph renderer (Decision 6 in the spec)
+-- ════════════════════════════════════════════════════════════════════════════
+
+--- Render the dep graph as ASCII art. Output width capped at 78 columns.
+--- Falls back to the simpler "Resolved dependency order" list only if graph width exceeds terminal width.
+---
+--- @param passes table<string, PassDescriptor>
+--- @param requested string[]  -- originally-requested passes (subset of closed)
+--- @param closed string[]     -- dep-closed execution order
+--- @return string
+local function render_dep_graph(passes, requested, closed)
+	local lines = {}
+	local function add(s) lines[#lines + 1] = s end
+
+	add("[ps1_meta] Resolved dependency order (closed under deps):")
+	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]",
+			pass_idx, name, deps_str, p.kind))
+	end
+	add("")
+
+	-- 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("")
+
+	-- Compute which passes feed which other passes (reverse of deps).
+	local feeds = {}  -- feeds[X] = list of passes that X feeds into
+	for _, name in ipairs(closed) do feeds[name] = {} end
+	for name, p in pairs(passes) do
+		for _, dep in ipairs(p.deps) do
+			if feeds[dep] then feeds[dep][#feeds[dep] + 1] = name end
+		end
+	end
+
+	-- Layout: source -> scan_source -> word-counts -> {components, annotation, offsets, static-analysis} -> report
+	-- Outputs are listed under each pass.
+	local outputs_for = function(name)
+		local p = passes[name]
+		if not p or not p.out or #p.out == 0 then return "" end
+		local outs = {}
+		for _, o in ipairs(p.out) do outs[#outs + 1] = o.path_template end
+		return table.concat(outs, ", ")
+	end
+
+	add("   +-----------+   +-------------------+    +-----------------+")
+	add("   |  source   |-->|  scan_source      |--->|   word-counts   |")
+	add("   |  files    |   | (scan_source.lua) |    |   (load)        |")
+	add("   +-----------+   +-------------------+    +-----------------+")
+	add("                          (single walk)         |")
+	add("                                                |")
+	add("        +-------------------+-------------------+-----------+")
+	add("        v                   v                   v           v")
+	add("   +--------------+   +--------------+   +--------------+   +---------------+")
+	add("   | components   |   | annotation   |   |   offsets    |   |static-analysis|")
+	add("   +--------------+   +--------------+   +--------------+   +---------------+")
+	add("   |<src>/gen/    |   |build/gen/    |   |<src>/gen/    |   |build/gen/     |")
+	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
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- 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)
+	local ok, err = pcall(function()
+		local args = parse_args(argv)
+		local ctx  = build_ctx(args)
+
+		local requested = args.requested_set
+		local closed    = topo_sort(PASSES, requested)
+
+		-- --dry-run: print dep order + ASCII graph, exit OK.
+		if args.dry_run then
+			io.write(render_dep_graph(PASSES, requested, closed))
+			os.exit(EXIT_OK)
+		end
+
+		local had_errors = dispatch_passes(ctx, closed)
+		if had_errors then os.exit(EXIT_VALIDATION_ERRORS) end
+	end)
+
+	if not ok then
+		io.stderr:write("[ps1_meta] internal error: " .. tostring(err) .. "\n")
+		os.exit(EXIT_INTERNAL_ERROR)
+	end
+
+	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