WIP: not fully reviewed. Adds auto-register allocation + mips atom procs + wip resolve look at atoms + atom bundle...

scripts/passes/auto_reg.lua

@@ -0,0 +1,322 @@
+--- passes/auto_reg.lua — Per-phase automatic GPR allocator + gen/auto_reg.h emitter.
+---
+--- Reads the per-source + corpus-level `atom_auto_regs` + `phase_auto_regs` registries populated by `passes/scan_source.lua`.
+--- Runs a deterministic first-fit allocator in the `R_T0..R_T7 + R_V0..R_V1` pool (10 physical GPRs).
+--- Emits one `#define R_<Sym>_Code R_Tn_Code` per marker into per-directory `gen/auto_reg.h`.
+---
+--- User-pinned GPRs (added 2026-08-10): The corpus's `register_alias_registry` is consulted to
+--- exclude GPRs the user has pinned via `atom_reg` + `_Code` defs (e.g. wave-context carriers like
+--- `R_ResolveScratch = R_T4 atom_reg`). These GPRs are unavailable to EVERY atom's source pool,
+--- not just to atoms in the same phase — wave-context carriers are preserved across atoms by the
+--- wave-context discipline and must never be reallocated.
+--- Per-atom body parsing also catches alias references (R_<Alias>) and hardcoded R_Tn references,
+--- so the user can write either `R_T4` or `R_ResolveScratch` in an atom body and the pass will
+--- exclude R_T4 from that atom's pool.
+---
+--- Conflict detection: If the user hardcodes `R_Tn` in an atom body that shares a phase with an auto-reg that picked `R_Tn`,
+--- emit `phase_register_clash` as an info finding (no build stop). Should be unreachable after the
+--- user-pinning + body-parsing fix above; kept as a defensive safety net.
+---
+--- Pool exhaustion: if a phase declares more `R_<Sym>` mappings than the 10-register pool can hold,
+--- emit `phase_register_pool_exhausted` as a build-stopping error.
+---
+--- @class AutoRegResult
+--- @field outputs  table[]  -- {kind=, path=} entries
+--- @field errors   table[]  -- {line=, msg=}  entries (build-stops)
+--- @field warnings table[]  -- {line=, msg=}  entries (build-continues)
+
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+
+-- The fixed allocation pool: 10 physical GPRs whose `R_<Sym>_Code` macros exist in mips.h (lines 92-107).
+-- Each pool entry is the PHYSICAL GPR ident (R_T0 etc.);
+-- `gpr .. "_Code"` resolves to the matching `R_Tn_Code` constant the source code references via `#define R_Load_Code R_T0_Code`.
+-- Excluded: R_AT (assembler temp per lottes_tape.h:86), R_T8 (deferred to ac_yield_load pattern),
+--           R_T9 (R_TapePtr; owned by the tape runtime).
+local POOL = {
+    "R_T0", "R_T1", "R_T2", "R_T3",
+    "R_T4", "R_T5", "R_T6", "R_T7",
+    "R_V0", "R_V1",
+}
+
+-- Map from integer MIPS GPR code (the `code` field on AliasEntry) to the physical GPR ident
+-- in POOL. The standard MIPS O32 ABI register numbering matches mips.h's R_*_Code #defines
+-- (mips.h:92-123). Only the POOL entries matter for auto_reg — non-pool aliases are out of scope.
+local INT_CODE_TO_POOL_GPR = {
+    [2]  = "R_V0", [3]  = "R_V1",
+    [8]  = "R_T0", [9]  = "R_T1", [10] = "R_T2", [11] = "R_T3",
+    [12] = "R_T4", [13] = "R_T5", [14] = "R_T6", [15] = "R_T7",
+}
+
+-- Stable sort for deterministic allocation order.
+local function stable_sort_keys(tbl)
+    local keys = {}
+    for k in pairs(tbl) do keys[#keys + 1] = k end
+    table.sort(keys)
+    return keys
+end
+
+-- Allocate one phase's auto-reg mappings.
+-- Returns (allocated_map, errors). On pool exhaustion, errors is populated and the function halts.
+local function allocate_phase(phase_label, decls)
+    -- Deep-copy POOL into a fresh sequence table. The original `table.unpack and table.unpack(POOL) or { unpack(POOL) }`
+    -- idiom wraps the unpacked values in a single inner table under LuaJIT 5.1 (`table.unpack` is nil; the `or` returns one value),
+    -- which corrupts the pool into `{ {R_T0, R_T1, ...} }` — making `table.remove(pool, 1)` return the inner table on iteration.
+    local pool   = {}
+    for i = 1, #POOL do pool[i] = POOL[i] end
+    local result = {}
+    local errors = {}
+    for _, sym in ipairs(stable_sort_keys(decls)) do
+        local next_gpr = table.remove(pool, 1)
+        if not next_gpr then
+            errors[#errors + 1] = {
+                line = 0,
+                msg  = string.format(
+                    "phase_register_pool_exhausted: phase '%s' requested symbol '%s' but the pool has no remaining registers (max 10 per phase: R_T0..R_T7 + R_V0..R_V1). Split the phase or use hardcoded GPRs."
+                    , phase_label, sym),
+            }
+            return result, errors
+        end
+        result[sym] = next_gpr
+    end
+    return result, errors
+end
+
+-- Build two projections from corpus.register_alias_registry:
+--   user_pinned   -- { [physical_gpr_ident] = true }   -- GPRs unavailable to auto_reg globally
+--                                                       -- (wave-context carriers, file-scope pinned aliases)
+--   alias_to_gpr  -- { [alias_ident]        = physical_gpr_ident }  -- for body parsing
+-- Both projections are derived from the same set of entries: every AliasEntry in
+-- register_alias_registry has `has_atom_reg = true` (only those entries are added to the
+-- registry; see passes/scan_source.lua parse_enum_entry). Each entry's `code` is the integer
+-- MIPS GPR number (0..31); INT_CODE_TO_POOL_GPR translates it back to the physical GPR ident.
+-- Aliases whose `code` points to a non-POOL GPR (e.g. R_S0, R_T8, R_K1) are ignored — they
+-- don't affect the auto_reg pool, and they're already excluded from POOL above.
+local function build_user_pins(corpus)
+    local user_pinned  = {}
+    local alias_to_gpr = {}
+    if not corpus.register_alias_registry then
+        return user_pinned, alias_to_gpr
+    end
+    for alias_name, alias_entry in pairs(corpus.register_alias_registry) do
+        if alias_entry.has_atom_reg and alias_entry.code then
+            local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code]
+            if gpr then
+                user_pinned[gpr]  = true
+                alias_to_gpr[alias_name] = gpr
+            end
+        end
+    end
+    return user_pinned, alias_to_gpr
+end
+
+-- Find every physical GPR referenced in the atom body, via EITHER:
+--   (a) a hardcoded physical GPR ident (R_T\d+|R_V\d+|R_A\d+|R_S\d+) — the existing regex;
+--   (b) an alias ident (R_<Alias>) resolved via alias_to_gpr back to its physical GPR ident.
+-- Returns { [physical_gpr_ident] = count }. The clash-detection and source-pool-exclusion logic
+-- only needs the presence of each GPR (boolean test), but keeping the count preserves the
+-- original find_hardcoded_rn shape so callers can switch without churn.
+-- The alias pattern is sorted lexicographically to keep the regex deterministic.
+local function find_used_gprs(body_text, alias_to_gpr)
+    local found = {}
+    -- (a) Hardcoded physical GPRs (R_T0..R_T7, R_V0..R_V1, R_A0..R_A3, R_S0..R_S7).
+    for gpr in body_text:gmatch("(R_T%d+|R_V%d+|R_A%d+|R_S%d+)") do
+        found[gpr] = (found[gpr] or 0) + 1
+    end
+    -- (b) Alias references (R_<Alias>) resolved to physical GPRs via the registry.
+    --      Sorted by name so the regex is byte-stable across runs.
+    if alias_to_gpr and next(alias_to_gpr) then
+        local aliases = {}
+        for alias_name in pairs(alias_to_gpr) do
+            aliases[#aliases + 1] = alias_name
+        end
+        table.sort(aliases)
+        local pattern = "(" .. table.concat(aliases, "|") .. ")"
+        for alias_name in body_text:gmatch(pattern) do
+            local gpr = alias_to_gpr[alias_name]
+            if gpr and not found[gpr] then
+                found[gpr] = 1
+            end
+        end
+    end
+    return found
+end
+
+-- Emit one gen/auto_reg.h header per directory.
+local function emit_auto_reg_h(out_dir, dir, sources, mappings)
+    if not mappings or next(mappings) == nil then return end
+    local out_path = out_dir .. "/" .. "auto_reg.h"
+    duffle.ensure_dir(out_dir)
+    local lines = {
+        "#ifdef INTELLISENSE_DIRECTIVES",
+        "#pragma once",
+        "#endif",
+        "// Auto-generated by ps1_meta.lua (passes/auto_reg.lua) — DO NOT EDIT",
+        "// Directory: " .. dir:gsub("/", "\\"),
+    }
+    for _, src in ipairs(sources) do
+        lines[#lines + 1] = "//   source: " .. src.path
+    end
+    lines[#lines + 1] = "// Per-phase register allocations resolved by the lua pass."
+    lines[#lines + 1] = "// R_<Sym>_Code = <chosen GPR's _Code constant> for every marker in this directory."
+    lines[#lines + 1] = ""
+    for _, sym in ipairs(stable_sort_keys(mappings)) do
+        local gpr      = mappings[sym]
+        local gpr_code = gpr .. "_Code"
+        lines[#lines + 1] = "#define " .. sym .. "_Code " .. gpr_code
+    end
+    lines[#lines + 1] = ""
+    duffle.write_file_lf(out_path, table.concat(lines, "\n") .. "\n")
+    print("  -> " .. out_path)
+    return out_path
+end
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- Pass entry
+-- ════════════════════════════════════════════════════════════════════════════
+
+local M = {}
+
+--- @param ctx PassCtx
+--- @return AutoRegResult
+function M.run(ctx)
+    local outputs  = {}
+    local errors   = {}
+    local warnings = {}
+
+    local corpus = ctx.shared and ctx.shared.corpus
+    if type(corpus) ~= "table" then
+        error("auto_reg.run requires ctx.shared.corpus", 0)
+    end
+
+    -- 0. Build the user-pinned GPR exclusion set + alias-to-GPR resolution map.
+    --    Wave-context carriers (e.g. `R_ResolveScratch = R_T4 atom_reg` in
+    --    hello_camera.atom.c) MUST NOT be allocated to any auto-reg marker — they're
+    --    preserved across atoms by the wave-context discipline. The corpus's
+    --    register_alias_registry is the source of truth for these opt-in pins.
+    --    Body references to those aliases (via alias_to_gpr) are also excluded on a
+    --    per-atom basis in step 2 below.
+    local user_pinned, alias_to_gpr = build_user_pins(corpus)
+
+    -- 1. Allocate phase pools first (phase declarations take precedence over per-atom declarations).
+    local phase_allocations = {}
+    for phase_label, decls in pairs(corpus.phase_auto_regs or {}) do
+        local mapping, errs = allocate_phase(phase_label, decls)
+        for sym, gpr in pairs(mapping) do
+            phase_allocations[phase_label]      = phase_allocations[phase_label] or {}
+            phase_allocations[phase_label][sym] = gpr
+        end
+        for _, e in ipairs(errs) do
+            errors[#errors + 1] = e
+        end
+    end
+
+    -- 2. Allocate per-atom auto-regs. If the atom scope matches a phase, reuse the phase pool.
+    -- Otherwise, allocate a private pool for the atom.
+    -- The phase membership is in `corpus.atom_phases[phase_label].atoms` (an array of atom names declared via `atom_phase(<phase>)` in the atom's `atom_info` line). 
+		-- Build a reverse map `atom_name -> phase_label` so the lookup is O(1) per atom scope.
+    local atom_name_to_phase = {}
+    for phase_label, entry in pairs(corpus.atom_phases or {}) do
+        for _, atom_name in ipairs(entry.atoms or {}) do
+            atom_name_to_phase[atom_name] = phase_label
+        end
+    end
+
+    local atom_allocations = {}
+    for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do
+        local phase_label = atom_name_to_phase[atom_scope]
+        -- Build the atom's source pool: start with the full POOL, subtract:
+        --   (a) every GPR already committed (phase allocations + prior atom allocations)
+        --   (b) every USER-PINNED GPR (wave-context carriers + file-scope pinned aliases)
+        --   (c) every GPR referenced in the atom's body — either hardcoded R_X or alias R_Xxx
+        --       (the latter resolved via alias_to_gpr; this catches cases where the user
+        --       wrote R_ResolveScratch instead of R_T4 directly)
+        -- Atoms whose scope matches a phase share the global pool with the phase allocations;
+        -- the original `source_pool = phase_allocations[phase_label]` form used the phase
+        -- allocation MAP as a pool, but that map has no array part, so `table.remove(source_pool, 1)`
+        -- returned nil and every atom-with-phase marker errored with `phase_register_pool_exhausted`.
+        local used = {}
+        for _, m in pairs(phase_allocations) do for _, gpr in pairs(m) do used[gpr] = true end end
+        for _, m in pairs(atom_allocations)  do for _, gpr in pairs(m) do used[gpr] = true end end
+        -- (c) Body references — scan the atom body for hardcoded + alias-resolved GPRs.
+        --      Folded into `used` so the source_pool exclusion is a single check.
+        local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+        if atom and atom.body then
+            local body_used = find_used_gprs(atom.body, alias_to_gpr)
+            for gpr in pairs(body_used) do used[gpr] = true end
+        end
+        local source_pool = {}
+        for _, gpr in ipairs(POOL) do
+            -- Exclude (a) prior commitments, (b) USER-PINNED GPRs (wave-context carriers
+            -- declared via atom_reg + _Code defs, preserved across atoms globally).
+            if not used[gpr] and not user_pinned[gpr] then
+                source_pool[#source_pool + 1] = gpr
+            end
+        end
+        local result = {}
+        for _, sym in ipairs(stable_sort_keys(decls)) do
+            local next_gpr = table.remove(source_pool, 1)
+            if not next_gpr then
+                errors[#errors + 1] = {
+                    line = 0,
+                    msg  = string.format("phase_register_pool_exhausted: atom '%s' requested symbol '%s' but no free registers remain in its scope pool."
+                    	, atom_scope, sym),
+                }
+            else
+                result[sym] = next_gpr
+            end
+        end
+        atom_allocations[atom_scope] = result
+    end
+
+    -- 3. Conflict-with-hardcoded detection (defensive — should be unreachable now).
+    -- The source_pool exclusion in step 2 (b) + (c) already accounts for both user-pinned GPRs
+    -- and body-referenced GPRs (hardcoded R_Tn OR alias R_<Alias>). An auto-reg allocation that
+    -- matched an existing body reference would be impossible by construction. This warning is kept
+    -- as a defensive safety net for cases the body scanner might miss (e.g. macros that expand to
+    -- register references the scanner cannot resolve).
+    -- For each resolved (scope, sym) -> R_Tn mapping, scan the atom body source for used GPRs.
+    for atom_scope, decls in pairs(atom_allocations) do
+        local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+        if atom and atom.body then
+            local used_in_body = find_used_gprs(atom.body, alias_to_gpr)
+            for sym, allocated_gpr in pairs(decls) do
+                if used_in_body[allocated_gpr] and used_in_body[allocated_gpr] > 0 then
+                    warnings[#warnings + 1] = {
+                        line  = atom.line or 0,
+                        msg   = string.format("phase_register_clash: atom '%s' has hardcoded '%s' in its body AND an auto-reg marker '%s' that was allocated to '%s' (same phase). Resolve by removing the hardcoded reference or renaming the auto-reg."
+                        	, atom_scope, allocated_gpr, sym, allocated_gpr),
+                    }
+                end
+            end
+        end
+    end
+
+    -- 4. Emit per-directory gen/auto_reg.h.
+    -- For each source directory that has atom_auto_regs or phase_auto_regs entries, emit one header.
+    local sources_by_dir = corpus.sources_by_dir or {}
+    for dir, sources in pairs(sources_by_dir) do
+        local per_dir_mappings = {}
+        for _, src in ipairs(sources) do
+            -- Collect every (sym -> gpr) entry that originated from a source in this directory.
+            -- `src.scan.atom_auto_regs` is keyed by ATOM SCOPE NAME; `pairs(t)` iterates KEYS so `scope_name` here is the scope ident (e.g. "cube_g4_face").
+						-- The previous `for _, scan_atom_auto` form silently assigned the VALUE (a `{sym = sym}` table) to the variable, which made `atom_allocations[scan_atom_auto]` a table-indexed lookup that never resolved.
+            for scope_name in pairs(src.scan and src.scan.atom_auto_regs or {}) do
+                for sym, gpr in pairs(atom_allocations[scope_name] or {}) do
+                    per_dir_mappings[sym] = gpr
+                end
+            end
+            for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do
+                for sym, gpr in pairs(phase_allocations[scope_name] or {}) do
+                    per_dir_mappings[sym] = gpr
+                end
+            end
+        end
+        local out_dir  = dir .. "/gen"
+        local out_path = emit_auto_reg_h(out_dir, dir, sources, per_dir_mappings)
+        if out_path then outputs[#outputs + 1] = { auto_reg_h = out_path } end
+    end
+    return { outputs = outputs, errors = errors, warnings = warnings }
+end
+
+return M

scripts/passes/components.lua

@@ -3,7 +3,7 @@
 --- Ownership: `corpus.word_counts`, `corpus.components`, and `corpus.component_body_index`.
 --- Scanner owns `declaration_comment` and `debug_skip` on each declaration record; this pass projects both forward.
 ---
---- Reads the pre-scanned SourceScan payload from `duffle.scan_source` for `MipsAtomComp_(ac_X)` and `MipsAtomComp_Proc_(ac_X, { body })` declarations,
+--- Reads the pre-scanned SourceScan payload from `duffle.scan_source` for `MipsAtomComp_(ac_X)`, `MipsAtomComp_Proc_(ac_X, { body })`, and `MipsAtom_Proc_(X, ab, { body })` declarations,
 --- then resolves the function-args string from the preceding `FI_ Slice_MipsCode ac_X(...)` declaration via a backward walk.
 ---
 --- Emits one `gen/macs.h` per *immediate source directory* with `#define mac_X(sig) \` macros plus `WORD_COUNT(mac_X, N)` entries for downstream offset computation.
@@ -76,7 +76,7 @@ local MACS_FILENAME   = "macs.h"
 --- @field args       string|nil -- Function-args string (function form only)
 --- @field line       integer    -- Source line of the declaration
 --- @field comment    string|nil -- Scanner-owned `declaration_comment`; the components pass reads it from the scanner record
---- @field kind       string     -- "comp_bare" | "comp_proc"
+--- @field kind       string     -- "comp_bare" | "comp_proc" | "atom_proc"
 --- @field debug_skip boolean    -- Mirror of `a.debug_skip` (scanner-owned); true iff a bare `atom_dbg_skip` marker immediately preceded the declaration
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -200,8 +200,16 @@ end
 local function project_components(source, scan)
 	local out = {}
 	for _, a in ipairs(scan.atoms) do
-		if a.kind == "comp_bare" or a.kind == "comp_proc" then
-			local args = find_function_args_for(source, a.raw_name, a.ident_pos)
+		if a.kind == "comp_bare" or a.kind == "comp_proc" or a.kind == "atom_proc" then
+			-- `MipsAtom_Proc_` atoms have no `FI_ Slice_MipsCode ac_X(...)` function-decl prelude
+			-- (the macro sits inside a wrapping `I_ void <proc_name>(...)` body), so the function-args
+			-- lookup is meaningless; signature defaults to `...` (variadic-ignored).
+			-- The `mac_<name>` alias expansion discards the `ab` (atom-builder) arg the same way
+			-- `MipsAtomComp_Proc_` components do.
+			local args = nil
+			if a.kind ~= "atom_proc" then
+				args = find_function_args_for(source, a.raw_name, a.ident_pos)
+			end
 			-- Comment ownership: scan_source.lua stamps `declaration_comment` on the record by walking backward past any associated bare marker.
 			-- The pass reads `declaration_comment` directly.
 			local comment = a.declaration_comment or ""
@@ -213,7 +221,7 @@ local function project_components(source, scan)
 				body_tokens = a.body_tokens,
 				args        = args,
 				comment     = comment,
-				kind        = a.kind,  -- "comp_bare" | "comp_proc"; provenance emitter reads this.
+				kind        = a.kind,  -- "comp_bare" | "comp_proc" | "atom_proc"; provenance emitter reads this.
 				debug_skip  = a.debug_skip == true,
 			}
 		end
@@ -475,12 +483,26 @@ local function split_comment_lines(s)
 end
 
 --- Determine the macro signature: function-args list (function form) or variadic-ignored (bare form).
+--- For `MipsAtomComp_Proc_` components, the leading `ab` (atom-builder) arg is dropped:
+--- the generated `mac_<name>` macros are inline-expansion aliases for baked atoms; their bodies
+--- don't reference `ab` (the builder is only consumed by the procedural `atombuilder_unroll` line
+--- that `MipsAtomComp_Proc_` appends after the body). Inline callers therefore don't need to thread
+--- a builder context.
 --- @param args_str string|nil
 --- @return string
 local function signature_from_args(args_str)
 	local arg_names = extract_arg_names(args_str)
 	if    arg_names and #arg_names > 0 then
-		return table.concat(arg_names, ", ")
+		-- Drop the leading `ab` (atom-builder) first arg if present.
+		-- Convention: `MipsAtomComp_Proc_` components always declare `ab` as the first function-arg
+		-- (type `MipsAtomBuilder_R`), mirroring the macro signature in `lottes_tape.h`.
+		if arg_names[1] == "ab" then
+			table.remove(arg_names, 1)
+		end
+		if #arg_names > 0 then
+			return table.concat(arg_names, ", ")
+		end
+		return "..."  -- `ab` was the only arg; fall through to variadic
 	end
 	return "..."
 end
@@ -646,7 +668,7 @@ end
 --- @field name       string  -- bare name (without ac_/mac_ prefix)
 --- @field line       integer -- definition source line (line of `MipsAtomComp_(ac_X)` / `MipsAtomComp_Proc_(ac_X, ...)`)
 --- @field path       string  -- absolute source path of the definition
---- @field kind       string  -- "comp_bare" | "comp_proc"
+--- @field kind       string  -- "comp_bare" | "comp_proc" | "atom_proc"
 --- @field debug_skip boolean -- mirror of the scanner-owned `a.debug_skip`; consumers read this directly
 
 --- (internal) Populate `corpus.components` with this source's components-by-name map.

scripts/passes/emission_model.lua

@@ -188,11 +188,11 @@ function M.run(ctx)
 	if type(corpus.source_order) ~= "table" then error("emission_model: ctx.shared.corpus.source_order is required", 0) end
 
 	-- Project once, collect errors + warnings for one atom.
-	-- Kind must be one of: atom | raw_atom | comp_bare | comp_proc.
+	-- Kind must be one of: atom | atom_proc | raw_atom | comp_bare | comp_proc.
 	local function process_atom(atom, src)
 		if not (atom and atom.body) then return end
 		local kind = atom.kind
-		if kind ~= "atom" and kind ~= "raw_atom" and kind ~= "comp_bare" and kind ~= "comp_proc" then
+		if kind ~= "atom" and kind ~= "atom_proc" and kind ~= "raw_atom" and kind ~= "comp_bare" and kind ~= "comp_proc" then
 			return
 		end
 		local proj = project_atom(atom, src, corpus)
@@ -215,7 +215,7 @@ function M.run(ctx)
 	end
 
 	-- Walk `corpus.source_order`; within each source, visit atoms followed by raw_atoms.
-	-- Recognized kinds (atom | raw_atom | comp_bare | comp_proc) each receive the atom.paths projection via duffle.project_emission.
+	-- Recognized kinds (atom | atom_proc | raw_atom | comp_bare | comp_proc) each receive the atom.paths projection via duffle.project_emission.
 	-- Components are macros inlined into atom bodies; focused tests and isolated component analyses consume atom.paths directly.
 	for _, src in ipairs(corpus.source_order) do
 		local scan = src.scan or {}

scripts/passes/scan_source.lua

@@ -3,6 +3,7 @@
 --- Single source-walk pass that produces the fat `SourceScan` payload consumed by all downstream passes. Walks each corpus source record once,
 --- extracting every construct type the metaprograms need:
 ---   MipsAtom_              (kind = "atom", with optional atom_info inner)
+---   MipsAtom_Proc_         (kind = "atom_proc", body inside last {})
 ---   MipsAtomComp_          (kind = "comp_bare")
 ---   MipsAtomComp_Proc_     (kind = "comp_proc", body inside last {})
 ---   atom_dbg_skip          — bare whole-atom/component debug-step marker; following declaration disambiguates
@@ -34,7 +35,7 @@ local parse_enum_int_literal
 -- ════════════════════════════════════════════════════════════════════════════
 
 --- @class SourceScan
---- @field atoms             AtomEntry[]     -- MipsAtom_ + MipsAtomComp_ + MipsAtomComp_Proc_
+--- @field atoms             AtomEntry[]     -- MipsAtom_ + MipsAtom_Proc_ + MipsAtomComp_ + MipsAtomComp_Proc_
 --- @field raw_atoms         AtomEntry[]     -- MipsCode code_<name> { body } (offsets pass only)
 --- @field binds             BindsEntry[]    -- typedef Struct_(Binds_X) { fields } (fields pre-parsed)
 --- @field atom_infos        AtomInfoEntry[] -- MipsAtom_(name) atom_info(...) (sub-calls pre-parsed)
@@ -55,7 +56,7 @@ local parse_enum_int_literal
 --- @field args           string|nil  -- Trimmed args inside the `(...)` (nil when has_parens is false)
 --- @field pending        boolean     -- true while awaiting the following declaration
 --- @field superseded_by_marker_line integer|nil -- set when a newer marker bumped this one out of the pending slot
---- @field target_kind    string|nil  -- "atom" | "comp_bare" | "comp_proc" | "unrelated" once observed (nil if no declaration ever followed)
+--- @field target_kind    string|nil  -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "unrelated" once observed (nil if no declaration ever followed)
 --- @field proc_prelude   boolean|nil -- true after the marker crossed an `FI_` prelude and awaits `MipsAtomComp_Proc_`
 
 --- @class RegTypeDefault
@@ -111,7 +112,7 @@ local parse_enum_int_literal
 --- @field name              string       -- Atom name (for components: without ac_ prefix)
 --- @field body              string       -- Brace-delimited body (without the braces)
 --- @field body_off          integer      -- Char offset of body[1] in source
---- @field kind              string       -- "atom" | "comp_bare" | "comp_proc" | "raw_atom"
+--- @field kind              string       -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "raw_atom"
 --- @field raw_name          string       -- Un-stripped name (for components: with ac_ prefix)
 --- @field ident_pos         integer      -- Position of the MipsAtom_/MipsAtomComp_ ident start
 --- @field after_paren       integer      -- Position past the closing paren
@@ -268,7 +269,7 @@ end
 ---   marker_kind == "atom_dbg_skip" AND is_bare == true
 --- Any other spelling or shape (parenthesized form, legacy name) is recorded as a raw marker for annotation validation but never stamps `debug_skip`.
 --- @param out         SourceScan
---- @param target_kind string|nil -- "atom" | "comp_bare" | "comp_proc" | "unrelated" once observed
+--- @param target_kind string|nil -- "atom" | "atom_proc" | "comp_bare" | "comp_proc" | "unrelated" once observed
 --- @return boolean|nil -- true iff the marker is the positive bare form
 local function attach_debug_skip_marker(out, target_kind)
 	local markers = out.debug_skip_markers
@@ -799,6 +800,11 @@ local BYTE_x          = 0x78   -- 'x'
 local BYTE_X          = 0x58   -- 'X'
 local BYTE_OPEN_BRACE = 0x7B   -- '{'
 local BYTE_CLOSE_BRACE= 0x7D   -- '}'
+local BYTE_SLASH      = 0x2F   -- '/'
+local BYTE_STAR       = 0x2A   -- '*'
+local BYTE_SPACE      = 0x20   -- ' '
+local BYTE_TAB        = 0x09   -- '\t'
+local BYTE_CR         = 0x0D   -- '\r'
 
 -- Maximum chain depth when resolving `R_*_Code` symbol RHS references.
 -- Eight hops is enough for any production chain (R_TapePtr_Code -> R_T8_Code -> ...).
@@ -822,6 +828,44 @@ local function hex_digit_value(b)
 	return nil
 end
 
+-- Read one trailing C-comment that appears immediately after `pos` in `body`,
+-- skipping horizontal whitespace and newlines first. Used by `parse_enum_entry` to
+-- recover the `atom_auto_reg:` / `phase_auto_reg:` scope annotation embedded by
+-- the `atom_auto_reg` / `phase_auto_reg` macros' RHS expansion
+-- (`R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`).
+-- Handles both block (`/* ... */`) and line (`// ...`) forms.
+-- Returns the comment text (without delimiters), or nil if no comment is adjacent.
+local function read_trailing_cmt_after(body, pos)
+	local body_len = #body
+	while pos <= body_len do
+		local b = body:byte(pos)
+		if b == BYTE_SPACE or b == BYTE_TAB or b == BYTE_NEWLINE or b == BYTE_CR then
+			pos = pos + 1
+		elseif b == BYTE_SLASH then
+			local b2 = body:byte(pos + 1)
+			if b2 == BYTE_STAR then
+				-- Block comment /* ... */
+				local i = pos + 2
+				while i < body_len do
+					if body:byte(i) == BYTE_STAR and body:byte(i + 1) == BYTE_SLASH then
+						return body:sub(pos + 2, i - 1)
+					end
+					i = i + 1
+				end
+				return nil  -- unterminated; treat as no comment
+			elseif b2 == BYTE_SLASH then
+				-- Line comment // ... (strip the trailing newline)
+				local end_pos = duffle.find_byte(body, BYTE_NEWLINE, pos + 2) or (body_len + 1)
+				return body:sub(pos + 2, end_pos - 1)
+			end
+			return nil
+		else
+			return nil
+		end
+	end
+	return nil
+end
+
 --- Parse a decimal/negative-decimal/hex integer literal starting at byte position `start`.
 --- Returns (value, end_pos) on success, or (nil, start) on failure / no match.
 --- Accepts: 12, -1, 0, 0x10, 0X1F, -0x10.
@@ -1128,6 +1172,46 @@ local function parse_dbg_skip_marker(source, pos, ident_end, line_of, out)
 	return marker_end
 end
 
+--- Parse `atom_auto_reg(<atom>, R_<Sym>)` and `phase_auto_reg(<phase>, R_<Sym>)` markers.
+---
+--- The macros expand to `sym = sym##_Code` per their definition in dsl.atom.h.
+--- After preprocessing, the marker renders as a full enum entry of the form `R_<Sym> = R_<Sym>_Code,`.
+--- This parser detects the macro invocation site, extracts `(scope_name, sym)`, and stores it
+--- in the per-source table (atom_auto_regs or phase_auto_regs) under the scope's name.
+---
+--- @param source    string
+--- @param pos       integer
+--- @param ident_end integer
+--- @param line_of   fun(pos: integer): integer
+--- @param out       SourceScan
+--- @return integer
+local function parse_auto_reg_marker(source, pos, ident_end, line_of, out)
+	local marker_kind = source:sub(pos, ident_end - 1)  -- "atom_auto_reg" or "phase_auto_reg"
+	local scope_kind  = marker_kind == "atom_auto_reg" and "atom" or "phase"
+
+	local inner, after_paren = read_parens_after(source, ident_end)
+	if not inner then return after_paren end
+
+	local args = duffle.split_top_level_commas(inner)
+	local scope_name = args[1] and duffle.trim(args[1]) or nil
+	local sym        = args[2] and duffle.trim(args[2]) or nil
+
+	-- Filter: only accept `R_<Sym>` form (matches `^R_[%w_]+$`).
+	if scope_name and sym and sym:match("^R_[%w_]+$") then
+		if scope_kind == "atom" then
+			out.atom_auto_regs = out.atom_auto_regs or {}
+			out.atom_auto_regs[scope_name] = out.atom_auto_regs[scope_name] or {}
+			out.atom_auto_regs[scope_name][sym] = sym
+		else
+			out.phase_auto_regs = out.phase_auto_regs or {}
+			out.phase_auto_regs[scope_name] = out.phase_auto_regs[scope_name] or {}
+			out.phase_auto_regs[scope_name][sym] = sym
+		end
+	end
+
+	return after_paren
+end
+
 -- Parse `atom_dbg_reg_default(R_X, <type>...)`;
 -- the second argument may be a `Type` or `Type*`/`Type**` chain. Records in `out.types[R_X]`.
 local function parse_atom_dbg_reg_default(source, pos, ident_end, line_of, out)
@@ -1282,6 +1366,49 @@ local function parse_mips_atom_comp_proc(source, pos, ident_end, line_of, out)
 	return after_paren
 end
 
+--- Parse: `MipsAtom_Proc_(<name>, <abuilder>, { <body> })` — body is inside the LAST `{` in args.
+--- Per Task 12.10: full support for the runtime-proc atom form. Registers the atom
+--- with kind `"atom_proc"` so offsets.lua / components.lua can emit
+---   * `mac_<name>` aliases in `gen/macs.h` (the components pass)
+---   * `atom_offset__X__Y` defs in `gen/offsets.h` (the offsets pass)
+--- The atom name is the FIRST ident of the args (the second arg `ab` is the
+--- atom-builder, not the name). Unlike `MipsAtomComp_Proc_`, there is no `ac_`
+--- prefix on the symbol — `MipsAtom_Proc_` is the runtime-proc wrapper, so the
+--- symbol IS the bare atom name (e.g. `normalize_v3s4`, not `ac_normalize_v3s4`).
+--- @param source    string
+--- @param pos       integer
+--- @param ident_end integer
+--- @param line_of   fun(pos: integer): integer
+--- @param out       SourceScan
+--- @return integer
+local function parse_mips_atom_proc(source, pos, ident_end, line_of, out)
+	local  inner, after_paren, open_paren = read_parens_after(source, ident_end)
+	if not inner then return after_paren end
+
+	-- Find the LAST `{` in inner (the body brace, not any potential embedded braces in expressions).
+	local last_brace_pos = nil
+	for search_pos = #inner, 1, -1 do
+		if inner:sub(search_pos, search_pos) == "{" then last_brace_pos = search_pos; break end
+	end
+	if not last_brace_pos then return after_paren end
+
+	-- Use duffle.read_braces to find the matching close brace.
+	-- Uses `read_balanced` for delimiter-depth tracking.
+	-- If close_pos is past the end of inner, the brace didn't match (malformed input); skip.
+	local body, close_pos = duffle.read_braces(inner, last_brace_pos)
+	if close_pos > #inner + 1 then return after_paren end
+
+	-- The atom name is the FIRST ident of the args (matches MipsAtomComp_Proc_'s "first ident" rule).
+	-- MipsAtom_Proc_ has no `ac_` prefix; `strip_ac_prefix` is a no-op for unprefixed names.
+	local raw_name = inner:match("^%s*([%w_]+)") or "?"
+	local name     = strip_ac_prefix(raw_name)
+	-- Position of body[1] in source = open_paren + 1 (start of inner) + last_brace_pos + 1 (past '{').
+	local body_off = open_paren + 2 + last_brace_pos
+	register_atom(out, "atom_proc", line_of(pos), name, body, body_off, raw_name, pos, after_paren, source)
+
+	return after_paren
+end
+
 --- Parse: `MipsCode code_<name> { <body> }` (raw atom form — offsets pass only).
 --- @param source    string
 --- @param pos       integer
@@ -1602,6 +1729,16 @@ local function parse_enum_entry(source, body, body_offset, line_of, out, entry_n
 	local value, value_end = parse_enum_value(body, after_ws, out)
 	if value == nil then return value_start end
 
+	-- Capture the trailing C-comment (if any) before `skip_ws_and_cmt` discards it.
+	-- The `atom_auto_reg(<scope>, <sym>)` macro expands to `R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`,
+	-- so the scope name lives in the comment after the RHS value. Routes through `out.atom_entry_comments`
+	-- for downstream `parse_enum` to split into `out.atom_auto_regs` / `out.phase_auto_regs`.
+	local trailing_cmt = read_trailing_cmt_after(body, value_end)
+	if trailing_cmt then
+		out.atom_entry_comments = out.atom_entry_comments or {}
+		out.atom_entry_comments[entry_name] = trailing_cmt
+	end
+
 	local after_value       = duffle.skip_ws_and_cmt(body, value_end)
 	local has_atom_reg, end_after_atom_reg = check_bare_atom_reg(body, after_value)
 
@@ -1657,15 +1794,24 @@ local function parse_enum_body(source, body, body_offset, line_of, out)
 		else
 			local entry_name, name_end = duffle.read_ident(body, pos)
 			if entry_name then
-				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
+				-- In-enum `atom_auto_reg(<scope>, R_<Sym>)` / `phase_auto_reg(<scope>, R_<Sym>)` markers:
+				-- the C preprocessor expands them to `R_<Sym> = R_<Sym>_Code /* atom_auto_reg: <scope> */`,
+				-- but the metaprogram reads source-as-written so we must dispatch the parser here too.
+				-- Mirrors the top-level `DECL_PARSERS` entry for `atom_auto_reg` / `phase_auto_reg`.
+				if entry_name == "atom_auto_reg" or entry_name == "phase_auto_reg" then
+					local new_pos = parse_auto_reg_marker(body, pos, name_end, line_of, out)
+					if new_pos > pos then pos = new_pos else pos = name_end end
 				else
-					pos = name_end
+					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
 				end
 			else
 				pos = pos + 1
@@ -1695,6 +1841,25 @@ local function parse_enum(source, pos, ident_end, line_of, out)
 	if not body then return after_brace end
 	parse_enum_body(source, body, body_off, line_of, out)
 
+	-- Route `atom_auto_reg:` / `phase_auto_reg:` markers discovered in trailing C-comments
+	-- into the per-source `atom_auto_regs` / `phase_auto_regs` projections.
+	-- Pattern matches the RHS expansion `R_<Sym> = R_<Sym>_Code /* <kind>_auto_reg: <scope> */`
+	-- emitted by the `atom_auto_reg` / `phase_auto_reg` macros in dsl.atom.h.
+	for entry_name, cmt_text in pairs(out.atom_entry_comments or {}) do
+		local atom_scope = cmt_text:match("atom_auto_reg:%s*([%w_]+)")
+		if atom_scope then
+			out.atom_auto_regs = out.atom_auto_regs or {}
+			out.atom_auto_regs[atom_scope] = out.atom_auto_regs[atom_scope] or {}
+			out.atom_auto_regs[atom_scope][entry_name] = entry_name
+		end
+		local phase_scope = cmt_text:match("phase_auto_reg:%s*([%w_]+)")
+		if phase_scope then
+			out.phase_auto_regs = out.phase_auto_regs or {}
+			out.phase_auto_regs[phase_scope] = out.phase_auto_regs[phase_scope] or {}
+			out.phase_auto_regs[phase_scope][entry_name] = entry_name
+		end
+	end
+
 	return after_brace
 end
 
@@ -1708,12 +1873,18 @@ end
 
 local DECL_PARSERS = {
 	MipsAtom_                  = parse_mips_atom,
+	MipsAtom_Proc_             = parse_mips_atom_proc,
 	MipsAtomComp_              = parse_mips_atom_comp,
 	MipsAtomComp_Proc_         = parse_mips_atom_comp_proc,
 	-- `atom_dbg_skip` is the only debug-skip parser entry. Every other
 	-- identifier follows the ordinary unrelated-token path; there is no alias.
 	atom_dbg_skip              = parse_dbg_skip_marker,
 	atom_dbg_reg_default       = parse_atom_dbg_reg_default,
+	-- `atom_auto_reg(atom, R_<Sym>)` and `phase_auto_reg(phase, R_<Sym>)` populate per-source
+	-- `out.atom_auto_regs` / `out.phase_auto_regs`; the cross-source merge lands in
+	-- `corpus.atom_auto_regs` / `corpus.phase_auto_regs` (first-wins).
+	atom_auto_reg              = parse_auto_reg_marker,
+	phase_auto_reg             = parse_auto_reg_marker,
 	MipsCode                   = parse_mips_code,
 	typedef                    = parse_typedef_binds,
 	_Pragma                    = parse_pragma_macro,
@@ -1748,6 +1919,14 @@ local function scan_source(source, source_file, code_macros, code_macro_bodies)
 		debug_skip_markers = {},
 		types             = {},
 		atom_views        = {},
+		-- Per-source projection for `atom_auto_reg(<atom>, R_<Sym>)` markers.
+		-- Each entry is keyed by atom_name; the inner table maps `R_<Sym>` -> `R_<Sym>` (raw LHS sym).
+		-- Merged cross-source into `corpus.atom_auto_regs` (first-wins).
+		atom_auto_regs    = {},
+		-- Per-source projection for `phase_auto_reg(<phase>, R_<Sym>)` markers.
+		-- Each entry is keyed by phase_label; the inner table maps `R_<Sym>` -> `R_<Sym>` (raw LHS sym).
+		-- Merged cross-source into `corpus.phase_auto_regs` (first-wins).
+		phase_auto_regs   = {},
 		line_of           = line_of,
 		-- Source-derived register-alias registry (atom_reg opt-in entries).
 		-- Keys are full R_* idents (never stripped); see parse_enum / parse_enum_body.
@@ -1987,6 +2166,8 @@ local function merge_corpus_registries(corpus)
 	corpus.atom_ctxs               = corpus.atom_ctxs               or {}
 	corpus.atom_phases             = corpus.atom_phases             or {}
 	corpus.atom_infos              = corpus.atom_infos              or {}
+	corpus.atom_auto_regs          = corpus.atom_auto_regs          or {}
+	corpus.phase_auto_regs         = corpus.phase_auto_regs         or {}
 	corpus.collisions              = corpus.collisions              or {}
 
 	-- Replace the existing corpus collections with empty tables so a re-run on the same corpus produces identical state (deterministic merge).
@@ -2030,7 +2211,7 @@ local function merge_corpus_registries(corpus)
 					corpus.collisions, "binds", bind_shape)
 			end
 
-			-- atoms_by_name: MipsAtom_(name) + MipsAtomComp_(name) + MipsAtomComp_Proc_(name).
+			-- atoms_by_name: MipsAtom_(name) + MipsAtom_Proc_(name) + MipsAtomComp_(name) + MipsAtomComp_Proc_(name).
 			-- Each atom carries `{line, name, body, body_off, kind, raw_name, ...}`.
 			-- Duplicate atom names across sources are first-wins + collision; see the atom_infos block below for the evidence list.
 			for _, atom_entry in ipairs(scan.atoms or {}) do
@@ -2065,6 +2246,22 @@ local function merge_corpus_registries(corpus)
 					corpus.collisions, "phase", phase_shape)
 			end
 
+			-- atom_auto_regs: keyed by atom scope name; each carries a `{R_<Sym> = R_<Sym>}` map.
+			-- Per-source entries are simple inner maps (no body / no shape comparison); first-wins suffices.
+			for atom_scope, syms in pairs(scan.atom_auto_regs or {}) do
+				if corpus.atom_auto_regs[atom_scope] == nil then
+					corpus.atom_auto_regs[atom_scope] = syms
+				end
+			end
+
+			-- phase_auto_regs: keyed by phase label; each carries a `{R_<Sym> = R_<Sym>}` map.
+			-- Per-source entries are simple inner maps (no body / no shape comparison); first-wins suffices.
+			for phase_label, syms in pairs(scan.phase_auto_regs or {}) do
+				if corpus.phase_auto_regs[phase_label] == nil then
+					corpus.phase_auto_regs[phase_label] = syms
+				end
+			end
+
 			-- atom_infos: ALWAYS append every record in source/declaration order.
 			-- Duplicates are preserved so the annotation pass can flag them via `check_unique_annotation`;
 			-- The merge is purely order-preserving.

scripts/passes/static_analysis.lua

@@ -1474,8 +1474,9 @@ end
 local function check_load_delay_slots(atom, pipe_ctx, findings)
 	-- The load-delay check applies to every atom and component body, including debug-skipped components (`ac_*` and `atom_dbg_skip MipsAtom_(...)`).
 	-- The `atom_dbg_skip` marker controls debugger stepping, not instruction safety.
+	-- `atom_proc` atoms have full bodies with loads that need delay slots, so the check applies to them too.
 	local p = atom.paths or {}
-	if atom.kind ~= "atom" then return end
+	if atom.kind ~= "atom" and atom.kind ~= "atom_proc" then return end
 	local events = p.word_events or {}
 	if   #events == 0 then return end
 
@@ -1579,6 +1580,8 @@ local function check_mac_yield_uniformity(atom, pipe_ctx, findings)
 	if is_runtime_helper(atom) then return end
 	-- Per-kind semantics:
 	--   MipsAtom_          (baked atom): exactly 1 mac_yield at the end of the body. Control transfer is the atom's job.
+	--   MipsAtom_Proc_     (runtime-proc atom): exactly 1 mac_yield at the end of the body. Same as baked atom;
+	--                      the proc IS the atom; the runtime call to `atombuilder_unroll` doesn't introduce a parent atom.
 	--   MipsAtomComp_      (bare static-array component): ZERO mac_yield.
 	--                      The component is invoked from inside an atom body; the parent atom does the yield.
 	--   MipsAtomComp_Proc_ (procedural component): ZERO mac_yield.
@@ -1602,7 +1605,7 @@ local function check_mac_yield_uniformity(atom, pipe_ctx, findings)
 		return atom.line + line_in_body[tokens[idx].rel]
 	end
 
-	if atom.kind == "atom" then
+	if atom.kind == "atom" or atom.kind == "atom_proc" then
 		-- Baked atom: exactly 1 yield at the end.
 		if count == 0 then
 			findings[#findings + 1] = {
@@ -1647,6 +1650,7 @@ local function check_mac_yield_uniformity(atom, pipe_ctx, findings)
 		-- The parent atom does the yield.
 		-- A yield inside a component would either be dead code (bare) or prematurely terminate the function (proc).
 		-- Both are bugs.
+		-- `atom_proc` atoms are NOT components; they're runtime-proc atoms that own their own yield (handled in the `if` branch above).
 		if count > 0 then
 			findings[#findings + 1] = {
 				atom  = atom.name,
@@ -1678,7 +1682,7 @@ end
 --- Per-atom. Runtime-helper atoms (`debug_skip`) are exempt.
 --- Takes `(atom, pipe_ctx, findings)`; `pipe_ctx` is unused.
 local function check_yield_load_tail_pairing(atom, _pipe_ctx, findings)
-	if atom.kind ~= "atom" then return end
+	if atom.kind ~= "atom" and atom.kind ~= "atom_proc" then return end
 	if is_runtime_helper(atom) then return end
 
 	local tokens       = atom.paths.tokens
@@ -1897,9 +1901,9 @@ end
 ---   - Atoms containing a `mac_<name>(...)` call whose `name` is not registered in `pipe_ctx.components_by_name` emit a "new macro;
 ---     Not in corpus.components" advisory — the auto-derivation returned nil for that name.
 ---
---- Applies only to `kind = "atom"` (baked atoms). Components don't emit full primitives.
+--- Applies only to `kind = "atom"` or `kind = "atom_proc"` (full-atom bodies). Components don't emit full primitives.
 local function check_gpu_portstore_shape(atom, pipe_ctx, findings)
-	if atom.kind ~= "atom" then return end
+	if atom.kind ~= "atom" and atom.kind ~= "atom_proc" then return end
 	local tokens         = atom.paths.tokens
 	local line_in_body   = atom.paths.line_in_body
 	local tc             = atom.paths.tok_class