diff --git a/.vscode/launch.json b/.vscode/launch.json
index 26615d2..ac29223 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -24,7 +24,7 @@
 			"osx": {
 				"gdbpath": "gdb"
 			},
-			"executable": "${workspaceRoot}/build/hello_psyq.elf",
+			"executable": "${workspaceRoot}/build/hello_gte.elf",
 			"setupCommands": [
 				{ "text": "set mi-async off" },
 				{ "text": "set remotetimeout 0" },
@@ -33,7 +33,7 @@
 			],
 			"autorun": [
 				"monitor reset shellhalt",
-				"load hello_psyq.elf",
+				"load hello_gte.elf",
 				"source scripts/gdb/gdb_tape_atoms.gdb",
 				"tbreak main",
 				"continue"
@@ -59,7 +59,7 @@
 			"osx": {
 				"gdbpath": "gdb"
 			},
-			"executable": "${workspaceRoot}/build/hello_gpu.elf",
+			"executable": "${workspaceRoot}/build/hello_gte.elf",
 			"setupCommands": [
 				{ "text": "set mi-async off" },
 				{ "text": "set remotetimeout 0" },
@@ -68,7 +68,7 @@
 			],
 			"autorun": [
 				"monitor reset shellhalt",
-				"load hello_gpu.elf",
+				"load hello_gte.elf",
 				"tbreak main",
 				"continue"
 			]
diff --git a/code/duffle/atom_dsl.h b/code/duffle/atom_dsl.h
index 866f9b4..ea4f1e8 100644
--- a/code/duffle/atom_dsl.h
+++ b/code/duffle/atom_dsl.h
@@ -63,11 +63,19 @@
 /* ============================================================================
  * atom_reads(...) / atom_writes(...)
  *
- * Used during the static analysis pass of the metaprogram to do 
+ * Used during the static analysis pass of the metaprogram to do
  * ============================================================================*/
 #define atom_reads(...)  (__VA_ARGS__)
 #define atom_writes(...) (__VA_ARGS__)
 
+/* ----------------------------------------------------------------------------
+ * atom_reg (per-enum opt-in marker for the DWARF register-alias registry)
+ *
+ * The bare `atom_reg` token adjacent to an enum entry in mips.h / lottes_tape.h flags that alias as debug-visible for scan_source's register_alias_registry.
+ * The C preprocessor strips it to a comment so no runtime symbol is created; the Lua scanner reads the bare token.
+ * ----------------------------------------------------------------------------*/
+#define atom_reg /* atom_reg: opt the preceding enum entry into the DWARF registry */
+
 /* ============================================================================
  *   atom_info :
  *      MipsAtom_(cube_tri) atom_info(
@@ -84,12 +92,38 @@
 /* ----------------------------------------------------------------------------
  * DEBUG SOURCE-STEP MARKERS
  *
- * Place atom_dbg_skip_over() before a MipsAtom_, MipsAtomComp_, or MipsAtomComp_Proc_. 
+ * Place atom_dbg_skip_over() before a MipsAtom_, MipsAtomComp_, or MipsAtomComp_Proc_.
  * The following declaration kind determines whether the marker selects a whole atom or a component inline view.
  * The source scanner associates the marker with that declaration; placement diagnostics are handled by the annotation pass.
  * ----------------------------------------------------------------------------*/
 #define atom_dbg_skip_over() /* atom_dbg_skip_over: skip the following atom or component source view */
 
+/* ----------------------------------------------------------------------------
+ * Typed-view annotations (Registry for DWARF RR_<R_X> chain resolution)
+ *   atom_type(<T>) -- overloaded:
+ *      (a) enum-site default: `R_Foo = R_Tn, atom_reg atom_type(T)` 
+ *      Sets the per-alias default typed view in the register_alias_registry.
+ *      Consumed by the DWARF chain step (e) when no per-atom atom_ctx / atom_phase / atom_type callsite provides a stronger resolution.
+ *      (b) callsite override: `atom_reads(R_Foo atom_type(T), ...)` Overrides the per-alias default for THIS atom only.
+ *      Last-write-wins per R_Name; conflict -> error.
+ *   atom_ctx(<atom_name>) -- atom-info sub-call:
+ *       Propagate another atom's atom.rbind.fields (its Binds_* typed fields) into THIS atom's typed-view resolution.
+ *       The named atom must be an rbind atom (have `atom_bind(Binds_X)` in its `atom_info`).
+ *       Used as the escape hatch when atom_phase is not the natural correlation.
+ *   atom_phase(<label>) -- atom-info sub-call: 
+ *       Free-form C-identifier label for grouping atoms.
+ *       Within a phase, the FIRST atom in source-order that owns its own atom.rbind provides 
+ *       the Binds_* field types used by all other atoms in the same phase.
+ *       The preferred correlation mechanism; atom_ctx is the escape hatch for non-natural cases.
+ *
+ * All three expand to C comments
+ * (the bare-token convention matching `atom_reg` and `atom_dbg_skip_over`).
+ * The Lua scanner reads the bare tokens in source-as-written; the C preprocessor strips them.
+ * ----------------------------------------------------------------------------*/
+#define atom_type(T)        /* atom_type: associate <T> with the preceding enum entry (enum site) or this register (atom-info site) */
+#define atom_ctx(atom_name) /* atom_ctx: propagate <atom_name>'s Binds_* field types into this atom's typed views */
+#define atom_phase(label)   /* atom_phase: tag this atom with <label> for grouped typed-view resolution */
+
 /* ----------------------------------------------------------------------------
  * atom_bind(Binds_X) -- rbind sub-call of atom_info
  *
diff --git a/code/duffle/lottes_tape.h b/code/duffle/lottes_tape.h
index 58bc542..e1f2808 100644
--- a/code/duffle/lottes_tape.h
+++ b/code/duffle/lottes_tape.h
@@ -32,16 +32,16 @@ typedef Slice_MipsCode MipsAtom;
 
 /* Register aliases */
 enum {
-	R_AtomJmp    = R_T9,
-	R_TapePtr    = R_T8,  /* The Instruction Stream Pointer */
-	R_InCursor   = R_T4,  /* Input data cursor */
+	R_AtomJmp    = R_T9 atom_reg,  /* debug-visible; tape yield handshake scratch */
+	R_TapePtr    = R_T8 atom_reg,  /* The Instruction Stream Pointer */
+	R_InCursor   = R_T4,
 
-	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 */
+	R_PrimCursor = R_T7 atom_reg atom_type(U4 *),    /* VRAM output cursor (primitive buffer) */
+	R_FaceCursor = R_T4 atom_reg atom_type(V4_S2 *), /* Cube face-index cursor (V4_S2*); floor context switches to V3_S2* via atom_phase */
+	R_VertBase   = R_T5 atom_reg atom_type(V3_S2 *), /* Base address of the vertex array */
+	R_OtBase     = R_T6 atom_reg atom_type(U4 *),    /* Base address of the Ordering Table */
 
-/* Stringification codes for the GCC inline assembler clobber lists */
+/* Stringification codes for the GCC inline assembler clobber lists. */
 #define R_TapePtr_Code     R_T8_Code
 #define R_InCursor_Code    R_T4_Code
 
diff --git a/code/gte_hello/hello_gte_tape.c b/code/gte_hello/hello_gte_tape.c
index 247af51..6b4e9df 100644
--- a/code/gte_hello/hello_gte_tape.c
+++ b/code/gte_hello/hello_gte_tape.c
@@ -22,7 +22,7 @@ typedef Struct_(Binds_CubeTri) {
 	V3_S2* VertBase;
 	U4*    OtBase;
 };
-internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri)
+internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri), atom_phase(cube_g4)
 ,	atom_reads(R_TapePtr)
 ,	atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
 ){
@@ -37,7 +37,7 @@ internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri)
 
  // cube_g4_face — Draw one cube face (Gouraud-shaded quad) via the GTE tape pipeline
 internal
-MipsAtom_(cube_g4_face) atom_info(
+MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 		atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase),
 		atom_writes(R_PrimCursor, R_FaceCursor)
 ){
@@ -90,7 +90,7 @@ typedef Struct_(Binds_FloorTri) {
 	U4*    OtBase;
 };
 internal
-MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri)
+MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri), atom_phase(floor_f3)
 	, atom_reads(R_TapePtr)
 	, atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
 ){
@@ -105,7 +105,7 @@ MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri)
 
 internal
 atom_dbg_skip_over()
-MipsAtom_(floor_f3_face) atom_info(
+MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 	, atom_reads( R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase)
 	, atom_writes(R_PrimCursor, R_FaceCursor)
 ) {
diff --git a/scripts/duffle.lua b/scripts/duffle.lua
index 7970d78..6d4edd8 100644
--- a/scripts/duffle.lua
+++ b/scripts/duffle.lua
@@ -8,7 +8,7 @@
 ---   - **C-language scanner** (`skip_ws_and_cmt`, `skip_str_or_cmt`, `read_ident`, `read_parens`, `read_braces`, `read_brackets`, `read_balanced`, `scan_to_char`, `split_top_level_commas`).
 ---   - **Word-count loader** (`load_word_counts` for `WORD_COUNT(...)` metadata files).
 ---   - **Line lookup** (`LineIndex` returns an O(log N) `line_of(pos)` closure for source-mapping).
----   - **Domain tables** (`WAVE_CONTEXT_REGS`, `TAPE_ATOM_MACROS`, `GTE_PIPELINE_LATENCY`, `GP0_CMD_SIZE`, `GP0_CMD_BY_SHAPE`, `GP0_MACRO_CONTRIB`, `INSTRUCTION_LATENCY`).
+---   - **Domain tables** (`TAPE_ATOM_MACROS`, `GTE_PIPELINE_LATENCY`, `GP0_CMD_SIZE`, `GP0_CMD_BY_SHAPE`, `GP0_MACRO_CONTRIB`, `INSTRUCTION_LATENCY`).
 ---   - **Process-bootstrap helper** (`setup_package_path`replaces the 8-line `arg[0]`-resolution boilerplate duplicated across 7 entry scripts)
 ---
 --- **Conventions**: tabs (1/level), EmmyLua annotations, no regex.
@@ -74,21 +74,14 @@ local BYTE_DIGIT_9 = 0x39       -- '9'
 -- Section -1: Bootstrap (path-setup at module load)
 -- ════════════════════════════════════════════════════════════════════════════
 --
--- Path setup is done by `scripts/duffle_paths.lua`, which derives the repo
--- root from `debug.getinfo(1, "S").source` (NO subprocess, ~0ms) and
--- then calls `require("duffle")`. The prior `io.popen("git rev-parse ...")`
--- approach in this section was removed during F'' because:
---
---   1. Every entry script + every passes script now uses
---      `dofile("duffle_paths.lua")` (14 call sites; verified via grep).
---      The `find_repo_root` / `setup_package_path` defined here was dead
---      code in practice.
+-- Path setup is done by `scripts/duffle_paths.lua`, which derives the repo root from `debug.getinfo(1, "S").source` (NO subprocess, ~0ms) and then calls `require("duffle")`.
+-- The prior `io.popen("git rev-parse ...")` approach in this section was removed during F'' because:
+--   1. Every entry script + every passes script now uses `dofile("duffle_paths.lua")` (14 call sites; verified via grep).
+--      The `find_repo_root` / `setup_package_path` defined here was dead code in practice.
 --   2. `git rev-parse` costs ~100-180ms per subprocess spawn on Windows.
---      `debug.getinfo` is <1ms. There's no reason to keep the slow path
---      even as a "fallback".
+--      `debug.getinfo` is <1ms. There's no reason to keep the slow path even as a "fallback".
 --
--- If a future use case ever needs to load `duffle.lua` WITHOUT going
--- through `duffle_paths.lua`, set `package.path` manually before `require`.
+-- If a future use case ever needs to load `duffle.lua` WITHOUT going through `duffle_paths.lua`, set `package.path` manually before `require`.
 -- See `docs/guide_metaprogram_ssdl.md` §"I/O primitives" for the pattern.
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -434,8 +427,7 @@ function M.skip_preprocessor_line(s, pos)
 	return scan + 1
 end
 
--- Split a brace-body into top-level comma-separated tokens. Honors nested
--- parens/braces/brackets and skips strings/comments.
+-- Split a brace-body into top-level comma-separated tokens. Honors nested parens/braces/brackets and skips strings/comments.
 --
 -- FIX (2026-07-09): split at top-level NEWLINES and SEMICOLONS too, AND emit a token break after a top-level comment/string. 
 -- Previous behavior glued the macro call after a comment into the same token, so `word_count_of_token` only saw the 
@@ -694,13 +686,6 @@ end
 -- Section 7: domain tables
 -- ════════════════════════════════════════════════════════════════════════════
 
-M.WAVE_CONTEXT_REGS = {
-	["R_PrimCursor"] = { alias = "R_T7", size = 4, role = "output cursor (prim arena)" },
-	["R_FaceCursor"] = { alias = "R_T4", size = 4, role = "input cursor (face array)" },
-	["R_VertBase"]   = { alias = "R_T5", size = 4, role = "base pointer (vertex array)" },
-	["R_OtBase"]     = { alias = "R_T6", size = 4, role = "base pointer (ordering table)" },
-}
-
 -- The annotation DSL has been reduced to a single annotation macro:
 --   atom_info(atom_bind(Binds_X), atom_reads(...), atom_writes(...))
 -- All phase / region / cadence / async / resource / group tokens have been dropped.
@@ -713,8 +698,7 @@ M.TAPE_ATOM_MACROS = {
 -- GTE pipeline-fill latency table.
 --
 -- For each `gte_cmdw_*` macro in code/duffle/gte.h, the minimum number of consecutive COP2 "nop" words that MUST appear
--- before the command issues so that any preceding `lwc2`/`swc2`/C2 state writes have retired before the GTE starts
--- reading its input registers.
+-- before the command issues so that any preceding `lwc2`/`swc2`/C2 state writes have retired before the GTE starts reading its input registers.
 --
 -- The check (`scripts/passes/static_analysis.lua :: check_gte_pipeline_fill`) walks each atom body,
 -- counts the consecutive nop words before every `gte_cmdw_*` invocation, and reports a finding if the count is below this minimum.
diff --git a/scripts/elf_dwarf.lua b/scripts/elf_dwarf.lua
index ad69226..2772e3b 100644
--- a/scripts/elf_dwarf.lua
+++ b/scripts/elf_dwarf.lua
@@ -41,7 +41,7 @@ M.DW_TAG = {
 }
 
 M.DW_AT = {
-	name                 = 0x03,
+	name                  = 0x03,
 	low_pc                = 0x11,
 	high_pc               = 0x12,
 	language              = 0x13,
@@ -214,11 +214,9 @@ M.DWARF_LINE_OPS = {
 ---
 --- **Convention:** offsets are 1-indexed (matching Lua `string.sub`).
 ---
---- **Byte weights** are written as `0x100`, `0x10000`, `0x1000000` (i.e.
---- 2^8, 2^16, 2^24) so the LE byte positions are visually explicit:
+--- **Byte weights** are written as `0x100`, `0x10000`, `0x1000000` (i.e. 2^8, 2^16, 2^24) so the LE byte positions are visually explicit:
 --- byte 0 contributes its value directly; byte 1 is shifted left by 8
 --- (= 0x100); byte 2 by 16 (= 0x10000); byte 3 by 24 (= 0x1000000).
----
 --- @param buf string
 --- @param off integer  -- 1-indexed
 --- @return integer
@@ -238,9 +236,12 @@ function M.read_u16_le(buf, off)
 	return buf:byte(off) + buf:byte(off + 0x01) * 0x00000100
 end
 
--- Pure-Lua 5.3 LEB128 readers (no `bit` library). `2^shift` arithmetic matches
--- the existing F' parser. Offsets are 0-based; returns (value, next_pos).
-local function read_uleb128_at(buf, pos)
+-- Pure-Lua 5.3 LEB128 readers (no `bit` library). `2^shift` arithmetic matches the existing F' parser.
+-- Offsets are 0-based; returns (value, next_pos).
+-- Track A Task 10: promoted from `local function` to M.* exports so passes/dwarf_injection.lua
+-- can import them as file-scope locals per the 2nd-caller lift precedent
+-- (the uleb128 + sleb128 encoders were promoted the same way).
+function M.read_uleb128_at(buf, pos)
 	local value, shift = 0, 0
 	local len = #buf
 	while pos < len do
@@ -253,7 +254,7 @@ local function read_uleb128_at(buf, pos)
 	return nil, pos
 end
 
-local function read_sleb128_at(buf, pos)
+function M.read_sleb128_at(buf, pos)
 	local value, shift = 0, 0
 	local len = #buf
 	while pos < len do
@@ -270,30 +271,30 @@ local function read_sleb128_at(buf, pos)
 end
 
 -- Find the 0-based offset of the table-terminator byte (a single 0) for the abbrev table starting at `table_start`.
--- Returns nil on truncated input. Walks declaration headers 
--- (code, tag, has_children, attr/form pairs, DW_FORM_implicit_const constant) until it finds a 0 byte that follows a complete declaration. Mirrors dwarf_injection.lua :: find_abbrev_table_end.
-local function find_abbrev_table_end(table_bytes, table_start)
+-- Returns nil on truncated input. Walks declaration headers
+-- (code, tag, has_children, attr/form pairs, DW_FORM_implicit_const constant) until it finds a 0 byte that follows a complete declaration.
+function M.find_abbrev_table_end(table_bytes, table_start)
 	local pos, len = table_start, #table_bytes
-	if pos >= len or table_bytes:byte(pos + 1) == 0 then return pos end
+	if    pos >= len or table_bytes:byte(pos + 1) == 0 then return pos end
 	while pos < len do
-		local  _code, code_end = read_uleb128_at(table_bytes, pos)
+		local  _code, code_end = M.read_uleb128_at(table_bytes, pos)
 		if not _code then return nil end
 		pos = code_end
-		local  _tag, tag_end = read_uleb128_at(table_bytes, pos)
+		local  _tag, tag_end = M.read_uleb128_at(table_bytes, pos)
 		if not _tag then return nil end
 		pos = tag_end
 		if pos >= len then return nil end
 		pos = pos + 1   -- has_children byte
 		while pos < len do
-			local  attr, attr_end = read_uleb128_at(table_bytes, pos)
+			local  attr, attr_end = M.read_uleb128_at(table_bytes, pos)
 			if not attr then return nil end
 			pos = attr_end
-			local  form, form_end = read_uleb128_at(table_bytes, pos)
+			local  form, form_end = M.read_uleb128_at(table_bytes, pos)
 			if not form then return nil end
 			pos = form_end
 			if attr == 0 and form == 0 then break end
 			if form == DW_FORM_implicit_const then
-				local _c, ce = read_sleb128_at(table_bytes, pos)
+				local _c, ce = M.read_sleb128_at(table_bytes, pos)
 				if not _c then return nil end
 				pos = ce
 			end
@@ -317,31 +318,31 @@ end
 -- {code, tag, has_children, attrs={ {name, form}, ... }}.
 -- Stops at the table terminator.
 local function parse_abbrev_table(table_bytes, table_start)
-	local table_end = find_abbrev_table_end(table_bytes, table_start)
+	local table_end = M.find_abbrev_table_end(table_bytes, table_start)
 	if not table_end then return nil, "no terminator" end
 	local decls = {}
 	local pos = table_start
 	while pos < table_end do
-		local  code, code_end = read_uleb128_at(table_bytes, pos)
+		local  code, code_end = M.read_uleb128_at(table_bytes, pos)
 		if not code then return nil, "truncated code" end
 		pos = code_end
-		local  tag, tag_end = read_uleb128_at(table_bytes, pos)
+		local  tag, tag_end = M.read_uleb128_at(table_bytes, pos)
 		if not tag then return nil, "truncated tag" end
 		pos = tag_end
 		local has_children = table_bytes:byte(pos + 1)
 		pos = pos + 1
 		local attrs = {}
 		while true do
-			local  attr, attr_end = read_uleb128_at(table_bytes, pos)
+			local  attr, attr_end = M.read_uleb128_at(table_bytes, pos)
 			if not attr then return nil, "truncated attr" end
 			pos = attr_end
-			local form, form_end = read_uleb128_at(table_bytes, pos)
+			local form, form_end = M.read_uleb128_at(table_bytes, pos)
 			if not form then return nil, "truncated form" end
 			pos = form_end
 			if attr == 0 and form == 0 then break end
 			attrs[#attrs + 1] = { name = attr, form = form }
 			if form == DW_FORM_implicit_const then
-				local  _c, ce = read_sleb128_at(table_bytes, pos)
+				local  _c, ce = M.read_sleb128_at(table_bytes, pos)
 				if not _c then return nil, "truncated const" end
 				pos = ce
 			end
@@ -366,7 +367,7 @@ local function read_form_value(buf, str_buf, pos, form)
 		-- DW_FORM_strp: 4-byte offset into .debug_str.
 		local strp_off = M.read_u32_le(buf, pos + 1)
 		return read_c_string_at(str_buf, strp_off), pos + 4
-	elseif form == M.DW_FORM.udata then return read_uleb128_at(buf, pos)
+	elseif form == M.DW_FORM.udata then return M.read_uleb128_at(buf, pos)
 	elseif form == M.DW_FORM.data1 then return buf:byte(pos + 1), pos + 1
 	elseif form == M.DW_FORM.data2 then return M.read_u16_le(buf, pos + 1), pos + 2
 	elseif form == M.DW_FORM.data4 then return M.read_u32_le(buf, pos + 1), pos + 4
@@ -379,7 +380,7 @@ local function read_form_value(buf, str_buf, pos, form)
 		return 1, pos
 	elseif form == M.DW_FORM.exprloc then
 		-- DW_FORM_exprloc: ULEB byte count + that many bytes of DW_OP_*.
-		local  len, ne = read_uleb128_at(buf, pos)
+		local  len, ne = M.read_uleb128_at(buf, pos)
 		if not len then return nil, pos end
 		return nil, ne + len
 	elseif form == DW_FORM_implicit_const then
@@ -392,8 +393,7 @@ local function read_form_value(buf, str_buf, pos, form)
 	end
 end
 
--- Index the .debug_info + .debug_abbrev sections of an existing ELF and collect one entry 
--- per "interesting" type DIE in the FIRST compilation unit. 
+-- Index the .debug_info + .debug_abbrev sections of an existing ELF and collect one entry per "interesting" type DIE in the FIRST compilation unit. 
 -- The index supports typed-views:
 --   index = {
 --     by_name = { ["V4_S2"]      = {kind="structure_type", die_offset, byte_size, fields={...}},
@@ -435,7 +435,7 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 			local unit_end = pos + 4 + ul
 			if    unit_end > #info then break end
 			local unit_abbrev = M.read_u32_le(info, pos + 9)
-			if unit_abbrev == abbrev_offset then
+			if    unit_abbrev == abbrev_offset then
 				cu_start    = pos
 				cu_end_excl = unit_end
 				break
@@ -455,12 +455,12 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 	-- Root DIE is the compile_unit; skip past it.
 	if pos_cursor >= cu_end_excl then return nil, "no DIE bytes" end
 	local root_decl_code
-	root_decl_code, pos_cursor = read_uleb128_at(info, pos_cursor)
+	root_decl_code, pos_cursor = M.read_uleb128_at(info, pos_cursor)
 	if not root_decl_code then return nil, "truncated root DIE code" end
 	local  root_decl = abbrev_by_code[root_decl_code]
 	if not root_decl then return nil, "unknown root DIE abbrev" end
 	-- Skip root DIE attributes.
-	for _, attr in ipairs(root_decl.attrs) do
+	for     _, attr in ipairs(root_decl.attrs) do
 		local _, ne = read_form_value(info, str_buf, pos_cursor, attr.form)
 		if not ne then return nil, "truncated root attr" end
 		pos_cursor = ne
@@ -502,7 +502,7 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 		local die_encoding   = nil
 		local die_type_ref   = nil
 		for ai, attr in ipairs(decl.attrs) do
-			local before = pos
+			local before  = pos
 			local val, ne = read_form_value(info, str_buf, pos, attr.form)
 			if not ne then
 				return nil, "truncated DIE attr"
@@ -510,8 +510,7 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 			pos = ne
 			if attr.name == M.DW_AT.name then
 				die_name = val
-			elseif attr.name == M.DW_AT.byte_size and
-			       (decl.tag == M.DW_TAG.base_type or decl.tag == M.DW_TAG.structure_type) then
+			elseif attr.name == M.DW_AT.byte_size and (decl.tag == M.DW_TAG.base_type or decl.tag == M.DW_TAG.structure_type) then
 				die_byte_size = val
 			elseif attr.name == M.DW_AT.encoding and decl.tag == M.DW_TAG.base_type then
 				die_encoding = val
@@ -539,9 +538,9 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 				local v, ne = read_form_value(info, str_buf, pos, a.form)
 				if not ne then return nil, "truncated member attr" end
 				pos = ne
-				if a.name == M.DW_AT.name then mname = v
-				elseif a.name == M.DW_AT.type then mtype_ref = v
-				elseif a.name == M.DW_AT.data_member_location then moffset = v end
+				if     a.name == M.DW_AT.name                 then mname     = v
+				elseif a.name == M.DW_AT.type                 then mtype_ref = v
+				elseif a.name == M.DW_AT.data_member_location then moffset   = v end
 			end
 			fields[#fields + 1] = { name = mname, type_offset = mtype_ref, offset = moffset }
 		end
@@ -575,7 +574,7 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 					end
 				end
 				-- Find the terminator (0 byte) of this table.
-				local  term = find_abbrev_table_end(abbrev, scan_pos)
+				local  term = M.find_abbrev_table_end(abbrev, scan_pos)
 				if not term then break end
 				scan_pos = term + 1
 				::continue::
@@ -594,11 +593,12 @@ function M.index_main_cu_types(info, abbrev, str_buf, abbrev_offset, cu_start)
 		local die_name, die_byte_size, die_encoding, die_type_ref, pos_after_attrs
 		= read_result[1], read_result[2], read_result[3], read_result[4], read_result[5]
 		n_visited = n_visited + 1
-		local is_type = (decl.tag == M.DW_TAG.base_type
-		             or decl.tag == M.DW_TAG.structure_type
-		             or decl.tag == M.DW_TAG.typedef
-		             or decl.tag == M.DW_TAG.pointer_type
-		             or decl.tag == M.DW_TAG.const_type)
+		local is_type = (
+		     decl.tag == M.DW_TAG.base_type
+			or decl.tag == M.DW_TAG.structure_type
+			or decl.tag == M.DW_TAG.typedef
+			or decl.tag == M.DW_TAG.pointer_type
+			or decl.tag == M.DW_TAG.const_type)
 
 		local member_fields = nil
 		pos_cursor = pos_after_attrs
@@ -716,7 +716,6 @@ end
 
 --- Return a 4-byte little-endian byte string for `value`.
 --- Caller concatenates with `..` if composing multi-word blobs.
----
 --- **Byte weights** written as `0x100` etc. (see `M.read_u32_le` for rationale).
 --- @param value integer  -- 0 ≤ value ≤ 0xFFFFFFFF
 --- @return string
@@ -857,7 +856,6 @@ end
 --- - We filter on STB_GLOBAL (high nibble of st_info = 1) to match `nm`'s default (external symbols only). STB_WEAK excluded.
 --- - We strip the `code_` prefix to match the previous `read_nm` output. 
 --- - `st_size > 0` filter excludes undefined/imported symbols.
----
 --- @param elf_path Path
 --- @return table<string, {integer, integer}>
 function M.read_nm(elf_path)
diff --git a/scripts/passes/annotation.lua b/scripts/passes/annotation.lua
index 41a2218..321f7c8 100644
--- a/scripts/passes/annotation.lua
+++ b/scripts/passes/annotation.lua
@@ -3,7 +3,7 @@
 --- 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`). 
+--- Source scanning: done ONCE upstream by `duffle.scan_source()` (ps1_meta.lua pre-scans each source and stashes the result in `src.scan`).
 ---
 --- Writes:
 ---   - `<ctx.out_root>/<dir_basename>.errors.h` — one per module, with `#error` directives on findings (the C compile will surface the error)
@@ -21,30 +21,9 @@ 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 function is_wave_context_reg(n) return WAVE_CONTEXT_REGS[n] ~= nil  end
-
--- Closed sets. atom_dbg_reg_default and atom_reg_types MUST target one of these registers;
--- atom_view MUST reference a real Binds_* struct.
-local SEMANTIC_DEFAULT_REGS = {
-	["R_TapePtr"] = true, ["R_AtomJmp"] = true,
-	["R_PrimCursor"] = true, ["R_FaceCursor"] = true,
-	["R_VertBase"] = true, ["R_OtBase"] = true,
-}
-
-local COMPUTE_REG_PREFIX = "R_"
-local COMPUTE_REG_RE =   -- permits R_T0..R_T3 + caller-trash (not wave-context)
-	"^R_T[0-3]$"
-
--- Compute-register types are restricted to byte-width primitives.
--- Pointer depth is also bounded typed pointer chains live in the Binds_* struct, not in a per-atom override.
-local ALLOWED_COMPUTE_TYPES = {
-	["U4"] = true, ["S4"] = true,
-	["U2"] = true, ["S2"] = true,
-	["U1"] = true, ["S1"] = true,
-}
+-- The annotation pass now consults the source-derived registries built by scan_source:
+--   * pipe_ctx.register_alias_registry — for atom_dbg_reg_default(R_X, ...) and atom_reg_types(R_X, ...) member-identity checks
+--   * pipe_ctx.type_name_registry      — for atom_dbg_reg_default(<T>, ...) and atom_reg_types(<T>, ...) type-identity checks
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
@@ -179,50 +158,6 @@ local function check_binds_struct_exists(a, pipe_ctx, findings)
 	}
 end
 
---- Check: Binds_* struct fields must correspond to known wave-context registers.
---- Also checks that all `atom_writes(...)` entries are wave-context registers.
---- @param a AtomAnnotation
---- @param pipe_ctx PipeCtx
---- @param findings Findings
-local function check_binds_field_wave_context(a, pipe_ctx, findings)
-	if not (a.binds and pipe_ctx.binds_index[a.binds]) then return end
-	local bs = pipe_ctx.binds_index[a.binds]
-
-	for _, f in ipairs(bs.fields) do
-		local candidate = "R_" .. f.name
-		if not is_wave_context_reg(candidate) then
-			findings.warnings[#findings.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
-			findings.warnings[#findings.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
-
---- Check: atom_reads(...) entries should be wave-context registers (or R_TapePtr for rbind).
---- @param a AtomAnnotation
---- @param pipe_ctx PipeCtx
---- @param findings Findings
-local function check_reads_wave_context(a, pipe_ctx, findings)
-	for _, r in ipairs(a.reads) do
-		if not is_wave_context_reg(r) and r ~= "R_TapePtr" then
-			findings.warnings[#findings.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
-
 --- Check: TAPE_WORDS(mac_X, N) ↔ WORD_COUNT(mac_X, N) drift.
 --- Three outcomes: missing (error), mismatch (error), match (info).
 --- @param m MacroEntry
@@ -250,28 +185,14 @@ local function check_macro_word_drift(m, wc, findings)
 	}
 end
 
----- Check: atom_dbg_reg_default(R_X, <type>) must target a wave-context register and the type name must be a recognized C type 
---- (we currently allow the types actually used in the codebase; pointer depth must be 0 or 1).
---- Also detects duplicate defaults for the same register.
+--- Check: atom_dbg_reg_default(R_X, <type>) must target a register declared as a debug-visible alias in `pipe_ctx.register_alias_registry`,
+--- with a type name found in `pipe_ctx.type_name_registry`.
+--- Pointer depth is still bounded to 0 or 1. Duplicate defaults are still detected.
 --- @param _src SourceFile        -- unused (kept for the per_source shape)
 --- @param pipe_ctx PipeCtx
 --- @param findings Findings
--- Known type names accepted in atom_dbg_reg_default and the Binds_*-via-atom_view resolution path.
-local KNOWN_REG_DEFAULT_TYPES = {
-	["U4"] = true, ["S4"] = true,
-	["U2"] = true, ["S2"] = true,
-	["U1"] = true, ["S1"] = true,
-	["MipsCode"] = true, ["MipsAtom"] = true,
-	["V2_S2"] = true, ["V2_S4"] = true,
-	["V3_S2"] = true, ["V3_S4"] = true,
-	["V4_S2"] = true, ["V4_S4"] = true,
-	["M3_S2"] = true,
-	["void"] = true,
-}
-
 local function check_semantic_reg_defaults(_src, pipe_ctx, findings)
-	-- Detect duplicate defaults using the ordered occurrence list (the
-	-- out.types hash only retains the last declaration).
+	-- Detect duplicate defaults using the ordered occurrence list (the out.types hash only retains the last declaration).
 	local seen_first_line = {}
 	for _, occ in ipairs(pipe_ctx.type_occurrences or {}) do
 		if seen_first_line[occ.reg] == nil then
@@ -285,12 +206,14 @@ local function check_semantic_reg_defaults(_src, pipe_ctx, findings)
 			}
 		end
 	end
+	local reg_registry  = pipe_ctx.register_alias_registry or {}
+	local type_registry = pipe_ctx.type_name_registry      or {}
 	for reg, def in pairs(pipe_ctx.types or {}) do
-		if not SEMANTIC_DEFAULT_REGS[reg] then
+		if not reg_registry[reg] then
 			findings.errors[#findings.errors + 1] = {
 				line = def.source_line,
 				msg  = string.format(
-					"atom_dbg_reg_default at line %d references unknown register %q; expected one of R_TapePtr, R_AtomJmp, R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase",
+					"atom_dbg_reg_default at line %d references unknown register %q (not in register_alias_registry)",
 					def.source_line, reg),
 			}
 		end
@@ -302,39 +225,43 @@ local function check_semantic_reg_defaults(_src, pipe_ctx, findings)
 					def.source_line, reg, def.pointer_depth or -1),
 			}
 		end
-		if not def.type_name or not KNOWN_REG_DEFAULT_TYPES[def.type_name] then
+		if not def.type_name or not type_registry[def.type_name] then
 			findings.errors[#findings.errors + 1] = {
 				line = def.source_line,
 				msg  = string.format(
-					"atom_dbg_reg_default at line %d for %q uses unknown type %q (allowed: byte-width primitives, V*_S*, M3_S2, MipsCode, void)",
+					"atom_dbg_reg_default at line %d for %q uses unknown type %q (not in type_name_registry)",
 					def.source_line, reg, tostring(def.type_name)),
 			}
 		end
 	end
 end
 
---- Check: atom_reg_types(R_X, <type>) entries must point to a compute register
---- (R_T0..R_T3) with a recognized fundamental type.
+--- Check: atom_reg_types(R_X, <type>) entries must point to a register declared in `pipe_ctx.register_alias_registry`, with a type name found in `pipe_ctx.type_name_registry`. 
+--- The alias ident `R_<n>` now encodes the GPR identity only for entries that are explicitly opted in via the bare `atom_reg` marker.
+--- R_T0..R_T3 are intentionally NOT auto-included (per the prototype principle: no auto-include of wave-context; explicit opt-in only). 
+--- The check fires for any R_T0..R_T3 reference that hasn't been opted in via `#define atom_reg`.
 --- @param _src SourceFile
 --- @param pipe_ctx PipeCtx
 --- @param findings Findings
 local function check_atom_reg_types(_src, pipe_ctx, findings)
+	local reg_registry  = pipe_ctx.register_alias_registry or {}
+	local type_registry = pipe_ctx.type_name_registry      or {}
 	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do
 		if ai.reg_type_overrides then
 			for reg, ov in pairs(ai.reg_type_overrides) do
-				if not reg:match(COMPUTE_REG_RE) then
+				if not reg_registry[reg] then
 					findings.errors[#findings.errors + 1] = {
 						line = ai.info_line,
 						msg  = string.format(
-							"atom '%s' has atom_reg_types for %q; compute-register types are restricted to R_T0..R_T3",
-							ai.atom_name, reg),
+							"atom '%s' has atom_reg_types for %q; compute-register types are restricted to opt-in aliases (%q not in register_alias_registry)",
+							ai.atom_name, reg, reg),
 					}
 				end
-				if not ov.type_name or not ALLOWED_COMPUTE_TYPES[ov.type_name] then
+				if not ov.type_name or not type_registry[ov.type_name] then
 					findings.errors[#findings.errors + 1] = {
 						line = ai.info_line,
 						msg  = string.format(
-							"atom '%s' atom_reg_types for %q uses unknown compute type %q (allowed: U1/U2/U4/S1/S2/S4)",
+							"atom '%s' atom_reg_types for %q uses unknown compute type %q (not in type_name_registry)",
 							ai.atom_name, reg, tostring(ov.type_name)),
 					}
 				end
@@ -397,16 +324,14 @@ local function check_binds_no_duplicate_fields(_src, pipe_ctx, findings)
 end
 
 -- Check: skip-over markers must satisfy shape + placement constraints.
---- Walks the priority list once; at most one error is appended per marker so that
---- a single source-level defect does not cascade into multiple findings.
+--- Walks the priority list once; at most one error is appended per marker so that a single source-level defect does not cascade into multiple findings.
 --- Priority order (first defect wins):
 ---   1. has_parens == false         -> requires parentheses: marker()
 ---   2. args  ~= ""                 -> takes no arguments
 ---   3. superseded_by_marker_line   -> duplicate marker (cite superseding line)
 ---   4. pending + no target_kind    -> dangling (no following declaration)
----   5. unsupported target_kind      -> marker precedes an unrelated declaration
---- Valid markers before whole-atom / bare-component / proc-component declarations
---- emit no error and remain in src.scan.skip_over.atoms / .components.
+---   5. unsupported target_kind     -> marker precedes an unrelated declaration
+--- Valid markers before whole-atom / bare-component / proc-component declarations emit no error and remain in src.scan.skip_over.atoms / .components.
 --- @param marker SkipOverMarker
 --- @param _pipe_ctx PipeCtx     -- unused today; kept for plex-shape consistency with per_annot
 --- @param findings Findings
@@ -460,30 +385,62 @@ local function check_skip_marker(marker, _pipe_ctx, findings)
 	end
 end
 
+--- Migration warning emitted alongside the new registry-membership check.
+---
+--- R_TapePtr / R_AtomJmp / R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase
+--- are the wave-context aliases opted in via `#define atom_reg` in lottes_tape.h (Task 21).
+--- Any source referencing an R_X that's NOT in the registry will trip the new check; a single pass-level info entry
+--- (emitted only when at least one such rejection lands in this source) tells users where to look.
+---
+--- Track A Task 13 added the proper `enum_alias_membership` per_source rule;
+--- this is the stop-gap until users migrate off raw C-ABI register names.
+--- @param _src SourceFile
+--- @param pipe_ctx PipeCtx
+--- @param findings Findings
+local function check_wave_context_migration(_src, pipe_ctx, findings)
+	if not (pipe_ctx.types and next(pipe_ctx.types)) then return end
+	if not (pipe_ctx.atom_infos_list) then return end
+	local reg_registry = pipe_ctx.register_alias_registry or {}
+	for _, ai in ipairs(pipe_ctx.atom_infos_list) do
+		if ai.reg_type_overrides then
+			for reg, _ in pairs(ai.reg_type_overrides) do
+				if not reg_registry[reg] then
+					findings.warnings[#findings.warnings + 1] = {
+						line = 0,
+						msg  = "wave-context removed; opt in via #define atom_reg in mips.h "
+							.. "(every R_<alias> that should be visible to the annotation pass "
+							.. "must be enum-declared with the bare atom_reg marker; see Track A Task 21)",
+					}
+					return
+				end
+			end
+		end
+	end
+end
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- CHECK_RULES — data-driven check dispatch (the plex pattern)
 -- ════════════════════════════════════════════════════════════════════════════
 --
 -- Each rule entry picks one of four "shapes" of dispatch:
---   per_annot(annot, pipe_ctx, findings)        — runs once per AtomAnnotation
---   post(pipe_ctx, findings)                    — runs once after all per_annot calls complete (full-corpus aggregation)
---   per_macro(macro, wc, findings)              — runs once per TAPE_WORDS / _Pragma macro declaration
---   per_skip_marker(marker, pipe_ctx, findings) — runs once per src.scan.skip_over.markers entry
+--   per_annot(annot, pipe_ctx, findings)        -- runs once per AtomAnnotation
+--   post(pipe_ctx, findings)                    -- runs once after all per_annot calls complete (full-corpus aggregation)
+--   per_macro(macro, wc, findings)              -- runs once per TAPE_WORDS / _Pragma macro declaration
+--   per_skip_marker(marker, pipe_ctx, findings) -- runs once per src.scan.skip_over.markers entry
 --
 -- Adding a new check = 1 row here + 1 function above. The `validate()` dispatch loop never needs editing.
 
 local CHECK_RULES = {
 	{ name = "atom_decl_exists",          per_annot       = check_atom_decl_exists          },
 	{ name = "binds_struct_exists",       per_annot       = check_binds_struct_exists       },
-	{ name = "binds_field_wave_context",  per_annot       = check_binds_field_wave_context  },
-	{ name = "reads_wave_context",        per_annot       = check_reads_wave_context        },
 	{ name = "unique_annotation",         post            = check_unique_annotation         },
 	{ name = "macro_word_drift",          per_macro       = check_macro_word_drift          },
-	{ name = "skip_marker_validation",    per_skip_marker = check_skip_marker              },
+	{ name = "skip_marker_validation",    per_skip_marker = check_skip_marker               },
 	{ name = "semantic_reg_defaults",     per_source      = check_semantic_reg_defaults     },
 	{ name = "atom_reg_types",            per_source      = check_atom_reg_types            },
 	{ name = "atom_view_layout",          per_source      = check_atom_view_layout          },
 	{ name = "binds_no_duplicate_fields", per_source      = check_binds_no_duplicate_fields },
+	{ name = "wave_context_migration",    per_source      = check_wave_context_migration    },
 }
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -536,15 +493,19 @@ local function validate(ctx, src)
 	end
 
 	local pipe_ctx = {
-		atom_index      = {},
-		binds_index     = {},
-		annot_counts    = {},
-		types           = scan.types or {},
-		type_occurrences = scan.type_occurrences or {},
-		atom_views      = scan.atom_views or {},
-		seen_defaults   = seen_defaults,
-		atom_infos_list = atom_infos_list,
-		binds_list      = scan.binds or {},
+		atom_index               = {},
+		binds_index              = {},
+		annot_counts             = {},
+		types                    = scan.types or {},
+		type_occurrences         = scan.type_occurrences or {},
+		atom_views               = scan.atom_views or {},
+		seen_defaults            = seen_defaults,
+		atom_infos_list          = atom_infos_list,
+		binds_list               = scan.binds or {},
+		-- Project the source-derived registries from the scan payload so per_source checks consult them instead of the deleted
+		-- SEMANTIC_DEFAULT_REGS / KNOWN_REG_DEFAULT_TYPES / etc.
+		register_alias_registry  = scan.register_alias_registry or {},
+		type_name_registry       = scan.type_name_registry or {},
 	}
 	for _, a in ipairs(atoms)      do pipe_ctx.atom_index [a.name] = a end
 	for _, b in ipairs(scan.binds) do pipe_ctx.binds_index[b.name] = b end
@@ -691,8 +652,7 @@ function M.run(ctx)
 	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.
+	-- 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)
 
diff --git a/scripts/passes/atoms_source_map.lua b/scripts/passes/atoms_source_map.lua
index 3c44d2b..ffd9908 100644
--- a/scripts/passes/atoms_source_map.lua
+++ b/scripts/passes/atoms_source_map.lua
@@ -170,17 +170,23 @@ end
 
 --- Compute per-word provenance entries for an atom. Mirrors `compute_word_entries` but additionally classifies each emitted `.word` as either:
 ---   - `RAW`     — emitted by a direct instruction token (no component provenance)
----   - `MACRO X` — emitted by a `mac_X(...)` component invocation,
----                 with the component's definition file:line resolved from `ctx.shared.components`.
+---   - `MACRO X` — emitted by a `mac_X(...)` component invocation, with the component's definition file:line resolved from `ctx.shared.components`.
 ---
---- Returns a list of `{pos, line, text, comp_name, comp_line, comp_path}` entries + the total word count.
---- `comp_name` is nil for RAW rows.
+--- Returns a list of `{pos, line, text, comp_name, comp_line, comp_path, body_line}` entries + the total word count.
+--- `comp_name` is nil for RAW rows. `body_line` is the line of THIS specific word in the macro body (component source file, not the caller's source);
+--- it differs from `comp_line` (= the macro signature line) for every body word whose macro-body token is on a different physical line.
+--- `body_line` is `nil` for RAW rows and for component words whose component declaration could not be indexed (older pass combinations / external macros).
+---
+--- The per-word body-line lookup mirrors `passes/dwarf_injection.lua :: compute_invocation_body_lines`:
+--- walk the component's pre-tokenized body in lockstep with `count_token_words` and attribute the source line via `src.scan.line_of(...)` to each emitted `.word`.
+--- Atom labels (`atom_label(...)`) emit 0 `.word`s and are skipped to stay aligned with the macro-side word-counting contract.
 --- @param atom table  -- one entry of scan.atoms / scan.raw_atoms
 --- @param src  table  -- SourceFile (has .scan with .line_of(), .path)
 --- @param wc   table  -- shared.word_counts
 --- @param comp table  -- shared.components map: bare_name -> {name=, line=, path=, kind=}
+--- @param comp_body_index table  -- per-source component body index: bare_name -> {body_off, body_tokens, line_of}
 --- @return table[], integer
-local function compute_provenance_entries(atom, src, wc, comp)
+local function compute_provenance_entries(atom, src, wc, comp, comp_body_index)
 	local entries = {}
 	local pos     = 0
 	for _, t in ipairs(atom.body_tokens) do
@@ -207,10 +213,41 @@ local function compute_provenance_entries(atom, src, wc, comp)
 			comp_kind = comp[bare].kind
 		end
 
+		-- Per-word body lines: lazily allocate from the indexed component body the first time we see a `mac_X(...)` call to a given component.
+		-- We allocate ONE full body_lines vector per (call) and consume it sequentially; 
+		-- if a single atom calls the same component more than once, each call refetches its own vector. 
+		-- (Today no atom calls the same `mac_X(...)` twice, but the refetch keeps the semantics correct even if that changes.)
+		local body_lines = nil
+		local function fetch_body_lines()
+			if not (bare and comp_body_index) then return nil end
+			local idx = comp_body_index[bare]
+			if not (idx and idx.body_tokens and idx.line_of) then return nil end
+			local lines = {}
+			for _, bt in ipairs(idx.body_tokens) do
+				local bt_tok = duffle.trim(bt.tok or "")
+				if bt_tok ~= "" then
+					local leading = duffle.read_ident(bt_tok, 1)
+					local bt_words
+					if leading == "atom_label" or leading == "atom_offset" then
+						bt_words = 0
+					else
+						bt_words = count_token_words(bt_tok, wc)
+					end
+					if bt_words > 0 then
+						local body_line = idx.line_of(idx.body_off + bt.rel)
+						for _ = 1, bt_words do lines[#lines + 1] = body_line end
+					end
+				end
+			end
+			return lines
+		end
+
 		if words > 0 then
 			local line = src.scan.line_of(atom.body_off + rel)
 			local text = duffle.trim(tok):gsub("[\t\r\n]+", " ")
-			for _ = 1, words do
+			-- Fetch body_lines ONCE per token (one mac_X(...) call exhausts N body words).
+			if comp_name then body_lines = fetch_body_lines() end
+			for i = 1, words do
 				entries[#entries + 1] = {
 					pos       = pos,
 					line      = line,
@@ -219,6 +256,7 @@ local function compute_provenance_entries(atom, src, wc, comp)
 					comp_line = comp_line,
 					comp_path = comp_path,
 					comp_kind = comp_kind,
+					body_line = body_lines and body_lines[i],
 				}
 				pos = pos + 1
 			end
@@ -228,26 +266,35 @@ local function compute_provenance_entries(atom, src, wc, comp)
 end
 
 --- Render one atom's provenance stanza. Format:
----   `WORD N  CALL <src-path>:<src-line>  MACRO <name> "<def-path>:<def-line>"`  (for component words)
----   `WORD N  CALL <src-path>:<src-line>  RAW`                                   (for direct instructions)
+---   `WORD N  CALL <src-path>:<src-line>  MACRO <name> "<def-path>:<def-line>"  [BODY <line>]`  (for component words)
+---   `WORD N  CALL <src-path>:<src-line>  RAW`                                                  (for direct instructions)
+--- `BODY <line>` is the source line of THIS specific word within the macro body
+--- (lottes_tape.h:N where N is the per-word body line).
+--- Absent for RAW rows and for component rows whose component declaration could not be indexed (older pass combinations / external macros).
+--- Downstream consumers (dwarf_injection, tests) fall back to DefLine / comp_line when BODY is absent.
 --- Returns (lines, total_words).
 --- @param src    table
 --- @param atom   table
 --- @param wc     table
 --- @param comp   table  -- shared.components map
+--- @param comp_body_index table  -- per-source component body index: bare_name -> {body_off, body_tokens, line_of}
 --- @return string[], integer
-local function emit_provenance_stanza(src, atom, wc, comp)
+local function emit_provenance_stanza(src, atom, wc, comp, comp_body_index)
 	local lines    = {}
 	local rel_path = src.path:gsub("\\", "/")
-	local entries, total = compute_provenance_entries(atom, src, wc, comp)
+	local entries, total = compute_provenance_entries(atom, src, wc, comp, comp_body_index)
 
 	-- ATOM header line with placeholder total (patched after we know it).
 	lines[#lines + 1] = string.format('ATOM %s "%s" 0', atom.raw_name or atom.name, rel_path)
 
 	for _, pe in ipairs(entries) do
 		if pe.comp_name then
-			lines[#lines + 1] = string.format('WORD %d  CALL %s:%d  MACRO %s "%s:%d"',
-				pe.pos, rel_path, pe.line, pe.comp_name, pe.comp_path, pe.comp_line)
+			local body_suffix = ""
+			if pe.body_line then
+				body_suffix = "  BODY " .. tostring(pe.body_line)
+			end
+			lines[#lines + 1] = string.format('WORD %d  CALL %s:%d  MACRO %s "%s:%d"%s',
+				pe.pos, rel_path, pe.line, pe.comp_name, pe.comp_path, pe.comp_line, body_suffix)
 		else
 			lines[#lines + 1] = string.format("WORD %d  CALL %s:%d  RAW", pe.pos, rel_path, pe.line)
 		end
@@ -259,26 +306,38 @@ local function emit_provenance_stanza(src, atom, wc, comp)
 	return lines, total
 end
 
+--- Build a per-source component body index keyed by the bare component name (e.g. `gte_load_tri_verts`).
+--- Each entry holds the data we need to map each emitted `.word` to its actual source line within the macro body:
+---   body_off    -- byte offset of the `{` (start of body) in the component's source file.
+---   body_tokens -- list of {tok, rel} pairs; `rel` is the byte offset within the body.
+---   line_of     -- closure resolving byte offsets in the component's source file to lines.
+--- Only `comp_bare` + `comp_proc` declarations contribute (a macro invocation can only resolve to one of those).
+--- First declaration wins (subsequent redeclarations would collide; today's sources declare each component exactly once).
 --- Render the full provenance file content for one source (one `.atoms.provenance.txt` per source).
 --- @param src table
 --- @param wc table
 --- @param comp table  -- shared.components map
+--- @param comp_body_index table  -- cross-source component body index (built once in M.run; may be empty)
 --- @return string
-local function render_provenance(src, wc, comp)
+local function render_provenance(src, wc, comp, comp_body_index)
 	local lines = {}
 	lines[#lines + 1] = "# FORMAT_VERSION 1"
 	lines[#lines + 1] = "# auto-generated by ps1_meta.lua (passes/atoms_source_map.lua) — DO NOT EDIT"
 	lines[#lines + 1] = "# Per-.word provenance: maps each emitted .word to its call site (atom body"
 	lines[#lines + 1] = "# file:line) and, when the word was emitted by a `mac_X(...)` component invocation,"
-	lines[#lines + 1] = "# the component's definition file:line. Used by dwarf_injection to synthesize"
-	lines[#lines + 1] = "# DW_TAG_inlined_subroutine instances for component step-into."
+	lines[#lines + 1] = "# the component's definition file:line + the per-word BODY line. Used by"
+	lines[#lines + 1] = "# dwarf_injection to synthesize DW_TAG_inlined_subroutine instances + per-word"
+	lines[#lines + 1] = "# line program rows for native source-level step into component bodies."
+
+	-- The cross-source component body index is passed in from M.run (one global lookup shared across every source's provenance file).
+	-- A per-source lookup would miss every component whose declaration is in another source (e.g. `gte_load_tri_verts` is declared in `lottes_tape.h` but invoked from `hello_gte_tape.c`).
 
 	for _, atom in ipairs(src.scan.atoms or {}) do
-		local stanza = emit_provenance_stanza(src, atom, wc, comp)
+		local stanza = emit_provenance_stanza(src, atom, wc, comp, comp_body_index)
 		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
 	end
 	for _, atom in ipairs(src.scan.raw_atoms or {}) do
-		local stanza = emit_provenance_stanza(src, atom, wc, comp)
+		local stanza = emit_provenance_stanza(src, atom, wc, comp, comp_body_index)
 		for _, line in ipairs(stanza) do lines[#lines + 1] = line end
 	end
 
@@ -648,9 +707,44 @@ end
 
 local M = {}
 
+--- Build the cross-source component body index used by `render_provenance` to attribute each emitted `.word` to its actual line within the macro body.
+---
+--- Components are declared in one source (the header that contains `MipsAtomComp_(ac_X)` / `MipsAtomComp_Proc_(ac_X, ...)`) 
+--- but invoked from many source files (every atom body that calls `mac_X(...)`).
+--- The body_offset + body_tokens + line_of live with the declaration source, so a per-source index would miss invocations from other sources.
+---
+--- The cross-source index is keyed by the bare component name (`gte_load_tri_verts`, NOT `ac_gte_load_tri_verts`) — `strip_mac_prefix_from_token` strips the `mac_` prefix
+--- from call-site identifiers and yields that exact bare name; matching it here keeps the lookup aligned with the `ctx.shared.components` map's keying convention.
+--- First declaration wins (subsequent redeclarations would collide; today's sources declare each component exactly once).
+--- @param ctx PassCtx
+--- @return table<string, table>  -- {[comp_name] = {body_off, body_tokens, line_of}}
+local function build_cross_source_component_body_index(ctx)
+	local index = {}
+	for _, src in ipairs(ctx.sources or {}) do
+		if src.scan and src.scan.atoms then
+			local line_of = src.scan.line_of
+			for _, atom in ipairs(src.scan.atoms) do
+				if atom.kind == "comp_bare" or atom.kind == "comp_proc" then
+					-- Prefer `atom.name` (stripped of `ac_` prefix); fall back to `raw_name`
+					-- only if the stripped name is absent (defensive — current scan-source always sets both).
+					local name = atom.name or atom.raw_name
+					if name and not index[name] then
+						index[name] = {
+							body_off    = atom.body_off,
+							body_tokens = atom.body_tokens,
+							line_of     = line_of,
+						}
+					end
+				end
+			end
+		end
+	end
+	return index
+end
+
 --- Pass entry: emit one `<out_root>/<basename>.atoms.sourcemap.txt` per source file that contains at least one `MipsAtom_(name)` / `MipsCode code_<name>` declaration.
 --- Also emits `<out_root>/<basename>.atoms.provenance.txt`:
---- per-.word provenance with `mac_X(...)` component resolution back to the component's definition file:line.
+--- per-.word provenance with `mac_X(...)` component resolution back to the component's definition file:line + the per-word body line.
 --- Optionally also emit `<ctx.out_root>/gdb_tape_atoms_runtime.gdb` when `ctx.flags.gdb_runtime` is true.
 --- @param ctx PassCtx
 --- @return PassResult
@@ -674,6 +768,12 @@ function M.run(ctx)
 	-- If absent, all words fall through as RAW (correct behavior — provenance is additive).
 	local comp = (ctx.shared and ctx.shared.components) or {}
 
+	-- Cross-source component body index.
+	-- Built ONCE so every source's provenance writer can resolve `mac_X(...)` invocations back to the macro's body tokens (regardless of which source declared the component).
+	-- Per-source copies were insufficient — the atom file (`hello_gte_tape.c`) does not contain the `MipsAtomComp_(...)` declarations, 
+	-- so the body data would be missing for every component invocation the atom file emitted.
+	local comp_body_index = build_cross_source_component_body_index(ctx)
+
 	-- Always emit the canonical text form (per-source).
 	for _, src in ipairs(ctx.sources) do
 		if src.scan then
@@ -689,7 +789,7 @@ function M.run(ctx)
 				-- (2) atoms.provenance.txt — per-.word provenance with `mac_X(...)` component resolution back to the component's definition file:line.
 				--     Consumed by `passes/dwarf_injection.lua` to synthesize `DW_TAG_inlined_subroutine` instances for source-level Step Into on component invocations.
 				local prov_path = ctx.out_root .. "/" .. basename .. ".atoms.provenance.txt"
-				local prov_body = render_provenance(src, wc, comp)
+				local prov_body = render_provenance(src, wc, comp, comp_body_index)
 
 				if not ctx.dry_run then
 					duffle.ensure_dir(duffle.dirname(sourcemap_path))
diff --git a/scripts/passes/dwarf_injection.lua b/scripts/passes/dwarf_injection.lua
index d061129..ef1c123 100644
--- a/scripts/passes/dwarf_injection.lua
+++ b/scripts/passes/dwarf_injection.lua
@@ -1,18 +1,12 @@
 --- passes/dwarf_injection.lua — Per-atom DWARF injection for tape-atom step-debug (F' + G').
 ---
---- Reads the post-link ELF directly 
---- (lfs + io.open; walks the ELF32 section header table to find 
---- 	`.debug_info` 
---- + `.debug_abbrev` 
---- + `.debug_str` 
---- + `.debug_line` 
---- + `.debug_aranges` 
---- + `.debug_rnglists`),
---- APPENDS synthetic DWARF line-program sequences for every `code_<name>` atom, EXTENDS the `.debug_aranges` and main-CU range tables with the atom ranges,
---- APPENDS a new compilation unit to `.debug_info` with per-atom `DW_TAG_subprogram` + per-wave-context-reg `DW_TAG_variable` entries
---- (so `R_PrimCursor` etc. appear as atom-scoped locals in VSCode's Variables pane).
---- Writes the new section data to `<out_root>/<basename>.dwarf_*.bin` (7 blobs total)
---- plus deterministic `<out_root>/<basename>.gdbinit` skip commands.
+--- Reads the post-link ELF directly (lfs + io.open; walks the ELF32 section header table to find
+--- `.debug_info` + `.debug_abbrev` + `.debug_str` + `.debug_line` + `.debug_aranges` + `.debug_rnglists`),
+--- APPENDS synthetic DWARF line-program sequences for every `code_<name>` atom, EXTENDS the `.debug_aranges`
+--- and main-CU range tables with the atom ranges, and APPENDS a new compilation unit to `.debug_info` with
+--- per-atom `DW_TAG_subprogram` + per-wave-context-reg `DW_TAG_variable` entries (so `R_PrimCursor` etc.
+--- appear as atom-scoped locals in VSCode's Variables pane). Writes the new section data to
+--- `<out_root>/<basename>.dwarf_*.bin` (7 blobs total) plus deterministic `<out_root>/<basename>.gdbinit` skip commands.
 ---
 --- The `build_psyq.ps1` post-link hook then splices those `.bin` files into a copy of the ELF via:
 ---   mipsel-none-elf-objcopy --update-section .debug_info=<bin>     <elf>
@@ -26,13 +20,11 @@
 --- Splice step runs from PowerShell — no Lua subprocess; no cmd /c parsing issues.
 --- objcopy's --update-section works fine in PowerShell even though Lua's `os.execute`/`io.popen` would mangle the `=` on Windows.)
 ---
---- Result: VSCode's source gutter follows per-stepi inside atom bodies (F'),
---- AND the Variables pane shows the wave-context regs as atom-scoped locals (G').
+--- Result: VSCode's source gutter follows per-stepi inside atom bodies (F'), AND the Variables pane shows the wave-context regs as atom-scoped locals (G').
 --- Native VSCode UX (gutter arrow + highlighted line + Run to Cursor + conditional BPs by source line + per-atom locals).
 --- No VSCode plugin, no Python, no pyelftools — pure Lua + objcopy.
 ---
---- **Conventions:** tabs (1/level), EmmyLua annotations, no regex,
---- Lua 5.3 compatible.
+--- **Conventions:** tabs (1/level), EmmyLua annotations, no regex, Lua 5.3 compatible.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Bootstrap
@@ -48,15 +40,25 @@ local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 -- (read_elf_sections, nm, source-map parser, LE byte r/w). `list_dir` lives in duffle.lua as a general I/O primitive (lifted out during F'').
 local elf_dwarf = require("elf_dwarf")
 
+-- word-counting helper shared with passes/atoms_source_map.lua.
+-- Used here to walk a component's body_tokens in lockstep with their word-count allocation
+-- when we propagate per-word body lines into each invocation's `body_lines` array.
+local word_count_eval = require("word_count_eval")
+local count_token_words = word_count_eval.count_token_words
+
 local lfs = require("lfs")
 
+-- File-scope LEB128 aliases; the helpers are available at module-load time so no forward-reference table is needed.
+local uleb128 = elf_dwarf.uleb128
+local sleb128 = elf_dwarf.sleb128
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- DWARF line-program opcodes + range-list entry encodings (per DWARF5 spec).
--- All values lifted from `elf_dwarf.DWARF_LINE_OPS` + `elf_dwarf.DWARF5_RNGLISTS`. 
--- Local aliases preserve the F' code's readability 
+-- All values lifted from `elf_dwarf.DWARF_LINE_OPS` + `elf_dwarf.DWARF5_RNGLISTS`.
+-- Local aliases preserve the F' code's readability
 -- (e.g. `DW_LNS_copy` reads better than `elf_dwarf.DWARF_LINE_OPS.DW_LNS_copy` in an emitter body).
 local DWARF_LINE_OPS      = elf_dwarf.DWARF_LINE_OPS
 local DWARF5_RNGLISTS     = elf_dwarf.DWARF5_RNGLISTS
@@ -78,34 +80,16 @@ local DW_RLE_start_length  = DWARF5_RNGLISTS.start_length
 -- The injector extends that unit rather than appending an unreferenced unit.
 local ATOM_SOURCE_FILE_INDEX = 11
 
--- Wave-context registers (per duffle.lua :: WAVE_CONTEXT_REGS). The MIPS register number is what DW_OP_regN uses as N.
---
---   R_PrimCursor = R_T7 = $15   →  DW_OP_reg15
---   R_FaceCursor = R_T4 = $12   →  DW_OP_reg12
---   R_VertBase   = R_T5 = $13   →  DW_OP_reg13
---   R_OtBase     = R_T6 = $14   →  DW_OP_reg14
---   R_TapePtr    = R_T8 = $24   →  DW_OP_reg24
---   R_AtomJmp    = R_T9 = $25   →  DW_OP_reg25
---
--- A register-resident variable uses DW_OP_regN (opcode 0x50 + N).
--- DW_OP_bregN instead describes a memory location addressed from a register;
--- it makes GDB dereference the atom register value rather than display it.
-local WAVE_CONTEXT_LOCATIONS = {
-	-- Names prefixed with `RR` to avoid collision with the C-level enum `{R_AtomJmp = 25, R_TapePtr = 24, R_InCursor = 12, R_PrimCursor = 15, ...}`
-	-- declared in the duffle headers (code/duffle/dsl.h or atom_dsl.h). 
-	-- Without the prefix, gdb's `print R_PrimCursor` resolves to the enum constant (= 15), not to this DWARF variable.
-	-- With `set print enum on` (gdb default for enum values), gdb displays the enum identifier, so the Watch panel shows
-	-- `R_PrimCursor = R_PrimCursor` instead of the register value.
-	{ name = "RR_PrimCursor", reg = 0x0F },   -- $15
-	{ name = "RR_FaceCursor", reg = 0x0C },   -- $12
-	{ name = "RR_VertBase",   reg = 0x0D },   -- $13
-	{ name = "RR_OtBase",     reg = 0x0E },   -- $14
-	{ name = "RR_TapePtr",    reg = 0x18 },   -- $24
-	{ name = "RR_AtomJmp",    reg = 0x19 },   -- $25
-}
+-- RR_<R_Name> debug-visible variables come from the merged register_alias_registry filtered to aliases whose code is a valid MIPS GPR 0..31
+-- (see collect_per_source_registries + by_alias in build_inserted_children).
+-- Names are prefixed with `RR` to avoid collision with the C-level enum (`{R_AtomJmp = 25, R_TapePtr = 24, R_PrimCursor = 15, ...}` declared in duffle headers);
+-- without the prefix, gdb's `print R_PrimCursor` resolves to the enum constant, not to this DWARF variable.
+-- With `set print enum on`, gdb displays the enum identifier, so the Watch panel would show `R_PrimCursor = R_PrimCursor` instead of the register value.
+-- Each RR_<R_Name>'s DW_OP_regN uses the alias's `code` as N.
+-- DW_OP_bregN would describe a memory location addressed from a register; 
+-- the breg form would make gdb dereference the atom register value rather than display it.
 
--- New abbreviation codes (100+ to avoid collision with gcc's existing
--- 1-60+ codes).
+-- New abbreviation codes (100+ to avoid collision with gcc's existing 1-60+ codes).
 local ABBREV_CU          = 0x64   -- 100: DW_TAG_compile_unit
 local ABBREV_SUBPROGRAM  = 0x65   -- 101: DW_TAG_subprogram
 local ABBREV_VARIABLE    = 0x66   -- 102: DW_TAG_variable (DW_AT_type = ref4 to U4; was missing pre-2026-07-13 → gdb resolved R_PrimCursor against the C-level enum, not the register)
@@ -122,118 +106,10 @@ local ABBREV_BIND_VAR_LOCLIST = 0x6D   -- 109: DW_TAG_variable no children + DW_
 
 -- DWARF5 §7.7.3 loclist opcodes.
 local DW_LLE_end_of_list    = 0x00
-local DW_LLE_start_length   = 0x06
+local DW_LLE_start_length   = 0x08
 local DW_OP_reg0            = 0x50   -- base reg op; regN = 0x50 + N
 local DW_OP_breg0           = 0x70   -- base breg op; bregN = 0x70 + N (SLEB offset)
 local MIPS_LOAD_DELAY_BYTES = 0x08 -- 1 load word + 1 BD-slot word
--- Late-binding table for forward references.
--- The loclist functions (defined below) use uleb128 + elf_dwarf which are not yet defined at this point. 
--- They look them up via this table at call time.
-local _late = { uleb128 = nil, elf_dwarf = nil }
-
--- Build the .debug_loclists section for every rbind atom. 
--- Returns the section bytes (DWARF5 layout: unit_length(4) + version=5(2) + address_size=4(1) + segment_size=0(1) + offset_entry_count=0(4) + DW_LLE entries; 
--- each atom contributes one loclist terminated by DW_LLE_end_of_list).
---
--- Per rbind atom we emit 2 loclist entries (tape → GPR split) using the last field's transition as the boundary. 
--- This is a conservative approximation that always reads the correct GPR value once the first load has retired (load_pc + 8).
--- A future task can refine to per-field transitions.
--- @param atom_table table[]  -- list of atoms with .rbind set
--- @return string  -- section bytes
-local function build_debug_loclists_section(atom_table)
-	-- Loclist header (per DWARF5 §7.7.3):
-	--   unit_length(4) + version(2) + address_size(1) + segment_size(1) + offset_entry_count(4)
-	-- All our entries are DW_LLE_start_length + addr(4) + length(ULEB) + expression terminated by DW_LLE_end_of_list (1 byte).
-	-- R_TapePtr is register 24 ($t8). R_<reg> maps via R_NAME_TO_INDEX above.
-	-- We compute the field-by-field transition: at each load_pc + 8, one more field has committed from tape memory to its destination GPR.
-	local tape_reg = R_NAME_TO_INDEX["R_TapePtr"]  -- = 24
-	if not tape_reg then tape_reg = 24 end  -- fallback if R_TapePtr isn't in the table
-	local parts = {}
-	for _, atom in ipairs(atom_table) do
-		if atom.rbind then
-			local fields   = atom.rbind.fields or {}
-			local regs     = atom.rbind.regs or {}
-			local n_fields = #fields
-			io.stderr:write(string.format("[loclists] %s: n_fields=%d, fields[1].name=%s offset=%s, regs[1]=%s\n",
-				atom.name, n_fields,
-				fields[1] and fields[1].name or "?",
-				fields[1] and tostring(fields[1].offset) or "?",
-				regs  [1] and (regs[1].field or "?") or "?"))
-			local last_load_pc = atom.addr + (n_fields - 1) * MIPS_BYTES_PER_WORD
-			local transition_pc = last_load_pc + MIPS_LOAD_DELAY_BYTES
-			-- Build the "all in tape" piece chain (one DW_OP_breg24 + offset + DW_OP_piece(4) per field).
-			local tape_pieces = {}
-			for _, f in ipairs(fields) do
-				local offset = f.offset or 0
-				local offset_sleb = elf_dwarf.sleb128(offset)
-				table.insert(tape_pieces, string.char(DW_OP_breg0 + tape_reg) .. offset_sleb .. string.char(DW_OP_piece) .. uleb128(4))
-			end
-			local tape_expr = table.concat(tape_pieces)
-			-- Build the "all in GPR" piece chain (one DW_OP_regN + DW_OP_piece(4) per field).
-			local gpr_pieces = {}
-			for _, pair in ipairs(regs) do
-				table.insert(gpr_pieces, string.char(DW_OP_reg0 + pair.reg) .. string.char(DW_OP_piece) .. uleb128(4))
-			end
-			local gpr_expr = table.concat(gpr_pieces)
-			-- Emit two DW_LLE_start_length entries + DW_LLE_end_of_list.
-			parts[#parts + 1] = string.char(DW_LLE_start_length)
-				.. elf_dwarf.write_u32_le(atom.addr)
-				.. uleb128(#tape_expr)
-				.. tape_expr
-			parts[#parts + 1] = string.char(DW_LLE_start_length)
-				.. elf_dwarf.write_u32_le(transition_pc)
-				.. uleb128(#gpr_expr)
-				.. gpr_expr
-			parts[#parts + 1] = string.char(DW_LLE_end_of_list)
-		end
-	end
-	-- Build the section header.
-	local body = table.concat(parts)
-	-- unit_length = 2 (version) + 1 (address_size) + 1 (segment_size) + 4 (offset_entry_count) + #body
-	local unit_length = 2 + 1 + 1 + 4 + #body
-	local header = elf_dwarf.write_u32_le(unit_length)
-		.. elf_dwarf.write_u16_le(5) -- version = 5
-		.. string.char(4)            -- address_size = 4
-		.. string.char(0)            -- segment_size = 0
-		.. elf_dwarf.write_u32_le(0) -- offset_entry_count = 0
-	return header .. body
-end
-
--- Compute the per-atom loclist offset within a .debug_loclists section that the caller will later pass to .debug_info
--- (DW_FORM_sec_offset is a 4-byte section-relative offset).
--- Returns a table {[atom_name] = offset_in_loclists}. 
--- The header is 12 bytes (unit_length(4) + version(2) + address_size(1) + segment_size(1) + offset_entry_count(4));
--- each loclist body is the sum of its DW_LLE entries (computed by replaying the same emission).
--- @param atom_table table[]  -- list of atoms with .rbind set
--- @return table  -- {[atom_name] = offset_in_section}
-local function compute_loclists_offsets(atom_table)
-	local offsets = {}
-	-- Header size = 4 (unit_length) + 2 (version) + 1 (address_size) + 1 (segment_size) + 4 (offset_entry_count)
-	local cursor = 4 + 2 + 1 + 1 + 4
-	for _, atom in ipairs(atom_table) do
-		if atom.rbind then
-			offsets[atom.name] = cursor
-			-- Each loclist body: 2 DW_LLE_start_length + 1 DW_LLE_end_of_list.
-			-- Per DW_LLE_start_length: 1 (opcode) + 4 (addr) + ULEB(length) + length bytes.
-			-- The length bytes are N pieces × (1 reg op + 1 piece op + 1 ULEB4) = 3N bytes for one-piece blocks
-			-- (tape: reg + SLEB + piece+4; GPR: reg + piece+4). 
-			-- For the all-tape form: N × (1 + 1 + 1) = 3N.
-			-- We compute the exact length for the current build.
-			local n_fields = #atom.rbind.fields
-			-- tape_expr: for each field, 1 (breg) + 1..4 (SLEB offset) + 1 (piece) + 1 (ULEB 4)
-			-- For our Binds_CubeTri / Binds_FloorTri, offsets are 0/4/8/12 (4 bytes ≤ 127, 1 SLEB byte).
-			-- So tape_expr = n_fields * 3 bytes.
-			local tape_expr_len = n_fields * 3
-			local tape_entry    = 1 + 4 + 1 + tape_expr_len
-			-- gpr_expr: for each field, 1 (reg op) + 1 (piece) + 1 (ULEB 4) = 3 bytes.
-			local gpr_expr_len = n_fields * 3
-			local gpr_entry    = 1 + 4 + 1 + gpr_expr_len
-			local body_len     = tape_entry + gpr_entry + 1  -- +1 for DW_LLE_end_of_list
-			cursor = cursor + body_len
-		end
-	end
-	return offsets
-end
 
 -- DWARF3/4/5 opcodes / attributes / forms (for the .debug_info synth).
 -- DW_TAG values are stable across DWARF3-5 per the standard's Table 7.1;
@@ -290,9 +166,8 @@ local function resolve_provenance_file_index(path)
 	if path == nil or path == "" then
 		error("[dwarf_injection] resolve_provenance_file_index: empty path")
 	end
-	-- Normalize backslashes → forward slashes (paths arrive with mixed separators from
-	-- the provenance file: forward slashes from Lua's io.lines; backslashes if the
-	-- input ever round-trips through Windows shell expansion).
+	-- Normalize backslashes → forward slashes (paths arrive with mixed separators from the provenance file: forward slashes from Lua's io.lines;
+	-- backslashes if the input ever round-trips through Windows shell expansion).
 	local normalized = path:gsub("\\", "/")
 	-- Take the last path component (the basename).
 	local basename = normalized:match("([^/]+)$") or normalized
@@ -325,40 +200,36 @@ local DW_ATE_unsigned        = 0x07   -- DWARF5 §7.8.1: DW_ATE_unsigned (used f
 local DW_LANG_C99            = 0x0C   -- = 12 (C99); use as a safe "C-like" placeholder
 -- (DW_LANG_Mips_Assembler = 0x8001 was used in the F', but we want this CU to look like a C TU so VSCode's Variables pane treats it as code.)
 
--- R_ alias → MIPS register number.
--- Subset covering every R_ name used in the source atoms.
--- Used to build the piece-chain location for bind_args (which field comes from which reg).
--- The wave-context entries match WAVE_CONTEXT_LOCATIONS above; the rest are the standard MIPS C-ABI register names.
-local R_NAME_TO_INDEX = {
-	["R_0"]  = 0,  ["R_AT"] = 1,  ["R_V0"] = 2,  ["R_V1"] = 3,
-	["R_A0"] = 4,  ["R_A1"] = 5,  ["R_A2"] = 6,  ["R_A3"] = 7,
-	["R_T0"] = 8,  ["R_T1"] = 9,  ["R_T2"] = 10, ["R_T3"] = 11,
-	["R_T4"] = 12, ["R_T5"] = 13, ["R_T6"] = 14, ["R_T7"] = 15,
-	["R_S0"] = 16, ["R_S1"] = 17,
-	["R_T8"] = 24, ["R_T9"] = 25,
-	-- Wave-context aliases (same encoding as R_T4..R_T7, R_T8..R_T9).
-	["R_PrimCursor"] = 15, ["R_FaceCursor"] = 12,
-	["R_VertBase"]   = 13, ["R_OtBase"]     = 14,
-	["R_TapePtr"]    = 24, ["R_AtomJmp"]    = 25,
-}
+-- R_<name> → MIPS GPR lookups go through the merged register_alias_registry
+-- (collected by collect_per_source_registries from ctx.sources[*].scan.register_alias_registry).
+-- Aliases without an `atom_reg` opt-in are absent from the registry, which means they are NOT debug-visible (no fallback GPR).
+-- See the precedence chain in build_inserted_children for the per-alias type resolution.
 
 -- Build the .debug_loclists section for every rbind atom.
--- Returns the section bytes (DWARF5 layout: unit_length(4) + version=5(2) + address_size=4(1)
--- + segment_size=0(1) + offset_entry_count=0(4) + DW_LLE entries; each atom contributes one loclist terminated by DW_LLE_end_of_list).
+-- Returns the section bytes (DWARF5 layout: unit_length(4) + version=5(2) + address_size=4(1) + segment_size=0(1) + offset_entry_count=0(4) + DW_LLE entries;
+-- each atom contributes one loclist terminated by DW_LLE_end_of_list).
 --
 -- Per rbind atom we emit 2 loclist entries (tape → GPR split) using the last field's transition as the boundary.
 -- This is a conservative approximation that always reads the correct GPR value once the first load has retired (load_pc + 8).
 -- A future task can refine to per-field transitions.
+--
+-- `tape_alias` (default: "R_TapePtr") names the wave-runtime pointer register whose value is the tape address.
+-- The GPR integer comes from the merged registry; if the alias is absent, this function fails loud 
+-- (the build was misconfigured; rbind atoms depend on R_TapePtr being in the registry for their piece-chain DW_OP_breg<N> location).
 -- @param atom_table table[]  -- list of atoms with .rbind set
--- @return string  -- section bytes
-local function build_debug_loclists_section(atom_table)
-	local uleb128    = _late.uleb128
-	local elf_dwarf  = _late.elf_dwarf
-	local tape_reg   = R_NAME_TO_INDEX["R_TapePtr"]  -- = 24
-	if not tape_reg then tape_reg = 24 end
+-- @param registries table    -- merged registries from collect_per_source_registries
+-- @return string             -- section bytes
+local function build_debug_loclists_section(atom_table, registries)
+	registries = registries or {}
+	-- R_TapePtr comes from the merged register_alias_registry (only present if the user opted it in via `#define atom_reg` in lottes_tape.h).
+	-- When absent we emit just the section terminator (a single DW_LLE_end_of_list byte);
+	-- the .debug_loclists section MUST not be empty for the linker, and `bind_args` will be emitted with no loclist PC range
+	-- (readelf will display it as having no .debug_loclists entries).
+	local tape_alias_entry = registries.register_alias_registry and registries.register_alias_registry["R_TapePtr"]
+	local tape_reg = tape_alias_entry and tape_alias_entry.code
 	local parts = {}
 	for _, atom in ipairs(atom_table) do
-		if atom.rbind then
+		if atom.rbind and tape_reg then
 			local fields        = atom.rbind.fields or {}
 			local regs          = atom.rbind.regs or {}
 			local n_fields      = #fields
@@ -483,6 +354,49 @@ local function collect_skip_over(ctx)
 	return skip_over
 end
 
+--- Merge the per-source scanner registries (register_alias_registry, type_name_registry, atom_views)
+--- into a single set of tables that downstream consumers can read from without re-iterating ctx.sources.
+---
+--- Every `R_*` lookup and per-atom type override resolution in this file goes through this merged table.
+--- Aliases without `atom_reg` adjacent are absent; the absence is treated as "not debug-visible" (see build_inserted_children for the precedence chain).
+---
+--- When two sources register the same key, the last-writer wins (later sources override earlier).
+--- Today only one source declares wave-context enums, so collisions are absent;
+--- future multi-source declarations would need a name-resolution rule (left as a follow-up).
+--- @param ctx DwarfInjectionCtx
+--- @return table  -- {
+---   register_alias_registry = {[R_Name]    = AliasEntry},
+---   type_name_registry      = {[T]         = TypeEntry},
+--- 	atom_views              = {[atom_name] = AtomViewEntry},
+--- }
+local function collect_per_source_registries(ctx)
+	local merged = {
+		register_alias_registry = {},
+		type_name_registry      = {},
+		atom_views              = {},
+		-- Per-atom atom_ctx declarations: atom_name -> {rbind_atom, ...}
+		-- (populated by scan_source from `atom_ctx(<atom_name>)` sub-calls inside `atom_info`)
+		atom_ctxs               = {},
+		-- Per-phase atom groups: phase_label -> {atoms = {atom_name1, ...}}
+		-- (populated by scan_source from `atom_phase(<label>)` sub-calls inside `atom_info`; cross-source merged)
+		atom_phases             = {},
+		-- Per-source already-resolved atom_infos (used by the precedence chain's ctx/phase steps)
+		atom_infos              = {},
+	}
+	for _, src in ipairs(ctx.sources or {}) do
+		local scan = src.scan
+		if scan then
+			for k, v in pairs(scan.register_alias_registry or {}) do merged.register_alias_registry[k] = v end
+			for k, v in pairs(scan.type_name_registry or {})      do merged.type_name_registry[k]      = v end
+			for k, v in pairs(scan.atom_views or {})              do merged.atom_views[k]              = v end
+			for k, v in pairs(scan.atom_ctxs or {})               do merged.atom_ctxs[k]               = v end
+			for k, v in pairs(scan.atom_phases or {})             do merged.atom_phases[k]             = v end
+			for _, ai in ipairs(scan.atom_infos or {})            do merged.atom_infos[#merged.atom_infos + 1] = ai end
+		end
+	end
+	return merged
+end
+
 --- Render deterministic debugger skip commands. Ordering is stable by category:
 --- exact atom symbols first (lexicographic), then exact component function names (lexicographic full command). 
 --- Atom commands come from the matched nm/source-map table so the emitted name is the actual ELF symbol.
@@ -520,15 +434,8 @@ end
 -- ════════════════════════════════════════════════════════════════════════════
 --
 -- Lifted to `elf_dwarf.uleb128` + `elf_dwarf.sleb128` (F'' refactor).
--- See those helpers for the bit-layout documentation + named constants
--- (LEB_CONT_BIT, LEB_DATA_MASK, SLEB_SIGN_BIT).
-
--- Local aliases so the line-program encoder (below) can keep its short names.
-local uleb128 = elf_dwarf.uleb128
--- Late-bind uleb128 + elf_dwarf into the loclist functions' lookup table.
-_late.uleb128   = uleb128
-_late.elf_dwarf = elf_dwarf
-local sleb128 = elf_dwarf.sleb128
+-- See those helpers for the bit-layout documentation + named constants (LEB_CONT_BIT, LEB_DATA_MASK, SLEB_SIGN_BIT).
+-- File-scope `local uleb128` + `local sleb128` aliases live near the module top so they're resolvable by every function below.
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- DWARF line-program encoder
@@ -577,7 +484,7 @@ local function build_atom_sequence(atom)
 	local function set_file(file_index)     return string.char(DW_LNS_set_file)     .. uleb128(file_index)  end
 	local function advance_pc(bytes_delta)  return string.char(DW_LNS_advance_pc)   .. uleb128(bytes_delta) end
 	local function advance_line(line_delta) return string.char(DW_LNS_advance_line) .. sleb128(line_delta)  end
-	local function negate_stmt()             return string.char(DW_LNS_negate_stmt) end
+	local function negate_stmt()            return string.char(DW_LNS_negate_stmt) end
 	local function end_sequence()
 		-- size = 1 (just the sub_opcode byte, no payload)
 		return string.char(DW_LNS_extended)
@@ -640,11 +547,11 @@ local function build_atom_sequence(atom)
 	local function emit_row(file_idx, line, want_stmt)
 		if cur_file ~= file_idx then
 			parts[#parts + 1] = set_file(file_idx)
-			cur_file = file_idx
+			cur_file          = file_idx
 		end
 		if cur_line ~= line then
 			parts[#parts + 1] = advance_line(line - cur_line)
-			cur_line = line
+			cur_line          = line
 		end
 		set_statement_state(want_stmt)
 		parts[#parts + 1] = copy_op()
@@ -672,15 +579,19 @@ local function build_atom_sequence(atom)
 	emit_row(entry_1_call_file, entry_1_call_line, atom_is_stmt)
 
 	-- If entry 1 is the first word of a component invocation, emit the component-definition row at the same PC immediately after.
-	-- A selected component suppresses only this definition view;
-	-- a selected atom suppresses both rows and therefore never inverts state for nested component markers.
+	-- The def line is always a statement target unless the inv is explicitly skip-over (atom_dbg_skip_over);
+	-- the whole-atom skip path takes the early-return at line ~497 above so atom_is_stmt is irrelevant here.
+	-- For the body row, prefer `body_lines[1]`  (the actual source line of the first body word in the macro's expansion)
+	-- over `comp_line` (the macro signature line).
+	-- When `body_lines` is absent (the component was not indexed by the scan, e.g. an external macro), 
+	-- fall back to `comp_line` so the line program remains valid.
 	if inv1 and 1 == inv1.start_pos + 1 then
 		local comp_file_idx_1 = resolve_provenance_file_index(inv1.comp_file)
-		emit_row(comp_file_idx_1, inv1.comp_line, atom_is_stmt and not inv1.skip_over)
+		local body_line_1     = (inv1.body_lines and inv1.body_lines[1]) or inv1.comp_line
+		emit_row(comp_file_idx_1, body_line_1, not inv1.skip_over)
 	end
 
-	-- GDB 12 zero-instruction-prologue marker:
-	-- duplicate of the PRIMARY entry-1 emission (the call-site row).
+	-- GDB 12 zero-instruction-prologue marker: duplicate of the PRIMARY entry-1 emission (the call-site row).
 	-- We must explicitly restore the source state to (call_file, call_line) before emitting the duplicate,
 	-- otherwise the duplicate lands at whatever state we ended entry-1 in (the component row, if entry 1 is an invocation start), 
 	---which would attach the marker to the wrong source statement.
@@ -700,13 +611,21 @@ local function build_atom_sequence(atom)
 			-- First word of a component invocation: emit TWO rows at this PC.
 			-- 1) call-site row remains a statement target unless the whole atom is marked.
 			emit_row(call_file_idx, inv.call_line, atom_is_stmt)
-			-- 2) selected component-definition view is non-statement.
-			emit_row(resolve_provenance_file_index(inv.comp_file), inv.comp_line,
-				atom_is_stmt and not inv.skip_over)
+			-- 2) component body row at this PC.
+			-- Prefer `body_lines[1]` over `comp_line` so gdb's `step` lands on the macro's actual body line (not the signature line above `{ ... }`).
+			-- Fallback to `comp_line` when the component isn't indexed.
+			local body_file_idx = resolve_provenance_file_index(inv.comp_file)
+			local body_line_1   = (inv.body_lines and inv.body_lines[1]) or inv.comp_line
+			emit_row(body_file_idx, body_line_1, not inv.skip_over)
 		elseif inv then
-			-- Subsequent word of an invocation: single comp-definition row.
-			emit_row(resolve_provenance_file_index(inv.comp_file), inv.comp_line,
-				atom_is_stmt and not inv.skip_over)
+			-- Subsequent word of an invocation: 1-based offset into body_lines:
+			-- word 1 of the invocation corresponds to body_lines[1], word 2 -> body_lines[2], etc.
+			-- 1-based offset = idx - inv.start_pos (since idx = inv.start_pos + i for the i-th body word).
+			-- When `body_lines` is missing (older emitters / external macros), fall back to comp_line.
+			local body_file_idx = resolve_provenance_file_index(inv.comp_file)
+			local words_into    = idx - inv.start_pos  -- 1-based word position in invocation
+			local body_line_i   = (inv.body_lines and inv.body_lines[words_into]) or inv.comp_line
+			emit_row(body_file_idx, body_line_i, not inv.skip_over)
 		else
 			-- RAW word: single call-site row. emit_row restores is_stmt after a selected component range before exposing this adjacent row.
 			emit_row(call_file_idx, entry.line, atom_is_stmt)
@@ -729,7 +648,17 @@ end
 --- Cross-references nm symbols with source-map.txt entries; sorted by addr.
 --- Also consumes the provenance file to record per-component invocations.
 --- Each atom gains an `invocations` field with one entry per `mac_X(...)` call site:
----   `{comp_name, call_file, call_line, comp_file, comp_line, start_pos, end_pos}`.
+---   `{comp_name, call_file, call_line, comp_file, comp_line, start_pos, end_pos, body_lines}`.
+---
+--- `body_lines` is the per-word source line within the macro body
+--- (lottes_tape.h:N where N is the actual line of this `.word` in the macro expansion).
+--- Without this field, the line program emits `comp_line` for EVERY body word, 
+--- so gdb's `step` from a `mac_X(...)` call lands on the macro signature line and immediately 
+--- returns without traversing the body (since no PC reports a different line).
+---
+--- The data is computed by walking the component's pre-tokenized body in `ctx.sources[i].scan.atoms[j]`
+--- (the MipsAtomComp_/MipsAtomComp_Proc_ declaration).
+--- Atom labels (`atom_label(...)`) emit 0 `.word`s and are ignored (matching `passes/atoms_source_map.lua :: is_marker_token` + `count_marker_rest`).
 --- @param ctx DwarfInjectionCtx
 --- @param skip_over table  -- collect_skip_over(ctx) result
 --- @return table[]  -- list of {name, addr, size_bytes, words, entries, invocations, skip_over?}
@@ -768,6 +697,64 @@ local function build_atom_table(ctx, skip_over)
 		end
 	end
 
+	-- Build a per-source component index keyed by the bare component name (e.g. `gte_load_tri_verts`, NOT `ac_gte_load_tri_verts`).
+	-- The bare name matches the provenance row's `comp_name` field (which is `strip_mac_prefix_from_token(tok)` — strips `mac_`, leaves the rest).
+	-- Each entry holds the data we need to walk the component body's tokens in lockstep with their word counts:
+	--   body_off    -- byte offset of the `{` (start of body) in the component's source file.
+	--   body_tokens -- list of {tok, rel} pairs; `rel` is the byte offset within the body.
+	--   line_of     -- closure resolving byte offsets in the component's source file to lines.
+	-- The data is consumed by `compute_invocation_body_lines` per invocation.
+	local component_index = {}
+	for _, src in ipairs(ctx.sources or {}) do
+		if src.scan and src.scan.atoms then
+			local line_of = src.scan.line_of
+			for _, atom in ipairs(src.scan.atoms) do
+				if atom.kind == "comp_bare" or atom.kind == "comp_proc" then
+					-- Prefer `atom.name` (stripped of `ac_` prefix); fall back to `raw_name`
+					-- only if `name` is missing (defensive; scan-source always sets both).
+					local name = atom.name or atom.raw_name
+					if name and not component_index[name] then
+						component_index[name] = {
+							body_off    = atom.body_off,
+							body_tokens = atom.body_tokens,
+							line_of     = line_of,
+							source_path = src.path,
+						}
+					end
+				end
+			end
+		end
+	end
+
+	-- Per-word line lookup for a component body: walk body_tokens, count each token's emitted .words via count_token_words, attribute that count the same source line.
+	-- Atom labels (atom_label/atom_offset) emit 0 .words; their lines are skipped to stay aligned with `passes/atoms_source_map.lua :: count_marker_rest`.
+	-- @param comp_name string  -- the bare name (e.g. `gte_load_tri_verts`)
+	-- @return table            -- list of source lines, 1-based by word position; empty if no data
+	local wc = (ctx.shared and ctx.shared.word_counts) or {}
+	local function compute_invocation_body_lines(comp_name)
+		local comp_idx = component_index[comp_name]
+		if not (comp_idx and comp_idx.body_tokens and comp_idx.line_of) then return {} end
+		local lines = {}
+		for _, bt in ipairs(comp_idx.body_tokens) do
+			local tok   = duffle.trim(bt.tok or "")
+			if tok ~= "" then
+				-- Match atoms_source_map.lua's marker check (no public export; duplicated for independence).
+				local leading = duffle.read_ident(tok, 1)
+				local words
+				if leading == "atom_label" or leading == "atom_offset" then
+					words = 0  -- markers emit 0 .words; do not advance the body line counter.
+				else
+					words = count_token_words(tok, wc)
+				end
+				if words > 0 then
+					local body_line = comp_idx.line_of(comp_idx.body_off + bt.rel)
+					for _ = 1, words do lines[#lines + 1] = body_line end
+				end
+			end
+		end
+		return lines
+	end
+
 	-- Cross-ref; keep atoms that exist in both.
 	local out = {}
 	for name, info in pairs(addrs) do
@@ -808,6 +795,10 @@ local function build_atom_table(ctx, skip_over)
 								end_pos    = w.pos,
 								skip_over  = skip_over.components[component_skip_key(w.comp_file, w.comp_name)] ~= nil,
 							}
+							-- Capture the per-word body lines for THIS invocation, indexed by 1-based word position within the invocation. 
+							-- body_lines[1] is the line of the first body word (= the line of the first macro-body token, NOT the comp def line).
+							-- Downstream consumers (the line program emitter) fall back to comp_line when this is empty.
+							cur_inv.body_lines = compute_invocation_body_lines(w.comp_name)
 						end
 					else
 						-- RAW row: flush the current invocation.
@@ -852,64 +843,11 @@ end
 -- The atom body pops one field per `load_word(R_<reg>, R_TapePtr, O_(Binds_X,Field))`
 -- and the order of these load_word calls defines the (reg, field) pairing for the piece-chain DWARF location expression.
 --
--- We use the SourceScan payload populated by `passes/scan_source.lua` (the dep-closed upstream pass). 
+-- We use the SourceScan payload populated by `passes/scan_source.lua` (the dep-closed upstream pass).
 -- That pass walks each source once and populates `src.scan.atom_infos` (the atom_info sub-call parse) and `src.scan.binds` (the Binds_X struct field parse).
--- We re-walk the body for the (reg, field) pairing because the SourceScan pass doesn't preserve which R_<reg> receives which Binds_X.<field>.
 --
--- **Local Binds_X field re-parse**: the source-scan pass's `scan_binds_fields` only recognizes U4 fields;
--- The current source uses pointer types too (`V4_S2* FaceCursor`, `U4* OtBase`).
--- (don't change the shared scan-source pass), we re-parse the Binds_X typedef body locally with a more permissive rule: 
--- U4 field = 4 bytes; any pointer type (`*`-suffixed) = 4 bytes (MIPS32 pointer). Everything else = skip + advance.
-
---- Re-parse a Binds_X typedef body, returning {fields = {{name, offset}, ...}, bytes = N}.
---- Walks one ident at a time. A field declaration looks like:
----     U4 PrimCursor;        | M3_S2* transform;        | V4_S2* FaceCursor;       | U4* OtBase;
----   which tokenizes as: TYPE [WS+ *] WS+ FIELD SEMI
---- Where TYPE is `U4` (recognized), or TYPE + optional `*` (pointer, recognized).
---- Other type tokens (e.g. user-defined `Struct_(Foo)`) are skipped + we move on.
---- @param body string  -- the typedef body (between `{` and `}`)
---- @return table, integer  -- (fields, byte_count)
-local function reparse_binds_body(body)
-	local fields   = {}
-	local byte_off = 0
-	local pos      = 1
-	local body_len = #body
-	while pos <= body_len do
-		pos = duffle.skip_ws_and_cmt(body, pos)
-		if pos > body_len then break end
-		local type_ident, type_end = duffle.read_ident(body, pos)
-		if not type_ident then
-			pos = pos + 1
-		else
-			-- Scan past optional whitespace + `*` + whitespace.
-			-- Recognized field types: U4 (no *) OR any TYPE* (pointer, 4 bytes on MIPS32).
-			local p = duffle.skip_ws_and_cmt(body, type_end)
-			local is_pointer = false
-			local pointer_depth = 0
-			while p <= body_len and body:sub(p, p) == "*" do
-				is_pointer     = true
-				pointer_depth  = pointer_depth + 1
-				p = p + 1
-				p = duffle.skip_ws_and_cmt(body, p)
-			end
-			local field_pos              = duffle.skip_ws_and_cmt(body, p)
-			local field_ident, field_end = duffle.read_ident(body, field_pos)
-			-- A field is "recognized" if type is `U4` (no *) OR if it's a pointer.
-			if field_ident and (type_ident == "U4" or is_pointer) then
-				fields[#fields + 1] = {
-					name          = field_ident,
-					offset        = byte_off,
-					type_name     = type_ident,
-					pointer_depth = pointer_depth,
-				}
-				byte_off = byte_off + 0x04    -- 4 bytes per field on MIPS32
-			end
-			-- Advance past the field ident (or the type ident if no field was found).
-			pos = field_end or (type_end + 1)
-		end
-	end
-	return fields, byte_off
-end
+-- The prior local `reparse_binds_body` fallback (and the 2nd source walk inside `parse_rbind_atoms`) is REMOVED.
+-- parse_rbind_atoms consumes `scan.binds[i].fields` directly, which is populated by the scan-source pass with the typed-field record ({name, type_name, pointer_depth, offset, byte_size}).
 
 --- Find every `load_word(R_<reg>, R_TapePtr, O_(Binds_X, FieldName))` call in the atom body and return ordered (reg_index, field_name) pairs.
 ---
@@ -917,13 +855,19 @@ end
 ---   load_word(R_PrimCursor, R_TapePtr, O_(Binds_CubeTri,PrimCursor)),
 ---   load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,FaceCursor)),
 ---   ...
---- @param body string  -- the atom body text (between { ... })
---- @param binds_name string  -- expected Binds_X name (skip pairs with mismatching binds)
---- @return table[]  -- list of {reg = <MIPS index>, field = <field name>}
-local function parse_body_load_pairs(body, binds_name)
+---
+--- The GPR for each `R_<reg>` is looked up in the merged register_alias_registry; aliases absent from the registry
+--- (no `atom_reg` opt-in) are silently skipped — the resulting rbind record will be incomplete and the atom will fail to bind a usable piece chain.
+--- This is intentional: silently falling back to a hardcoded GPR would mask the missing opt-in.
+--- @param body string       -- the atom body text (between { ... })
+--- @param binds_name string -- expected Binds_X name (skip pairs with mismatching binds)
+--- @param registries table  -- merged registries from collect_per_source_registries
+--- @return table[]          -- list of {reg = <MIPS index>, field = <field name>}
+local function parse_body_load_pairs(body, binds_name, registries)
 	local pairs    = {}
 	local pos      = 1
 	local body_len = #body
+	local reg_index_by_name = (registries and registries.register_alias_registry) or {}
 	while pos <= body_len do
 		-- Find the next "load_word" identifier.
 		pos = duffle.skip_ws_and_cmt(body, pos)
@@ -949,9 +893,10 @@ local function parse_body_load_pairs(body, binds_name)
 					local third_arg = duffle.trim(args[3])
 					-- Match O_(Binds_<X>, FieldName)
 					local b, f = third_arg:match("^O_%((Binds_[%w_]+)%s*,%s*(.-)%s*%)$")
-					if b and b == binds_name and R_NAME_TO_INDEX[reg_name] then
+					local alias_entry = reg_index_by_name[reg_name]
+					if b and b == binds_name and alias_entry and alias_entry.code then
 						pairs[#pairs + 1] = {
-							reg   = R_NAME_TO_INDEX[reg_name],
+							reg   = alias_entry.code,
 							field = duffle.trim(f),
 						}
 					end
@@ -975,52 +920,36 @@ end
 ---
 --- The `regs` list per atom is ordered: each entry is the MIPS reg index that holds the matching field in the source-order pop sequence.
 --- The piece chain uses (DW_OP_regN, DW_OP_piece, ULEB128(field_size)).
+---
+--- The 2nd source walk (the body-text `text:find("typedef Struct_(...)")` re-walk) is removed;
+--- per-source `scan.binds[i].fields` already carries the typed-field record after the scan-source generalization.
 --- @param ctx DwarfInjectionCtx
---- @param atom_table table[]  -- the cross-ref'd atom table from build_atom_table
---- @return table, table  -- (rbind_atoms, rbind_structs)
-local function parse_rbind_atoms(ctx, atom_table)
+--- @param atom_table table[]     -- the cross-ref'd atom table from build_atom_table
+--- @param registries table       -- merged registries from collect_per_source_registries
+--- @return table, table          -- (rbind_atoms, rbind_structs)
+local function parse_rbind_atoms(ctx, atom_table, registries)
+	registries = registries or {}
 	local rbind_atoms   = {}
 	local rbind_structs = {}
 
-	-- Index binds by struct name; RE-PARSE the body locally (local parser handles pointer types too; the scan-source pass's parser only handles U4).
-	local binds_body_by_name = {}
+	-- Index binds by struct name; consume `scan.binds[i].fields` directly (no body-text re-walk).
+	-- The scan-source pass emits each Binds_X's fields as {[type_name, pointer_depth, offset, byte_size, ...]} 
+	-- so this pass can build the rbind_structs entry without re-parsing.
+	local binds_by_name = {}
 	for _, src in ipairs(ctx.sources or {}) do
 		local scan = src.scan
 		if scan then
 			for _, b in ipairs(scan.binds or {}) do
-				binds_body_by_name[b.name] = b  -- need `b.body`; falls through to local reparse below
+				binds_by_name[b.name] = b
 			end
 		end
 	end
 
-	-- Re-parse each Binds_X body via the local reparser (U4 + pointer support).
-	-- The scan-source pass preserves the original body text under each entry's `line` field but doesn't re-emit the body;
-	-- so we re-walk the source file directly for each Binds_X typedef. (Future: ask scan_source to preserve body.)
-	for binds_name in pairs(binds_body_by_name) do
-		local body_text = nil
-		for _, src in ipairs(ctx.sources or {}) do
-			local text = src.text
-			if text then
-				-- Look for `typedef Struct_(<binds_name>)` in the source.
-				-- Plain search (4th arg = true) avoids Lua pattern metachar interpretation.
-				local needle = "typedef Struct_(" .. binds_name .. ")"
-				local s, e   = text:find(needle, 1, true)
-				if s then
-					-- Find the body between `{` and matching `}` after `e`.
-					local brace = text:find("{", e, true)
-					if brace then
-						local inner, _after = duffle.read_braces(text, brace)
-						body_text = inner
-						break
-					end
-				end
-			end
-		end
-		if body_text then
-			local fields, byte_count  = reparse_binds_body(body_text)
+	for binds_name, b in pairs(binds_by_name) do
+		if b.fields and b.bytes then
 			rbind_structs[binds_name] = {
-				bytes      = byte_count,
-				fields     = fields,
+				bytes      = b.bytes,
+				fields     = b.fields,
 				atom_names = {},
 			}
 		end
@@ -1052,11 +981,11 @@ local function parse_rbind_atoms(ctx, atom_table)
 			local struct = rbind_structs[ai.binds]
 			local body   = body_by_atom[atom_name]
 			if struct and body then
-				local pairs = parse_body_load_pairs(body, ai.binds)
+				local pairs = parse_body_load_pairs(body, ai.binds, registries)
 				if #pairs > 0 then
 					rbind_atoms[atom_name] = {
 						binds     = ai.binds,
-						fields    = struct.fields,   -- {name, offset} from local reparse
+						fields    = struct.fields,   -- {name, offset} from scan.binds
 						bytes     = struct.bytes,
 						regs      = pairs,           -- ordered list of {reg, field}
 						info_line = ai.info_line,
@@ -1109,7 +1038,7 @@ local function build_dwarf_line_section(existing, atom_table)
 		if unit_pos + 3 > #existing then return existing end
 		local unit_length =  elf_dwarf.read_u32_le(existing, unit_pos)
 		if    unit_length == elf_dwarf.ELF32.dw_dwarf32_terminator then return existing end
-		local unit_end    = unit_pos + 3 + unit_length
+		local unit_end    =  unit_pos + 3 + unit_length
 		if unit_end > #existing then return existing end
 		last_pos, last_length, last_end = unit_pos, unit_length, unit_end
 		unit_pos                        = unit_end + 1
@@ -1215,7 +1144,6 @@ end
 --- Current section shape (one DWARF32 table):
 ---   unit_length(4), version=5(2), address_size=4(1), segment_size=0(1),
 ---   offset_entry_count=0(4), start_length entries..., end_of_list(1).
----
 --- @param existing string
 --- @param atom_table table
 --- @return string
@@ -1387,9 +1315,9 @@ end
 --- The declaration's attr-spec list ends at the (0, 0) pair.
 ---
 --- Returns nil on truncated or malformed input.
---- @param existing string  -- the .debug_abbrev section bytes
+--- @param existing string      -- the .debug_abbrev section bytes
 --- @param table_start integer  -- 0-based offset of the table's first byte
---- @return integer|nil  -- 0-based offset of the table-terminator byte
+--- @return integer|nil         -- 0-based offset of the table-terminator byte
 local function find_abbrev_table_end(existing, table_start)
 	local pos     = table_start
 	local buf_len = #existing
@@ -1625,10 +1553,27 @@ local function build_new_abbrev()
 end
 
 --- Build the new strings to append to .debug_str. Each string is null-terminated.
---- The CU name + comp_dir + 6 per-atom register names all go into one new blob.
---- @param atom_table table[]  -- list of {name, addr, size_bytes, ...}
---- @return string, table  -- (new_strings_blob, map_of_name_to_offset_in_new_blob)
-local function build_new_strings(atom_table)
+-- The CU name + comp_dir + one entry per RR_<name> debug-visible alias all go into one new blob.
+-- Register names are sourced from the merged registry filtered to MIPS GPR 0..31
+-- (the same filter that build_inserted_children applies for the RR_<name> locals, so .debug_str entries stay in sync with .debug_info).
+-- @param atom_table  table[]   -- list of {name, addr, size_bytes, ...}
+-- @param registries  table    -- merged registries from collect_per_source_registries
+-- @return string, table        -- (new_strings_blob, map_of_name_to_offset_in_new_blob)
+
+--- Strip a leading "R_" prefix from an enum alias name.
+--- The .debug_str/.debug_info consumers display the local without the C-enum prefix (RR_PrimCursor, not RR_R_PrimCursor)
+--- because the C-level identifier `R_PrimCursor` would collide with the enum constant value 15 when the user runs `print R_PrimCursor` in gdb.
+--- @param r_name string  -- e.g. "R_PrimCursor"
+--- @return string        -- "PrimCursor" (or the input unchanged if it does not start with "R_")
+local function strip_r_prefix(r_name)
+	if #r_name >= 2 and r_name:byte(1) == 0x52 and r_name:byte(2) == 0x5F then  -- "R_"
+		return r_name:sub(3)
+	end
+	return r_name
+end
+
+local function build_new_strings(atom_table, registries)
+	registries = registries or {}
 	-- The CU name + comp_dir are the first two strings (offsets 0 and N1).
 	-- Then each unique atom name + each register name follows.
 	local strings = {}
@@ -1653,11 +1598,16 @@ local function build_new_strings(atom_table)
 		end
 	end
 
-	-- Register names (one per unique wave-context reg)
-	for _, loc in ipairs(WAVE_CONTEXT_LOCATIONS) do
-		if not map[loc.name] then
-			map[loc.name]         = #table.concat(strings)
-			strings[#strings + 1] = loc.name .. "\0"
+	-- Register names (one per unique debug-visible R_Name alias from the merged registry,
+	-- filtered to MIPS GPR 0..31 — the same filter that build_inserted_children applies
+	-- for the RR_<name> locals, so .debug_str entries stay in sync with .debug_info).
+	for r_name, alias in pairs(registries.register_alias_registry or {}) do
+		if alias.code and alias.code >= 0 and alias.code <= 31 then
+			local rr_name = "RR_" .. strip_r_prefix(r_name)
+			if not map[rr_name] then
+				map[rr_name]         = #table.concat(strings)
+				strings[#strings + 1] = rr_name .. "\0"
+			end
 		end
 	end
 
@@ -1708,15 +1658,37 @@ end
 --- Our inserted DIEs live in the main CU, so every ref4 = (target section offset) - main_cu_offset.
 --- Per-die section offsets are tracked via the running `next_offset` cursor (= section offset of the NEXT byte to emit).
 ---
---- @param main_cu_offset integer  -- 0-based section offset of the main CU's unit_length field
+--- @param main_cu_offset integer    -- 0-based section offset of the main CU's unit_length field
 --- @param main_cu_end_excl integer  -- 0-based section offset of the first byte AFTER the main CU
---- @param atom_table table[]  -- atoms (with atom.rbind set if rbind; atom.invocations set if mac_X(...) calls)
---- @param rbind_structs table  -- {[binds_name] = {bytes, fields, atom_names}}
---- @param loclists_offsets table  -- {[atom_name] = section-relative offset into the new .debug_loclists}
+--- @param atom_table table[]        -- atoms (with atom.rbind set if rbind; atom.invocations set if mac_X(...) calls)
+--- @param rbind_structs table       -- {[binds_name] = {bytes, fields, atom_names}}
+--- @param loclists_offsets table    -- {[atom_name] = section-relative offset into the new .debug_loclists}
+--- @param registries table          -- merged registries from collect_per_source_registries
 --- @return string  -- bytes to splice into the main CU just before its root terminator
-local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_table, rbind_structs, loclists_offsets)
-	rbind_structs = rbind_structs or {}
+local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_table, rbind_structs, loclists_offsets, registries)
+	rbind_structs    = rbind_structs    or {}
 	loclists_offsets = loclists_offsets or {}
+	registries       = registries       or {}
+
+	-- by_alias: the merged register_alias_registry filtered to aliases whose `code` is a valid MIPS GPR 0..31.
+	-- Aliases absent from the merged registry are not debug-visible and are skipped entirely (no fallback GPR).
+	local by_alias = {}
+	for r_name, alias in pairs(registries.register_alias_registry or {}) do
+		if alias.code and alias.code >= 0 and alias.code <= 31 then
+			by_alias[r_name] = alias
+		end
+	end
+
+	-- Build a name->atom lookup for fast rbind_atom resolution during the per-atom phase/ctx propagation.
+	-- Cheap (O(atom_table)) and built once.
+	local function build_atom_name_index(atoms)
+		local m = {}
+		for _, a in ipairs(atoms or {}) do
+			if a and a.name then m[a.name] = a end
+		end
+		return m
+	end
+	local atom_by_name_global = build_atom_name_index(atom_table)
 
 	-- We insert IMMEDIATELY BEFORE the main CU's root children-terminator (the last byte of the main CU).
 	-- The first emitted byte lives at section offset (main_cu_end_excl - 1).
@@ -1779,66 +1751,171 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 	-- The displayed type name is the type_name (e.g. "V4_S2") because we use DW_FORM_string on the field type. 
 	-- gdb walks the chain and displays the name.
 	--
-	-- For each (type_name, depth), emit (depth) base_type DIEs forming a chain.
-	-- The outermost base_type's name is the type_name; the inner ones are named "ptr_<type>_<d>".
-	-- gdb shows the outermost name as the type.
+	-- For each (type_name, depth), emit a real structure_type with proper member layout,
+	-- then a single DW_TAG_pointer_type pointing at the structure_type. gdb's
+	-- `print *<var>` then expands the struct and lists its members (x, y, z, w for V4_S2; etc.).
 	--
-	-- (Full typedef + pointer_type chain with proper DW_TAG_pointer_type + byte_size=4 is a follow-up;
-	-- for now we use base_type entries which gdb can resolve.)
-	local type_chain_offsets = {}  -- { [type_name .. "|" .. depth] = section_offset (the OUTERMOST entry, the one referenced as the variable's type) }
-	-- For pointer_depth = 1, the chain is: [base_type "V4_S2" 4 bytes] [pointer_type → V4_S2].
-	-- For pointer_depth = 2, the chain is: [base_type "ptr_V4_S2_1"] [base_type "V4_S2"] [pointer_type → ptr_V4_S2_1].
-	-- The OUTERMOST pointer_type is what gdb shows as "<type> *" and is what the Locals panel uses to render the dereference affordance.
-	-- Build the chain bottom-up: emit the innermost base_type first, then each next-outer pointer_type, recording the offset of each.
-	-- The outermost is the last one emitted; type_chain_offsets stores its offset as the variable's DW_AT_type.
+	-- Hardcoded member-info table for the 6 typed views the prototype uses (V2_S2 / V3_S2 / V4_S2 / V2_S4 / V3_S4 / V4_S4).
+	-- Each row is {byte_size, members}, where each member is {name, offset, byte_size, type_name}.
+	-- `type_name` is the base type name from `type_name_registry`; "S2" / "S4" need a signed base_type emit too.
+	--
+	-- The table is small + explicit (no introspection of the struct types from production source)
+	-- because the prototype principle treats the typed-view struct layout as data, not derived state.
+	local STRUCT_MEMBER_TABLE = {
+		-- 2-element signed short vector (rare; placeholder for future use).
+		V2_S2 = { byte_size = 4, members = {
+			{ name = "x", offset = 0, byte_size = 2 },
+			{ name = "y", offset = 2, byte_size = 2 },
+		}},
+		-- 4-element signed short vector (the dominant face-cursor type).
+		V4_S2 = { byte_size = 8, members = {
+			{ name = "x", offset = 0, byte_size = 2 },
+			{ name = "y", offset = 2, byte_size = 2 },
+			{ name = "z", offset = 4, byte_size = 2 },
+			{ name = "w", offset = 6, byte_size = 2 },
+		}},
+		-- 3-element signed short vector (the floor face-cursor type; includes explicit pad byte to match math.h's S2 pad member).
+		V3_S2 = { byte_size = 8, members = {
+			{ name = "x",   offset = 0, byte_size = 2 },
+			{ name = "y",   offset = 2, byte_size = 2 },
+			{ name = "z",   offset = 4, byte_size = 2 },
+			{ name = "pad", offset = 6, byte_size = 2 },
+		}},
+		-- 2-element signed int vector.
+		V2_S4 = { byte_size = 8, members = {
+			{ name = "x", offset = 0, byte_size = 4 },
+			{ name = "y", offset = 4, byte_size = 4 },
+		}},
+		-- 3-element signed int vector.
+		V3_S4 = { byte_size = 16, members = {
+			{ name = "x",   offset = 0,  byte_size = 4 },
+			{ name = "y",   offset = 4,  byte_size = 4 },
+			{ name = "z",   offset = 8,  byte_size = 4 },
+			{ name = "pad", offset = 12, byte_size = 4 },
+		}},
+		-- 4-element signed int vector.
+		V4_S4 = { byte_size = 16, members = {
+			{ name = "x", offset = 0,  byte_size = 4 },
+			{ name = "y", offset = 4,  byte_size = 4 },
+			{ name = "z", offset = 8,  byte_size = 4 },
+			{ name = "w", offset = 12, byte_size = 4 },
+		}},
+	}
+	local S2_TYPE_BYTE_SIZE = 2  -- S2 = signed 16-bit (see dsl.h)
+	local S4_TYPE_BYTE_SIZE = 4  -- S4 = signed 32-bit (see dsl.h)
+
+	-- Pre-emit the signed base types (S2, S4) once if any typed view's member needs them.
+	-- We emit per-typed-view lazily below; build a member-base-type offset cache (idempotent).
+	local member_base_type_offsets = {}
+	local function ensure_member_base_type(tn, byte_size, encoding)
+		local key = tn .. "|" .. byte_size .. "|" .. encoding
+		if member_base_type_offsets[key] then return member_base_type_offsets[key] end
+		local off = next_offset
+		emit(uleb128(ABBREV_BASE_TYPE))
+		emit(tn .. "\0")
+		emit(string.char(byte_size))
+		emit(string.char(encoding))
+		member_base_type_offsets[key] = off
+		return off
+	end
+	-- Always emit S2 + S4 (the v*_S2 / v*_S4 family base types) once before any typed-view,
+	-- even if no atom currently declares a v*_S2 field, so future atoms pick them up without rewiring.
+	ensure_member_base_type("S2", S2_TYPE_BYTE_SIZE, 5)  -- DW_ATE_signed = 5
+	ensure_member_base_type("S4", S4_TYPE_BYTE_SIZE, 5)
+
+	local type_chain_offsets = {}
 	for _, tn in ipairs(sorted_typed_types) do
 		if tn ~= "U4" then
 			local depth = used_typed_views[tn]
-			-- First, emit the chain of base_types from innermost (d=1) to d=depth-1.
-			-- The innermost (d=1) carries the user's type_name (V4_S2); outer levels are placeholders named "ptr_<type>_<d>".
-			-- Each base_type is 4 bytes unsigned (a stand-in for the actual type).
-			local innermost_offset
-			local base_offsets = {}  -- base_offsets[d] = offset of the d-th level base_type (1-indexed)
-			for d = 1, depth do
-				local off = next_offset
-				base_offsets[d] = off
+			local type_info = STRUCT_MEMBER_TABLE[tn]
+			if not type_info then
+				-- Unknown typed view — fall back to a generic base_type to keep the wire valid
+				-- (gdb will render as the typename but `print *ptr` will only see the first 4 bytes).
+				-- This is the pre-Track-A behavior; preserved here for forward compatibility with future typed views not in our table.
+				local innermost_offset = next_offset
 				emit(uleb128(ABBREV_BASE_TYPE))
-				if d == 1 then
-					emit(tn .. "\0")  -- innermost: the user's type name
-				else
-					emit("ptr_" .. tn .. "_" .. (d-1) .. "\0")  -- inner: pointer-depth label
-				end
-				emit(string.char(4))                   -- byte_size = 4
+				emit(tn .. "\0")
+				emit(string.char(4))                   -- byte_size = 4 (legacy stand-in)
 				emit(string.char(DW_ATE_unsigned))     -- encoding = unsigned
-				innermost_offset = off
-			end
-			-- Now emit a DW_TAG_pointer_type (abbrev 9 in the duplicate) ON TOP of the chain.
-			-- The pointer_type's DW_AT_type ref4 points at the base_type it dereferences.
-			-- The outermost pointer_type is what the variable's DW_AT_type uses.
-			local outermost_offset = next_offset
-			emit(uleb128(9))  -- DW_TAG_pointer_type abbrev code (abbrev 9 in duplicate)
-			-- Abbrev 9's attributes: DW_AT_byte_size (implicit_const 4; no DIE bytes), DW_AT_type (ref4 → target). 
-			-- So the DIE bytes are just the 4-byte ref4 pointing at the base_type it dereferences.
-			-- The variable uses the OUTERMOST pointer_type. 
-			-- Inner pointer levels (for depth > 1) would chain pointer_type → pointer_type → ... → base_type. For the user's case (depth ≤ 1), one pointer_type suffices.
-			-- For depth > 1, we'd need intermediate pointer_type DIEs — emit depth-1 of them, each pointing at the next.
-			if depth == 1 then
-				-- Single pointer: target = innermost base_type
+				local outermost_offset = next_offset
+				emit(uleb128(9))  -- DW_TAG_pointer_type
 				emit(elf_dwarf.write_u32_le(ref4_of(innermost_offset)))
+				type_chain_offsets[tn .. "|" .. depth] = outermost_offset
 			else
-				-- depth > 1: emit (depth - 1) pointer_types, each pointing at the next.
-				-- The last pointer_type (outermost) becomes the variable's DW_AT_type.
-				-- The innermost pointer_type points at the innermost base_type.
-				-- For simplicity, emit depth pointer_types total, each pointing at the previous base_type or pointer_type. 
-				-- The outermost is what we return.
-				-- Actually, for the current build the only typed fields are at depth 1 (V4_S2* / V3_S2*). depth > 1 is not exercised. 
-				-- We can handle depth == 1 inline and defer depth > 1 to a future task.
-				error("typed-view: pointer_depth > 1 is not yet supported in this emission path")
+				-- Emit a proper structure_type DIE for this typed view.
+				local struct_offset = next_offset
+				emit(uleb128(ABBREV_STRUCT_TYPE))
+				emit(tn .. "\0")                                  -- DW_AT_name (struct_type has children, no name in abbrev 103 [DW_FORM_string only])
+				emit(uleb128(type_info.byte_size))                -- DW_AT_byte_size (DW_FORM_udata)
+				-- For each member, emit ABBREV_MEMBER (name + data_member_location + type ref4).
+				for _, m in ipairs(type_info.members) do
+					emit(uleb128(ABBREV_MEMBER))
+					emit(m.name .. "\0")
+					emit(uleb128(m.offset))
+					-- The member's type is S2 (for v*_S2 family) or S4 (for v*_S4 family), based on the member's byte_size.
+					local member_type_name, member_type_encoding
+					if m.byte_size == 2 then
+						member_type_name = "S2"
+						member_type_encoding = 5  -- DW_ATE_signed = 5
+					elseif m.byte_size == 4 then
+						member_type_name = "S4"
+						member_type_encoding = 5  -- DW_ATE_signed = 5
+					else
+						-- Unexpected byte_size; fall back to U4 (unsigned int) since U4 base type is already emitted
+						member_type_name = "U4"
+						member_type_encoding = 7  -- DW_ATE_unsigned = 7
+					end
+					local member_base_off = ensure_member_base_type(member_type_name, m.byte_size, member_type_encoding)
+					emit(elf_dwarf.write_u32_le(ref4_of(member_base_off)))  -- DW_AT_type ref4 → base_type
+				end
+				emit(string.char(0x00))                            -- end of structure_type's children
+				-- Emit a single DW_TAG_pointer_type (abbrev 9) pointing at the structure_type.
+				-- For depth > 1, we'd chain pointer_type → pointer_type → ... → structure_type; not exercised.
+				if depth == 1 then
+					local outermost_offset = next_offset
+					emit(uleb128(9))  -- DW_TAG_pointer_type
+					emit(elf_dwarf.write_u32_le(ref4_of(struct_offset)))  -- DW_AT_type → structure_type
+					type_chain_offsets[tn .. "|" .. depth] = outermost_offset
+				else
+					error("typed-view: pointer_depth > 1 is not yet supported in this emission path")
+				end
 			end
-			type_chain_offsets[tn .. "|" .. depth] = outermost_offset
 		end
 	end
 
+	-- 1b) Emit the void* fallback chain (used by step (f) of the per-RR_<R_Name> precedence chain).
+	-- One DW_TAG_base_type DIE named "void" + one DW_TAG_pointer_type pointing at it.
+	-- Unannotated RR_<R_X> locals reference the outermost pointer_type; gdb displays the value as `(void *) 0x...` 
+	-- (hex) per the prototype principle rather than `unsigned int`.
+	-- The void base_type is emitted BEFORE any other typed chain so its ref4 pointer remains stable.
+	-- Follow the SAME pattern as the typed-views chain above: capture the offset BEFORE the uleb tag
+	-- (this is the ref4 target), emit the DIE bytes, then emit the pointer_type pointing at the offset.
+	local void_chain_offset = next_offset
+	emit(uleb128(ABBREV_BASE_TYPE))
+	emit("void\0")                              -- DW_FORM_string (DW_AT_name)
+	emit(string.char(1))                        -- DW_FORM_data1  (DW_AT_byte_size = 1; DWARF's "void" base_type)
+	emit(string.char(DW_ATE_unsigned))          -- DW_FORM_data1  (DW_AT_encoding = unsigned; DWARF doesn't define a void encoding but gdb reads the name "void" off the DIE and renders it correctly as `(void *)` when wrapped in a pointer_type)
+	emit(uleb128(9))                            -- DW_TAG_pointer_type (abbrev 9; DW_AT_type = ref4 to its target)
+	emit(elf_dwarf.write_u32_le(ref4_of(void_chain_offset)))  -- 4-byte ref4: points at the void base_type's tag byte
+	-- type_chain_offsets["void|1"] is what step (f) of the per-RR_<R_Name> chain looks up.
+	type_chain_offsets["void|1"] = void_chain_offset  -- both the base_type offset and the pointer_type are emitted consecutively; the OUTERMOST is the pointer_type. The variable's DW_AT_type must reference the pointer_type, not the base_type. Patch below.
+	-- Capture the pointer_type's offset (the last-thing-emitted DIE start) and overwrite the lookup.
+	-- The pointer_type was emitted as: uleb(9) (1 byte) + 4-byte ref4 = 5 bytes. Its tag byte is at void_chain_offset + 8 (the base_type's 8 bytes: 1 tag + 5 name + 1 byte_size + 1 encoding).
+	local ptr_void_offset = void_chain_offset + 8
+	type_chain_offsets["void|1"] = ptr_void_offset
+
+	-- 1c) Emit the U4 * pointer chain (step (e) fallback for enum-site `atom_type(U4 *)`).
+	-- The chain is just one DW_TAG_pointer_type pointing at the pre-emitted "unsigned int" base_type at `base_type_section_offset`.
+	-- This is intentionally separate from the per-type typed-views chain (which emits V4_S2* / V3_S2* etc.)
+	-- because U4 is the C-side typedef alias for `unsigned int`, not a fresh struct;
+	-- reusing the pre-emitted base type keeps the wire consistent.
+	-- Once this chain is registered as `type_chain_offsets["U4|1"]`, step (e) of the per-RR_<R_Name> precedence chain will resolve `atom_type(U4 *)`
+	-- declarations on aliases like `R_PrimCursor` and `R_OtBase` to `U4 *` (gdb renders as `(unsigned int *)` with the value displayed in hex).
+	emit(uleb128(9))                                                 -- DW_TAG_pointer_type (abbrev 9; DW_AT_type = ref4 to its target)
+	emit(elf_dwarf.write_u32_le(ref4_of(base_type_section_offset)))  -- 4-byte ref4 → "unsigned int" base_type
+	local u4_chain_offset = next_offset - 5                          -- 1 (uleb tag) + 4 (ref4) = 5 bytes; capture the pointer_type's start offset
+	type_chain_offsets["U4|1"] = u4_chain_offset
+
 	-- 2) Emit one DW_TAG_structure_type per unique Binds_X.
 	local struct_section_offsets = {}
 	local sorted_struct_names    = {}
@@ -1888,9 +1965,9 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 		local def = component_defs[comp_name]
 		abstract_offsets[comp_name] = next_offset
 		emit(uleb128(ABBREV_ABSTRACT_SUBPROGRAM))
-		emit("mac_" .. comp_name .. "\0")     -- DW_FORM_string (DW_AT_name)
-		emit(string.char(DW_INL_inlined))    -- DW_FORM_data1 (DW_AT_inline)
-		emit(string.char(0x01))               -- DW_FORM_data1 (DW_AT_external=1)
+		emit("mac_" .. comp_name .. "\0") -- DW_FORM_string (DW_AT_name)
+		emit(string.char(DW_INL_inlined)) -- DW_FORM_data1 (DW_AT_inline)
+		emit(string.char(0x01))           -- DW_FORM_data1 (DW_AT_external=1)
 		-- decl_file + decl_line resolve the abstract origin back to its definition site even when no inlined_subroutine instance maps to it.
 		emit(uleb128(resolve_provenance_file_index(def.def_file)))  -- DW_FORM_udata (DW_AT_decl_file)
 		emit(uleb128(def.def_line))                                 -- DW_FORM_udata (DW_AT_decl_line)
@@ -1902,19 +1979,25 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 	--    gdb's symbol resolution picks our subprogram (it has low_pc/high_pc + children) over the gcc global for function-context lookups.
 	for _, atom in ipairs(atom_table) do
 		emit(uleb128(ABBREV_SUBPROGRAM))
-		emit(atom.name .. "\0")                  -- DW_FORM_string (DW_AT_name)
+		emit(atom.name .. "\0") -- DW_FORM_string (DW_AT_name)
 		emit(elf_dwarf.write_u32_le(atom.addr))
 		emit(elf_dwarf.write_u32_le(atom.addr + atom.size_bytes))
-		emit(atom.name .. "\0")                  -- DW_FORM_string (DW_AT_linkage_name; same as DW_AT_name for non-mangled C)
+		emit(atom.name .. "\0") -- DW_FORM_string (DW_AT_linkage_name; same as DW_AT_name for non-mangled C)
 
-		-- Per wave-context reg: DW_TAG_variable.
-		--   1. explicit per-atom register type annotation (atom_reg_types)
-		--   2. atom_view(Binds_X) field type (from the rbind regs → fields map)
-		--   3. semantic default (R_TapePtr → U4*, R_AtomJmp → MipsCode*,
-		--      cursor/base aliases → void*)
-		--   4. void* (unannotated)
-		-- For rbind atoms the precedence comes from the rbind regs/fields
-		-- (the load_word calls already mapped each R_<reg> to a Binds_X.<field> with a known type_name + pointer_depth).
+	-- Per debug-visible R_ alias (filtered to GPR 0..31 in `by_alias`): DW_TAG_variable.
+	-- Precedence chain (per atom, per RR_<R_Name>):
+	--   (a) per-atom callsite atom_type(R_X, <T>):  atom_views reg_type_overrides[atom_name][R_Name] — most specific; user explicit override for THIS atom only
+	--   (b) atom_ctx(<rbind_atom>):                 propagate THIS atom's declared rbind atom's Binds_* field types
+	--   (c) self-binding:                           atom.rbind.fields / regs (only when this atom IS the rbind atom for its Binds_*)
+	--   (d) atom_phase(<label>)-grouped:            first atom in source-order that shares this label AND has its own atom.rbind provides the Binds_* field types
+	--   (e) enum-site atom_type(<T>) default:       register_alias_registry[R_Name].default_type  (per-alias fallback declared in lottes_tape.h)
+	--   (f) void* fallback:                         the void_chain_offset built in section 1b; gdb renders `(void *) 0x...` (hex)
+	-- If (a)..(e) miss AND no alias registry entry exists for this R_Name, the emission is skipped for that alias entirely.
+		local atom_view_ctx_fields   = nil  -- populated by step (b); map field_name -> field entry
+		local reg_to_field_ctx       = nil  -- populated by step (b); map GPR index -> field name
+		local atom_view_phase_fields = nil  -- populated by step (d); map field_name -> field entry
+		local reg_to_field_phase     = nil  -- populated by step (d); map GPR index -> field name
+		-- atom-name -> atom lookup is precomputed once as atom_by_name_global.
 		local field_type_by_name = {}
 		if atom.rbind and atom.rbind.fields then
 			for _, f in ipairs(atom.rbind.fields) do
@@ -1929,31 +2012,96 @@ local function build_inserted_children(main_cu_offset, main_cu_end_excl, atom_ta
 				reg_to_field[pair.reg] = pair.field
 			end
 		end
-		-- Semantic defaults per register.
-		local SEMANTIC_DEFAULTS = {
-			[24] = { type_name = "U4", pointer_depth = 1 },  -- R_TapePtr (R_T8)
-			[25] = { type_name = "MipsCode", pointer_depth = 1 },  -- R_AtomJmp (R_T9)
-		}
-
-		for _, loc in ipairs(WAVE_CONTEXT_LOCATIONS) do
-			emit(uleb128(ABBREV_VARIABLE))
-			emit(loc.name .. "\0")         -- DW_FORM_string (DW_AT_name)
-			emit(reg_exprloc(loc.reg))     -- DW_FORM_exprloc (DW_OP_regN)
-			-- Resolve the type for this register.
-			local type_offset = base_type_section_offset  -- default: U4
-			local field_name = reg_to_field[loc.reg]
-			if field_name then
-				local f = field_type_by_name[field_name]
-				if    f and f.pointer_depth and f.pointer_depth > 0 then
-					local chain_offset = type_chain_offsets[f.type_name .. "|" .. f.pointer_depth]
-					if chain_offset then type_offset = chain_offset end
+		local atom_view = (registries.atom_views or {})[atom.name]
+		-- Build the atom-name lookup table once (cheap; O(atom_table)) so step (b) and step (d) can resolve rbind_atom names.
+		local atom_by_name = atom_by_name or (function() local m = {}; for _, a in ipairs(atom_table) do if a.name then m[a.name] = a end end; return m end)()
+		-- step (b) inputs: this atom's `atom_ctx(<rbind_atom>)` (resolved from the registries' atom_ctxs)
+		local this_ctx = registries.atom_ctxs and registries.atom_ctxs[atom.name]
+		if this_ctx and this_ctx.rbind_atom then
+			local rbind = atom_by_name_global[this_ctx.rbind_atom]
+			if rbind and rbind.rbind and rbind.rbind.fields then
+				atom_view_ctx_fields = {}
+				for _, f in ipairs(rbind.rbind.fields) do atom_view_ctx_fields[f.name] = f end
+				if rbind.rbind.regs then
+					reg_to_field_ctx = {}
+					for _, pair in ipairs(rbind.rbind.regs) do reg_to_field_ctx[pair.reg] = pair.field end
 				end
+			end
+		end
+		-- step (d) inputs: this atom's `atom_phase(<label>)`;
+		-- find the FIRST atom in the same phase group that has its own rbind and is in source-order (i.e., declared before this atom in any source file).
+		-- Find the per-atom_info entry that has phase == this atom's name.
+		local my_phase_label = nil
+		for _, ai in ipairs(registries.atom_infos or {}) do
+			if ai.atom_name == atom.name and ai.phase then
+				my_phase_label = ai.phase
+				break
+			end
+		end
+		if my_phase_label then
+			local group = (registries.atom_phases or {})[my_phase_label]
+			if group and group.atoms then
+				for _, group_atom_name in ipairs(group.atoms) do
+					if group_atom_name ~= atom.name then
+						local cand = atom_by_name_global[group_atom_name]
+						if cand and cand.rbind and cand.rbind.fields then
+							atom_view_phase_fields = {}
+							for _, f in ipairs(cand.rbind.fields) do atom_view_phase_fields[f.name] = f end
+							if cand.rbind.regs then
+								reg_to_field_phase = {}
+								for _, pair in ipairs(cand.rbind.regs) do reg_to_field_phase[pair.reg] = pair.field end
+							end
+							break
+						end
+					end
+				end
+			end
+		end
+
+		for r_name, alias in pairs(by_alias) do
+			local rr_name = "RR_" .. strip_r_prefix(r_name)
+			local alias_code = alias.code
+			emit(uleb128(ABBREV_VARIABLE))
+			emit(rr_name .. "\0")         -- DW_FORM_string (DW_AT_name)
+			emit(reg_exprloc(alias_code)) -- DW_FORM_exprloc (DW_OP_regN from registry code)
+			-- Resolve the type for this register via the 6-step precedence chain.
+			local type_offset = type_chain_offsets["void|1"]  -- step (f) fallback: void* (renders as hex)
+
+			-- step (a): per-atom callsite atom_type(R_X, <T>)
+			local override = atom_view and atom_view.reg_type_overrides and atom_view.reg_type_overrides[r_name]
+			if override and override.pointer_depth and override.pointer_depth > 0 then
+				local chain_offset = type_chain_offsets[override.type_name .. "|" .. override.pointer_depth]
+				if chain_offset then type_offset = chain_offset end
 			else
-				-- Not loaded from Binds_*: use the semantic default.
-				local def = SEMANTIC_DEFAULTS[loc.reg]
-				if def and def.pointer_depth and def.pointer_depth > 0 then
-					local chain_offset = type_chain_offsets[def.type_name .. "|" .. def.pointer_depth]
+				-- step (b): atom_ctx(<rbind_atom>) propagation
+				local ctx_field_name = reg_to_field_ctx and reg_to_field_ctx[alias_code]
+				local ctx_f          = ctx_field_name and atom_view_ctx_fields and atom_view_ctx_fields[ctx_field_name]
+				if ctx_f and ctx_f.pointer_depth and ctx_f.pointer_depth > 0 then
+					local chain_offset = type_chain_offsets[ctx_f.type_name .. "|" .. ctx_f.pointer_depth]
 					if chain_offset then type_offset = chain_offset end
+				else
+					-- step (c): self-bind (this atom is the rbind atom)
+					local field_name = reg_to_field[alias_code]
+					local f = field_name and field_type_by_name[field_name]
+					if f and f.pointer_depth and f.pointer_depth > 0 then
+						local chain_offset = type_chain_offsets[f.type_name .. "|" .. f.pointer_depth]
+						if chain_offset then type_offset = chain_offset end
+					else
+						-- step (d): atom_phase(<label>)-grouped propagation
+						local phase_field_name = reg_to_field_phase and reg_to_field_phase[alias_code]
+						local phase_f          = phase_field_name and atom_view_phase_fields and atom_view_phase_fields[phase_field_name]
+						if phase_f and phase_f.pointer_depth and phase_f.pointer_depth > 0 then
+							local chain_offset = type_chain_offsets[phase_f.type_name .. "|" .. phase_f.pointer_depth]
+							if chain_offset then type_offset = chain_offset end
+						else
+							-- step (e): enum-site atom_type(<T>) default on the registry entry
+							if alias.default_type and alias.default_depth and alias.default_depth > 0 then
+								local chain_offset = type_chain_offsets[alias.default_type .. "|" .. alias.default_depth]
+								if chain_offset then type_offset = chain_offset end
+							end
+							-- step (f): void* fallback (set as type_offset initial value above).
+						end
+					end
 				end
 			end
 			emit(elf_dwarf.write_u32_le(ref4_of(type_offset)))  -- DW_FORM_ref4 → type
@@ -2025,8 +2173,8 @@ local function build_debug_abbrev_section(existing, main_abbrev_offset)
 	if not table_end then return existing, nil end
 
 	-- Duplicate the main table declarations EXCLUDING its terminating 0 byte.
-	-- (1-indexed sub: existing:sub(main_abbrev_offset + 1, table_end) reads bytes
-	--  from 0-based [main_abbrev_offset .. table_end - 1].)
+	-- (1-indexed sub: existing:sub(main_abbrev_offset + 1, table_end)
+	-- reads bytes from 0-based [main_abbrev_offset .. table_end - 1].)
 	local main_table_dup = existing:sub(main_abbrev_offset + 1, table_end)
 	local new_abbrevs    = build_new_abbrev()  -- includes its own terminating 0
 
@@ -2038,9 +2186,10 @@ end
 --- Build the new .debug_str: existing strings + new strings appended.
 --- @param existing string  -- existing .debug_str bytes (verbatim)
 --- @param atom_table table[]
+--- @param registries table  -- merged registries from collect_per_source_registries
 --- @return string, integer, table  -- (new_str_bytes, new_strings_offset, string_map)
-local function build_debug_str_section(existing, atom_table)
-	local new_strings, string_map = build_new_strings(atom_table)
+local function build_debug_str_section(existing, atom_table, registries)
+	local new_strings, string_map = build_new_strings(atom_table, registries)
 	return existing .. new_strings, #existing, string_map
 end
 
@@ -2064,10 +2213,11 @@ end
 --- @param atom_table table[]
 --- @param rbind_structs table     -- {[binds_name] = {bytes, fields, atom_names}}
 --- @param loclists_offsets table  -- {[atom_name] = section-relative offset}
+--- @param registries table        -- merged registries from collect_per_source_registries
 --- @return string  -- the rebuilt .debug_info bytes
-local function build_debug_info_section(existing, main_cu_start, main_cu_end_excl, new_abbrev_offset, atom_table, rbind_structs, loclists_offsets)
+local function build_debug_info_section(existing, main_cu_start, main_cu_end_excl, new_abbrev_offset, atom_table, rbind_structs, loclists_offsets, registries)
 	-- 1) Build the inserted children bytes (just before the main CU's root terminator).
-	local inserted     = build_inserted_children(main_cu_start, main_cu_end_excl, atom_table, rbind_structs, loclists_offsets)
+	local inserted     = build_inserted_children(main_cu_start, main_cu_end_excl, atom_table, rbind_structs, loclists_offsets, registries)
 	local inserted_len = #inserted
 
 	-- 2) Patch main CU's unit_length += inserted_len.
@@ -2115,7 +2265,8 @@ local SECTION_BUILDERS = {
 	debug_info     = build_debug_info_section,
 	debug_str      = build_debug_str_section,
 	debug_loc      = function() return build_debug_loc_section() end,
-	debug_loclists = function() return build_debug_loclists_section({}) end,  -- placeholder; replaced per-run
+	-- debug_loclists is fed directly in M.run (it needs the merged registries for the R_TapePtr GPR lookup;
+	-- the SECTION_BUILDERS table cannot carry that context, so the dispatch is inlined in the per-run writers loop).
 }
 
 -- Per-section output path resolver (mirrors SECTION_BUILDERS).
@@ -2163,8 +2314,10 @@ function M.run(ctx)
 	elf_path = duffle.to_absolute_path(elf_path)
 
 	-- Read the existing DWARF sections directly (no subprocess; lfs + io.open + manual ELF32 section-header walk).
-	-- We need ALL 7 sections since the F' group (.debug_line, .debug_aranges, .debug_rnglists)
-	-- extends the existing sections + the G' group (.debug_info, .debug_abbrev, .debug_str, .debug_loc) appends a new compile unit.
+	-- We need all 8 sections: .debug_line / .debug_aranges / .debug_rnglists get extended
+	-- (additional rows appended to the existing unit), and .debug_info / .debug_abbrev / .debug_str / .debug_loc / .debug_loclists 
+	-- get spliced (the main CU's unit_length is patched;
+	-- no new compile unit is appended; debug_loc/debug_loclists may not exist in the source ELF so we add-section them on splice).
 	-- The dispatch (SECTION_BUILDERS) handles each.
 	local existing_sections = elf_dwarf.read_elf_sections(elf_path, {
 		".debug_line", ".debug_aranges", ".debug_rnglists",
@@ -2187,31 +2340,31 @@ function M.run(ctx)
 
 	-- Consume source-as-written skip associations from every scanned source,
 	-- then build the atom/provenance table with those generic selections.
-	local skip_over = collect_skip_over(ctx)
+	local skip_over  = collect_skip_over(ctx)
+	local registries = collect_per_source_registries(ctx)
 	local atom_table = build_atom_table(ctx, skip_over)
 	io.stderr:write(string.format("[dwarf_injection] matched %d atoms between nm + source-map\n", #atom_table))
 
 	-- Detect rbind atoms + index Binds_* struct fields (from ctx.sources[i].scan, populated by scan-source pass).
-	local _rbind_atoms, rbind_structs = parse_rbind_atoms(ctx, atom_table)
+	-- The merged registries are threaded through so parse_body_load_pairs resolves R_<reg> via register_alias_registry.
+	local _rbind_atoms, rbind_structs = parse_rbind_atoms(ctx, atom_table, registries)
 	local rbind_count = 0
 	for _ in pairs(_rbind_atoms) do rbind_count = rbind_count + 1 end
 	io.stderr:write(string.format("[dwarf_injection] matched %d rbind atoms across %d Binds_* structs\n",
 		rbind_count, (function() local n = 0; for _ in pairs(rbind_structs) do n = n + 1 end; return n end)()))
 
 	-- Write the .bin files. The build_psyq.ps1 post-link hook splices these into a copy of the ELF via objcopy --update-section.
-	--
 	-- Build order:
 	--   0. Validate .debug_info layout (crT CU + DWARF5 main CU + final 0 root terminator).
 	--      If validation fails, FAIL SAFELY by writing the existing sections verbatim (no malformed output, no synthetic CU append, no header patch).
 	--   1. Build new .debug_abbrev using the main CU's abbrev offset → returns the offset of the duplicate main table (= #existing_abbrev).
-	--   2. Build new .debug_info by splicing inserted children into the main CU (patches main CU's unit_length + debug_abbrev_offset; 
+	--   2. Build new .debug_info by splicing inserted children into the main CU (patches main CU's unit_length + debug_abbrev_offset;
 	--      preserves all original DIE bytes; does NOT append a synthetic CU).
 	--   3. Build .debug_line + .debug_aranges + .debug_rnglists.
 	--   4. Build .debug_loc (just a terminator).
 	--
-	-- .debug_str is left untouched in this slice: 
-	-- the inserted children use DW_FORM_string (inline) for all DW_AT_name values, so no new strings are required.
-	-- The existing strings table is preserved verbatim.
+	-- .debug_str now also receives the new RR_<R_Name> entries
+	-- (the prior "left untouched in this slice" claim is obsolete; the merged registry drives the strings table to keep .debug_str and .debug_info in sync).
 	local basename = ctx.basename or duffle.basename_no_ext(elf_path) or DEFAULT_BASENAME
 	if ctx.out_root and ctx.out_root ~= "" then
 		duffle.ensure_dir(ctx.out_root)
@@ -2223,10 +2376,11 @@ function M.run(ctx)
 		local main_cu_start, main_cu_end_excl, main_abbrev_offset = find_main_cu_layout(existing_info)
 		if not main_cu_start then
 			io.stderr:write("[dwarf_injection] layout validation failed; writing existing sections unchanged\n")
+			local existing_str = existing_sections[".debug_str"] or ""
 			local results_safe = {
 				{ name = "debug_info",     data = existing_info,       was = #existing_info },
 				{ name = "debug_abbrev",   data = existing_abbrev,     was = #existing_abbrev },
-				{ name = "debug_str",      data = existing_sections[".debug_str"] or "", was = #(existing_sections[".debug_str"] or "") },
+				{ name = "debug_str",      data = existing_str,                                                       was = #existing_str },
 				{ name = "debug_line",     data = build_dwarf_line_section    (existing_sections[".debug_line"] or "",     atom_table), was = #(existing_sections[".debug_line"]     or "") },
 				{ name = "debug_aranges",  data = build_dwarf_aranges_section (existing_sections[".debug_aranges"] or "",  atom_table), was = #(existing_sections[".debug_aranges"]  or "") },
 				{ name = "debug_rnglists", data = build_dwarf_rnglists_section(existing_sections[".debug_rnglists"] or "", atom_table), was = #(existing_sections[".debug_rnglists"] or "") },
@@ -2258,18 +2412,22 @@ function M.run(ctx)
 		local loclists_offsets = compute_loclists_offsets(atom_table)
 
 		-- Step 2: splice inserted children into the main CU (patches unit_length + abbrev_offset; no synthetic CU).
-		local new_info = build_debug_info_section(existing_info, main_cu_start, main_cu_end_excl, new_abbrev_offset, atom_table, rbind_structs, loclists_offsets)
+		local new_info  = build_debug_info_section(existing_info, main_cu_start, main_cu_end_excl, new_abbrev_offset, atom_table, rbind_structs, loclists_offsets, registries)
 
-		-- Step 3-5: independent sections (.debug_str left untouched — see comment above).
+		-- Step 2b: rebuild .debug_str now that we know which RR_<R_Name> entries
+		-- get emitted (this aligns with build_debug_info_section's by_alias loop).
+		local new_str, new_str_offset, string_map = build_debug_str_section(existing_sections[".debug_str"] or "", atom_table, registries)
+
+		-- Step 3-5: independent sections.
 		local results = {
 			{ name = "debug_abbrev",   data = new_abbrev,                                                                            was = #existing_abbrev },
 			{ name = "debug_info",     data = new_info,                                                                              was = #existing_info },
-			{ name = "debug_str",      data = existing_sections[".debug_str"] or "",                                                 was = #(existing_sections[".debug_str"]      or "") },
+			{ name = "debug_str",      data = new_str,                                                                               was = #(existing_sections[".debug_str"]      or "") },
 			{ name = "debug_line",     data = build_dwarf_line_section    (existing_sections[".debug_line"] or "",     atom_table),  was = #(existing_sections[".debug_line"]     or "") },
 			{ name = "debug_aranges",  data = build_dwarf_aranges_section (existing_sections[".debug_aranges"] or "",  atom_table),  was = #(existing_sections[".debug_aranges"]  or "") },
 			{ name = "debug_rnglists", data = build_dwarf_rnglists_section(existing_sections[".debug_rnglists"] or "", atom_table),  was = #(existing_sections[".debug_rnglists"] or "") },
 			{ name = "debug_loc",      data = build_debug_loc_section(),                                                             was = #(existing_sections[".debug_loc"]      or "") },
-			{ name = "debug_loclists", data = build_debug_loclists_section(atom_table),                                              was = 0 },
+			{ name = "debug_loclists", data = build_debug_loclists_section(atom_table, registries),                                 was = 0 },
 		}
 
 		local outputs = { gdbinit_output }
diff --git a/scripts/passes/scan_source.lua b/scripts/passes/scan_source.lua
index bcfb78b..0240b64 100644
--- a/scripts/passes/scan_source.lua
+++ b/scripts/passes/scan_source.lua
@@ -34,12 +34,14 @@ local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --- @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 skip_over  SkipOverScan    -- atom/component debug-step markers + resolved declaration associations
---- @field types      table<string, RegTypeDefault> -- atom_dbg_reg_default(R_X, <type>) declarations
---- @field atom_views table<string, AtomViewEntry>  -- MipsAtom_(name) -> {binds_name, reg_type_overrides, info_line}
---- @field line_of    fun(pos: integer): integer    -- shared LineIndex closure
+--- @field atom_infos  AtomInfoEntry[]                 -- MipsAtom_(name) atom_info(...) (sub-calls pre-parsed)
+--- @field macros      MacroEntry[]                    -- #pragma mac_X tape_atom words=N  +   _Pragma("...")
+--- @field skip_over   SkipOverScan                    -- atom/component debug-step markers + resolved declaration associations
+--- @field types       table<string, RegTypeDefault>   -- atom_dbg_reg_default(R_X, <type>) declarations
+--- @field atom_views  table<string, AtomViewEntry>    -- MipsAtom_(name) -> {binds_name, reg_type_overrides, info_line}
+--- @field atom_ctxs   table<string, AtomCtxEntry>     -- MipsAtom_(name) -> {rbind_atom, info_line, source} (atom_ctx(...) call sites)
+--- @field atom_phases table<string, AtomPhaseGroup>   -- phase_label -> {atoms = {atom_name1, atom_name2, ...}} (atom_phase(...) tags)
+--- @field line_of     fun(pos: integer): integer      -- shared LineIndex closure
 
 --- @class SkipOverScan
 --- @field atoms      table<string, SkipOverAssociation>
@@ -72,6 +74,15 @@ local duffle        = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 --- @field reg           string  -- "R_T0"
 --- @field type_name     string
 --- @field pointer_depth integer
+--- @field source_line   integer -- line of the call site (callsite or enum-site)
+
+--- @class AtomCtxEntry
+--- @field rbind_atom string  -- the rbind atom ident that this consumer should propagate types from
+--- @field info_line  integer
+--- @field source     string  -- absolute path of the source file
+
+--- @class AtomPhaseGroup
+--- @field atoms string[]  -- atom names tagged with this phase label (source-order)
 
 --- @class AtomViewEntry
 --- @field atom_name        string                 -- e.g. "red_cube_g4_face"
@@ -235,29 +246,288 @@ local function parse_type_chain(text, pos)
 	return ident, depth, cursor
 end
 
--- Parse the U4 fields from a Binds_X body. Returns (fields, byte_count).
-local function scan_binds_fields(body)
+-- Byte-size lookup for builtin C primitives + the GCC __UINT*_TYPE__ family.
+-- Returns a confident byte_size (positive integer) or nil if `type_name` is not a known builtin primitive.
+-- Builtin primitive map; used by the byte-size propagation pass to seed confident byte_size values for typedef chains that bottom out at a builtin.
+local BUILTIN_BYTE_SIZES = {
+	["U1"]                  = 1,
+	["U2"]                  = 2,
+	["U4"]                  = 4,
+	["S1"]                  = 1,
+	["S2"]                  = 2,
+	["S4"]                  = 4,
+	-- GCC __UINT*_TYPE__ family (used by the duffle TSet_ convention). TODO(Ed): Do we really need these, they shouldn't be directly used...
+	["__UINT8_TYPE__"]      = 1,
+	["__UINT16_TYPE__"]     = 2,
+	["__UINT32_TYPE__"]     = 4,
+	["__UINT64_TYPE__"]     = 8,
+	["__INT8_TYPE__"]       = 1,
+	["__INT16_TYPE__"]      = 2,
+	["__INT32_TYPE__"]      = 4,
+	["__INT64_TYPE__"]      = 8,
+}
+
+-- Pointer fields collapse to 4 bytes on MIPS32 (PS1).
+local POINTER_BYTE_SIZE = 4
+
+-- Maximum chain depth when resolving typedef / TSet_ chains (cycle guard).
+local TYPE_CHAIN_MAX_DEPTH = 8
+
+-- Parse the `<type> <field>;` declarations from a Struct_ body.
+-- Returns the raw fields array with `{name, type_name, pointer_depth}` only (NO offset / byte_size).
+-- The propagation pass `resolve_struct_field_sizes` walks each struct's fields AFTER type resolution and populates offset + byte_size in place.
+-- Returns (fields). The aggregate byte_count is computed in the propagation pass (it depends on whether every field's type resolved).
+local function parse_struct_body_fields(body)
 	local fields   = {}
-	local byte_off = 0
 	local body_pos = 1
-	while body_pos <= #body do
+	local body_len = #body
+	while body_pos <= body_len do
 		body_pos = duffle.skip_ws_and_cmt(body, body_pos)
-		if body_pos > #body then break end
+		if body_pos > body_len 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 + 0x04    -- U4 field = 4 bytes (= 1 .word)
-			end
-			body_pos = field_end or (type_end + 1)
 		else
-			body_pos = type_end + 1
+			-- Parse the trailing `*` chain to derive pointer_depth.
+			local depth  = 0
+			local cursor = duffle.skip_ws_and_cmt(body, type_end)
+			while cursor <= body_len and body:sub(cursor, cursor) == "*" do
+				depth  = depth + 1
+				cursor = cursor + 1
+				cursor = duffle.skip_ws_and_cmt(body, cursor)
+			end
+
+			-- Read the field ident immediately after the type chain.
+			local field_ident, field_end = duffle.read_ident(body, cursor)
+			if not field_ident then
+				body_pos = type_end + 1
+			else
+				fields[#fields + 1] = {
+					name          = field_ident,
+					type_name     = type_ident,
+					pointer_depth = depth,
+					-- offset + byte_size filled by resolve_struct_field_sizes
+					offset        = nil,
+					byte_size     = nil,
+				}
+				body_pos = field_end
+			end
+		end
+	end
+	return fields
+end
+
+-- Parse the `Enum_(<underlying>, <name>) { <body> }` body for entries.
+-- Captures one field per named enumerator with the shape { name, value } value is the integer literal parsed from the source.
+-- Returns the fields array (may be empty for `enum { }` shapes).
+-- Self-contained integer parser (no upvalue on parse_enum_int_literal which lives further down in the file).
+local function parse_enum_body_fields(body)
+	local fields   = {}
+	local body_pos = 1
+	local body_len = #body
+	while body_pos <= body_len do
+		body_pos = duffle.skip_ws_and_cmt(body, body_pos)
+		if body_pos > body_len then break end
+		local entry_name, name_end = duffle.read_ident(body, body_pos)
+		if not entry_name then
+			body_pos = body_pos + 1
+		else
+			local after_name = duffle.skip_ws_and_cmt(body, name_end)
+			local value
+			if body:sub(after_name, after_name) == "=" then
+				local val_pos = duffle.skip_ws_and_cmt(body, after_name + 1)
+				-- Self-contained integer literal parse (decimal, negative, hex).
+				-- Mirrors parse_enum_int_literal for the subset of shapes that appear in `typedef Enum_(...)` bodies.
+				local sign = 1
+				local p    = val_pos
+				if p <= body_len and body:sub(p, p) == "-" then
+					sign = -1
+					p    = p + 1
+				end
+				local start_digit = p
+				-- Hex form `0xNN` / `0XNN`.
+				local hex_value
+				if p + 1 <= body_len and body:sub(p, p) == "0"
+					and (body:sub(p + 1, p + 1) == "x"
+						or body:sub(p + 1, p + 1) == "X") then
+					p = p + 2
+					hex_value = 0
+					local any_hex = false
+					while p <= body_len do
+						local c = body:byte(p)
+						local d
+						if     c >= 0x30 and c <= 0x39 then d = c - 0x30
+						elseif c >= 0x61 and c <= 0x66 then d = c - 0x61 + 10
+						elseif c >= 0x41 and c <= 0x46 then d = c - 0x41 + 10
+						else break end
+						hex_value = hex_value * 16 + d
+						p         = p + 1
+						any_hex   = true
+					end
+					if any_hex then value = sign * hex_value end
+				elseif start_digit <= body_len and body:sub(start_digit, start_digit):match("[%d]") then
+					-- Decimal form.
+					local dec_value = 0
+					local any_digit = false
+					while p <= body_len do
+						local c = body:byte(p)
+						if c < 0x30 or c > 0x39 then break end
+						dec_value = dec_value * 10 + (c - 0x30)
+						p         = p + 1
+						any_digit = true
+					end
+					if any_digit then value = sign * dec_value end
+				end
+				if value ~= nil then
+					body_pos = p
+				else
+					body_pos = after_name + 1
+				end
+			else
+				body_pos = name_end
+			end
+			fields[#fields + 1] = { name = entry_name, value = value }
+		end
+		-- Skip past any trailing comma.
+		body_pos = duffle.skip_ws_and_cmt(body, body_pos)
+		if body_pos <= body_len and body:sub(body_pos, body_pos) == "," then
+			body_pos = body_pos + 1
+		end
+	end
+	return fields
+end
+
+-- Resolve a typedef chain's `byte_size` via repeated underlying_type walks.
+-- Returns a positive integer byte_size when the chain bottoms out at a builtin, or nil if the chain is broken, exceeds TYPE_CHAIN_MAX_DEPTH, or contains a cycle.
+local function resolve_typedef_byte_size(type_name, type_name_registry, visited, depth)
+	if depth > TYPE_CHAIN_MAX_DEPTH then return nil end
+	if visited[type_name] then return nil end
+	visited[type_name] = true
+
+	-- Check the builtin primitive map FIRST.
+	-- This handles undeclared builtin idents (e.g. `__UINT32_TYPE__` appears as underlying_type in `typedef __UINT32_TYPE__ TSet_(V4_S2);` 
+	-- even though the fixture never declares `__UINT32_TYPE__` itself).
+	local builtin = BUILTIN_BYTE_SIZES[type_name]
+	if builtin ~= nil then return builtin end
+
+	local entry = type_name_registry[type_name]
+	if not entry then return nil end
+
+	-- Confident: this entry was already resolved by the propagation pass
+	-- (e.g., a builtin or a struct whose fields are all resolved).
+	if entry.byte_size ~= nil then return entry.byte_size end
+
+	-- Chain-following: typedef / TSet_ aliases follow underlying_type.
+	if entry.underlying_type then
+		return resolve_typedef_byte_size(
+			entry.underlying_type, type_name_registry, visited, depth + 1)
+	end
+
+	-- Struct_ entries with unresolved byte_size can still resolve when their fields are all resolved.
+	if entry.kind == "struct" and entry.fields then
+		local sum       = 0
+		local all_have  = true
+		for _, f in ipairs(entry.fields) do
+			if f.byte_size == nil then all_have = false; break end
+			sum = sum + f.byte_size
+		end
+		if all_have and #entry.fields > 0 then return sum end
+	end
+
+	return nil
+end
+
+-- Propagation pass: resolve every entry's `byte_size` field by walking typedef chains, struct field sums, and the builtin primitive map.
+-- Builtins seed confident values; chains follow underlying_type recursively with a per-chain cycle guard (depth <= 8);
+-- struct byte_size derives from confident fields; void is invalid and skipped; pointers collapse to 4 bytes at parse time.
+-- Mutates `out.type_name_registry[name].byte_size` AND each struct's fields' `offset` + `byte_size` in place.
+local function propagate_type_sizes(out)
+	local reg = out.type_name_registry
+	if not reg then return end
+
+	-- Phase 1: seed builtin primitives (U1/U2/U4/S1/S2/S4 + __UINT*_TYPE__ family).
+	for name, size in pairs(BUILTIN_BYTE_SIZES) do
+		if reg[name] and reg[name].byte_size == nil then
+			reg[name].byte_size = size
+		end
+	end
+
+	-- Resolve typedef / TSet_ chains. Iterate to a fixed point (max TYPE_CHAIN_MAX_DEPTH iterations) 
+	-- since chains may span multiple hops and the resolution order isn't guaranteed by declaration order.
+	-- The visited map is empty when handed to the resolver.
+	-- The resolver marks visited as it enters each node, so the cycle guard fires only on RECURSIVE re-entry (not on the initial call).
+	for _ = 1, TYPE_CHAIN_MAX_DEPTH do
+		local any_change = false
+		for name, entry in pairs(reg) do
+			if entry.byte_size == nil then
+				local resolved = resolve_typedef_byte_size(name, reg, {}, 1)
+				if resolved ~= nil then
+					entry.byte_size = resolved
+					any_change = true
+				end
+			end
+		end
+		if not any_change then break end
+	end
+
+	-- Resolve struct field byte_sizes + offsets, then aggregate the struct's own byte_size.
+	-- Iterate to a fixed point: struct A may reference struct B which hasn't been resolved yet on the first pass.
+	-- Each pass updates as many fields + aggregates as possible; the loop terminates when no struct's byte_size changes between passes.
+	for _ = 1, TYPE_CHAIN_MAX_DEPTH do
+		local any_change = false
+		for _, entry in pairs(reg) do
+			if entry.kind == "struct" and entry.fields then
+				local byte_off  = 0
+				local gap_seen  = false
+				local sum       = 0
+				local all_have  = true
+				for _, f in ipairs(entry.fields) do
+					-- Resolve field byte_size (pointer / builtin / typedef chain).
+					if f.byte_size == nil then
+						if     f.pointer_depth > 0                                    then f.byte_size = POINTER_BYTE_SIZE
+						elseif BUILTIN_BYTE_SIZES[f.type_name]                        then f.byte_size = BUILTIN_BYTE_SIZES[f.type_name]
+						elseif reg[f.type_name] and reg[f.type_name].byte_size ~= nil then f.byte_size = reg[f.type_name].byte_size
+						end
+					end
+
+					-- Set offset (clean prefix rule).
+					if not gap_seen then
+						if f.byte_size ~= nil then
+							f.offset = byte_off
+							byte_off = byte_off + f.byte_size
+						else
+							f.offset = nil
+							gap_seen = true
+						end
+					else
+						f.offset = nil
+					end
+
+					if f.byte_size ~= nil then
+						sum = sum + f.byte_size
+					else
+						all_have = false
+					end
+				end
+				if all_have and #entry.fields > 0 then
+					if entry.byte_size ~= sum then
+						entry.byte_size = sum
+						any_change      = true
+					end
+				end
+			end
+		end
+		if not any_change then break end
+	end
+
+	-- Mirror aggregate byte_size onto the Binds_* entries in out.binds (Binds_* structs are shared via type_name_registry fields;
+	-- Only the aggregate bytes needs a mirror write since binds.bytes is a separate field from type_name_registry[name].byte_size).
+	for _, bind_entry in ipairs(out.binds or {}) do
+		local reg_entry = reg[bind_entry.name]
+		if reg_entry then
+			bind_entry.bytes = reg_entry.byte_size
 		end
 	end
-	return fields, byte_off
 end
 
 -- Parse the register list from inside `atom_reads(...)` or `atom_writes(...)`.
@@ -280,13 +550,85 @@ local function scan_reg_list(sub_inner)
 	return regs
 end
 
--- Parse the sub-calls inside `atom_info(atom_bind(...), atom_reads(...), atom_writes(...), atom_view(...), atom_reg_types(...))`.
--- Returns (binds, reads, writes, view_binds, reg_overrides).
+-- Parse one entry inside `atom_reads(...)` or `atom_writes(...)`.
+-- Each top-level comma-separated entry is either:
+--   - a plain register ident:               `R_FaceCursor` → reg_name only
+--   - register + atom_type sub-call:        `R_FaceCursor atom_type(V4_S2*)` → reg_name + override entry
+-- Returns (reg_name, override_entry_or_nil, malformed_flag).
+-- On malformed `atom_type(...)` (missing close paren, trailing tokens after the close paren, empty type chain, trailing junk inside the
+-- parens like `V4_S2*()`), the function still returns the leading reg_name but sets `malformed_flag = true` and `override_entry = nil`
+-- so the caller can silently drop the override while keeping the register in the reads/writes list
+-- (per the parser-safety contract — "malformed atom_type MUST NOT create any override").
+--
+-- The legacy `atom_rtype(...)` spelling is accepted as a transparent alias so test fixtures
+-- authored against the pre-Track-A grammar continue to parse. Canonical: `atom_type`.
+local function parse_atom_info_reg_entry(entry)
+	local pos = 1
+	pos = duffle.skip_ws_and_cmt(entry, pos)
+	if pos > #entry then return nil, nil, false end
+	local reg_name, reg_end = duffle.read_ident(entry, pos)
+	if not reg_name then return nil, nil, false end
+	pos = duffle.skip_ws_and_cmt(entry, reg_end)
+	-- Plain register, no adjacent atom_type — done.
+	if pos > #entry then return reg_name, nil, false end
+
+	-- Adjacent ident must be a bare `atom_type` (word-bounded both sides).
+	-- `atom_rtype` is the legacy alias; matches silently.
+	local next_ident, next_end = duffle.read_ident(entry, pos)
+	if not next_ident or (next_ident ~= "atom_type" and next_ident ~= "atom_rtype") then
+		return reg_name, nil, false
+	end
+	-- Left word-boundary: `_atom_type` should NOT match `atom_type`.
+	if pos > 1 then
+		local prev = entry:byte(pos - 1)
+		if duffle.is_alnum_byte(prev) then return reg_name, nil, false end
+	end
+	-- Right word-boundary: `atom_type_foo` should NOT match `atom_type`.
+	if next_end <= #entry then
+		local nxt = entry:byte(next_end)
+		if duffle.is_alnum_byte(nxt) then return reg_name, nil, false end
+	end
+
+	-- Expect `(` immediately after `atom_type` (whitespace tolerated).
+	pos = duffle.skip_ws_and_cmt(entry, next_end)
+	if pos > #entry or entry:sub(pos, pos) ~= "(" then
+		return reg_name, nil, true
+	end
+	local sub_inner, sub_after = duffle.read_parens(entry, pos)
+
+	-- Reject any trailing tokens (including `;` / `,`) after the close paren.
+	-- The outer caller already split on top-level commas, so the only legal terminator here is end-of-entry.
+	local after_close = duffle.skip_ws_and_cmt(entry, sub_after)
+	if after_close <= #entry then
+		return reg_name, nil, true
+	end
+
+	-- Parse the type chain inside the parens; require full consumption.
+	-- parse_type_chain returns (ident, depth, end_pos);
+	-- we reject any non-whitespace residue past end_pos (catches `V4_S2*()` etc.).
+	local type_name, depth, after_chain = parse_type_chain(sub_inner, 1)
+	if not type_name then return reg_name, nil, true end
+	local end_check = duffle.skip_ws_and_cmt(sub_inner, after_chain)
+	if end_check <= #sub_inner then
+		return reg_name, nil, true
+	end
+
+	return reg_name, { type_name = type_name, pointer_depth = depth }, false
+end
+
+-- Parse the sub-calls inside `atom_info(atom_bind(...), atom_reads(...), atom_writes(...), atom_view(...), atom_reg_types(...), atom_ctx(...), atom_phase(...))`.
+-- Returns (binds, reads, writes, view_binds, reg_overrides, ctx_atom_name, phase_label).
 -- `view_binds` is the Binds_X ident from `atom_view(Binds_X)`.
--- `reg_overrides` is a {reg_name = {type_name, pointer_depth}} table for `atom_reg_types(R_X, <type>)`.
-local function scan_atom_info_subcalls(info_inner)
+-- `reg_overrides` is a {reg_name = {reg, type_name, pointer_depth, source_line}}
+-- table populated from BOTH `atom_reg_types(R_X, <type>)` (legacy) and `atom_type(...)` sub-entries inside `atom_reads(...)` / `atom_writes(...)`.
+-- `ctx_atom_name` is the rbind atom ident from `atom_ctx(<atom_name>)` (singular; last-write-wins).
+-- `phase_label` is the user-authored C-ident label from `atom_phase(<label>)` (singular; last-write-wins).
+-- `info_line` is the 1-based line of the enclosing `atom_info(...)` call;
+-- It is recorded as `source_line` on every override entry so downstream passes can locate the declaration.
+local function scan_atom_info_subcalls(info_inner, info_line)
 	local binds, reads, writes = nil, nil, nil
 	local view_binds, reg_overrides = nil, nil
+	local ctx_atom_name, phase_label = nil, nil
 	local sub_pos = 1
 	while sub_pos <= #info_inner do
 		sub_pos = duffle.skip_ws_and_cmt(info_inner, sub_pos)
@@ -309,8 +651,27 @@ local function scan_atom_info_subcalls(info_inner)
 			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)
+				-- scan: atom_reads(<R_X [atom_type(<T>)], ...>)  OR atom_writes(<R_X [atom_type(<T>)], ...>)
+				-- The reads/writes arrays contain ONLY register idents;
+				-- the `atom_type(...)` sub-entry (when present and well-formed) is recorded as a per-atom reg_type_override.
+				local entries = read_top_level_args(sub_inner, 1)
+				local regs     = {}
+				for _, entry in ipairs(entries) do
+					local reg_name, override, malformed = parse_atom_info_reg_entry(entry)
+					if reg_name then
+						regs[#regs + 1] = reg_name
+						if override then
+							reg_overrides = reg_overrides or {}
+							reg_overrides[reg_name] = {
+								reg           = reg_name,
+								type_name     = override.type_name,
+								pointer_depth = override.pointer_depth,
+								source_line   = info_line,
+							}
+						end
+						-- malformed = silent: plain register still recorded; no override.
+					end
+				end
 				if kind == "atom_reads" then reads = regs else writes = regs end
 				sub_pos = sub_after2
 			else
@@ -342,7 +703,44 @@ local function scan_atom_info_subcalls(info_inner)
 							type_name, depth = duffle.trim(args[2]), 0
 						end
 					end
-					reg_overrides[reg_name] = { type_name = type_name, pointer_depth = depth }
+					reg_overrides[reg_name] = {
+						reg           = reg_name,
+						type_name     = type_name,
+						pointer_depth = depth,
+						source_line   = info_line,
+					}
+				end
+				sub_pos = sub_after2
+			else
+				sub_pos = sub_open + 1
+			end
+		elseif sub_ident == "atom_ctx" then
+			-- scan: atom_ctx(<atom_name>)
+			-- The argument must be a single C identifier (no commas, no parens, no whitespace inside).
+			-- Anything else is silently rejected (no `ctx_atom_name` is set) so the DWARF chain falls through.
+			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)
+				local name = duffle.read_ident(sub_inner, 1)
+				if name then
+					local after_id = duffle.skip_ws_and_cmt(sub_inner, 1 + #name)
+					if after_id > #sub_inner then ctx_atom_name = name end
+				end
+				sub_pos = sub_after2
+			else
+				sub_pos = sub_open + 1
+			end
+		elseif sub_ident == "atom_phase" then
+			-- scan: atom_phase(<label>)
+			-- The argument is a free-form C identifier label (atomic single ident; no commas / parens / whitespace inside).
+			-- Silently reject malformed args; the DWARF chain treats the atom as un-grouped.
+			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)
+				local name = duffle.read_ident(sub_inner, 1)
+				if name then
+					local after_id = duffle.skip_ws_and_cmt(sub_inner, 1 + #name)
+					if after_id > #sub_inner then phase_label = name end
 				end
 				sub_pos = sub_after2
 			else
@@ -352,7 +750,7 @@ local function scan_atom_info_subcalls(info_inner)
 			sub_pos = sub_end
 		end
 	end
-	return binds, reads, writes, view_binds, reg_overrides
+	return binds, reads, writes, view_binds, reg_overrides, ctx_atom_name, phase_label
 end
 
 -- Skip C qualifier keywords and return the position past the last one.
@@ -365,6 +763,297 @@ local function scan_skip_qualifiers(source, pos)
 	end
 end
 
+-- ════════════════════════════════════════════════════════════════════════════
+-- Track A helpers: enum / atom_reg / R_*_Code parsing
+-- ════════════════════════════════════════════════════════════════════════════
+--
+-- The Track A parser walks `enum { <body> }` declarations and emits one AliasEntry per R_* entry whose value is followed by a bare `atom_reg` token.
+-- Value resolution handles decimal/negative/hex literals and `R_*_Code` symbol references; 
+-- symbol references resolve via the cross-source `_code_macros` registry built in two passes by `M.run`.
+
+-- Byte constants (local to this file).
+local BYTE_HASH       = 0x23   -- '#'
+local BYTE_NEWLINE    = 0x0A   -- '\n'
+local BYTE_DASH       = 0x2D   -- '-'
+local BYTE_COMMA      = 0x2C   -- ','
+local BYTE_EQUAL      = 0x3D   -- '='
+local BYTE_R          = 0x52   -- 'R'
+local BYTE_UNDERSCORE = 0x5F   -- '_'
+local BYTE_0          = 0x30   -- '0'
+local BYTE_9          = 0x39   -- '9'
+local BYTE_a          = 0x61   -- 'a'
+local BYTE_f          = 0x66   -- 'f'
+local BYTE_A          = 0x41   -- 'A'
+local BYTE_F          = 0x46   -- 'F'
+local BYTE_x          = 0x78   -- 'x'
+local BYTE_X          = 0x58   -- 'X'
+local BYTE_OPEN_BRACE = 0x7B   -- '{'
+local BYTE_CLOSE_BRACE= 0x7D   -- '}'
+
+-- Maximum chain depth when resolving `R_*_Code` symbol RHS references.
+-- Eight hops is enough for any production chain (R_TapePtr_Code -> R_T8_Code -> ...).
+local CODE_MACRO_MAX_DEPTH = 8
+
+-- Returns true iff the byte is one of [0-9a-fA-F].
+local function is_hex_digit_byte(b)
+	if not b then return false end
+	if b >= BYTE_0 and b <= BYTE_9 then return true end
+	if b >= BYTE_a and b <= BYTE_f then return true end
+	if b >= BYTE_A and b <= BYTE_F then return true end
+	return false
+end
+
+-- Returns the hex digit value for byte `b`, or nil if `b` is not a hex digit.
+local function hex_digit_value(b)
+	if not b then return nil end
+	if b >= BYTE_0 and b <= BYTE_9 then return b - BYTE_0 end
+	if b >= BYTE_a and b <= BYTE_f then return b - BYTE_a + 10 end
+	if b >= BYTE_A and b <= BYTE_F then return b - BYTE_A + 10 end
+	return nil
+end
+
+-- Parse a decimal/negative-decimal/hex integer literal starting at byte position `start`.
+-- Returns (value, end_pos) on success, or (nil, start) on failure / no match.
+-- Accepts: 12, -1, 0, 0x10, 0X1F, -0x10.
+-- @param text string
+-- @param start integer
+-- @return integer|nil, integer
+local function parse_enum_int_literal(text, start)
+	local pos = start
+	local len = #text
+	if pos > len then return nil, start end
+
+	local sign = 1
+	if text:byte(pos) == BYTE_DASH then
+		sign = -1
+		pos  = pos + 1
+	end
+	if pos > len then return nil, start end
+	if not duffle.is_digit_byte(text:byte(pos)) then return nil, start end
+
+	-- Detect hex form: `0x` / `0X`. Decimal fallback otherwise.
+	if text:byte(pos) == BYTE_0 and pos + 1 <= len then
+		local peek = text:byte(pos + 1)
+		if peek == BYTE_x or peek == BYTE_X then
+			pos = pos + 2
+			local value     = 0
+			local has_digit = false
+			while pos <= len do
+				local d = hex_digit_value(text:byte(pos))
+				if not d then break end
+				value     = value * 16 + d
+				has_digit = true
+				pos       = pos + 1
+			end
+			if not has_digit then return nil, start end
+			return sign * value, pos
+		end
+	end
+
+	-- Decimal form.
+	local value = 0
+	while pos <= len do
+		local b = text:byte(pos)
+		if not (b >= BYTE_0 and b <= BYTE_9) then break end
+		value = value * 10 + (b - BYTE_0)
+		pos   = pos + 1
+	end
+	return sign * value, pos
+end
+
+-- Returns true iff `name` matches the `R_*_Code` ident pattern (R, _, <anything>, _Code).
+-- Uses byte checks for the fixed bytes per the Track A spec.
+local function is_r_code_macro(name)
+	if not name or #name < 6 then return false end
+	if name:byte(1) ~= BYTE_R          then return false end
+	if name:byte(2) ~= BYTE_UNDERSCORE then return false end
+	if name:sub(-5) ~= "_Code"         then return false end
+	return true
+end
+
+-- Look up an already-extracted `R_*_Code` macro name via the resolved `code_macros` registry,
+-- with cross-source fallback to the raw RHS bodies in `code_macro_bodies` when the registry misses.
+-- The chain recurses through the body via `resolve_code_macro_value` (which parses the body string as if it were the original RHS text).
+-- Cycle guard via the per-chain `visited` table; cap at CODE_MACRO_MAX_DEPTH. Returns the resolved integer or nil.
+local function lookup_code_value(sym, code_macros, code_macro_bodies, visited, depth)
+	if depth > CODE_MACRO_MAX_DEPTH then return nil end
+	if visited[sym] then return nil end
+	visited[sym] = true
+
+	-- Direct registry hit.
+	if code_macros and code_macros[sym] ~= nil then return code_macros[sym] end
+
+	-- Cross-source fallback: walk the raw RHS body of the missing symbol.
+	local body = code_macro_bodies and code_macro_bodies[sym]
+	if body then
+		return resolve_code_macro_value(body, 1, code_macros, code_macro_bodies, visited, depth + 1)
+	end
+
+	return nil
+end
+
+-- Try to resolve the RHS at byte position `pos` (in `source`) as an integer code.
+-- The RHS may be either an integer literal (decimal/negative/hex) or a `R_*_Code` symbol reference resolved via the `code_macros` registry.
+-- When the registry misses, falls back to the cross-source `code_macro_bodies` table
+-- (raw RHS text collected from all sources during pass 1a) so the chain `R_TapePtr_Code -> R_T8_Code -> 24`
+-- resolves even when the defining `#define R_T8_Code 24` lives in a different source than the chain call site.
+-- Recursive via per-chain `visited` + `depth`; cap at CODE_MACRO_MAX_DEPTH; on cycle return nil.
+-- Returns the resolved integer value, or nil if unresolvable.
+local function resolve_code_macro_value(source, pos, code_macros, code_macro_bodies, visited, depth)
+	if depth > CODE_MACRO_MAX_DEPTH then return nil end
+	pos = duffle.skip_ws_and_cmt(source, pos)
+
+	-- Try integer literal first (decimal / negative / hex).
+	local int_val, int_end = parse_enum_int_literal(source, pos)
+	if int_val ~= nil then return int_val end
+
+	-- Try symbol reference (must be R_*_Code per the spec).
+	local sym = duffle.read_ident(source, pos)
+	if not sym then return nil end
+	if not is_r_code_macro(sym) then return nil end
+
+	-- Cycle guard: bail if we've already seen this symbol on the current chain.
+	if visited[sym] then return nil end
+	visited[sym] = true
+
+	-- Direct registry hit — done.
+	if code_macros[sym] ~= nil then return code_macros[sym] end
+
+	-- Cross-source fallback: walk the body of the missing symbol if any other source collected its RHS during pass 1a.
+	-- The body is parsed as a fresh RHS (it's the raw post-`=` text of the original `#define` line), so the chain continues transparently.
+	local body = code_macro_bodies and code_macro_bodies[sym]
+	if body then
+		return resolve_code_macro_value(body, 1, code_macros, code_macro_bodies, visited, depth + 1)
+	end
+
+	-- Forward reference / unresolved: pass 1 stores resolved ints;
+	-- pass 2 re-encounters every `#define R_*_Code` line and resolves using the now-populated cross-source registries.
+	-- Returning nil here is the documented behavior; the enum-value lookup in pass 2 will also see nil and report via the AliasEntry.code = nil path.
+	return nil
+end
+
+-- Intercept a `#define R_*_Code <RHS>` preprocessor line.
+-- Always saves the raw RHS text into `code_macro_bodies` (for cross-source fallback during chain resolution),
+-- then (if resolvable) stores the resolved integer code into `code_macros` keyed by the macro name.
+-- `directive_start` points at the `#` byte. The function is silent on non-matching directives, the caller skips the line in any case.
+-- @param source string
+-- @param directive_start integer  -- byte position of `#`
+-- @param code_macros table        -- out._code_macros / ctx.shared._code_macros
+-- @param code_macro_bodies table  -- out._code_macro_bodies / ctx.shared._code_macro_bodies
+local function try_extract_code_macro(source, directive_start, code_macros, code_macro_bodies)
+	local rest = duffle.skip_ws_and_cmt(source, directive_start + 1)
+	local kw, kw_end = duffle.read_ident(source, rest)
+	if kw ~= "define" then return end
+
+	local after_kw = duffle.skip_ws_and_cmt(source, kw_end)
+	local macro_name, macro_end = duffle.read_ident(source, after_kw)
+	if not macro_name then return end
+	if not is_r_code_macro(macro_name) then return end
+
+	-- Save the raw RHS (post-`=` text up to the line end) into the cross-source body table 
+	-- FIRST so the chain walker can fall back to it when the defining `#define` lives in a different source.
+	local rhs_pos  = duffle.skip_ws_and_cmt(source, macro_end)
+	local rhs_end  = duffle.find_byte(source, BYTE_NEWLINE, rhs_pos) or (#source + 1)
+	local rhs_text = duffle.trim(source:sub(rhs_pos, rhs_end - 1))
+	if rhs_text ~= "" then
+		code_macro_bodies[macro_name] = rhs_text
+	end
+
+	-- Resolve RHS via per-chain visited + depth-bounded recursion.
+	local visited = { [macro_name] = true }
+	local value   = resolve_code_macro_value(source, rhs_pos, code_macros, code_macro_bodies, visited, 1)
+	if value ~= nil then code_macros[macro_name] = value end
+end
+
+-- Quick pre-pass: walk the source looking ONLY for `#define R_*_Code` lines.
+-- Populates `code_macros` with resolved integer codes AND `code_macro_bodies` with raw RHS text
+-- (used by the chain walker as cross-source fallback during pass 1b in `M.run`); ignores everything else.
+-- Used by `M.run` pass 1a to build the cross-source `_code_macros` + `_code_macro_bodies` registries before pass 1b resolves chains.
+-- @param source string
+-- @param code_macros table
+-- @param code_macro_bodies table
+local function scan_source_pre_pass(source, code_macros, code_macro_bodies)
+	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
+		if source:byte(pos) == BYTE_HASH then
+			local pp_pos = duffle.skip_preprocessor_line(source, pos)
+			if pp_pos then
+				try_extract_code_macro(source, pos, code_macros, code_macro_bodies)
+				pos = pp_pos
+			else
+				pos = pos + 1
+			end
+		else
+			pos = pos + 1
+		end
+	end
+end
+
+-- Check whether `atom_reg` appears as a BARE token at byte position `pos`.
+-- `pos` should be at the first non-whitespace byte after the value position
+-- (caller is responsible for skipping whitespace before calling).
+-- Returns (true, end_pos) iff the identifier at `pos` is exactly `atom_reg` AND the byte immediately before `pos` is a non-word char
+-- (whitespace, `,`, `=`, `{`, `}`, `(`, `)`, `[`, `]`, etc.) AND the byte immediately after the ident is a non-word char or end-of-input.
+-- Returns (false, pos) otherwise.
+local function check_bare_atom_reg(body, pos)
+	if pos > #body then return false, pos end
+
+	local ident, ident_end = duffle.read_ident(body, pos)
+	if ident ~= "atom_reg" then return false, pos end
+
+	-- Word-boundary check on the LEFT side: the byte at `pos - 1` must NOT be an alphanumeric/underscore byte (otherwise `atom_reg` is a suffix of `_not_atom_reg` or similar).
+	if pos > 1 then
+		local prev = body:byte(pos - 1)
+		if duffle.is_alnum_byte(prev) then return false, pos end
+	end
+
+	-- Word-boundary check on the RIGHT side: the byte at `ident_end` must NOT be an alphanumeric/underscore byte (otherwise `atom_reg` is a prefix of a longer identifier).
+	if ident_end <= #body then
+		local nxt = body:byte(ident_end)
+		if duffle.is_alnum_byte(nxt) then return false, pos end
+	end
+
+	return true, ident_end
+end
+
+-- Parse the type chain in an enum-site `atom_type(<T>)` call following the bare `atom_reg` token.
+-- Returns (type_name, depth, after_pos) on success or (nil, 0, pos) on any malformed input
+-- (silent; the alias is still emitted with `has_atom_reg = true` but without a default typed view).
+-- Caller has already advanced past `atom_reg` and skipped whitespace.
+local function parse_enum_atom_type_default(body, pos)
+	if pos > #body then return nil, 0, pos end
+	-- Bare `atom_type` word with word-bounding on both sides.
+	local ident, ident_end = duffle.read_ident(body, pos)
+	if ident ~= "atom_type" and ident ~= "atom_rtype" then return nil, 0, pos end
+	if pos > 1 then
+		local prev = body:byte(pos - 1)
+		if duffle.is_alnum_byte(prev) then return nil, 0, pos end
+	end
+	if ident_end <= #body then
+		local nxt = body:byte(ident_end)
+		if duffle.is_alnum_byte(nxt) then return nil, 0, pos end
+	end
+	-- Expect `( ... )` immediately after.
+	local open_pos = duffle.skip_ws_and_cmt(body, ident_end)
+	if open_pos > #body or body:sub(open_pos, open_pos) ~= "(" then return nil, 0, pos end
+	local inner, after_close = duffle.read_parens(body, open_pos)
+	-- Reject any trailing tokens past the close paren other than comma / close-brace (next enum entry / end of enum).
+	local residue = duffle.skip_ws_and_cmt(body, after_close)
+	if residue <= #body then
+		local rbyte = body:byte(residue)
+		if rbyte ~= BYTE_COMMA and rbyte ~= BYTE_CLOSE_BRACE then return nil, 0, pos end
+	end
+	-- Parse the type chain inside the parens (e.g. `V4_S2*` -> ("V4_S2", 1)).
+	local type_name, depth, after_chain = parse_type_chain(inner, 1)
+	if not type_name then return nil, 0, pos end
+	local end_check = duffle.skip_ws_and_cmt(inner, after_chain)
+	if end_check <= #inner then return nil, 0, pos end
+	return type_name, depth, duffle.skip_ws_and_cmt(body, after_close)
+end
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- Per-form parsers (the DECL_PARSERS table's payload)
 -- ════════════════════════════════════════════════════════════════════════════
@@ -380,8 +1069,8 @@ end
 --   returns   -- new position after the construct
 --
 -- All parsers read source-as-written via the duffle primitives (skip_ws_and_cmt / read_parens / read_braces / read_balanced).
--- No regex per the no_regex constraint; no hand-rolled depth tracking (the MipsAtomComp_Proc_ brace matcher
--- now uses duffle.read_braces instead of bespoke byte-dispatch).
+-- No regex per the no_regex constraint; no hand-rolled depth tracking
+-- (the MipsAtomComp_Proc_ brace matcher now uses duffle.read_braces instead of bespoke byte-dispatch).
 --
 -- Adding a new construct = 1 row in DECL_PARSERS + 1 parser function. The scan_source() loop never needs editing.
 
@@ -396,12 +1085,12 @@ end
 local function parse_skip_over_marker(source, pos, ident_end, line_of, out, marker_kind)
 	local open_paren = duffle.skip_ws_and_cmt(source, ident_end)
 	local marker = {
-		marker_kind = marker_kind,
-		marker_line = line_of(pos),
-		marker_pos    = pos,
-		after_paren   = ident_end,
-		args          = nil,
-		has_parens    = false,
+		marker_kind  = marker_kind,
+		marker_line  = line_of(pos),
+		marker_pos   = pos,
+		after_paren  = ident_end,
+		args         = nil,
+		has_parens   = false,
 	}
 	if source:sub(open_paren, open_paren) == "(" then
 		local inner, after_paren = duffle.read_parens(source, open_paren)
@@ -440,8 +1129,8 @@ local function parse_atom_dbg_reg_default(source, pos, ident_end, line_of, out)
 	}
 	out.type_occurrences = out.type_occurrences or {}
 	out.type_occurrences[#out.type_occurrences + 1] = {
-		reg        = reg_name,
-		type_name  = type_name,
+		reg         = reg_name,
+		type_name   = type_name,
 		source_line = line_of(pos),
 	}
 	return after_paren
@@ -469,26 +1158,42 @@ local function parse_mips_atom(source, pos, ident_end, line_of, out)
 		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)
-			local ai_binds, ai_reads, ai_writes, ai_view, ai_overrides = scan_atom_info_subcalls(info_inner)
+			-- info_line feeds the per-atom reg_type_overrides table.
+			local info_line = line_of(info_open)
+			local ai_binds, ai_reads, ai_writes, ai_view, ai_overrides, ai_ctx, ai_phase = scan_atom_info_subcalls(info_inner, info_line)
 			out.atom_infos[#out.atom_infos + 1] = {
 				atom_name = raw_name or "?", binds = ai_binds,
 				reads     = ai_reads or {}, writes = ai_writes or {},
 				view      = ai_view,
 				reg_type_overrides = ai_overrides,
+				ctx_atom  = ai_ctx,
+				phase     = ai_phase,
 				info_line = line_of(lookahead),
 			}
 			if ai_view and raw_name then
 				out.atom_views[raw_name] = {
-					atom_name         = raw_name,
-					binds_name        = ai_view,
+					atom_name          = raw_name,
+					binds_name         = ai_view,
 					reg_type_overrides = ai_overrides,
-					info_line         = line_of(lookahead),
+					info_line          = line_of(lookahead),
 				}
 			elseif raw_name and ai_overrides then
 				-- Record per-atom overrides even without atom_view.
 				out.atom_views[raw_name] = out.atom_views[raw_name] or { atom_name = raw_name, binds_name = nil, reg_type_overrides = nil, info_line = line_of(lookahead) }
 				out.atom_views[raw_name].reg_type_overrides = ai_overrides
 			end
+			-- Project the per-atom atom_ctx / atom_phase declarations onto the global phase index.
+			if raw_name then
+				if ai_ctx then
+					out.atom_ctxs = out.atom_ctxs or {}
+					out.atom_ctxs[raw_name] = { rbind_atom = ai_ctx, info_line = line_of(lookahead), source = source }
+				end
+				if ai_phase then
+					out.atom_phases = out.atom_phases or {}
+					out.atom_phases[ai_phase] = out.atom_phases[ai_phase] or { atoms = {} }
+					out.atom_phases[ai_phase].atoms[#out.atom_phases[ai_phase].atoms + 1] = raw_name
+				end
+			end
 			brace_search_pos = info_after
 		end
 	end
@@ -525,12 +1230,12 @@ local function parse_mips_atom_comp(source, pos, ident_end, line_of, out)
 	local  raw_name = duffle.read_ident(inner, 1)
 	if not raw_name then return open_paren + 1 end
 
-	local brace = duffle.scan_to_char(source, "{", after_paren)
+	local  brace = duffle.scan_to_char(source, "{", after_paren)
 	if not brace then return open_paren + 1 end
 
 	local body, after_brace = duffle.read_braces(source, brace)
-	local name = strip_ac_prefix(raw_name)
-	local declaration_line = line_of(pos)
+	local name              = strip_ac_prefix(raw_name)
+	local declaration_line  = line_of(pos)
 
 	out.atoms[#out.atoms + 1] = {
 		line        = declaration_line, name = name, body = body, body_off = brace + 1,
@@ -574,9 +1279,9 @@ local function parse_mips_atom_comp_proc(source, pos, ident_end, line_of, out)
 	local body_off = open_paren + 2 + last_brace_pos
 
 	out.atoms[#out.atoms + 1] = {
-		line        = declaration_line, name = name, body = body, body_off = body_off,
-		kind        = "comp_proc", raw_name = raw_name,
-		ident_pos   = pos, after_paren = after_paren,
+		line      = declaration_line, name = name, body = body, body_off = body_off,
+		kind      = "comp_proc", raw_name = raw_name,
+		ident_pos = pos, after_paren = after_paren,
 	}
 	associate_skip_over_marker(out, name, raw_name, "comp_proc", declaration_line, pos)
 
@@ -591,28 +1296,122 @@ end
 --- @param out SourceScan
 --- @return integer
 local function parse_mips_code(source, pos, ident_end, line_of, out)
-	local next_pos = duffle.skip_ws_and_cmt(source, ident_end)
-	local next_ident, next_after = duffle.read_ident(source, next_pos)
+	local  next_pos               = duffle.skip_ws_and_cmt(source, ident_end)
+	local  next_ident, next_after = duffle.read_ident(source, next_pos)
 	if not next_ident or #next_ident <= 5 or next_ident:sub(1, 5) ~= "code_" then
 		return ident_end
 	end
 
-	local atom_name = next_ident:sub(6)
-	local brace_pos = duffle.scan_to_char(source, "{", next_after)
+	local  atom_name = next_ident:sub(6)
+	local  brace_pos = duffle.scan_to_char(source, "{", next_after)
 	if not brace_pos then return ident_end end
 
 	local body, after_brace = duffle.read_braces(source, brace_pos)
 	local declaration_line = line_of(pos)
 	out.raw_atoms[#out.raw_atoms + 1] = {
-		line      = declaration_line, name = atom_name, body = body, body_off = brace_pos + 1,
-		kind      = "raw_atom", raw_name = atom_name,
+		line = declaration_line, name = atom_name, body = body, body_off = brace_pos + 1,
+		kind = "raw_atom", raw_name = atom_name,
 	}
 	associate_skip_over_marker(out, atom_name, next_ident, "unrelated", declaration_line, pos)
 
 	return after_brace
 end
 
---- Parse: `typedef Struct_(<name>) { <fields> }` — only emits when name starts with `Binds_`.
+--- Register a Struct_ entry in type_name_registry.
+--- Local helper for parse_typedef_binds. Populates the registry with
+---   { 
+--- 		name          = name, 
+--- 		kind          = "struct",
+--- 		fields        = [...],
+--- 		body          = body,
+---     source_line   = line,
+--- 		source_file   = source_path,
+---     pointer_depth = 0 
+--- 	} -- byte_size + per-field offset/byte_size set by the propagation pass.
+--- Also populates `out.binds[]` IFF `name:sub(1, 6) == "Binds_"`.
+--- @param body string
+--- @param name string
+--- @param pos integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+local function register_struct_type(body, name, pos, line_of, out)
+	local fields = parse_struct_body_fields(body)
+	local source_pos = line_of(pos)
+	out.type_name_registry[name] = {
+		name          = name,
+		kind          = "struct",
+		fields        = fields,
+		body          = body,
+		source_line   = source_pos,
+		source_file   = out._source_file,
+		pointer_depth = 0,
+		byte_size     = nil,    -- set by propagation pass
+	}
+	if name:sub(1, 6) == "Binds_" then
+		out.binds[#out.binds + 1] = {
+			line   = source_pos,
+			name   = name,
+			fields = fields,
+			body   = body,
+			bytes  = nil,    -- set by propagation pass
+		}
+	end
+end
+
+--- Register an Enum_ entry in type_name_registry.
+--- Local helper for parse_typedef_binds. Captures the underlying type (1st arg of `Enum_(<underlying>, <name>)`) and the body fields.
+--- @param underlying string
+--- @param name string
+--- @param body string
+--- @param pos integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+local function register_enum_type(underlying, name, body, pos, line_of, out)
+	local fields = parse_enum_body_fields(body)
+	out.type_name_registry[name] = {
+		name            = name,
+		kind            = "enum",
+		underlying_type = underlying,
+		fields          = fields,
+		body            = body,
+		source_line     = line_of(pos),
+		source_file     = out._source_file,
+		pointer_depth   = 0,
+	}
+end
+
+--- Register a simple typedef / TSet_ alias in type_name_registry.
+--- Captures the underlying type ident (LHS of `typedef <type> <alias>;`) and exposes it through the registry.
+--- The propagation pass follows the underlying_type chain to resolve byte_size.
+--- @param underlying string
+--- @param name string
+--- @param pos integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+local function register_typedef_alias(underlying, name, pos, line_of, out)
+	out.type_name_registry[name] = {
+		name           = name,
+		kind           = "typedef",
+		underlying_type = underlying,
+		source_line    = line_of(pos),
+		source_file    = out._source_file,
+		pointer_depth  = 0,
+	}
+end
+
+--- Parse: `typedef` declarations.
+---
+--- Recognizes four shapes:
+---   1. `typedef Struct_(<name>) { <body> } <alias>;` adds to type_name_registry (kind="struct"). 
+---       Binds_* aliases also land in out.binds[].
+---   2. `typedef Enum_(<underlying>, <name>) { <body> } <alias>;` 
+---       adds to type_name_registry (kind="enum"). 
+---   3. `typedef <type> <alias>;` simple typedef alias.
+---       Adds to type_name_registry (kind="typedef").
+---   4. `typedef <type> TSet_(<name>);` duffle TSet_ convention.
+---       Strips TSet_ wrapper; adds to type_name_registry (kind="typedef") with underlying_type=<type>.
+---
+--- All four shapes also associate an "unrelated" skip-over marker (the existing behavior — typedef declarations don't carry atom_dbg_skip_over).
 --- @param source string
 --- @param pos integer
 --- @param ident_end integer
@@ -621,26 +1420,69 @@ end
 --- @return integer
 local function parse_typedef_binds(source, pos, ident_end, line_of, out)
 	local after_typedef = duffle.skip_ws_and_cmt(source, ident_end)
-	local id2, id2_end = duffle.read_ident(source, after_typedef)
-	if id2 ~= "Struct_" then return ident_end end
+	local id2, id2_end  = duffle.read_ident(source, after_typedef)
+	if not id2 then return ident_end end
 
-	local open_paren = duffle.skip_ws_and_cmt(source, id2_end)
-	if source:sub(open_paren, open_paren) ~= "(" then return id2_end end
+	-- ── Shape 1: `typedef Struct_(<name>) { <body> } <alias>;` ────────────
+	if id2 == "Struct_" then
+		local open_paren = duffle.skip_ws_and_cmt(source, id2_end)
+		if source:sub(open_paren, open_paren) ~= "(" then return id2_end end
 
-	local inner, after_paren = duffle.read_parens(source, open_paren)
-	local name = duffle.trim(inner)
+		local inner, after_paren = duffle.read_parens(source, open_paren)
+		local name               = duffle.trim(inner)
 
-	local brace = duffle.scan_to_char(source, "{", after_paren)
-	if not brace then return open_paren + 1 end
+		local  brace = duffle.scan_to_char(source, "{", after_paren)
+		if not brace then return open_paren + 1 end
 
-	local body, after_brace = duffle.read_braces(source, brace)
-	if name:sub(1, 6) == "Binds_" then
-		local fields, byte_off = scan_binds_fields(body)
-		out.binds[#out.binds + 1] = { line = line_of(pos), name = name, fields = fields, bytes = byte_off }
+		local body, after_brace = duffle.read_braces(source, brace)
+		register_struct_type(body, name, pos, line_of, out)
+		associate_skip_over_marker(out, name, name, "unrelated", line_of(pos), pos)
+		return after_brace
 	end
-	associate_skip_over_marker(out, name, name, "unrelated", line_of(pos), pos)
 
-	return after_brace
+	-- ── Shape 2: `typedef Enum_(<underlying>, <name>) { <body> } <alias>;`
+	if id2 == "Enum_" then
+		local open_paren = duffle.skip_ws_and_cmt(source, id2_end)
+		if source:sub(open_paren, open_paren) ~= "(" then return id2_end end
+
+		local inner, after_paren = duffle.read_parens(source, open_paren)
+		-- Split `inner` on the first top-level comma into (<underlying>, <name>).
+		local args = read_top_level_args(inner, 1)
+		if   #args < 2 then return after_paren end
+		local underlying = duffle.trim(args[1])
+		local name       = duffle.trim(args[2])
+
+		local  brace = duffle.scan_to_char(source, "{", after_paren)
+		if not brace then return open_paren + 1 end
+
+		local body, after_brace = duffle.read_braces(source, brace)
+		register_enum_type(underlying, name, body, pos, line_of, out)
+		associate_skip_over_marker(out, name, name, "unrelated", line_of(pos), pos)
+		return after_brace
+	end
+
+	-- ── Shapes 3 + 4: `typedef <type> <alias>;`  or
+	--                  `typedef <type> TSet_(<name>);`
+	-- Read the <type> ident we already have (id2) and the trailing alias.
+	local after_id2 = duffle.skip_ws_and_cmt(source, id2_end)
+	local id3, id3_end = duffle.read_ident(source, after_id2)
+	if not id3 then return ident_end end
+
+	-- Shape 4: `typedef <type> TSet_(<name>);`
+	if id3 == "TSet_" then
+		local open_paren = duffle.skip_ws_and_cmt(source, id3_end)
+		if source:sub(open_paren, open_paren) ~= "(" then return id3_end end
+		local tset_inner, tset_after = duffle.read_parens(source, open_paren)
+		local tset_name = duffle.trim(tset_inner)
+		register_typedef_alias(id2, tset_name, pos, line_of, out)
+		associate_skip_over_marker(out, tset_name, tset_name, "unrelated", line_of(pos), pos)
+		return tset_after
+	end
+
+	-- Shape 3: `typedef <type> <alias>;`
+	register_typedef_alias(id2, id3, pos, line_of, out)
+	associate_skip_over_marker(out, id3, id3, "unrelated", line_of(pos), pos)
+	return id3_end
 end
 
 --- Parse: `_Pragma("mac_X tape_atom words=N")` (operator form).
@@ -658,18 +1500,18 @@ local function parse_pragma_macro(source, pos, ident_end, line_of, out)
 	str = duffle.trim(str)
 	if str:sub(1, 1) ~= '"' or str:sub(-1) ~= '"' then return str_end end
 
-	local inner = str:sub(2, -2)
-	local space = duffle.find_byte(inner, 32, 1)
+	local  inner = str:sub(2, -2)
+	local  space = duffle.find_byte(inner, 32, 1)
 	if not space then return str_end end
 
-	local name = inner:sub(1, space - 1)
-	local rest = inner:sub(space + 1)
-	local eq = duffle.find_byte(rest, 61, 1)
+	local  name = inner:sub(1, space - 1)
+	local  rest = inner:sub(space + 1)
+	local  eq   = duffle.find_byte(rest, 61, 1)
 	if not eq then return str_end end
 
 	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
+	if    key == "tape_atom words" or key == "words" then
 		out.macros[#out.macros + 1] = { line = line_of(pos), name = name, words = tonumber(val) or 0 }
 	end
 
@@ -689,6 +1531,146 @@ local function parse_pragma_dummy(source, pos, ident_end, line_of, out)
 	return ident_end
 end
 
+-- Parse the value side of an enum entry.
+-- Accepts integer literals (decimal/negative/hex), `R_*_Code` symbol references resolved via `out._code_macros`,
+-- AND bare `R_*` symbols that map to an `R_*_Code` variant in the registry.
+-- The bare-`R_*` fallback is needed for the lottes_tape.h wave-context aliases whose enum RHS is the bare register ident (e.g. `R_TapePtr = R_T8 atom_reg`);
+-- the `R_*_Code` form (e.g. `R_T8_Code`) holds the actual GPR code in mips.h and is now resolvable cross-source via the chain walker.
+-- Returns (value, end_pos) on success or (nil, pos) if unresolvable.
+local function parse_enum_value(body, pos, out)
+	local int_val, int_end = parse_enum_int_literal(body, pos)
+	if int_val ~= nil then return int_val, int_end end
+
+	local sym = duffle.read_ident(body, pos)
+	if not sym then return nil, pos end
+
+	-- Bare `R_*` (no `_Code` suffix) → translate to `R_*_Code` and look that up. Non-`R_*` symbols
+	-- (plain idents without the prefix) are not value sources and fall through to the nil return.
+	local lookup_sym = sym
+	if not is_r_code_macro(sym)
+		and sym:byte(1) == BYTE_R
+		and sym:byte(2) == BYTE_UNDERSCORE then
+		lookup_sym = sym .. "_Code"
+	end
+
+	-- visited starts empty; lookup_code_value marks visited[sym] = true on its first cycle-guard check,
+	-- so pre-marking here would falsely trigger the cycle short-circuit and return nil.
+	local value = lookup_code_value(lookup_sym, out._code_macros, out._code_macro_bodies, {}, 1)
+	if value ~= nil then return value, (pos + #sym) end
+
+	return nil, pos
+end
+
+-- Walk one enum entry: read value, check for bare `atom_reg`,
+-- and (if both are present and the name starts with `R_`) write an AliasEntry into `out.register_alias_registry`.
+-- If `atom_reg` is followed by an adjacent `atom_type(<T>)`, the parsed T is stored on the AliasEntry
+-- as `default_type` (type_name + pointer_depth). Silent if `atom_type(...)` is malformed.
+-- Returns the new byte position within `body` (advanced past `atom_type(...)` if well-formed, past `atom_reg` alone,
+-- or past the value if neither was present).
+local function parse_enum_entry(source, body, body_offset, line_of, out, entry_name, name_body_pos, value_start)
+	-- value_start is within `body`, just past the `=`.
+	local after_ws = duffle.skip_ws_and_cmt(body, value_start)
+	local value, value_end = parse_enum_value(body, after_ws, out)
+	if value == nil then return value_start end
+
+	local after_value       = duffle.skip_ws_and_cmt(body, value_end)
+	local has_atom_reg, end_after_atom_reg = check_bare_atom_reg(body, after_value)
+
+	-- Only register R_* entries whose value is followed by bare `atom_reg`.
+	if has_atom_reg and entry_name:byte(1) == BYTE_R and entry_name:byte(2) == BYTE_UNDERSCORE then
+		local entry_source_pos = body_offset + name_body_pos - 1
+		local entry = {
+			name          = entry_name,
+			code          = value,
+			source_line   = line_of(entry_source_pos),
+			source_file   = source,
+			pointer_depth = 0,
+			has_atom_reg  = true,
+		}
+		-- Adjacent enum-site default view, if any. Tolerant of malformed `atom_type(...)`.
+		local after_atom_reg = duffle.skip_ws_and_cmt(body, end_after_atom_reg)
+		local dflt_type_name, dflt_depth, end_after_atom_type = parse_enum_atom_type_default(body, after_atom_reg)
+		if dflt_type_name then
+			entry.default_type  = dflt_type_name
+			entry.default_depth = dflt_depth
+			entry.pointer_depth = dflt_depth   -- override; this alias is a pointer-type alias by default
+			out.register_alias_registry[entry_name] = entry
+			return end_after_atom_type
+		end
+		out.register_alias_registry[entry_name] = entry
+		return end_after_atom_reg
+	end
+
+	return has_atom_reg and end_after_atom_reg or value_end
+end
+
+-- Walk the body of an `enum { ... }` declaration. Each entry is comma-separated (mips.h style: leading commas allowed);
+-- each entry optionally has the shape `NAME = VALUE atom_reg`.
+-- Inline `#define` directives inside the body (lottes_tape.h style) are skipped past the newline.
+local function parse_enum_body(source, body, body_offset, line_of, out)
+	local pos      = 1
+	local body_len = #body
+	while pos <= body_len do
+		pos = duffle.skip_ws_and_cmt(body, pos)
+		if pos > body_len then break end
+
+		local c = body:byte(pos)
+		if c == BYTE_COMMA then
+			-- Leading comma (mips.h style: `, rtmp_0 = R_T0,`).
+			pos = pos + 1
+		elseif c == BYTE_CLOSE_BRACE then
+			break
+		elseif c == BYTE_HASH then
+			-- Inline `#define` inside the enum body (lottes_tape.h style).
+			-- Skip past the newline; the main preprocessor intercept in scan_source has already resolved the `_Code` chain.
+			local nl = duffle.find_byte(body, BYTE_NEWLINE, pos)
+			if nl then pos = nl + 1 else pos = body_len + 1 end
+		else
+			local entry_name, name_end = duffle.read_ident(body, pos)
+			if entry_name then
+				local after_name = duffle.skip_ws_and_cmt(body, name_end)
+				if body:byte(after_name) == BYTE_EQUAL then
+					local new_pos = parse_enum_entry(
+						source, body, body_offset, line_of, out,
+						entry_name, pos, after_name + 1
+					)
+					if new_pos > pos then pos = new_pos else pos = after_name + 1 end
+				else
+					pos = name_end
+				end
+			else
+				pos = pos + 1
+			end
+		end
+	end
+end
+
+--- Parse: `enum [<tag>] { <body> }`. Walks the body and populates `out.register_alias_registry` with one entry per `R_* = <value> atom_reg` line.
+--- @param source string
+--- @param pos integer
+--- @param ident_end integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+--- @return integer
+local function parse_enum(source, pos, ident_end, line_of, out)
+	-- pos points at the `e` of `enum`; ident_end points past `enum`.
+	-- Optional enum tag (e.g. `enum Foo { ... }`): a single ident between `enum` and `{` that is not followed by `(`.
+	local after_ident        = duffle.skip_ws_and_cmt(source, ident_end)
+	local tag_ident, tag_end = duffle.read_ident(source, after_ident)
+	if tag_ident and source:byte(tag_end) ~= 0x28 then  -- not '('
+		after_ident = tag_end
+	end
+
+	-- Find the opening brace of the enum body.
+	local  brace_pos = duffle.scan_to_char(source, "{", after_ident)
+	if not brace_pos then return ident_end end
+
+	local body, after_brace = duffle.read_braces(source, brace_pos)
+	parse_enum_body(source, body, brace_pos + 1, line_of, out)
+
+	return after_brace
+end
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- DECL_PARSERS — data-driven construct dispatch (the plex pattern)
 -- ════════════════════════════════════════════════════════════════════════════
@@ -708,6 +1690,8 @@ local DECL_PARSERS = {
 	typedef                    = parse_typedef_binds,
 	_Pragma                    = parse_pragma_macro,
 	pragma                     = parse_pragma_dummy,
+	-- Track A: `enum [<tag>] { <body> }` populates `out.register_alias_registry`.
+	enum                       = parse_enum,
 }
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -717,8 +1701,11 @@ local DECL_PARSERS = {
 --- 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, skip_over, line_of }
-local function scan_source(source)
+--- @param source_file string|nil       -- absolute source path (forwarded into AliasEntry.source_file)
+--- @param code_macros table|nil        -- cross-source `R_*_Code` registry; nil = local-only
+--- @param code_macro_bodies table|nil  -- cross-source raw RHS body table; nil = local-only
+--- @return table  -- SourceScan { atoms, raw_atoms, binds, atom_infos, macros, skip_over, line_of, register_alias_registry, _code_macros, _code_macro_bodies }
+local function scan_source(source, source_file, code_macros, code_macro_bodies)
 	local line_of = duffle.LineIndex(source)
 	local out     = {
 		atoms      = {},
@@ -734,6 +1721,24 @@ local function scan_source(source)
 		types      = {},
 		atom_views = {},
 		line_of    = line_of,
+		-- Track A: source-derived register-alias registry (atom_reg opt-in entries).
+		-- Keys are full R_* idents (never stripped); see parse_enum / parse_enum_body.
+		register_alias_registry = {},
+		-- Track A: source-derived type-name registry. 
+		-- Populated from `typedef Struct_(...)`, `typedef Enum_(...)`, `typedef <type> <alias>`, and `typedef <type> TSet_(<name>)` declarations. 
+		-- The propagation pass at the end of `scan_source()` resolves byte_size via the builtin map, 
+		-- typedef chain walking (cycle-guarded, depth <= 8), and struct field sums.
+		-- See `propagate_type_sizes()` below.
+		type_name_registry = {},
+		-- Track A: shared `R_*_Code -> integer code` registry 
+		-- (passed in from M.run pass 1; same reference so preprocessor intercept writes are visible to the enum-value resolver).
+		-- Stripped from `src.scan` before return.
+		_code_macros       = code_macros or {},
+		-- Track A: shared raw RHS body table (passed in from M.run pass 1a;
+		-- same reference so preprocessor intercept writes are visible to the cross-source chain walker in resolve_code_macro_value).
+		-- Stripped from `src.scan` before return.
+		_code_macro_bodies = code_macro_bodies or {},
+		_source_file       = source_file,
 	}
 	local pos     = 1
 	local src_len = #source
@@ -746,6 +1751,9 @@ local function scan_source(source)
 		-- _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
+			-- Track A intercept: resolve `#define R_*_Code <int-or-symbol>`
+			-- into the shared `_code_macros` registry before skipping the line.
+			try_extract_code_macro(source, pos, out._code_macros, out._code_macro_bodies)
 			pos = pp_pos
 		else
 			-- Skip C qualifiers (static, const, etc.) that may precede a declaration.
@@ -757,10 +1765,9 @@ local function scan_source(source)
 					if parser then
 						pos = parser(source, pos, ident_end, line_of, out)
 					else
-						-- A component-procedure declaration has an FI_ signature before
-						-- MipsAtomComp_Proc_; keep the marker pending across that prelude.
-						-- Any other identifier begins an unrelated declaration/construct
-						-- and consumes the marker so it cannot drift to a later atom.
+						-- A component-procedure declaration has an FI_ signature before MipsAtomComp_Proc_;
+						-- keep the marker pending across that prelude. 
+						-- Any other identifier begins an unrelated declaration/construct and consumes the marker so it cannot drift to a later atom.
 						local markers = out.skip_over.markers
 						local marker  = markers[#markers]
 						if marker and marker.pending then
@@ -787,6 +1794,11 @@ local function scan_source(source)
 		end
 	end
 
+	-- Propagate byte_size through the type-name registry.
+	-- Runs AFTER the source walk so all typedef / Struct_ / Enum_ declarations have been parsed into `out.type_name_registry`.
+	-- Mutates each entry's `byte_size` field in place; fields with pointer_depth > 0 already carry byte_size = 4 from parse time and are unaffected.
+	propagate_type_sizes(out)
+
 	return out
 end
 
@@ -800,22 +1812,71 @@ 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.
+---
+--- Track A: runs in 3 phases.
+---   Pass 1a: `scan_source_pre_pass` over every source, populating the cross-source `ctx.shared._code_macros` AND `ctx.shared._code_macro_bodies` registries.
+---             The bodies table holds the raw post-`=` text of every `#define R_*_Code` line (cross-source) so the chain walker can fall back when a 
+---             sdefining `#define` lives in a different source than the chain call site.
+---   Pass 1b:  Resolve every collected macro's chain using the bodies table as fallback.
+---             This fills in `code_macros` entries whose defining source was scanned AFTER the call site 
+---             (e.g. lottes_tape.h's `R_TapePtr_Code -> R_T8_Code` chain into mips.h's `R_T8_Code = 24`).
+---   Pass 2:   The full `scan_source(source, source_file, code_macros, code_macro_bodies)` walk, which feeds `out._code_macros = ctx.shared._code_macros`
+---             (and `out._code_macro_bodies = ctx.shared._code_macro_bodies`)
+---             so the enum parser can resolve cross-source `R_*_Code` references and bare `R_*` symbols via the `_Code` registry fallback.
+---   Strip:    `src.scan._code_macros` AND `src.scan._code_macro_bodies` are nilled before returning so downstream passes 
+---             (annotation, components, offsets, dwarf_injection, etc.) don't see the private parse state.
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
+	-- Initialize the cross-source code-macro + body registries in ctx.shared.
+	-- (Pass 1a writes into both; pass 1b reads from both; pass 2 reads both.)
+	ctx.shared                       = ctx.shared or {}
+	ctx.shared._code_macros          = ctx.shared._code_macros or {}
+	ctx.shared._code_macro_bodies    = ctx.shared._code_macro_bodies or {}
+	local code_macros                = ctx.shared._code_macros
+	local code_macro_bodies          = ctx.shared._code_macro_bodies
+
+	-- Pass 1a: collect `_code_macros` + `_code_macro_bodies` across ALL sources.
 	for _, src in ipairs(ctx.sources) do
-		src.scan = scan_source(src.text)
+		scan_source_pre_pass(src.text, code_macros, code_macro_bodies)
+	end
+
+	-- Pass 1b: resolve every collected macro's chain with cross-source fallback.
+	-- The bodies table was populated for every `#define R_*_Code` line in pass 1a;
+	-- this iteration finishes the chain even when the chain hops span sources
+	-- (e.g. R_TapePtr_Code -> R_T8_Code -> 24 spans lottes_tape.h into mips.h).
+	-- Same `code_macros` table is shared with pass 2 below.
+	for macro_name, _ in pairs(code_macro_bodies) do
+		if code_macros[macro_name] == nil then
+			local body    = code_macro_bodies[macro_name]
+			local visited = { [macro_name] = true }
+			local value   = resolve_code_macro_value(body, 1, code_macros, code_macro_bodies, visited, 1)
+			if value ~= nil then code_macros[macro_name] = value end
+		end
+	end
+
+	-- Pass 2: run the full scan with the shared `_code_macros` + `_code_macro_bodies` 
+	-- so the enum parser can resolve cross-source `R_*_Code` references and bare `R_*` symbols via the `_Code` registry fallback.
+	for _, src in ipairs(ctx.sources) do
+		src.scan = scan_source(src.text, src.path, code_macros, code_macro_bodies)
 		-- 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)
+		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
+
+	-- Strip `_code_macros` + `_code_macro_bodies` (and the convenience `_source_file` pointer)
+	-- before returning so downstream passes don't see private parse state.
+	for _, src in ipairs(ctx.sources) do
+		if src.scan then
+			src.scan._code_macros       = nil
+			src.scan._code_macro_bodies = nil
+			src.scan._source_file       = nil
 		end
 	end
+
 	return { outputs = {}, errors = {}, warnings = {} }
 end
 
diff --git a/scripts/passes/static_analysis.lua b/scripts/passes/static_analysis.lua
index 2896a39..1d4ee90 100644
--- a/scripts/passes/static_analysis.lua
+++ b/scripts/passes/static_analysis.lua
@@ -1,13 +1,22 @@
 --- passes/static_analysis.lua — Per-atom static-analysis checks.
 ---
---- The 5 checks currently shipped:
----   1. **GTE pipeline-fill** — every `gte_cmdw_*` invocation must be preceded by the minimum number of `nop` words
----      (per `duffle.GTE_PIPELINE_LATENCY`) so the COP2 pipeline latency is fully retired before the command issues.
----   2. **mac_yield uniformity** — every atom body must contain exactly one `mac_yield()` call (control transfer pattern).
----   3. **ABI handoff** — every `atom_bind(Binds_X)` must reference a `typedef Struct_(Binds_X) { ... }` declaration.
----   4. **GPU port-store shape** — per-shape (`f3`/`f4`/`g4`/etc.) the sum of `mac_format_X_color` + `mac_gte_store_X_*` +
----      `mac_insert_ot_tag_X` words must equal the GP0 cmd's expected packet size.
----   5. **per-atom cycle budget** — sum each atom body's instruction latencies (per `duffle.INSTRUCTION_LATENCY`); report total.
+--- The 9 checks currently shipped:
+---   Per-atom rules:
+---     1. **GTE pipeline-fill** — every `gte_cmdw_*` invocation must be preceded by the minimum number of `nop` words
+---        (per `duffle.GTE_PIPELINE_LATENCY`) so the COP2 pipeline latency is fully retired before the command issues.
+---     2. **mac_yield uniformity** — every atom body must contain exactly one `mac_yield()` call (control transfer pattern).
+---     3. **ABI handoff** — every `atom_bind(Binds_X)` must reference a `typedef Struct_(Binds_X) { ... }` declaration.
+---     4. **GPU port-store shape** — per-shape (`f3`/`f4`/`g4`/etc.) the sum of `mac_format_X_color` + `mac_gte_store_X_*` +
+---        `mac_insert_ot_tag_X` words must equal the GP0 cmd's expected packet size.
+---     5. **per-atom cycle budget** — sum each atom body's instruction latencies (per `duffle.INSTRUCTION_LATENCY`); report total.
+---   Per-source rules (registry-driven, added 2026-07-16):
+---     6. **enum_alias_membership** — every `R_X` referenced from `atom_dbg_reg_default`, `atom_reg_types`,
+---        `atom_rtype(...)`, `atom_reads`, or `atom_writes` must be in `scan.register_alias_registry`. Missing -> warning.
+---     7. **atom_rtype_consistency** — every `reg_type_overrides[R_X].type_name` must resolve in `scan.type_name_registry`. Missing -> error.
+---     8. **binds_no_substruct_deref** — every `load_word(R_A, R_B, O_(Type, Field))` and `store_word(...)` in every atom body
+---        must reference a leaf scalar (pointer-to-struct counts as leaf; nested struct members do NOT). Missing -> warning (build continues).
+---     9. **reads_writes_alias_membership** — distinct check name duplicating #6's reads/writes coverage so the report can
+---        attribute failures to a precedence class. Missing -> warning (build continues).
 ---
 --- The orchestrator (`ps1_meta.lua`) wires this module in via the PASSES table:
 ---   `["static-analysis"] = { module = "passes.static_analysis", kind = "validation", deps = {"word-counts", "components"},
@@ -24,7 +33,7 @@
 -- 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 duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
@@ -503,8 +512,8 @@ local function check_gpu_portstore_shape(atom, pipe_ctx, findings)
 	local saw_format = false
 	local saw_prim_write = false
 
-	-- Reads from tc_entry fields pre-computed by classify_tokens (R3 lift). Eliminates 4 per-token
-	-- string matches (mac_format_X_color + mac_gte_store_<shape> + mac_insert_ot_tag_<shape> + R_PrimCursor)
+	-- Reads from tc_entry fields pre-computed by classify_tokens (R3 lift).
+	-- Eliminates 4 per-token string matches (mac_format_X_color + mac_gte_store_<shape> + mac_insert_ot_tag_<shape> + R_PrimCursor)
 	for tok_idx = 1, #tokens do
 		local tc_entry = tc[tok_idx]
 		local shape    = tc_entry.mac_format_shape
@@ -628,7 +637,7 @@ local function analyze_atom_paths(atom)
 				end
 			end
 			-- For literal-offset branches (label == false), the taken path would jump to a non-tracked address; conservatively omit.
-			-- Return (succ, nil) -- the second value is the terminator marker (nil = not a terminator).
+			-- Return (succ, nil), the second value is the terminator marker (nil = not a terminator).
 			return succ, nil
 		end
 		-- Normal token: just the next one
@@ -732,21 +741,273 @@ local function check_per_atom_cycle_budget(atom, pipe_ctx, findings)
 	end
 end
 
+-- ════════════════════════════════════════════════════════════════════════════
+-- Check #6: enum_alias_membership (Track A Task 13)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Every R_X referenced from a debug-visible surface — atom_dbg_reg_default, atom_reg_types, atom_rtype sub-entries, atom_reads, atom_writes;
+-- MUST be present in `pipe_ctx.register_alias_registry`.
+-- The registry is the source-derived answer to "is this R_X a real, opt-in alias?"
+-- (populated by scan_source's `parse_enum_aliases` from `enum { R_X = N atom_reg }` declarations).
+-- Per-source rule (called once per source via the CHECK_RULES dispatch).
+-- Signature matches the per_source shape established by check_semantic_reg_defaults.
+--
+-- Severity: WARNING (build continues).
+-- The rule is intentionally permissive because the production `code/duffle/` and `code/gte_hello/`
+-- sources use R_* aliases in atom_reads / atom_writes that may not yet be opted in via the 
+-- bare `atom_reg` marker. R_TapePtr / R_AtomJmp / R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase ARE opted in (lottes_tape.h Task 21).
+-- Raw C-ABI aliases like R_T0..R_T3 are intentionally NOT auto-included (per the prototype principle:
+-- no auto-include of wave-context; explicit opt-in only). Warnings keep the build green
+-- and surface the migration gap so users see which atoms still need opt-in registration.
+local function check_enum_alias_membership(_src, pipe_ctx, findings)
+	local reg_registry = pipe_ctx.register_alias_registry or {}
+
+	-- (a) atom_dbg_reg_default(R_X, T) -- pipe_ctx.types.
+	--     source_line is on every entry; emit the diagnostic against the default declaration's own line so the report's
+	--     "Findings by atom" section can attribute the failure to the marker location.
+	for reg, def in pairs(pipe_ctx.types or {}) do
+		if not reg_registry[reg] then
+			findings[#findings + 1] = {
+				atom  = "", line = def.source_line or 0,
+				check = "enum_alias_membership", kind = "warning",
+				msg   = string.format(
+					"atom_dbg_reg_default at line %d references unknown register %q (not in register_alias_registry)",
+					def.source_line or 0, reg),
+			}
+		end
+	end
+
+	-- (b) atom_reg_types(R_X, T) + (c) atom_rtype(R_X, T) sub-entries both populate `ai.reg_type_overrides` (Track A Task 5 merge).
+	--     (d) atom_reads(R_X) + (e) atom_writes(R_X) populate the reads/writes arrays.
+	--     All four are checked against the same registry; the per-rule dispatch iterates `ai` once and covers all three locations
+	--     so we don't re-walk atom_infos for each sub-check.
+	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do
+		local info_line = ai.info_line or 0
+		local atom_name = ai.atom_name or ""
+		if ai.reg_type_overrides then
+			for reg in pairs(ai.reg_type_overrides) do
+				if not reg_registry[reg] then
+					findings[#findings + 1] = {
+						atom  = atom_name, line = info_line,
+						check = "enum_alias_membership", kind = "warning",
+						msg   = string.format(
+							"atom '%s' at line %d has reg_type_overrides for %q; the alias is not in register_alias_registry",
+							atom_name, info_line, reg),
+					}
+				end
+			end
+		end
+		for _, reg in ipairs(ai.reads or {}) do
+			if not reg_registry[reg] then
+				findings[#findings + 1] = {
+					atom  = atom_name, line = info_line,
+					check = "enum_alias_membership", kind = "warning",
+					msg   = string.format(
+						"atom '%s' at line %d has atom_reads for %q; the alias is not in register_alias_registry",
+						atom_name, info_line, reg),
+				}
+			end
+		end
+		for _, reg in ipairs(ai.writes or {}) do
+			if not reg_registry[reg] then
+				findings[#findings + 1] = {
+					atom  = atom_name, line = info_line,
+					check = "enum_alias_membership", kind = "warning",
+					msg   = string.format(
+						"atom '%s' at line %d has atom_writes for %q; the alias is not in register_alias_registry",
+						atom_name, info_line, reg),
+				}
+			end
+		end
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Check #7: atom_type_consistency (Track A Task 13; legacy alias atom_rtype_consistency)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- Every `reg_type_overrides[R_X].type_name` (populated by BOTH `atom_reg_types(R_X, <type>)`
+-- and `atom_type(R_X, <type>)` sub-entries inside atom_reads/atom_writes — legacy `atom_rtype` is
+-- accepted as a transparent alias) MUST resolve to a `type_name_registry` entry.
+-- The registry is the source-derived answer to "is this type name declared in this translation unit?"
+-- (populated by `typedef Struct_(...)`, `typedef Enum_(...)`, `typedef ... TSet_(...)` declarations).
+-- Missing type names are errors (the build stops) so the user adds the typedef before re-running.
+-- Per-source rule.
+local function check_atom_rtype_consistency(_src, pipe_ctx, findings)
+	local type_registry = pipe_ctx.type_name_registry or {}
+	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do
+		local info_line = ai.info_line or 0
+		local atom_name = ai.atom_name or ""
+		if ai.reg_type_overrides then
+			for reg, ov in pairs(ai.reg_type_overrides) do
+				if not ov.type_name or not type_registry[ov.type_name] then
+					findings[#findings + 1] = {
+						atom  = atom_name, line = info_line,
+						check = "atom_rtype_consistency", kind = "error",
+						msg   = string.format(
+							"atom '%s' at line %d reg_type_overrides[%q] uses unknown type %q (not in type_name_registry)",
+							atom_name, info_line, reg, tostring(ov.type_name)),
+					}
+				end
+			end
+		end
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Check #8: binds_no_substruct_deref (Track A Task 13)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- For every `load_word(R_A, R_B, O_(<Type>, <Field>))` and matching `store_word(...)` call in every atom body,
+-- the `<Field>` MUST resolve to a leaf scalar of `<Type>`. A "leaf scalar" is:
+--   * a non-struct field with `pointer_depth >= 1` (pointer-to-struct IS a leaf — the field is a pointer; the pointee is unrelated), OR
+--   * a non-struct field whose type_name resolves to a typedef / enum / builtin in `type_name_registry`.
+-- A nested struct member (pointer_depth == 0 AND type_name resolves to a `kind = "struct"` registry entry) is NOT a leaf scalar and is flagged.
+-- The check also flags fields whose Type has no `fields` table (typedefs and enums don't have fields — any Field reference against them is bogus)
+-- and fields whose name doesn't appear in the resolved Type's fields array.
+--
+-- Walks every atom's pre-computed `paths.tok_class`
+-- (set by `classify_tokens` once per atom in validate()) and uses the `o_arg1` / `o_arg2` captures instead of re-matching the token string.
+-- Resolution consults `pipe_ctx.type_name_registry`
+-- (Binds_* structs are registered there by scan_source's `register_struct_type`, so a unified lookup works for both Binds_* and non-Binds structs).
+--
+-- Severity: warning (build continues) — this catches a category of bugs
+-- (passing a struct by value through the tape payload) where the symptom is runtime corruption, not a compile error.
+-- Look up a field by name in a type's `fields` array. Returns the matching field entry, or nil if not found.
+-- Extracted to keep check_binds_no_substruct_deref's nesting depth <= 5 (the project convention; this is the 5th nesting level:
+-- function -> for-atom -> for-token -> if-load/store -> if-type-resolves -> [helper]).
+local function find_field_by_name(type_entry, field_name)
+	for _, f in ipairs(type_entry.fields or {}) do
+		if f.name == field_name then return f end
+	end
+	return nil
+end
+
+-- True iff a (field, type_registry) pair is a leaf scalar (safe to dereference as a tape-payload field).
+-- Pointer-to-X is always leaf; non-pointer struct members are NOT leaf.
+local function is_field_leaf(field, type_registry)
+	if field.pointer_depth and field.pointer_depth > 0 then
+		return true
+	end
+	local ftype_entry = type_registry[field.type_name]
+	if ftype_entry and ftype_entry.kind == "struct" then
+		return false
+	end
+	return true
+end
+
+local function check_binds_no_substruct_deref(_src, pipe_ctx, findings)
+	local type_registry = pipe_ctx.type_name_registry or {}
+	for _, a in ipairs(pipe_ctx.atoms or {}) do
+		local tc           = a.paths and a.paths.tok_class or {}
+		local tokens       = a.paths and a.paths.tokens or {}
+		local line_in_body = a.paths and a.paths.line_in_body or {}
+		for ti = 1, #tokens do
+			local tc_entry = tc[ti]
+			if (tc_entry.is_load_word or tc_entry.is_store_word)
+				and tc_entry.o_arg1 and tc_entry.o_arg2 then
+				local type_name  = tc_entry.o_arg1
+				local field_name = tc_entry.o_arg2
+				local body_line  = a.line + (line_in_body[tokens[ti].rel] or 0)
+
+				local type_entry = type_registry[type_name]
+				if not type_entry or not type_entry.fields then
+					findings[#findings + 1] = {
+						atom  = a.name, line = body_line,
+						check = "binds_no_substruct_deref", kind = "warning",
+						msg   = string.format(
+							"atom '%s' at line %d O_(%s, %s) refers to type %q which has no fields table in type_name_registry",
+							a.name, body_line, type_name, field_name, type_name),
+					}
+				else
+					local field = find_field_by_name(type_entry, field_name)
+					if not field then
+						findings[#findings + 1] = {
+							atom  = a.name, line = body_line,
+							check = "binds_no_substruct_deref", kind = "warning",
+							msg   = string.format(
+								"atom '%s' at line %d O_(%s, %s) does not resolve to a field of %s",
+								a.name, body_line, type_name, field_name, type_name),
+						}
+					elseif not is_field_leaf(field, type_registry) then
+						findings[#findings + 1] = {
+							atom  = a.name, line = body_line,
+							check = "binds_no_substruct_deref", kind = "warning",
+							msg   = string.format(
+								"atom '%s' at line %d O_(%s, %s) dereferences a non-pointer struct field of type %q; nested struct members are forbidden",
+								a.name, body_line, type_name, field_name, field.type_name),
+						}
+					end
+				end
+			end
+		end
+	end
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Check #9: reads_writes_alias_membership (Track A Task 13)
+-- ════════════════════════════════════════════════════════════════════════════
+
+-- For every `atom_reads(R_X)` and `atom_writes(R_X)` entry in every `atom_infos` entry, the `R_X` MUST be present in `pipe_ctx.register_alias_registry`.
+-- This DUPLICATES `enum_alias_membership`'s coverage of the reads/writes arrays;
+-- the distinct check name is intentional so the report can attribute the failure to a precedence-class (warnings vs errors) — the production reads/writes
+-- paths are intentionally permissive at the warning level even when the registry-driven check is strict at the error level.
+-- Per-source rule. Severity: warning (build continues).
+local function check_reads_writes_alias_membership(_src, pipe_ctx, findings)
+	local reg_registry = pipe_ctx.register_alias_registry or {}
+	for _, ai in ipairs(pipe_ctx.atom_infos_list or {}) do
+		local info_line = ai.info_line or 0
+		local atom_name = ai.atom_name or ""
+		for _, reg in ipairs(ai.reads or {}) do
+			if not reg_registry[reg] then
+				findings[#findings + 1] = {
+					atom  = atom_name, line = info_line,
+					check = "reads_writes_alias_membership", kind = "warning",
+					msg   = string.format(
+						"atom '%s' at line %d atom_reads for %q; the alias is not in register_alias_registry",
+						atom_name, info_line, reg),
+				}
+			end
+		end
+		for _, reg in ipairs(ai.writes or {}) do
+			if not reg_registry[reg] then
+				findings[#findings + 1] = {
+					atom  = atom_name, line = info_line,
+					check = "reads_writes_alias_membership", kind = "warning",
+					msg   = string.format(
+						"atom '%s' at line %d atom_writes for %q; the alias is not in register_alias_registry",
+						atom_name, info_line, reg),
+				}
+			end
+		end
+	end
+end
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- CHECK_RULES — data-driven check dispatch (Muratori: data over control flow)
 -- ════════════════════════════════════════════════════════════════════════════
 
--- Each rule is a table entry: { name, per_atom }.
--- `per_atom(atom, pipe_ctx, findings)` runs once per atom inside validate()'s single loop.
--- Adding a new check = 1 row here + 1 check_* function. No validate() edit required.
+-- Each rule is a table entry: { name, <dispatch> }.
+-- Dispatch shapes:
+--   per_atom(atom, pipe_ctx, findings)          — runs once per atom inside validate()'s single loop
+--   post(pipe_ctx, findings)                    — runs once after all per-atom calls complete
+--   per_macro(macro, wc, findings)              — runs once per TAPE_WORDS / _Pragma macro declaration
+--   per_skip_marker(marker, pipe_ctx, findings) — runs once per src.scan.skip_over.markers entry
+--   per_source(src, pipe_ctx, findings)         — runs once per source AFTER the per-atom loop completes
+--                                                 (added for the registry-driven rule set; same CHECK_RULES table — no parallel dispatch)
+-- Adding a new check = 1 row here + 1 check_* function. validate() is updated only to invoke the per_source dispatch loop (the per_atom dispatch loop never changes).
 -- This is the plex pattern: the iteration is in ONE place (validate), the variation is in DATA (this table).
 
 local CHECK_RULES = {
-	{ name = "gte_pipeline_fill",     per_atom = check_gte_pipeline_fill     },
-	{ name = "mac_yield_uniformity",  per_atom = check_mac_yield_uniformity  },
-	{ name = "abi_handoff",           per_atom = check_abi_handoff           },
-	{ name = "gpu_portstore_shape",   per_atom = check_gpu_portstore_shape   },
-	{ name = "per_atom_cycle_budget", per_atom = check_per_atom_cycle_budget },
+	{ name = "gte_pipeline_fill",            per_atom   = check_gte_pipeline_fill            },
+	{ name = "mac_yield_uniformity",         per_atom   = check_mac_yield_uniformity         },
+	{ name = "abi_handoff",                  per_atom   = check_abi_handoff                  },
+	{ name = "gpu_portstore_shape",          per_atom   = check_gpu_portstore_shape          },
+	{ name = "per_atom_cycle_budget",        per_atom   = check_per_atom_cycle_budget        },
+	{ name = "enum_alias_membership",        per_source = check_enum_alias_membership        },
+	{ name = "atom_rtype_consistency",       per_source = check_atom_rtype_consistency       },
+	{ name = "binds_no_substruct_deref",     per_source = check_binds_no_substruct_deref     },
+	{ name = "reads_writes_alias_membership",per_source = check_reads_writes_alias_membership},
 }
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -770,17 +1031,28 @@ local function validate(ctx, src)
 	-- pipe_ctx: the cross-atom shared state for the per-atom pipeline (Fleury "expose structure").
 	-- Pre-allocated here, mutated by each per-atom check call below.
 	-- Replaces the per-check local tables that used to live inside each check_* function body.
-	--   info_by_atom  — atom_name -> atom_info (built once; check_abi_handoff reads it)
-	--   binds_index   — Binds_X -> binds struct (built once; check_abi_handoff reads it)
-	--   unknown_seen  — macro_name -> first atom line (accumulated across atoms; check_per_atom_cycle_budget dedups)
+	--   info_by_atom             — atom_name -> atom_info (built once; check_abi_handoff reads it)
+	--   binds_index              — Binds_X -> binds struct (built once; check_abi_handoff reads it)
+	--   unknown_seen             — macro_name -> first atom line (accumulated across atoms; check_per_atom_cycle_budget dedups)
+	--   atoms                    — full atom list (used by check_binds_no_substruct_deref's per-source body walk)
+	--   types                    — R_X -> default-type info from atom_dbg_reg_default (check_enum_alias_membership source a)
+	--   atom_infos_list          — flat list of atom_info entries (checks #6/#7/#9 iterate it)
+	--   register_alias_registry  — R_X -> {name, code, has_atom_reg, source_line} from parse_enum_aliases
+	--   type_name_registry       — T -> {name, kind, fields, ...} from parse_typedef_binds
+	-- All registry fields are READ from src.scan (the dep-closed scan-source payload); this pass never re-parses.
 	local info_by_atom = {}
 	for _, info in ipairs(atom_infos) do
 		info_by_atom[info.atom_name] = info
 	end
 	local pipe_ctx = {
-		info_by_atom  = info_by_atom,
-		binds_index   = binds_index,
-		unknown_seen  = {},
+		info_by_atom            = info_by_atom,
+		binds_index             = binds_index,
+		unknown_seen            = {},
+		atoms                   = atoms,
+		types                   = scan.types or {},
+		atom_infos_list         = atom_infos or {},
+		register_alias_registry = scan.register_alias_registry or {},
+		type_name_registry      = scan.type_name_registry or {},
 	}
 
 	-- THE per-atom pipeline. ONE iteration of atoms; the 5 check_* functions + analyze_atom_paths
@@ -788,6 +1060,7 @@ local function validate(ctx, src)
 	-- Plex move: every piece of state derived from an atom body lives on `atom.paths` (the per-atom mega-struct);
 	-- readers (analyze_atom_paths, the 5 checks, the renderers) all consume `atom.paths`, not the raw `atoms` list.
 	-- Stage 1B: each check_* now takes `(atom, ...)` instead of `(atoms, findings)` — no more single-atom `{a}` shim.
+	-- Per-source rules run once after this loop completes (no parallel dispatch table).
 	local findings = {}
 	for _, a in ipairs(atoms) do
 		a.paths                  = a.paths or {}
@@ -798,13 +1071,20 @@ local function validate(ctx, src)
 		-- analyze_atom_paths fills the *cycles / branches / has_loops / unknown_macros* fields of a.paths.
 		analyze_atom_paths(a)
 
-		-- Run all checks on this one atom via the CHECK_RULES data table (Muratori: data over control flow).
+		-- Run all per-atom checks on this one atom via the CHECK_RULES data table (Muratori: data over control flow).
 		-- Adding a new check = 1 row in CHECK_RULES; this loop never needs editing.
 		for _, rule in ipairs(CHECK_RULES) do
-			rule.per_atom(a, pipe_ctx, findings)
+			if rule.per_atom then rule.per_atom(a, pipe_ctx, findings) end
 		end
 	end
 
+	-- Per-source dispatch. Run once per source AFTER the per-atom loop;
+	-- consults pipe_ctx's cross-atom registries (register_alias_registry, type_name_registry).
+	-- Same CHECK_RULES table; no parallel dispatch table.
+	for _, rule in ipairs(CHECK_RULES) do
+		if rule.per_source then rule.per_source(src, pipe_ctx, findings) end
+	end
+
 	local errors   = {}
 	local warnings = {}
 	local info     = {}