posts-article minor changes

Feel like opting for u1-4.. (b1-4 not meaning byte anymore, not sure why I bothered, just bools/bits)

.vscode/cozy-and-windy/themes/cozy-and-windy-color-theme.json

@@ -30,7 +30,7 @@
 		"editorHoverWidget.background": "#2c334b"
 	},
 	"semanticTokenColors": {
-		"comment": { "foreground": "#868686", "fontStyle": "italic" },
+		"comment": { "foreground": "#868686", }, //"fontStyle": "italic" },
 		"keyword": { "foreground": "#d8bd5b" },
 		"string": { "foreground": "#d46a54" },
 		"number": { "foreground": "#b5cea8" },
@@ -81,7 +81,7 @@
 		"tapeDelaySlot": { "foreground": "#ff5647" }
 	},
 	"tokenColors": [
-		{ "scope": ["comment", "comment.block", "comment.line", "comment.block.documentation"], "settings": { "foreground": "#868686", "fontStyle": "italic" } },
+		{ "scope": ["comment", "comment.block", "comment.line", "comment.block.documentation"], "settings": { "foreground": "#868686", } }, //"fontStyle": "italic" } },
 		{ "scope": ["keyword", "keyword.control", "keyword.other"], "settings": { "foreground": "#d8bd5b" } },
 		{ "scope": ["string", "string.quoted"], "settings": { "foreground": "#d46a54" } },
 		{ "scope": ["string.quoted.other"], "settings": { "foreground": "#d69d85" } },

.vscode/tape-atom-syntax/classifier.js

@@ -21,72 +21,108 @@ const TOKEN_TYPES = [
 	"tapeGprRegister",
 	"tapeCop2Register",
 	"tapeDuffleType",
-	"tapeAttribute",
+	"tapeAt__ibute",
 	"keyword",
 	"macro",
 ];
 
-const TOKEN_MODIFIERS = ["declaration", "tapeRead", "tapeWrite", "tapeAuto"];
-const TOKEN_TYPE_INDEX = new Map(TOKEN_TYPES.map((name, index) => [name, index]));
+const TOKEN_MODIFIERS      = ["declaration", "tapeRead", "tapeWrite", "tapeAuto"];
+const TOKEN_TYPE_INDEX     = new Map(TOKEN_TYPES.map((name, index) => [name, index]));
 const TOKEN_MODIFIER_INDEX = new Map(TOKEN_MODIFIERS.map((name, index) => [name, index]));
 
 const ATOM_KEYWORDS = new Set(["MipsAtom_", "MipsAtom_Proc_"]);
 const COMPONENT_KEYWORDS = new Set(["MipsAtomComp_", "MipsAtomComp_Proc_"]);
 const ANNOTATIONS = new Set([
-	"atom_info", "atom_bind", "atom_reads", "atom_writes", "atom_label",
-	"atom_offset", "atom_reg", "atom_type", "atom_ctx", "atom_phase",
-	"atom_auto_reg", "phase_auto_reg", "atom_dbg_skip",
+	"atom_info",
+	"atom_bind",
+	"atom_reads",
+	"atom_writes",
+	"atom_label",
+	"atom_offset",
+	"atom_reg",
+	"atom_type",
+	"atom_ctx",
+	"atom_phase",
+	"atom_auto_reg", 
+	"phase_auto_reg", 
+	"atom_dbg_skip",
 ]);
 
 const DSL_KEYWORDS = new Set([
-	"FI_", "I_", "NI_", "Relative_", "Struct_", "Enum_", "Union_", "Array_",
-	"Slice_", "TypeR_", "TypeV_", "align_", "internal", "local_persist", "global",
-	"RO_", "LP_", "gknown", "expect_", "cexpr_",
+	"enum", "struct", "union",
+	"offset_of", "static_assert", "typeof", "typeof_ptr", "typeof_same",
+	"glue", "tmpl",
+	"A_", "FI_", "I_", "NI_", 
+	"Array_", "Enum_", "Proc_", "Relative_", "Struct_", "Union_", "Slice_", 
+
+	// "TypeR_", "TypeV_",
+
+	"align_", 
+	"internal", "local_persist", "global",
+
+	"RO_", "LP_", 
+	"gknown", "expect_", "cexpr_",
+
+	"O_", "OA_", "S_", "C_", "T_", "T_same", "R_", "V_",
+	"r_", "v_", "rt_", "vt_",
+
 	"asm", "asm_words", "asm_rpins", "asm_clobber",
-	"O_", "S_", "C_", "T_", "tmpl", "glue", "r_", "v_", "tr_", "tv_",
 	"rgcc", "r_use", "r_set", "r_mod", "r_imm", "r_mem",
-	"u1_", "u2_", "u4_", "u8_", "s1_", "s2_", "s4_", "s8_",
-	"u1_r", "u2_r", "u4_r", "u8_r", "u1_v", "u2_v", "u4_v", "u8_v",
+	
+	"b1_", "b2_", "b4_", "b8_", 
+	"u1_", "u2_", "u4_", "u8_", 
+	"s1_", "s2_", "s4_", "s8_",
+	"b1_r", "b2_r", "b4_r", "b8_r", 
+	"b1_v", "b2_v", "b4_v", "b8_v", 
+	"u1_r", "u2_r", "u4_r", "u8_r", 
+	"u1_v", "u2_v", "u4_v", "u8_v",
+
+	"u4_lo", "u4_hi",
 ]);
 
-const DELAY_SLOT_KEYWORDS = new Set(["LdSlot_", "BdSlot_", "DmaSlot_", "GteDelay_"]);
+const DELAY_SLOT_KEYWORDS = new Set([
+	"LdSlot_",
+	"BdSlot_",
+	"DmaSlot_",
+	"GteDelay_"
+]);
 
 const CONTROL_FLOW_PREFIXES = /^(?:branch_|jump_|call_)/;
 
 const ROLE_TO_TYPE = {
-	atomName: "tapeAtomName",
+	atomName:      "tapeAtomName",
 	componentName: "tapeComponentName",
-	bindType: "tapeBindType",
-	duffleType: "tapeDuffleType",
-	gprRegister: "tapeGprRegister",
-	cop2Register: "tapeCop2Register",
+	bindType:      "tapeBindType",
+	duffleType:    "tapeDuffleType",
+	gprRegister:   "tapeGprRegister",
+	cop2Register:  "tapeCop2Register",
 };
 
 function registerType(name, index) {
 	const kind = index.registers.get(name);
-	if (kind === "gpr" || /^R_[A-Za-z0-9_]+$/.test(name)) return "tapeGprRegister";
-	if (kind === "cop2" || /^(?:C2_|gte_cr_)[A-Za-z0-9_]+$/.test(name)) return "tapeCop2Register";
+	if (kind === "gpr"  || /^R_[A-Za-z0-9_]              + $/.test(name)) return "tapeGprRegister";
+	if (kind === "cop2" || /^(?:C2_|gte_cr_)[A-Za-z0-9_] + $/.test(name)) return "tapeCop2Register";
 	return null;
 }
 
 function instructionType(name, index) {
 	const domain = index.macros.get(name);
 	if (domain === "control") return "tapeControlFlow";
-	if (domain === "cpu") return "tapeCpuInstruction";
-	if (domain === "gte") return "tapeGteInstruction";
-	if (domain === "gpu") return "tapeGpuInstruction";
+	if (domain === "cpu")     return "tapeCpuInstruction";
+	if (domain === "gte")     return "tapeGteInstruction";
+	if (domain === "gpu")     return "tapeGpuInstruction";
 	if (domain === "component") {
 		if (/^mac_gte_/.test(name)) return "tapeGteInstruction";
-		if (/^mac_gp/.test(name)) return "tapeGpuInstruction";
-		if (/^mac_/.test(name)) return "tapeComponentInstruction";
+		if (/^mac_gp/.test(name))   return "tapeGpuInstruction";
+		if (/^mac_/.test(name))     return "tapeComponentInstruction";
 		return "macro";
 	}
-	if (domain === "utility") return "macro";
+	if (domain === "utility")      return "macro";
 	if (/^gte_(?!cr_)/.test(name)) return "tapeGteInstruction";
-	if (/^gp[01]_/.test(name)) return "tapeGpuInstruction";
-	if (/^mac_gte_/.test(name)) return "tapeGteInstruction";
-	if (/^mac_gp/.test(name)) return "tapeGpuInstruction";
-	if (/^mac_/.test(name)) return "tapeComponentInstruction";
+	if (/^gp[01]_/.test(name))     return "tapeGpuInstruction";
+	if (/^mac_gte_/.test(name))    return "tapeGteInstruction";
+	if (/^mac_gp/.test(name))      return "tapeGpuInstruction";
+	if (/^mac_/.test(name))        return "tapeComponentInstruction";
 	return null;
 }
 
@@ -100,13 +136,11 @@ function modifierMask(modifiers) {
 }
 
 function isRegUseAccess(tokens, tokenIndex) {
-	const prev = tokens[tokenIndex - 1];
-	if (!prev || prev.text !== ".") return false;
-	const prevPrev = tokens[tokenIndex - 2];
-	if (!prevPrev || prevPrev.kind !== "identifier") return false;
-	const next = tokens[tokenIndex + 1];
+	const prev     = tokens[tokenIndex - 1]; if (!prev || prev.text !== ".") return false;
+	const prevPrev = tokens[tokenIndex - 2]; if (!prevPrev || prevPrev.kind !== "identifier") return false;
+	const next     = tokens[tokenIndex + 1];
 	if (next && next.text === ".") return false;
-	if (prevPrev.text === "r") return true;
+	if (prevPrev.text     === "r") return true;
 	const prev3 = tokens[tokenIndex - 3];
 	const prev4 = tokens[tokenIndex - 4];
 	if (prev3 && prev3.text === "." && prev4 && prev4.kind === "identifier" && prev4.text === "r") return true;
@@ -115,81 +149,92 @@ function isRegUseAccess(tokens, tokenIndex) {
 
 function classifyDocument(source, filePath, workspaceIndex, shouldCancel = () => false) {
 	const scanned = scanSource(source, filePath);
-	const index = mergeIndexes(workspaceIndex, scanned.index);
-	const spans = [];
+	const index   = mergeIndexes(workspaceIndex, scanned.index);
+	const spans   = [];
 
 	for (let tokenIndex = 0; tokenIndex < scanned.tokens.length; tokenIndex += 1) {
 		if (shouldCancel()) break;
-		const token = scanned.tokens[tokenIndex];
-		if (token.kind !== "identifier") continue;
+		const token = scanned.tokens[tokenIndex]; if (token.kind !== "identifier") continue;
 
-		let type = null;
-		let modifiers = [];
+		let type          = null;
+		let modifiers     = [];
 		const declaration = scanned.declarations.get(token.start);
-		const context = nearestCall(scanned.contexts, tokenIndex);
+		const context     = nearestCall(scanned.contexts, tokenIndex);
 
 		if (declaration) {
-			type = ROLE_TO_TYPE[declaration.role] || null;
+			type      = ROLE_TO_TYPE[declaration.role] || null;
 			modifiers = declaration.modifiers.slice();
-		} else if (ATOM_KEYWORDS.has(token.text)) {
+		} 
+		else if (ATOM_KEYWORDS.has(token.text)) {
 			type = "tapeAtomKeyword";
-		} else if (COMPONENT_KEYWORDS.has(token.text)) {
+		} 
+		else if (COMPONENT_KEYWORDS.has(token.text)) {
 			type = "keyword";
-		} else if (ANNOTATIONS.has(token.text)) {
+		} 
+		else if (ANNOTATIONS.has(token.text)) {
 			type = "tapeAnnotation";
-		} else if (context && context.callee === "atom_bind" && context.argIndex === 0) {
+		} 
+		else if (context && context.callee === "atom_bind" && context.argIndex === 0) {
 			type = "tapeBindType";
-		} else if (context && context.callee === "atom_phase" && context.argIndex === 0) {
+		} 
+		else if (context && context.callee === "atom_phase" && context.argIndex === 0) {
 			type = "tapePhase";
 			modifiers = ["declaration"];
-		} else if (context && context.callee === "atom_ctx" && context.argIndex === 0) {
+		} 
+		else if (context && context.callee === "atom_ctx" && context.argIndex === 0) {
 			type = "tapeAtomName";
-		} else if (context && context.callee === "atom_label" && context.argIndex === 0) {
+		} 
+		else if (context && context.callee === "atom_label" && context.argIndex === 0) {
 			type = "tapeLabel";
 			modifiers = ["declaration"];
-		} else if (context && context.callee === "atom_offset" && context.argIndex <= 1) {
+		} 
+		else if (context && context.callee === "atom_offset" && context.argIndex <= 1) {
 			type = "tapeLabel";
-		} else if (context && context.callee === "atom_reads") {
+		} 
+		else if (context && context.callee === "atom_reads") {
 			type = registerType(token.text, index);
 			if (type) modifiers = ["tapeRead"];
-		} else if (context && context.callee === "atom_writes") {
+		} 
+		else if (context && context.callee === "atom_writes") {
 			type = registerType(token.text, index);
 			if (type) modifiers = ["tapeWrite"];
-		} else if (context && context.callee === "atom_auto_reg") {
+		} 
+		else if (context && context.callee === "atom_auto_reg") {
 			if (context.argIndex === 0) type = "tapeAtomName";
 			if (context.argIndex === 1) {
-				type = "tapeGprRegister";
+				type      = "tapeGprRegister";
 				modifiers = ["declaration", "tapeAuto"];
 			}
-		} else if (context && context.callee === "phase_auto_reg") {
+		} 
+		else if (context && context.callee === "phase_auto_reg") {
 			if (context.argIndex === 0) type = "tapePhase";
 			if (context.argIndex === 1) {
-				type = "tapeGprRegister";
+				type      = "tapeGprRegister";
 				modifiers = ["declaration", "tapeAuto"];
 			}
 		}
 
-		if (!type && index.bindTypes.has(token.text)) type = "tapeBindType";
-		if (!type && DSL_KEYWORDS.has(token.text)) type = "keyword";
-		if (!type && index.types.has(token.text)) type = "tapeDuffleType";
-		if (!type && index.attributes.has(token.text)) type = "tapeAttribute";
-		if (!type) type = registerType(token.text, index);
-		if (!type && DELAY_SLOT_KEYWORDS.has(token.text)) type = "tapeDelaySlot";
-		if (!type) {
+		if (! type && index.bindTypes.has(token.text))     type = "tapeBindType";
+		if (! type && DSL_KEYWORDS.has(token.text))        type = "keyword";
+		if (! type && index.types.has(token.text))         type = "tapeDuffleType";
+		if (! type && index.attributes.has(token.text))    type = "tapeAttribute";
+		if (! type)                                        type = registerType(token.text, index);
+		if (! type && DELAY_SLOT_KEYWORDS.has(token.text)) type = "tapeDelaySlot";
+		if (! type) {
 			const domain = index.macros.get(token.text);
 			if (domain === "control" || (domain && CONTROL_FLOW_PREFIXES.test(token.text))) {
 				type = "tapeControlFlow";
 			}
 		}
-		if (!type && isRegUseAccess(scanned.tokens, tokenIndex)) type = "tapeGprRegister";
-		if (!type) type = instructionType(token.text, index);
-		if (!type && /^(?:Slice_|A[0-9]+_)/.test(token.text)) type = "tapeDuffleType";
-		if (!type && /_[RV]$/.test(token.text)) type = "tapeDuffleType";
-		if (!type && index.atoms.has(token.text)) type = "tapeAtomName";
-		if (!type && index.components.has(token.text)) type = "tapeComponentName";
-		if (!type && index.phases.has(token.text)) type = "tapePhase";
-		if (!type && index.labels.has(token.text)) type = "tapeLabel";
-		if (!type) continue;
+		if (! type && isRegUseAccess(scanned.tokens, tokenIndex)) type = "tapeGprRegister";
+		if (! type)                                               type = instructionType(token.text, index);
+		if (! type && /^(?:Slice_|A[0-9]+_)/.test(token.text))    type = "tapeDuffleType";
+		if (! type && /_[RV]$/.test(token.text))                  type = "tapeDuffleType";
+		if (! type && index.atoms.has(token.text))                type = "tapeAtomName";
+		if (! type && index.components.has(token.text))           type = "tapeComponentName";
+		if (! type && index.phases.has(token.text))               type = "tapePhase";
+		if (! type && index.labels.has(token.text))               type = "tapeLabel";
+		if (! type) continue;
 
 		spans.push({
 			text: token.text,

.vscode/tape-atom-syntax/extension.js

@@ -2,10 +2,10 @@
 
 const vscode = require("vscode");
 const { TOKEN_MODIFIERS, TOKEN_TYPES, classifyDocument } = require("./classifier");
-const { createIndex, mergeIndexes, scanSource } = require("./source-index");
+const { createIndex, mergeIndexes, scanSource }          = require("./source-index");
 
-const SOURCE_GLOB = "**/*.{c,h,cc,cpp,cxx,hh,hpp,hxx}";
-const EXCLUDE_GLOB = "**/{gen,build,.slop_cache,toolchain,node_modules}/**";
+const SOURCE_GLOB        = "**/*.{c,h,cc,cpp,cxx,hh,hpp,hxx}";
+const EXCLUDE_GLOB       = "**/{gen,build,.slop_cache,toolchain,node_modules}/**";
 const EXCLUDED_SEGMENTS = new Set(["gen", "build", ".slop_cache", "toolchain", "node_modules"]);
 
 function isExcluded(uri) {
@@ -18,28 +18,29 @@ function formatError(filePath, error) {
 }
 
 async function activate(context) {
-	const output = vscode.window.createOutputChannel("Tape Atom DSL");
+	const output  = vscode.window.createOutputChannel("Tape Atom DSL");
 	const emitter = new vscode.EventEmitter();
-	const legend = new vscode.SemanticTokensLegend(TOKEN_TYPES, TOKEN_MODIFIERS);
-	let workspaceIndex = createIndex();
+	const legend  = new vscode.SemanticTokensLegend(TOKEN_TYPES, TOKEN_MODIFIERS);
+	let workspaceIndex    = createIndex();
 	let rebuildGeneration = 0;
-	let debounceHandle = null;
+	let debounceHandle    = null;
 
 	async function rebuildIndex() {
 		const generation = ++rebuildGeneration;
-		const files = await vscode.workspace.findFiles(SOURCE_GLOB, EXCLUDE_GLOB);
-		let nextIndex = createIndex();
+		const files      = await vscode.workspace.findFiles(SOURCE_GLOB, EXCLUDE_GLOB);
+		let nextIndex    = createIndex();
 
 		for (const uri of files) {
 			if (generation !== rebuildGeneration) return;
 			if (isExcluded(uri)) continue;
 			try {
-				const bytes = await vscode.workspace.fs.readFile(uri);
+				const bytes  = await vscode.workspace.fs.readFile(uri);
 				const source = Buffer.from(bytes).toString("utf8");
 				const result = scanSource(source, uri.fsPath);
-				nextIndex = mergeIndexes(nextIndex, result.index);
+				nextIndex    = mergeIndexes(nextIndex, result.index);
 				for (const error of result.errors) output.appendLine(formatError(uri.fsPath, error));
-			} catch (error) {
+			} 
+			catch (error) {
 				output.appendLine(`${uri.fsPath}: ${error.stack || error.message || error}`);
 			}
 		}
@@ -53,9 +54,11 @@ async function activate(context) {
 		if (uri && isExcluded(uri)) return;
 		if (debounceHandle !== null) clearTimeout(debounceHandle);
 		debounceHandle = setTimeout(() => {
-			debounceHandle = null;
-			rebuildIndex().catch((error) => output.appendLine(error.stack || String(error)));
-		}, 100);
+				debounceHandle = null;
+				rebuildIndex().catch((error) => output.appendLine(error.stack || String(error)));
+			}, 
+			100
+		);
 	}
 
 	const provider = {
@@ -77,7 +80,8 @@ async function activate(context) {
 					output.appendLine(formatError(document.uri.fsPath || document.uri.toString(), error));
 				}
 				return builder.build();
-			} catch (error) {
+			}
+			catch (error) {
 				output.appendLine(`${document.uri}: ${error.stack || error.message || error}`);
 				return new vscode.SemanticTokensBuilder(legend).build();
 			}
@@ -85,8 +89,8 @@ async function activate(context) {
 	};
 
 	const selector = [
-		{ language: "c", scheme: "file" },
-		{ language: "c", scheme: "untitled" },
+		{ language: "c",   scheme: "file" },
+		{ language: "c",   scheme: "untitled" },
 		{ language: "cpp", scheme: "file" },
 		{ language: "cpp", scheme: "untitled" },
 	];

.vscode/tape-atom-syntax/lexer.js

@@ -10,29 +10,30 @@ function isIdentifierContinue(code) {
 	return isIdentifierStart(code) || (code >= 48 && code <= 57);
 }
 
-function lex(source) {
+function lex(source)
+{
 	if (typeof source !== "string") throw new TypeError("source must be a string");
 
-	const tokens = [];
-	const errors = [];
-	let offset = 0;
-	let line = 0;
-	let character = 0;
+	const tokens    = [];
+	const errors    = [];
+	let   offset    = 0;
+	let   line      = 0;
+	let   character = 0;
 
 	function advance() {
 		if (source[offset] === "\r" && source[offset + 1] === "\n") {
-			offset += 2;
-			line += 1;
+			offset   += 2;
+			line     += 1;
 			character = 0;
 			return;
 		}
 		if (source[offset] === "\n") {
-			offset += 1;
-			line += 1;
+			offset   += 1;
+			line     += 1;
 			character = 0;
 			return;
 		}
-		offset += 1;
+		offset    += 1;
 		character += 1;
 	}
 
@@ -47,7 +48,8 @@ function lex(source) {
 		});
 	}
 
-	while (offset < source.length) {
+	while (offset < source.length)
+	{
 		const ch = source[offset];
 
 		if (/\s/.test(ch)) {
@@ -60,12 +62,14 @@ function lex(source) {
 			continue;
 		}
 
-		if (ch === "/" && source[offset + 1] === "*") {
+		if (ch === "/" && source[offset + 1] === "*")
+		{
 			const start = offset;
 			advance();
 			advance();
 			let closed = false;
-			while (offset < source.length) {
+			while (offset < source.length)
+			{
 				if (source[offset] === "*" && source[offset + 1] === "/") {
 					advance();
 					advance();
@@ -78,12 +82,14 @@ function lex(source) {
 			continue;
 		}
 
-		if (ch === "\"" || ch === "'") {
+		if (ch === "\"" || ch === "'")
+		{
 			const quote = ch;
 			const start = offset;
 			advance();
 			let closed = false;
-			while (offset < source.length) {
+			while (offset < source.length)
+			{
 				if (source[offset] === "\\") {
 					advance();
 					if (offset < source.length) advance();
@@ -97,14 +103,14 @@ function lex(source) {
 				if (source[offset] === "\n" || source[offset] === "\r") break;
 				advance();
 			}
-			if (!closed) errors.push({ kind: "unterminated-literal", offset: start });
+			if (! closed) errors.push({ kind: "unterminated-literal", offset: start });
 			continue;
 		}
 
 		const code = source.charCodeAt(offset);
 		if (isIdentifierStart(code)) {
-			const start = offset;
-			const startLine = line;
+			const start          = offset;
+			const startLine      = line;
 			const startCharacter = character;
 			advance();
 			while (offset < source.length && isIdentifierContinue(source.charCodeAt(offset))) advance();
@@ -112,8 +118,8 @@ function lex(source) {
 			continue;
 		}
 
-		const start = offset;
-		const startLine = line;
+		const start          = offset;
+		const startLine      = line;
 		const startCharacter = character;
 		advance();
 		pushToken("punctuation", start, startLine, startCharacter);
@@ -124,9 +130,9 @@ function lex(source) {
 
 function buildCallContexts(tokens) {
 	const contexts = Array.from({ length: tokens.length }, () => []);
-	const calls = [];
+	const calls  = [];
 	const errors = [];
-	const stack = [];
+	const stack  = [];
 
 	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
 		const token = tokens[tokenIndex];
@@ -134,7 +140,8 @@ function buildCallContexts(tokens) {
 		if (token.text === ")") {
 			if (stack.length === 0) {
 				errors.push({ kind: "unmatched-close-paren", offset: token.start });
-			} else {
+			}
+			else {
 				const frame = stack.pop();
 				if (frame.callee !== null) calls.push({ ...frame, closeTokenIndex: tokenIndex });
 			}
@@ -143,20 +150,20 @@ function buildCallContexts(tokens) {
 		contexts[tokenIndex] = stack
 			.filter((frame) => frame.callee !== null)
 			.map((frame) => ({
-				callee: frame.callee,
+				callee:           frame.callee,
 				calleeTokenIndex: frame.calleeTokenIndex,
-				openTokenIndex: frame.openTokenIndex,
-				argIndex: frame.argIndex,
+				openTokenIndex:   frame.openTokenIndex,
+				argIndex:         frame.argIndex,
 			}));
 
 		if (token.text === "(") {
-			const previous = tokens[tokenIndex - 1];
+			const previous  = tokens[tokenIndex - 1];
 			const hasCallee = previous && previous.kind === "identifier";
 			stack.push({
-				callee: hasCallee ? previous.text : null,
+				callee:           hasCallee ? previous.text : null,
 				calleeTokenIndex: hasCallee ? tokenIndex - 1 : -1,
-				openTokenIndex: tokenIndex,
-				argIndex: 0,
+				openTokenIndex:   tokenIndex,
+				argIndex:         0,
 			});
 			continue;
 		}

.vscode/tape-atom-syntax/source-index.js

@@ -4,8 +4,10 @@ const path = require("node:path");
 const { buildCallContexts, lex, nearestCall } = require("./lexer");
 
 const BASE_TYPES = [
-	"B1", "B2", "B4", "B8", "F4", "F8", "S1", "S2", "S4", "S8",
-	"U1", "U2", "U4", "U8", "MipsAtom", "MipsCode", "Reg",
+	"B1", "B2", "B4", "B8",
+	"F4", "F8", "S1", "S2", "S4", "S8",
+	"U1", "U2", "U4", "U8",
+	"MipsAtom", "MipsCode", "Reg",
 ];
 
 const C_BUILTINS = new Set([
@@ -15,11 +17,13 @@ const C_BUILTINS = new Set([
 ]);
 
 const BASE_ATTRIBUTES = [
-	"FI_", "I_", "NI_", "Relative_", "Struct_", "Enum_", "Union_", "Array_",
-	"Slice_", "TypeR_", "TypeV_", "align_", "internal", "local_persist", "global",
-	"RO_", "LP_", "gknown", "expect_", "cexpr_",
+	"FI_", "I_", "NI_", 
+	"Relative_", "Struct_", "Enum_", "Union_", "Array_", "Slice_", 
+	"align_", "internal", "local_persist", "global",
+	"RO_", "LP_", 
+	"gknown", "expect_", "cexpr_",
 	"asm", "asm_words", "asm_rpins", "asm_clobber",
-	"O_", "S_", "C_", "T_", "tmpl", "glue", "r_", "v_", "tr_", "tv_",
+	"O_", "OA_", "S_", "C_", "T_", "tmpl", "glue", "r_", "v_", "rt_", "vt_",
 	"rgcc", "r_use", "r_set", "r_mod", "r_imm", "r_mem",
 	"u1_", "u2_", "u4_", "u8_", "s1_", "s2_", "s4_", "s8_",
 	"u1_r", "u2_r", "u4_r", "u8_r", "u1_v", "u2_v", "u4_v", "u8_v",
@@ -27,16 +31,16 @@ const BASE_ATTRIBUTES = [
 
 function createIndex() {
 	return {
-		atoms: new Set(),
-		components: new Set(),
+		atoms:            new Set(),
+		components:       new Set(),
 		componentAliases: new Set(),
-		macros: new Map(),
-		registers: new Map(),
-		bindTypes: new Set(),
-		types: new Set(BASE_TYPES),
-		phases: new Set(),
-		labels: new Set(),
-		attributes: new Set(BASE_ATTRIBUTES),
+		macros:           new Map(),
+		registers:        new Map(),
+		bindTypes:        new Set(),
+		types:            new Set(BASE_TYPES),
+		phases:           new Set(),
+		labels:           new Set(),
+		attributes:       new Set(BASE_ATTRIBUTES),
 		componentCallees: new Map(),
 	};
 }
@@ -46,8 +50,8 @@ function cloneIndex(source) {
 	for (const key of ["atoms", "components", "componentAliases", "bindTypes", "types", "phases", "labels", "attributes"]) {
 		for (const value of source[key]) result[key].add(value);
 	}
-	for (const [name, domain] of source.macros) result.macros.set(name, domain);
-	for (const [name, domain] of source.registers) result.registers.set(name, domain);
+	for (const [name, domain]  of source.macros)           result.macros.set(name, domain);
+	for (const [name, domain]  of source.registers)        result.registers.set(name, domain);
 	for (const [name, callees] of source.componentCallees) result.componentCallees.set(name, callees.slice());
 	return result;
 }
@@ -63,7 +67,7 @@ function mergeIndexes(...sources) {
 			const existing = result.macros.get(name);
 			if (!existing || domainRank(domain) >= domainRank(existing)) result.macros.set(name, domain);
 		}
-		for (const [name, domain] of source.registers) result.registers.set(name, domain);
+		for (const [name, domain]  of source.registers) result.registers.set(name, domain);
 		for (const [name, callees] of source.componentCallees) {
 			const existing = result.componentCallees.get(name) || [];
 			result.componentCallees.set(name, existing.concat(callees));
@@ -75,21 +79,21 @@ function mergeIndexes(...sources) {
 function domainFromPath(filePath) {
 	const base = path.basename(filePath.replaceAll("\\", "/")).toLowerCase();
 	if (base === "mips.h") return "cpu";
-	if (base === "gte.h") return "gte";
-	if (base === "gp.h") return "gpu";
+	if (base === "gte.h")  return "gte";
+	if (base === "gp.h")   return "gpu";
 	return null;
 }
 
 function prefixDomain(name) {
 	if (/^(?:branch_|jump_|call_)/.test(name)) return "control";
 	if (/^gte_(?!cr_)/.test(name) || name.startsWith("mac_gte_") || name.startsWith("ac_gte_")) return "gte";
-	if (/^gp[01]_/.test(name) || name.startsWith("mac_gp_") || name.startsWith("ac_gp_")) return "gpu";
+	if (/^gp[01]_/.test(name)     || name.startsWith("mac_gp_")  || name.startsWith("ac_gp_"))  return "gpu";
 	return null;
 }
 
 function collectBraceIdentifiers(tokens, openBraceIndex) {
 	const names = [];
-	let depth = 0;
+	let   depth = 0;
 	for (let tokenIndex = openBraceIndex; tokenIndex < tokens.length; tokenIndex += 1) {
 		if (tokens[tokenIndex].text === "{") depth += 1;
 		if (tokens[tokenIndex].text === "}") {
@@ -103,17 +107,17 @@ function collectBraceIdentifiers(tokens, openBraceIndex) {
 
 function resolveComponentDomains(index) {
 	const hardwareRank = { cpu: 1, gpu: 2, gte: 3, control: 4 };
-	let changed = true;
+	let   changed      = true;
 	while (changed) {
 		changed = false;
 		for (const [alias, callees] of index.componentCallees) {
-			let best = index.macros.get(alias) || "component";
+			let best     = index.macros.get(alias) || "component";
 			let bestRank = hardwareRank[best] || 0;
 			for (const callee of callees) {
 				const domain = prefixDomain(callee) || index.macros.get(callee);
-				const rank = hardwareRank[domain] || 0;
+				const rank   = hardwareRank[domain] || 0;
 				if (rank > bestRank) {
-					best = domain;
+					best     = domain;
 					bestRank = rank;
 				}
 			}
@@ -134,7 +138,7 @@ function domainRank(domain) {
 }
 
 function registerKind(name) {
-	if (/^R_[A-Za-z0-9_]+$/.test(name)) return "gpr";
+	if (/^R_[A-Za-z0-9_]+$/.test(name))              return "gpr";
 	if (/^(?:C2_|gte_cr_)[A-Za-z0-9_]+$/.test(name)) return "cop2";
 	return null;
 }
@@ -161,14 +165,15 @@ function findFunctionNameBefore(tokens, calleeTokenIndex) {
 	return null;
 }
 
-function scanSource(source, filePath) {
-	const lexical = lex(source);
-	const balanced = buildCallContexts(lexical.tokens);
-	const tokens = lexical.tokens;
-	const contexts = balanced.contexts;
-	const index = createIndex();
+function scanSource(source, filePath)
+{
+	const lexical      = lex(source);
+	const balanced     = buildCallContexts(lexical.tokens);
+	const tokens       = lexical.tokens;
+	const contexts     = balanced.contexts;
+	const index        = createIndex();
 	const declarations = new Map();
-	const domain = domainFromPath(filePath);
+	const domain       = domainFromPath(filePath);
 
 	function mark(token, role, modifiers = ["declaration"]) {
 		declarations.set(token.start, { role, modifiers });
@@ -191,7 +196,8 @@ function scanSource(source, filePath) {
 		if (!index.macros.has(alias)) index.macros.set(alias, "component");
 	}
 
-	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1)
+	{
 		const token = tokens[tokenIndex];
 		if (token.kind !== "identifier") continue;
 
@@ -240,12 +246,14 @@ function scanSource(source, filePath) {
 			mark(token, "gprRegister", ["declaration", "tapeAuto"]);
 		}
 
-		if (token.text === "define" && tokens[tokenIndex - 1] && tokens[tokenIndex - 1].text === "#") {
+		if (token.text === "define" && tokens[tokenIndex - 1] && tokens[tokenIndex - 1].text === "#")
+		{
 			const name = tokens[tokenIndex + 1];
 			if (name && name.kind === "identifier" && name.line === token.line) {
 				if (/^(?:RegUse_|Struct_|Enum_|Union_|TypeR_|TypeV_|Relative_|Binds_)/.test(name.text)) {
 					index.types.add(name.text);
-				} else if (/^(?:ac_|mac_)/.test(name.text)) {
+				}
+				else if (/^(?:ac_|mac_)/.test(name.text)) {
 					const alias = name.text.startsWith("ac_") ? componentAlias(name.text) : name.text;
 					const rest = [];
 					for (let restIndex = tokenIndex + 2; restIndex < tokens.length && tokens[restIndex].line === name.line; restIndex += 1) {
@@ -256,7 +264,8 @@ function scanSource(source, filePath) {
 						index.macros.set(alias, prefixDomain(alias) || "component");
 						if (rest.length) index.componentCallees.set(alias, rest);
 					}
-				} else {
+				}
+				else {
 					index.macros.set(name.text, domain || "utility");
 				}
 			}

code/duffle/dsl.atom.h

@@ -44,7 +44,7 @@
  *
  *  Annotation rules
  *  ----------------
- *      1. atom_info(...) is OPTIONAL. Atoms without atom_info are silently skipped by the metaprogram.
+ *      1. atom_info(...) is optional. Atoms without atom_info are silently skipped by the metaprogram.
  *      2. If present, atom_info takes up to three sub-calls, all order-independent within the arg list:
  *           - atom_bind(Binds_X)
  *           - atom_reads(...)
@@ -160,6 +160,8 @@
  * ----------------------------------------------------------------------------*/
 #define atom_bind(binds_struct)  /* atom_bind(binds_struct) */
 
+#define Binds_(type) (tmpl(Binds,type)) // TODO(Ed): Do we want to use this?
+
 /* ============================================================================
  * atom_label / atom_offset — branch target machinery
  *

code/duffle/dsl.h

@@ -14,8 +14,8 @@
 #define glue(A, B)         glue_impl(A, B)
 #define tmpl(prefix, type) prefix ## _ ## type
 
-#define stringify_impl(S)        #S
-#define stringify(S)             stringify_impl(S)
+#define stringify_impl(S) #S
+#define stringify(S)      stringify_impl(S)
 
 #define VA_Sel_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
 #define VA_Sel_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
@@ -29,8 +29,7 @@
 
 #define asm           __asm__
 
-#define A_(data)      (& data)
-#define align_(value) __attribute__((aligned (value)))             // for easy alignment
+#define A_(data)      (& (data))
 #define align_(value) __attribute__((aligned (value)))             // for easy alignment
 #define C_(type,data) ((type)(data))                               // for enforced precedence
 #define expect_(x, y) __builtin_expect(x, y)                       // so compiler knows the common path
@@ -45,7 +44,8 @@
 #define R_    restrict 
 #define V_    volatile 
 
-#pragma region Fictional //, used for intiution
+#pragma region Fictional 
+//, used for intiution
 
 #define EUB_  restrict // Execute Unit Bound:    Data is siloed in the ALU Register File. The Load/Store Unit is bypassed. (Route to Execution Unit.  Keep in registers)
 #define ISO_  restrict // Isolated Provenance:   Alternative to Exu_. Guarantees electrical memory isolation, 
@@ -83,8 +83,8 @@
 
 #define r_(ptr)        C_(T_(ptr[0])*R_, ptr) // Constrain pointer to restrict
 #define v_(ptr)        C_(T_(ptr[0])V_*, ptr) // 
-#define tr_(type, ptr) C_(type *R_, ptr)
-#define tv_(type, ptr) C_(type V_*, ptr)
+#define rt_(type, ptr) C_(type *R_, ptr)
+#define vt_(type, ptr) C_(type V_*, ptr)
 
 #define TypeR_(type)   type *R_ type ## _R  // type *restrict type_R
 #define TypeV_(type)   type V_* type ## _V  // type volatile* type_V
@@ -120,6 +120,10 @@ typedef unsigned char   TSet_(B1);
 typedef __UINT16_TYPE__ TSet_(B2); 
 typedef __UINT32_TYPE__ TSet_(B4);
 
+#define b1_(value)  C_(B1, value)
+#define b2_(value)  C_(B2, value)
+#define b4_(value)  C_(B4, value)
+
 #define u1_(value)  C_(U1, value)
 #define u2_(value)  C_(U2, value)
 #define u4_(value)  C_(U4, value)
@@ -127,6 +131,13 @@ typedef __UINT32_TYPE__ TSet_(B4);
 #define s2_(value)  C_(S2, value)
 #define s4_(value)  C_(S4, value)
 
+#define b1_r(value) C_(B1*R_, value)
+#define b2_r(value) C_(B2*R_, value)
+#define b4_r(value) C_(B4*R_, value)
+#define b1_v(value) C_(B1 V_*, value)
+#define b2_v(value) C_(B2 V_*, value)
+#define b4_v(value) C_(B4 V_*, value)
+
 #define u1_r(value) C_(U1 *R_, value)
 #define u2_r(value) C_(U2 *R_, value)
 #define u4_r(value) C_(U4 *R_, value)
@@ -183,12 +194,12 @@ def_signed_ops(le, <=)
 #undef def_generic_sop
 #endif
 
-#define alignas                             _Alignas
-#define alignof                             _Alignof
-#define byte_pad(amount, ...)               B1 glue(_PAD_, __VA_ARGS__) [amount]
-#define C_ptr(type, data)                   (C_(type*, & (data)) [0])
+#define alignas               _Alignas
+#define alignof               _Alignof
+#define byte_pad(amount, ...) B1 glue(_PAD_, __VA_ARGS__) [amount]
+#define C_ptr(type, data)     (C_(type*, & (data)) [0])
 
-#define dbg_args(...)                      __VA_ARGS__
+#define dbg_args(...) __VA_ARGS__
 
 #pragma region Control Flow & Iteration
 #define each_iter(type, iter, end)             (type iter = 0; iter < end; ++ iter)

code/duffle/gcc_asm.h

@@ -79,14 +79,6 @@
  *  Why bundle the `__asm__()` wrapper?
  *  - The integer R_T4 (= 12, via R_T4_Code) already indicates the register.
  *  - The string "$12" is derived from it via reg_str, so they cannot drift apart.
- *  - Spelling `__asm__(reg_str(R_T4_Code))` at every call site is noise.
- *
- *  tmpl defined in dsl.h (token-paste glue). 
- *  rgcc define here (gcc_asm.h) because the `__asm__` keyword is GCC-specific. 
- *  Anyone porting to a different compiler's asm dialect overrides rgcc,
- *  and the integer→string derivation in rlit can be retargeted in one place.
- *
- *  For clobber lists and asm-template strings, use the bare `rlit(R_T4_Code)`.
  * ------------------------------------------------------------------------ */
 #define rgcc(n) __asm__(rlit(n))
 

code/duffle/gen/macs.h

@@ -13,7 +13,7 @@
 //   source: C:\projects\Pikuma\ps1\code\duffle\gte.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\pad.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\dsl.atom.h
-//   source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\tape.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\bios.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\psyq.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\pad.c
@@ -35,6 +35,7 @@
  *  These do NOT yield. They are expanded inline inside Tape Atoms.
  * ---------------------------------------------------------------------------*/
 // The 'Yield' sequence for Tape Atoms (mac_yield).
+// In Forth this is considered the "NEXT" mechanism.
 #define mac_yield(...) \
 	load_word(R_AtomJmp, R_TapePtr, 0) \
 	LdSlot_ \
@@ -55,6 +56,12 @@ WORD_COUNT(mac_yield_load, 1)
 ,	BdSlot_ nop
 WORD_COUNT(mac_yield_tail, 3)
 
+/* atom_dbg_skip */
+#define mac_yield_to(code_ptr) \
+	jump_reg(code_ptr) \
+,	BdSlot_ nop
+WORD_COUNT(mac_yield_to, 2)
+
 /* atom_dbg_skip */
 #define mac_load_half_v3(tx, ty, tz, base, offset) \
 	load_half(tx, base, offset + OA_(U2,[0])) \
@@ -228,21 +235,21 @@ WORD_COUNT(mac_gte_op_cross_v3s4, 13)
 WORD_COUNT(mac_gte_store_f3, 3)
 
 /* atom_dbg_skip */
-#define mac_gte_load_tri_verts(r_vert_base, r_v0, r_v1, r_v2) \
-	shift_lleft(R_AT, r_v0, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+#define mac_gte_load_tri_verts(vbase, v0, v1, v2) \
+	shift_lleft(R_AT, v0, v3s2_byteoff) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY0) \
 ,	gte_mv_to_data_r(R_V1, C2_VZ0) \
-,	shift_lleft(R_AT, r_v1, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+,	shift_lleft(R_AT, v1, v3s2_byteoff) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY1) \
 ,	gte_mv_to_data_r(R_V1, C2_VZ1) \
-,	shift_lleft(R_AT, r_v2, v3s2_byteoff) \
-,	add_u_self(R_AT, r_vert_base) \
+,	shift_lleft(R_AT, v2, v3s2_byteoff) \
+,	add_u_self(R_AT, vbase) \
 ,	load_word(R_V0, R_AT, O_(V3_S2,x)) \
 ,	load_word(R_V1, R_AT, O_(V3_S2,z)) \
 ,	LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY2) \
@@ -270,10 +277,10 @@ WORD_COUNT(mac_gte_store_g4_p3, 1)
 WORD_COUNT(mac_gte_sqr_v3, 8)
 
 /* atom_dbg_skip */
-#define mac_gte_sqr_v3s4(r_sx, r_sy, r_sz, delay_slot) \
-	gte_mv_to_data_r(r_sx, C2_IR1) \
-,	gte_mv_to_data_r(r_sy, C2_IR2) \
-,	gte_mv_to_data_r(r_sz, C2_IR3) \
+#define mac_gte_sqr_v3s4(sx, sy, sz, delay_slot) \
+	gte_mv_to_data_r(sx, C2_IR1) \
+,	gte_mv_to_data_r(sy, C2_IR2) \
+,	gte_mv_to_data_r(sz, C2_IR3) \
 ,	delay_slot \
 ,	gte_cmdw_sqr
 WORD_COUNT(mac_gte_sqr_v3s4, 5)
@@ -304,12 +311,12 @@ WORD_COUNT(mac_gte_gpf_scale, 13)
 WORD_COUNT(mac_trans_mt3s3s4, 6)
 
 /* atom_dbg_skip */
-#define mac_lzcr_round_even_half_shift(r_shift, r_mag_sq, r_mag_sq_copy) \
-	and_i(r_shift, r_shift, gte_lzcr_even_mask) \
-,	or_u(r_mag_sq_copy, r_mag_sq, 0) \
-,	li_s(        r_mag_sq, 31) \
-,	sub_s(       r_mag_sq, r_mag_sq, r_shift) \
-,	shift_aright(r_mag_sq, r_mag_sq, 1)
+#define mac_lzcr_round_even_half_shift(shift, mag_sq, mag_sq_copy) \
+	and_i(shift, shift, gte_lzcr_even_mask) \
+,	or_u(mag_sq_copy, mag_sq, 0) \
+,	li_s(        mag_sq, 31) \
+,	sub_s(       mag_sq, mag_sq, shift) \
+,	shift_aright(mag_sq, mag_sq, 1)
 WORD_COUNT(mac_lzcr_round_even_half_shift, 5)
 
 #define mac_gte_general_purpose_interopolation(to_ir0, to_ir1, to_ir2, to_ir3, fr_mac1, fr_mac2, fr_mac3, nop_slot1, nop_slot2) \

code/duffle/gen/offsets.h

@@ -10,7 +10,7 @@
 //   source: C:\projects\Pikuma\ps1\code\duffle\gte.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\pad.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\dsl.atom.h
-//   source: C:\projects\Pikuma\ps1\code\duffle\lottes_tape.h
+//   source: C:\projects\Pikuma\ps1\code\duffle\tape.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\bios.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\psyq.h
 //   source: C:\projects\Pikuma\ps1\code\duffle\pad.c
@@ -33,7 +33,7 @@ enum {
     atom_offset_example_atom_proc_skip = _atom_offset_example_atom_proc_skip,
 };
 
-// --- atom: build_normalize_v3s4 (63 words) ---
+// --- atom: normalize_v3s4 (62 words) ---
 
 #define _atom_offset_aligned_done_srav_path           3
 #define _atom_offset_srav_path_aligned_done           4

code/duffle/gp.atom.c

@@ -1,14 +1,14 @@
 #ifdef INTELLISENSE_DIRECTIVES
 #	include "dsl.h"
 #	include "gp.h"
-#	include "lottes_tape.h"
+#	include "tape.h"
 #endif
 
 ATOM_FILE_DEBUGGER_LINE_MARKER(gp_atom_c);
 
 #pragma region MACs (Mips Atom Components)
 
-FI_ Slice_MipsCode ac_gcmd_push(AtomBuilder_R ab, U4 cmd, U4 reg_transfer, U4 reg_base, U2 port)
+FI_ Slice_MipsCode ac_gcmd_push(AtomBuilder_R ab, U2 cmd, Reg reg_transfer, Reg reg_base, U2 port)
 atom_dbg_skip MipsAtomComp_Proc_(ab, {
 	mac_load_word_imm(reg_transfer, cmd),
 	store_word(       reg_transfer, reg_base, port),

code/duffle/gp.h

@@ -6,26 +6,13 @@
  *  Primitive commands: gp0_cmd_poly_f3 = 0x20    (byte opcode)
  *  Packed 32-bit cmd:  gp0_word_poly_f3(r, g, b) (32-bit, shifted)
  *
- *  Type ordering: domain?_(direction)?_action_target_modifier_type?
- *  Examples: add_ui             (add + unsigned + immediate)
- *            add_s              (add + signed, R-type implicit)
- *            shift_lleft        (shift + logical + left)
- *            shift_aright       (shift + arithmetic + right)
- *            call_reg(rs)       (call + register, $ra implicit)
- *            gte_mv_to_data_r   (gte + mv + to + data + register)
- *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
- *            load_upper_i       (load-upper + immediate, unique verb)
- *
  *  --- GPU-domain layer cake ---
  *  Every gp.h macro follows the same 4-layer composition as mips.h and gte.h:
  *    4. Semantic encoders      gp0_word_poly_f3(r,g,b)
  *    3. Composite encoders     enc_color_word(cmd, r, g, b)
  *    2. Per-field encoders     enc_gp0_color_r(r), enc_gp0_color_g(g), ...
- *    1. Bitfield layout consts gp0_color_red_shift = 0, gp0_color_red_width = 8
+ *    1. Bitfield layout consts gp0_color_red_pos = 0, gp0_color_red_width = 8
  *    0. Opcode IDs             gp0_cmd_poly_f3 = 0x20
- *
- *  Vendor mnemonics (gte_mtc2, gte_mfc2, etc.) are NOT in this header.
- *  They live in the opt-in `gp_vendor_sym.h` for users who prefer the PSYQ-style names.
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES
@@ -75,7 +62,7 @@ enum {
  *  ============================================================================
  *  8-bit GP0 opcodes (the upper byte of a primitive's first word). These are the BYTE only.
  *  NO macro body past this point uses a raw shift or raw mask.
- *  Mirrors the OPCODE_SHIFT / RS_SHIFT convention from mips.h.
+ *  Mirrors the OPCODE_POS / RS_POS convention from mips.h.
  * ============================================================================ */
 enum {
 	gp0_cmd_Nop             = 0x00,
@@ -117,9 +104,9 @@ enum {
 	gp0_cmd_SetDrawOffset        = 0xE5,
 	gp0_cmd_SetMaskBit           = 0xE6,
 
-	/* bitfield shifts / widths ----
+	/* bitfield offset pos / widths ----
 		* Generic GP0/GP1 command byte (upper 8 bits of every word sent to either port). */
-	gp0_cmd_shift = 24,
+	gp0_cmd_pos   = 24,
 	gp0_cmd_width =  8,
 
 	/* Color word layout (lives in Poly_F3.color, Poly_G4.c0..c3, etc.):
@@ -127,10 +114,10 @@ enum {
 		*   bits 23..16 = BLUE
 		*   bits 15..08 = GREEN
 		*   bits 07..00 = RED     (PSX GPU is BGR, NOT RGB) */
-	gp0_color_cmd_shift   = 24, gp0_color_cmd_width   = 8,
-	gp0_color_blue_shift  = 16, gp0_color_blue_width  = 8,
-	gp0_color_green_shift =  8, gp0_color_green_width = 8,
-	gp0_color_red_shift   =  0, gp0_color_red_width   = 8,
+	gp0_color_cmd_pos   = 24, gp0_color_cmd_width   = 8,
+	gp0_color_blue_pos  = 16, gp0_color_blue_width  = 8,
+	gp0_color_green_pos =  8, gp0_color_green_width = 8,
+	gp0_color_red_pos   =  0, gp0_color_red_width   = 8,
 };
 
 /* ============================================================================
@@ -143,12 +130,12 @@ enum {
  * ============================================================================ */
 
 /* ---- Layer 1.5: per-field encoders ---- */
-#define enc_gp0_cmd(cmd)       ((cmd) << gp0_cmd_shift)
+#define enc_gp0_cmd(cmd)       ((cmd) << gp0_cmd_pos)
 
-#define enc_gp0_color_cmd(cmd) ((cmd) << gp0_color_cmd_shift)
-#define enc_gp0_color_r(r)     ((r)   << gp0_color_red_shift)
-#define enc_gp0_color_g(g)     ((g)   << gp0_color_green_shift)
-#define enc_gp0_color_b(b)     ((b)   << gp0_color_blue_shift)
+#define enc_gp0_color_cmd(cmd) ((cmd) << gp0_color_cmd_pos)
+#define enc_gp0_color_r(r)     ((r)   << gp0_color_red_pos)
+#define enc_gp0_color_g(g)     ((g)   << gp0_color_green_pos)
+#define enc_gp0_color_b(b)     ((b)   << gp0_color_blue_pos)
 
 /* ---- Layer 2: composite encoders ---- */
 #define enc_color_word(cmd, r, g, b) (enc_gp0_color_cmd(cmd) | enc_gp0_color_r(r) | enc_gp0_color_g(g) | enc_gp0_color_b(b))
@@ -212,37 +199,37 @@ enum {
 	gp1_disp_VInterlace = 0x1,
 
 	/* ---- Layer 1: GP1 display-mode + range + draw-area shifts/widths ---- */
-	gp1_disp_hres_shift      =  0, gp1_disp_hres_width      = 2,
-	gp1_disp_vres_shift      =  2, gp1_disp_vres_width      = 1,
-	gp1_disp_color_shift     =  4, gp1_disp_color_width     = 1,
-	gp1_disp_interlace_shift =  5, gp1_disp_interlace_width = 1,
+	gp1_disp_hres_pos      =  0, gp1_disp_hres_width      = 2,
+	gp1_disp_vres_pos      =  2, gp1_disp_vres_width      = 1,
+	gp1_disp_color_pos     =  4, gp1_disp_color_width     = 1,
+	gp1_disp_interlace_pos =  5, gp1_disp_interlace_width = 1,
 
 	/* GP1 horizontal display range: bits 0..11 = X2, bits 12..23 = X1 */
-	gp1_hrange_x1_shift = 12, gp1_hrange_x1_width = 12,
-	gp1_hrange_x2_shift =  0, gp1_hrange_x2_width = 12,
+	gp1_hrange_x1_pos = 12, gp1_hrange_x1_width = 12,
+	gp1_hrange_x2_pos =  0, gp1_hrange_x2_width = 12,
 
 	/* GP1 vertical display range: bits 0..9 = Y2, bits 10..19 = Y1 */
-	gp1_vrange_y1_shift = 10, gp1_vrange_y1_width = 10,
-	gp1_vrange_y2_shift =  0, gp1_vrange_y2_width = 10,
+	gp1_vrange_y1_pos = 10, gp1_vrange_y1_width = 10,
+	gp1_vrange_y2_pos =  0, gp1_vrange_y2_width = 10,
 
 	/* GP1 draw area (top-left or bottom-right): bits 0..9 = X, bits 10..19 = Y
 		* (10-bit signed — caller pre-signs) */
-	gp1_draw_x_shift =  0, gp1_draw_x_width = 10,
-	gp1_draw_y_shift = 10, gp1_draw_y_width = 10,
+	gp1_draw_x_pos =  0, gp1_draw_x_width = 10,
+	gp1_draw_y_pos = 10, gp1_draw_y_width = 10,
 };
 
 /* ---- Layer 1.5: GP1 per-field encoders ---- */
-#define enc_gp1_disp_hres(h)      ((h) << gp1_disp_hres_shift)
-#define enc_gp1_disp_vres(v)      ((v) << gp1_disp_vres_shift)
-#define enc_gp1_disp_color(c)     ((c) << gp1_disp_color_shift)
-#define enc_gp1_disp_interlace(i) ((i) << gp1_disp_interlace_shift)
+#define enc_gp1_disp_hres(h)      ((h) << gp1_disp_hres_pos)
+#define enc_gp1_disp_vres(v)      ((v) << gp1_disp_vres_pos)
+#define enc_gp1_disp_color(c)     ((c) << gp1_disp_color_pos)
+#define enc_gp1_disp_interlace(i) ((i) << gp1_disp_interlace_pos)
 
-#define enc_gp1_hrange_x1(x1) ((x1) << gp1_hrange_x1_shift)
-#define enc_gp1_hrange_x2(x2) ((x2) << gp1_hrange_x2_shift)
-#define enc_gp1_vrange_y1(y1) ((y1) << gp1_vrange_y1_shift)
-#define enc_gp1_vrange_y2(y2) ((y2) << gp1_vrange_y2_shift)
-#define enc_gp1_draw_x(x)     ((x)  << gp1_draw_x_shift)
-#define enc_gp1_draw_y(y)     ((y)  << gp1_draw_y_shift)
+#define enc_gp1_hrange_x1(x1) ((x1) << gp1_hrange_x1_pos)
+#define enc_gp1_hrange_x2(x2) ((x2) << gp1_hrange_x2_pos)
+#define enc_gp1_vrange_y1(y1) ((y1) << gp1_vrange_y1_pos)
+#define enc_gp1_vrange_y2(y2) ((y2) << gp1_vrange_y2_pos)
+#define enc_gp1_draw_x(x)     ((x)  << gp1_draw_x_pos)
+#define enc_gp1_draw_y(y)     ((y)  << gp1_draw_y_pos)
 
 /* ---- Layer 2: GP1 composite encoders ---- */
 #define enc_gp1_disp_mode_word(h, v, c, i) (enc_gp0_cmd(gp1_cmd_DisplayMode)            | enc_gp1_disp_hres(h)  | enc_gp1_disp_vres(v) | enc_gp1_disp_color(c) | enc_gp1_disp_interlace(i))
@@ -391,17 +378,15 @@ enum {
  *  Primitive structs (8 polygon variants + tag)
  *  ============================================================================
  *  Each struct follows the GPU-documented memory layout for the corresponding primitive command. 
- *  The PolyTag is the OT-link header; the rest of the struct is the primitive's body.
+ *  PolyTag is an OT-link header. Rest of the struct is the primitive's body.
  *
- *  The current working layouts match the existing demo 
- *  (floor_tri uses Poly_F3; cube_tri uses Poly_G4). 
  *  They are NOT necessarily byte-identical to the PSX-SPX reference layout. 
  *  The demo layout uses color+vertex interleaving that doesn't match the standard PSX SDK file format. 
  *  For PSX-SDK file compatibility, the textured variants (FT*, GT*) would need layout adjustments.
  * ============================================================================ */
 
 /* ---------- RGB8 (3-byte packed color) ---------- */
-typedef Struct_(RGB8) { B1 r; B1 g; B1 b; };
+typedef Struct_(RGB8) { U1 r; U1 g; U1 b; };
 #define rgb8(r,g,b) ((RGB8){r,g,b})
 
 /* ---------- PolyTag (the OT-link header; 1 word) ---------- */
@@ -431,7 +416,7 @@ typedef Struct_(PolyTag) {
 typedef Struct_(Poly_F3) {
 	U4   tag;
 	RGB8 color;
-	B1   code;
+	U1   code;
 	union {
 		struct { V2_S2 p0; V2_S2 p1; V2_S2 p2; };
 		A3_V2_S2 points;
@@ -442,7 +427,7 @@ typedef Struct_(Poly_F3) {
 typedef Struct_(Poly_F4) {
 	U4   tag;
 	RGB8 color;
-	B1   code;
+	U1   code;
 	union {
 		struct { V2_S2 p0; V2_S2 p1; V2_S2 p2; V2_S2 p3; };
 		A4_V2_S2 points;
@@ -451,18 +436,18 @@ typedef Struct_(Poly_F4) {
 
 /* ---------- Poly_G3 (Gouraud Triangle; 7 words) ---------- */
 typedef Struct_(Poly_G3) {
-	U4    tag; RGB8 c0; B1 code;
-	V2_S2 p0;  RGB8 c1; B1 pad1;
-	V2_S2 p1;  RGB8 c2; B1 pad2;
+	U4    tag; RGB8 c0; U1 code;
+	V2_S2 p0;  RGB8 c1; U1 pad1;
+	V2_S2 p1;  RGB8 c2; U1 pad2;
 	V2_S2 p2;
 };
 
 /* ---------- Poly_G4 (Gouraud Quad; 9 words) ---------- */
 typedef Struct_(Poly_G4) {
-	U4    tag; RGB8 c0; B1 code;
-	V2_S2 p0;  RGB8 c1; B1 pad1;
-	V2_S2 p1;  RGB8 c2; B1 pad2;
-	V2_S2 p2;  RGB8 c3; B1 pad3;
+	U4    tag; RGB8 c0; U1 code;
+	V2_S2 p0;  RGB8 c1; U1 pad1;
+	V2_S2 p1;  RGB8 c2; U1 pad2;
+	V2_S2 p2;  RGB8 c3; U1 pad3;
 	V2_S2 p3;
 };
 
@@ -471,7 +456,7 @@ typedef Struct_(Poly_G4) {
 typedef Struct_(Poly_FT3) {
 	U4   tag;
 	RGB8 color;
-	B1   code;
+	U1   code;
 	U4   tpage;
 	U4   clut;
 	V2_S2 p0; U1 u0; U1 v0;
@@ -483,7 +468,7 @@ typedef Struct_(Poly_FT3) {
 typedef Struct_(Poly_FT4) {
 	U4   tag;
 	RGB8 color;
-	B1   code;
+	U1   code;
 	U4   tpage;
 	U4   clut;
 	V2_S2 p0; U1 u0; U1 v0;
@@ -494,9 +479,9 @@ typedef Struct_(Poly_FT4) {
 
 /* ---------- Poly_GT3 (Gouraud Textured Triangle) ---------- */
 typedef Struct_(Poly_GT3) {
-	U4    tag; RGB8 c0; B1 code;
-	V2_S2 p0;  RGB8 c1; B1 pad1;
-	V2_S2 p1;  RGB8 c2; B1 pad2;
+	U4    tag; RGB8 c0; U1 code;
+	V2_S2 p0;  RGB8 c1; U1 pad1;
+	V2_S2 p1;  RGB8 c2; U1 pad2;
 	V2_S2 p2;
 	U4    tpage;
 	U4    clut;
@@ -507,10 +492,10 @@ typedef Struct_(Poly_GT3) {
 
 /* ---------- Poly_GT4 (Gouraud Textured Quad) ---------- */
 typedef Struct_(Poly_GT4) {
-	U4    tag; RGB8 c0; B1 code;
-	V2_S2 p0;  RGB8 c1; B1 pad1;
-	V2_S2 p1;  RGB8 c2; B1 pad2;
-	V2_S2 p2;  RGB8 c3; B1 pad3;
+	U4    tag; RGB8 c0; U1 code;
+	V2_S2 p0;  RGB8 c1; U1 pad1;
+	V2_S2 p1;  RGB8 c2; U1 pad2;
+	V2_S2 p2;  RGB8 c3; U1 pad3;
 	V2_S2 p3;
 	U4    tpage;
 	U4    clut;
@@ -553,16 +538,16 @@ typedef Struct_(Poly_GT4) {
  * ============================================================================ */
 enum {
 	/* ---- Layer 1: TPage bitfield shifts / widths ---- */
-	gp0_tpage_x_shift            =  0, gp0_tpage_x_width            =  4,
-	gp0_tpage_y_shift            =  4, gp0_tpage_y_width            =  1,
-	gp0_tpage_semi_trans_shift   =  5, gp0_tpage_semi_trans_width   =  2,
-	gp0_tpage_color_depth_shift  =  7, gp0_tpage_color_depth_width  =  2,
-	gp0_tpage_dither_shift       =  9, gp0_tpage_dither_width       =  1,
-	gp0_tpage_draw_to_disp_shift = 10, gp0_tpage_draw_to_disp_width =  1,
-	gp0_tpage_tex_disable_shift  = 11, gp0_tpage_tex_disable_width  =  1,
+	gp0_tpage_x_pos            =  0, gp0_tpage_x_width            =  4,
+	gp0_tpage_y_pos            =  4, gp0_tpage_y_width            =  1,
+	gp0_tpage_semi_trans_pos   =  5, gp0_tpage_semi_trans_width   =  2,
+	gp0_tpage_color_depth_pos  =  7, gp0_tpage_color_depth_width  =  2,
+	gp0_tpage_dither_pos       =  9, gp0_tpage_dither_width       =  1,
+	gp0_tpage_draw_to_disp_pos = 10, gp0_tpage_draw_to_disp_width =  1,
+	gp0_tpage_tex_disable_pos  = 11, gp0_tpage_tex_disable_width  =  1,
 
 	/* TPage color-depth payload values (NOT bit positions — these go in
-	 * the 2-bit field at gp0_tpage_color_depth_shift). */
+	 * the 2-bit field at gp0_tpage_color_depth_pos). */
 	gp0_tpage_color_4bpp  = 0x0,
 	gp0_tpage_color_8bpp  = 0x1,
 	gp0_tpage_color_16bpp = 0x2,
@@ -578,13 +563,13 @@ enum {
 };
 
 /* ---- Layer 1.5: TPage per-field encoders. Mirrors enc_gte_sf/mx/v in gte.h. ---- */
-#define enc_gp0_tpage_x(x)            ((x) << gp0_tpage_x_shift)
-#define enc_gp0_tpage_y(y)            ((y) << gp0_tpage_y_shift)
-#define enc_gp0_tpage_semi_trans(s)   ((s) << gp0_tpage_semi_trans_shift)
-#define enc_gp0_tpage_color_depth(c)  ((c) << gp0_tpage_color_depth_shift)
-#define enc_gp0_tpage_dither(d)       ((d) << gp0_tpage_dither_shift)
-#define enc_gp0_tpage_draw_to_disp(d) ((d) << gp0_tpage_draw_to_disp_shift)
-#define enc_gp0_tpage_tex_disable(t)  ((t) << gp0_tpage_tex_disable_shift)
+#define enc_gp0_tpage_x(x)            ((x) << gp0_tpage_x_pos)
+#define enc_gp0_tpage_y(y)            ((y) << gp0_tpage_y_pos)
+#define enc_gp0_tpage_semi_trans(s)   ((s) << gp0_tpage_semi_trans_pos)
+#define enc_gp0_tpage_color_depth(c)  ((c) << gp0_tpage_color_depth_pos)
+#define enc_gp0_tpage_dither(d)       ((d) << gp0_tpage_dither_pos)
+#define enc_gp0_tpage_draw_to_disp(d) ((d) << gp0_tpage_draw_to_disp_pos)
+#define enc_gp0_tpage_tex_disable(t)  ((t) << gp0_tpage_tex_disable_pos)
 
 /* ---- Layer 2: TPage composite encoder. Mirrors enc_gte_cmdw in gte.h ---- */
 #define enc_gp0_tpage_word(x, y, semi_trans, color_depth, dither, draw_to_disp, tex_disable) \
@@ -615,16 +600,16 @@ typedef Struct_(TexturePage) { U4 raw; };
  * ============================================================================ */
 enum {
 	/* ---- Layer 1: CLUT bitfield shifts / widths ---- */
-	gp0_clut_y_shift = 0, gp0_clut_y_width = 6,
-	gp0_clut_x_shift = 6, gp0_clut_x_width = 9,
+	gp0_clut_y_pos = 0, gp0_clut_y_width = 6,
+	gp0_clut_x_pos = 6, gp0_clut_x_width = 9,
 	/* CLUT-load cmd-byte variants — the upper byte of the GP0 word. */
 	gp0_clut_cmd_Load4bpp = 0x20,
 	gp0_clut_cmd_Load8bpp = 0x25,
 };
 
 /* ---- Layer 1.5: CLUT per-field encoders ---- */
-#define enc_gp0_clut_x(x) ((x) << gp0_clut_x_shift)
-#define enc_gp0_clut_y(y) ((y) << gp0_clut_y_shift)
+#define enc_gp0_clut_x(x) ((x) << gp0_clut_x_pos)
+#define enc_gp0_clut_y(y) ((y) << gp0_clut_y_pos)
 
 /* ---- Layer 2: CLUT composite encoder ---- */
 #define enc_gp0_clut_word(cmd, x, y) (enc_gp0_cmd(cmd) | enc_gp0_clut_x(x) | enc_gp0_clut_y(y))

code/duffle/gte.atom.c

@@ -3,7 +3,8 @@
 #	include "gen/offsets.h"
 #	include "gte.h"
 #	include "gp.h"
-#	include "lottes_tape.h"	
+#	include "tape.h"	
+#	include "math.atom.h"
 #endif
 
 ATOM_FILE_DEBUGGER_LINE_MARKER(gte_atom_c);
@@ -63,10 +64,10 @@ FI_ Slice_MipsCode ac_gte_store_f3(AtomBuilder_R ab, U4 r_primitive_cursor) atom
 })
 
 /* Words: 18; Translates indices to vertex addresses and pushes them to GTE  */
-I_ Slice_MipsCode ac_gte_load_tri_verts(AtomBuilder_R ab, U4 r_vert_base, U4 r_v0, U4 r_v1, U4 r_v2) atom_dbg_skip MipsAtomComp_Proc_(ab, {
-	shift_lleft(R_AT, r_v0, v3s2_byteoff), add_u_self(R_AT, r_vert_base), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
-	shift_lleft(R_AT, r_v1, v3s2_byteoff), add_u_self(R_AT, r_vert_base), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
-	shift_lleft(R_AT, r_v2, v3s2_byteoff), add_u_self(R_AT, r_vert_base), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
+I_ Slice_MipsCode ac_gte_load_tri_verts(AtomBuilder_R ab, Reg vbase, Reg v0, Reg v1, Reg v2) atom_dbg_skip MipsAtomComp_Proc_(ab, {
+	shift_lleft(R_AT, v0, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY0), gte_mv_to_data_r(R_V1, C2_VZ0),
+	shift_lleft(R_AT, v1, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY1), gte_mv_to_data_r(R_V1, C2_VZ1),
+	shift_lleft(R_AT, v2, v3s2_byteoff), add_u_self(R_AT, vbase), load_word(R_V0, R_AT, O_(V3_S2,x)), load_word(R_V1, R_AT, O_(V3_S2,z)), LdSlot_ gte_mv_to_data_r(R_V0, C2_VXY2), gte_mv_to_data_r(R_V1, C2_VZ2),
 })
 
 /* Words: 3; Stores the 3 transformed (V2_S2 screen) vertices of the
@@ -96,11 +97,11 @@ FI_ Slice_MipsCode ac_gte_sqr_v3(AtomBuilder_R ab, U4 r_sx, U4 r_sy, U4 r_sz, U4
 })
 
 /* ─── SQR FIRE — mtc2 3 GPRs into IR1/IR2/IR3, then fire SQR. ─── */
-FI_ Slice_MipsCode ac_gte_sqr_v3s4(AtomBuilder_R ab, Reg r_sx, Reg r_sy, Reg r_sz, MipsCode delay_slot)
+FI_ Slice_MipsCode ac_gte_sqr_v3s4(AtomBuilder_R ab, Reg sx, Reg sy, Reg sz, MipsCode delay_slot)
 atom_dbg_skip MipsAtomComp_Proc_(ab, {
-	gte_mv_to_data_r(r_sx, C2_IR1),
-	gte_mv_to_data_r(r_sy, C2_IR2),
-	gte_mv_to_data_r(r_sz, C2_IR3),
+	gte_mv_to_data_r(sx, C2_IR1),
+	gte_mv_to_data_r(sy, C2_IR2),
+	gte_mv_to_data_r(sz, C2_IR3),
 	delay_slot, gte_cmdw_sqr,
 })
 
@@ -157,16 +158,13 @@ FI_ Slice_MipsCode ac_trans_mt3s3s4(AtomBuilder_R ab
  *
  * Note: C2_LZCR (cop2r31) is a fixed read-only C2 data register — the caller must read it via mfc2 from C2_LZCR;
  * there is no register choice at the hardware level. Only the GPR that holds the result is caller-determined. */
-FI_ Slice_MipsCode ac_lzcr_round_even_half_shift(AtomBuilder_R ab,
-	U4 r_shift,
-	U4 r_mag_sq,
-	U4 r_mag_sq_copy)
+FI_ Slice_MipsCode ac_lzcr_round_even_half_shift(AtomBuilder_R ab, Reg shift, Reg mag_sq, Reg mag_sq_copy)
 atom_dbg_skip MipsAtomComp_Proc_(ab, {
-	and_i(r_shift, r_shift, gte_lzcr_even_mask),
-	or_u(r_mag_sq_copy, r_mag_sq, 0),
-	li_s(        r_mag_sq, 31),
-	sub_s(       r_mag_sq, r_mag_sq, r_shift),
-	shift_aright(r_mag_sq, r_mag_sq, 1),
+	and_i(shift, shift, gte_lzcr_even_mask),
+	or_u(mag_sq_copy, mag_sq, 0),
+	li_s(        mag_sq, 31),
+	sub_s(       mag_sq, mag_sq, shift),
+	shift_aright(mag_sq, mag_sq, 1),
 })
 
 FI_ Slice_MipsCode ac_gte_general_purpose_interopolation(AtomBuilder_R ab
@@ -186,60 +184,95 @@ MipsAtomComp_Proc_(ab, {
 	gte_mv_from_data_r(fr_mac3, C2_MAC3),
 })
 
-FI_ Slice_MipsCode ac_gte_mv_from_data_r_mac123(AtomBuilder_R ab
-	, Reg fr_mac1, Reg fr_mac2, Reg fr_mac3)
+FI_ Slice_MipsCode ac_gte_mv_from_data_r_mac123(AtomBuilder_R ab, Reg fr_mac1, Reg fr_mac2, Reg fr_mac3) 
 MipsAtomComp_Proc_(ab, {
 	gte_mv_from_data_r(fr_mac1, C2_MAC1),
 	gte_mv_from_data_r(fr_mac2, C2_MAC2),
 	gte_mv_from_data_r(fr_mac3, C2_MAC3),
 })
 
-
 FI_ Slice_MipsCode ac_gte_mv_from_mac123_v3s4(AtomBuilder_R ab, Reg_(V3_S4) v) MipsAtomComp_ProcMap_(ab, mac_gte_mv_from_data_r_mac123(v.x, v.y, v.z))
 
 #pragma endregion MACs (Mips Atom Components)
 
 #pragma region Atom Procs
 
-/* ─── Local copy of PSYQ's sqrtbl (1/sqrt lookup table for VectorNormal). ───
- * Source: PSYQ 4.7 libgte sqrtbl at 0x800185B4 in hello_camera.elf.
- *   objdump -s --start-address=0x800185B4 --stop-address=0x800185F4 hello_camera.elf → 192 entries × 16-bit signed, in 1.12 fixed-point (max value 0x1000 = 1.0).
+/* Normalize V3_S4 using the PSYQ/libgte reciprocal-sqrt method:
+ *   |v|² = x² + y² + z²
+ *   LZCR determines the exponent of |v|².
+ *   Round that exponent even and shift |v|² into [1, 4).
+ *   sqrtbl approximates 1/sqrt(mantissa).
+ *   GPF multiplies v by that reciprocal-sqrt mantissa.
+ *   srav_shift restores the exponent scale.
+ * Effectively: v_normalized = v * (1 / sqrt(|v|²)).
  * 
+ * ─── Local port of PSYQ's sqrtbl (1/sqrt lookup table for VectorNormal). ───
+ * Source: PSYQ 4.7 libgte sqrtbl at 0x800185B4 in hello_camera.elf.
+ *   objdump -s --start-address=0x800185B4 --stop-address=0x800185F4 hello_camera.elf -> 192 entries x 16-bit signed, stored in 1.12 fixed point.
  * Data is identical to the libgte original (byte-for-byte verified).
  *
- * ─── Per-entry semantics (decoded from libgte msc02 VectorNormal) ───
- * Each entry is `1/sqrt(x)` in 1.12 fixed point (value / 4096).
- * The 192 entries span 4 octaves of the input magnitude, with 48 entries per octave:
- *   Octave 0 (entries  0- 47): mantissa in [0x8000,  0x10000)  output ~[1.000, 0.707]
- *   Octave 1 (entries 48- 95): mantissa in [0x10000, 0x20000)  output ~[0.707, 0.500]
- *   Octave 2 (entries 96-143): mantissa in [0x20000, 0x40000)  output ~[0.500, 0.354]
- *   Octave 3 (entries144-191): mantissa in [0x40000, 0x80000)  output ~[0.354, 0.251]
- * Within each octave, 8 sub-entries interpolate over the 8 fractional bits of the mantissa
- * (the byte `(0x80 | (i mod 8))` for the lower-byte of the aligned value).
- * Sampling the first value of each octave:
- *   [0]   0x1000 = 1.0000                 ; 1 / sqrt(1.0000)
- *   [48]  0x0e4f = 0.8940                 ; 1 / sqrt(1.2500)
- *   [96]  0x0d10 = 0.8164                 ; 1 / sqrt(1.5000)
- *   [144] 0x0c0a = 0.7520                 ; 1 / sqrt(1.7500)
- * And representative sub-entries within octave 0 (mantissa in [0x8000, 0x8100)):
- *   [0]   0x1000 = 1.0000                 ; 1 / sqrt(0x8000)
- *   [1]   0x0fe0 = 0.9922                 ; 1 / sqrt(0x8100)
- *   [2]   0x0fc1 = 0.9846                 ; 1 / sqrt(0x8200)
- *   [3]   0x0fa3 = 0.9773                 ; 1 / sqrt(0x8300)
- *   [4]   0x0f85 = 0.9700                 ; 1 / sqrt(0x8400)
- *   [5]   0x0f68 = 0.9629                 ; 1 / sqrt(0x8500)
- *   [6]   0x0f4c = 0.9561                 ; 1 / sqrt(0x8600)
- *   [7]   0x0f30 = 0.9492                 ; 1 / sqrt(0x8700)
+ * ─── Table semantics ───
+ * For table index i in [0, 192):
+ *     x      = 1 + i / 64
+ *     tbl[i] = floor(4096 / sqrt(x))
+ * Thus the table uniformly samples 1/sqrt(x) over:
+ *     x in [1.0, 4.0)
+ * at steps of 1/64, with the result represented in 1.12 fixed point (0x1000 = 1.0).
  *
- * The algorithm's `addi -64 / sll 1 / lh` selects the entry at `(aligned - 64) * 2` for the case where `aligned` has its top bit at bit 24.
- * After the sllv/srav pair, `aligned` always lands in `[0x80, 0x100)` 
- * (with top bit at bit 24 → after `sub $aligned - 64`, the index sits in `[0x40, 0x80) * 2 = [0x80, 0x100)` bytes = entries [64, 128) within the sqrtbl).
- * The earlier 64 entries (octave 0) are reached when the magnitude after shifting puts the top bit below bit 24 (the `sllv` branch),
- * and the load upper_halves of the table bracket the input range.
- * The later 64 entries (octaves 2-3) are the `srav` branch when the magnitude's top bit is well above bit 24.
+ * Representative entries:
+ *     [  0] 0x1000 = 1.000000   ; 1 / sqrt(1.000000)
+ *     [ 16] 0x0e4f = 0.894287   ; 1 / sqrt(1.250000)
+ *     [ 32] 0x0d10 = 0.816406   ; 1 / sqrt(1.500000)
+ *     [ 48] 0x0c18 = 0.755859   ; 1 / sqrt(1.750000)
+ *     [ 64] 0x0b50 = 0.707031   ; 1 / sqrt(2.000000)
+ *     [128] 0x093c = 0.577148   ; 1 / sqrt(3.000000)
+ *     [191] 0x0804 = 0.500977   ; 1 / sqrt(3.984375)
  *
- * Reproduced verbatim from libgte (verified against libpsn00b/psxgte/vector.s:100-123 — 24 rows × 8 halfwords, last entry 0x0804).
- * */
+ * ─── How VectorNormal indexes it ───
+ * Let:
+ *     mag_sq = x*x + y*y + z*z
+ *     lzcr   = leading-zero count of mag_sq
+ * For a non-zero magnitude, libgte first rounds LZCR down to an even number:
+ *     lzcr_even = lzcr & ~1
+ *
+ * It then shifts mag_sq so that its significant bits land in one of two
+ * adjacent normalized ranges:
+ *     if lzcr_even >= 24:
+ *         aligned = mag_sq << (lzcr_even - 24)
+ *     else:
+ *         aligned = mag_sq >> (24 - lzcr_even)
+ *
+ * Because lzcr_even differs from the true LZCR by at most one bit:
+ *     raw LZCR even -> aligned in [0x80, 0x100)
+ *     raw LZCR odd  -> aligned in [0x40, 0x080)
+ * therefore:
+ *     aligned in [0x40, 0x100)
+ *
+ * Dividing this normalized integer by 64 gives exactly the table domain:
+ *     x = aligned / 64
+ *     x in [1.0, 4.0)
+ *
+ * The lookup is therefore:
+ *     index       = aligned - 0x40
+ *     byte_offset = index * sizeof(S2)
+ *     inv_len     = sqrtbl[index]
+ * or equivalently, matching the libgte instructions:
+ *     addi aligned, -64
+ *     sll  aligned, 1
+ *     lh   inv_len, sqrtbl + aligned
+ *
+ * ─── Why the domain spans [1, 4) instead of [1, 2) ───
+ * Square-root scaling depends on the parity of the exponent.
+ * Rounding LZCR to even absorbs exponent changes in pairs of bits, leaving the lookup mantissa normalized over a factor-of-four interval [1, 4).
+ *
+ * The corresponding exponent correction is retained separately as:
+ *     srav_shift = (31 - lzcr_even) >> 1
+ *
+ * After GPF multiplies the original vector components by the table's reciprocal-square-root coefficient,
+ * this shift restores the exponent scale and yields the normalized vector.
+ *
+ * Reproduced verbatim from libgte; also matches PSn00bSDK VectorNormalS _norm_table (24 rows x 8 halfwords, final entry 0x0804).
+ **/
 internal S2 const gte_normalize_sqr_tbl[192] align_(2) = {
 	0x1000, 0x0fe0, 0x0fc1, 0x0fa3, 0x0f85, 0x0f68, 0x0f4c, 0x0f30,
 	0x0f15, 0x0efb, 0x0ee1, 0x0ec7, 0x0eae, 0x0e96, 0x0e7e, 0x0e66,
@@ -267,28 +300,25 @@ internal S2 const gte_normalize_sqr_tbl[192] align_(2) = {
 	0x0820, 0x081c, 0x0818, 0x0814, 0x0810, 0x080c, 0x0808, 0x0804,
 };
 
-typedef Struct_(Binds_NormalizeV3S4) {
-	U2 src_offset;    /* offset of src V3_S4 within the BIOS scratchpad */
-	U2 dst_offset;    /* offset of dst V3_S4 within the BIOS scratchpad */
-};
-typedef Struct_(RegUse_build_normalize_v3s4) {
+typedef Struct_(Binds_normalize_v3s4) { U2 src_offset; U2 dst_offset; };
+typedef Struct_(RegUse_normalize_v3s4) {
 	union { Reg_(V3_S4) res, src; };
-	union { Reg t0, src_ptr, mac2; };
-	union { Reg t1, dst_ptr; };
-	union { Reg t2, dst_offset, mac1, v_sqr_aligned; };
-	union { Reg t3, src_offset, btarget, shift_count, sqrtbl_index; };
-	union { Reg t4, mac3, v_sqr_sum, half_shift_tmp, inv_len; };
-	union { Reg t5, lzcr, half_shift; };
+	union { Reg r0, src_ptr, mac2; };
+	union { Reg r1, dst_ptr; };
+	union { Reg r2, dst_offset, mac1, v_sqr_aligned, sqrtbl_byte_offset; };
+	union { Reg r3, src_offset, align_delta, shift_count, sqrtbl_lookup; };
+	union { Reg r4, mac3, v_sqr_sum, srav_shift; };
+	union { Reg r5, lzcr_raw, lzcr_even, inv_len; };
 };
 /* ─── Full normalize (all 4 stages inline) ───
  * Generic 4-stage GTE normalize (SQR → sum+LZCR → align+sqrtbl → GPF+srav). */
-internal MipsAtom* build_normalize_v3s4(AtomArena_R aa, RegUse_build_normalize_v3s4 r)
+internal MipsAtom* normalize_v3s4(AtomArena_R aa, RegUse_normalize_v3s4 r)
 MipsAtom_Proc_(aa, {
-	load_half(r.src_offset, R_TapePtr, O_(Binds_NormalizeV3S4, src_offset)),
-	load_half(r.dst_offset, R_TapePtr, O_(Binds_NormalizeV3S4, dst_offset)),
+	load_half(r.src_offset, R_TapePtr, O_(Binds_normalize_v3s4, src_offset)),
+	load_half(r.dst_offset, R_TapePtr, O_(Binds_normalize_v3s4, dst_offset)),
 	LdSlot_ add_u(r.src_ptr, R_ScratchBase, r.src_offset),
 	LdSlot_ add_u(r.dst_ptr, R_ScratchBase, r.dst_offset),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_NormalizeV3S4)),
+	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_normalize_v3s4)),
 
 	mac_load_v3s4(r.src, r.src_ptr, 0),
 
@@ -300,39 +330,38 @@ MipsAtom_Proc_(aa, {
 	add_u_self(        r.v_sqr_sum, r.mac1),
 	add_u_self(        r.v_sqr_sum, r.mac2),
 	gte_mv_to_data_r(  r.v_sqr_sum, C2_LZCS), GteDelay_ nop2,
-	gte_mv_from_data_r(r.lzcr,      C2_LZCR), GteDelay_ nop,
+	gte_mv_from_data_r(r.lzcr_raw,  C2_LZCR), GteDelay_ nop,
 
 	/* Stage 3: even(LZCR), half-shift, align |v|² to bit 24. */
-	mac_lzcr_round_even_half_shift(r.lzcr, r.v_sqr_sum, r.v_sqr_aligned),
-	add_si(        r.btarget, r.lzcr, -24),
-	branch_lt_zero(r.btarget, atom_offset(aligned_done, srav_path)), BdSlot_ nop, /* bltz → srav_path (LZCR <  24 path) */
+	mac_lzcr_round_even_half_shift(r.lzcr_raw, r.v_sqr_sum, r.v_sqr_aligned),
+	add_si(        r.align_delta, r.lzcr_even, -24),
+	branch_lt_zero(r.align_delta, atom_offset(aligned_done, srav_path)), BdSlot_ nop, /* bltz → srav_path (LZCR <  24 path) */
 		jump_rel(atom_offset(srav_path, aligned_done)),                             /* b → aligned_done (LZCR >= 24 path) */
-		BdSlot_ shift_lleft_var(r.v_sqr_aligned, r.v_sqr_aligned, r.btarget),
+		BdSlot_ shift_lleft_var(r.v_sqr_aligned, r.v_sqr_aligned, r.align_delta),
 		atom_label(srav_path)
 			li_s( r.shift_count, 24),
-			sub_s(r.shift_count, r.shift_count, r.lzcr),
+			sub_s(r.shift_count, r.shift_count, r.lzcr_even),
 			shift_aright_var(r.v_sqr_aligned, r.v_sqr_aligned, r.shift_count),
 	atom_label(aligned_done)
-		or_u(r.half_shift, r.half_shift_tmp, 0),
-		add_si(     r.v_sqr_aligned, r.v_sqr_aligned, -64),
-		shift_lleft(r.v_sqr_aligned, r.v_sqr_aligned, 1),
-		mac_load_word_imm(r.sqrtbl_index, & gte_normalize_sqr_tbl), add_u_self(r.sqrtbl_index, r.v_sqr_aligned),
-		load_half(r.inv_len, r.sqrtbl_index, 0),
+		add_si(     r.sqrtbl_byte_offset, r.v_sqr_aligned,    -64),
+		shift_lleft(r.sqrtbl_byte_offset, r.sqrtbl_byte_offset, 1),
+		mac_load_word_imm(r.sqrtbl_lookup, & gte_normalize_sqr_tbl), add_u_self(r.sqrtbl_lookup, r.sqrtbl_byte_offset),
+		load_half(r.inv_len, r.sqrtbl_lookup, 0),
 		LdSlot_ nop,
 
 	mac_gte_general_purpose_interopolation(r.inv_len,
 		r.src.x, r.src.y, r.src.z,
 		r.res.x, r.res.y, r.res.z,
 		GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0), LdSlot_   // ac_yield: word 1
-		GteDelay_ add_ui_self(         R_TapePtr, S_(MipsCode)) // ac_yield: word 2
+		GteDelay_ add_ui_self(         R_TapePtr, S_(MipsCode)) // ac_yield: word 
 	),
-	mac_shift_aright_var_v3s4_self(r.res, r.half_shift),
+	mac_shift_aright_var_v3s4_self(r.res, r.srav_shift),
 	mac_store_v3s4(r.res, r.dst_ptr, 0),
 
 	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
-	// mac_yield()
 })
 
+
 /* ─── GTE OP cross product (a × b → out) ───
  * Generalized V3_S4 cross product via GTE OP (OuterProduct12 libpsyx convention).
  * The >> 12 shift converts S12.20 → S12.0 OuterProduct12. */
@@ -340,21 +369,21 @@ typedef Struct_(Binds_gte_cross_v3s4) { V3_S4* src_a; V3_S4* src_b; V3_S4* out;
 typedef Struct_(RegUse_gte_cross_v3s4) {
 	Reg_(V3_S4) a;
 	Reg_(V3_S4) b;
-	union { Reg out, t0; } x;
-	union { Reg src_a, t1, rt11; } y;
-	union { Reg src_b, t2, rt22; } z;
+	Reg out;
+	Reg src_a;
+	Reg src_b;
 };
 internal MipsAtom* gte_cross_v3s4(AtomArena_R aa, RegUse_gte_cross_v3s4 r)
 atom_info(atom_bind(Binds_gte_cross_v3s4)) MipsAtom_Proc_(aa, {
-	load_word(r.y.src_a,  R_TapePtr, O_(Binds_gte_cross_v3s4,src_a)),
-	load_word(r.z.src_b,  R_TapePtr, O_(Binds_gte_cross_v3s4,src_b)),
-	load_word(r.x.out,    R_TapePtr, O_(Binds_gte_cross_v3s4,out)),
-	LdSlot_ add_ui_self(  R_TapePtr, S_(Binds_gte_cross_v3s4)),
+	load_word(r.src_a,  R_TapePtr, O_(Binds_gte_cross_v3s4,src_a)),
+	load_word(r.src_b,  R_TapePtr, O_(Binds_gte_cross_v3s4,src_b)),
+	load_word(r.out,    R_TapePtr, O_(Binds_gte_cross_v3s4,out)),
+	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_gte_cross_v3s4)),
 
-	mac_load_v3s4(r.a, r.y.src_a, 0), LdSlot_
-	mac_load_v3s4(r.b, r.z.src_b, 0), LdSlot_
+	mac_load_v3s4(r.a, r.src_a, 0), LdSlot_
+	mac_load_v3s4(r.b, r.src_b, 0), LdSlot_
 	mac_gte_op_cross_v3s4(r.a, r.b), /* RT diagonal + IR + OP + MAC read + shift */
-	mac_store_v3s4(r.a, r.x.out, 0),
+	mac_store_v3s4(r.a, r.out, 0),
 
 	mac_yield()
 })

code/duffle/gte.h

@@ -1,21 +1,10 @@
 /* ============================================================================
  *  duffle DSL Suffix Conventions
  *  ============================================================================
- *
  *  Every mnemonic in this header follows the same suffix grammar:
  *
  *  Primitive commands: gp0_cmd_poly_f3 = 0x20    (byte opcode)
  *  Packed 32-bit cmd:  gp0_word_poly_f3(r, g, b) (32-bit, shifted)
- *
- *  Type ordering: domain?_(direction)?_action_target_modifier_type?
- *  Examples: add_ui             (add + unsigned + immediate)
- *            add_s              (add + signed, R-type implicit)
- *            shift_lleft        (shift + logical + left)
- *            shift_aright       (shift + arithmetic + right)
- *            call_reg(rs)       (call + register, $ra implicit)
- *            gte_mv_to_data_r   (gte + mv + to + data + register)
- *            gte_lw_v0_xy(base) (gte + lw + v0 + xy)
- *            load_upper_i       (load-upper + immediate, unique verb)
  * ============================================================================ */
 
 #ifdef INTELLISENSE_DIRECTIVES
@@ -29,21 +18,7 @@
 /* ============================================================================
  *  gte.h — Geometry Transformation Engine (COP2) for the PS1
  * ============================================================================
- *
- *  Hand-rolled DSL for emitting GTE/MIPS instruction words from C.
- *  No GCC inline-assembly string syntax in the code body.
- *
- *  STYLE NOTES
- *  -----------
- *  - Per-field encoders are named `enc_gte_<field>(value)` and each one self-masks its argument before shifting.
- *    Mirrors the `enc_op / enc_rs / enc_rt / ...` family in mips.h.
- *  - The composite `enc_gte_cmdw(sf, mx, v, cv, lm, cmd)` is a flat OR of the per-field encoders, plus the COP2/CO base.
- *  - Pre-baked shortcuts (`gte_cmd_rtpt`, `gte_cmd_rtps`, …) are defined for the common cases so call sites read like assembly source.
- *  - All register/field values are enums (not `#define`s) so they show up in debugger symbol tables and IDE autocomplete.
- *
- *  SEE ALSO
- *  --------
- *  - mips.h: The MIPS encoder layer this builds on.
+ *  DSL for emitting GTE/MIPS instruction words from C.
  */
 
 /* C2 data registers */
@@ -170,20 +145,20 @@ enum {
  *   +------------+--+-----+------+------+------+------+---+--------+----------+
  *                                    \_____ GTE_PAYLOAD _____/       \__ GTE_CMD __/
  *
- * Shifts/masks below are the *bit positions* and *bit widths* of each configurable field, used by the ENC_GTE_CMD encoder. 
- * Mirrors the OPCODE_SHIFT / RS_SHIFT convention used in mips.h.
+ * Offset position & masks below are the *bit positions* and *bit widths* of each configurable field, used by the ENC_GTE_CMD encoder. 
+ * Mirrors the OPCODE_POS / RS_POS convention used in mips.h.
  */
 
-	gte_shift_sf  = 19,  gte_width_sf  = 1,
-	gte_shift_mx  = 17,  gte_width_mx  = 2,
-	gte_shift_v   = 15,  gte_width_v   = 2,
-	gte_shift_cv  = 13,  gte_width_cv  = 2,
-	gte_shift_lm  = 10,  gte_width_lm  = 1,
-	gte_shift_cmd =  0,  gte_width_cmd = 6,
+	gte_pos_sf  = 19,  gte_width_sf  = 1,
+	gte_pos_mx  = 17,  gte_width_mx  = 2,
+	gte_pos_v   = 15,  gte_width_v   = 2,
+	gte_pos_cv  = 13,  gte_width_cv  = 2,
+	gte_pos_lm  = 10,  gte_width_lm  = 1,
+	gte_pos_cmd =  0,  gte_width_cmd = 6,
 
 	/* Fake command number (bits 24-20) — IGNORED by the GTE hardware per PSX-SPX `geometrytransformationenginegte.md` line 48.
 	 * libgte's compiler emits non-zero values in this field as a disassembly signature. */
-	gte_shift_fake_cmd = 20,
+	gte_pos_fake_cmd   = 20,
 	gte_width_fake_cmd = 5,
 };
 
@@ -340,13 +315,13 @@ enum { _C2_TX_SUBS_ = 0
 #define gte_cmd_base (enc_op(op_cop2) | (1 << 25))
 
 /* Per-field encoders. Each one does (value & mask) << shift on its own. */
-#define enc_gte_sf(sf)      ((sf)  << gte_shift_sf )
-#define enc_gte_mx(mx)      ((mx)  << gte_shift_mx )
-#define enc_gte_v(v)        ((v)   << gte_shift_v  )
-#define enc_gte_cv(cv)      ((cv)  << gte_shift_cv )
-#define enc_gte_lm(lm)      ((lm)  << gte_shift_lm )
-#define enc_gte_cmd(cmd)    ((cmd) << gte_shift_cmd )
-#define enc_gte_fake_cmd(x) ((x)   << gte_shift_fake_cmd)
+#define enc_gte_sf(sf)      ((sf)  << gte_pos_sf )
+#define enc_gte_mx(mx)      ((mx)  << gte_pos_mx )
+#define enc_gte_v(v)        ((v)   << gte_pos_v  )
+#define enc_gte_cv(cv)      ((cv)  << gte_pos_cv )
+#define enc_gte_lm(lm)      ((lm)  << gte_pos_lm )
+#define enc_gte_cmd(cmd)    ((cmd) << gte_pos_cmd )
+#define enc_gte_fake_cmd(x) ((x)   << gte_pos_fake_cmd)
 
 /* Composite: all six GTE fields + the COP2/CO base. */
 #define enc_gte_cmdw(sf, mx, v, cv, lm, cmd) ( \

code/duffle/math.atom.h

@@ -2,7 +2,7 @@
 #	include "gen/macs.h"
 #	include "gen/offsets.h"
 #	include "math.h"
-#	include "lottes_tape.h"
+#	include "tape.h"
 #endif
 
 ATOM_FILE_DEBUGGER_LINE_MARKER(math_atom_c);

code/duffle/memory.h

@@ -5,7 +5,7 @@
 
 #define MEM_ALIGNMENT_DEFAULT  4
 
-#define assert_bounds(point, start, end) for(;0;){ \
+#define assert_bounds(point, start, end) do{ \
 	assert((start) <= (point)); \
 	assert((point) <= (end));   \
 } while(0)
@@ -23,10 +23,10 @@ FI_ void mem_bump(U4 cap, U4*R_ used, U4 amount) {
 	used[0] += amount; 
 }
 
-FI_ U4 mem_copy            (U4 dest, U4 src,   U4 len) { return (U4)(__builtin_memcpy ((void*)dest, (void const*)src,   len)); }
-FI_ U4 mem_copy_overlapping(U4 dest, U4 src,   U4 len) { return (U4)(__builtin_memmove((void*)dest, (void const*)src,   len)); }
-FI_ U4 mem_fill            (U4 dest, U4 value, U4 len) { return (U4)(__builtin_memset ((void*)dest, (int)        value, len)); }
-FI_ B4 mem_zero            (U4 dest,           U4 len) { if(dest == 0){return false;} mem_fill(dest, 0, len); return true; }
+FI_ U4 mem_copy            (U1_R dest, U1_R src, U4 len) { return (U4)(__builtin_memcpy ((void*)dest, (void const*)src,   len)); }
+FI_ U4 mem_copy_overlapping(U1*  dest, U1*  src, U4 len) { return (U4)(__builtin_memmove((void*)dest, (void const*)src,   len)); }
+FI_ U4 mem_fill            (U1_R dest, U4 value, U4 len) { return (U4)(__builtin_memset ((void*)dest, (int)        value, len)); }
+FI_ B4 mem_zero            (U1_R dest,           U4 len) { if(dest == 0){return false;} mem_fill(dest, 0, len); return true; }
 
 #pragma region DAG
 
@@ -58,31 +58,30 @@ typedef Struct_(Str8)        { UTF8* ptr; U4 len; };
 typedef Struct_(Slice_Str8)  { Str8* ptr; U4 len; };
 #define slit(string_literal) (Str8){ (UTF8*) string_literal, S_(string_literal) - 1 }
 
-typedef Struct_(Slice) { B1* ptr; U4 len; }; // Untyped Slice (byte-addressable; .len in elements)
-FI_ Slice slice_ut_(U4 ptr, U4 len) { return (Slice){(B1*)ptr, len}; }
+typedef Struct_(Slice) { U1* ptr; U4 len; };
+FI_ Slice slice_ut_(U1* ptr, U4 len) { return (Slice){ptr, len}; }
 
 #define Slice_(type)       Struct_(tmpl(Slice,type)) { type* ptr; U4 len; }
-typedef Slice_(B1);
 #define slice_assert(s)    do { assert((s).ptr != 0); assert((s).len > 0); } while(0)
-#define slice_end(slice)   ((slice).ptr + S_slice(slice) / S_(B1))  /* byte-ptr arithmetic; .len is in elements per slice convention */
+#define slice_end(slice)   ((slice).ptr + S_slice(slice))
 #define S_slice(s)         ((s).len * S_((s).ptr[0]))
 
-#define slice_ut(ptr,len)  slice_ut_(u4_(ptr),     u4_(len))
-#define slice_ut_arr(a)    slice_ut_(u4_(a),       S_(a))
-#define slice_to_ut(s)     slice_ut_(u4_((s).ptr), S_slice(s))
+#define slice_ut(ptr,len)  slice_ut_(C_(U1*,ptr),    u4_(len))
+#define slice_ut_arr(a)    slice_ut_(C_(U1*,a),       S_(a))
+#define slice_to_ut(s)     slice_ut_(C_(U1*,(s).ptr), S_slice(s))
 
 #define slice_iter(container, iter)     (T_((container).ptr) iter = (container).ptr; iter != slice_end(container); ++ iter)
 #define slice_arg_from_array(type, ...) & (tmpl(Slice,type)) { .ptr = Array_decl(type,__VA_ARGS__), .len = Array_len( Array_decl(type,__VA_ARGS__)) }
 #define slice_from_array(type, array)     (tmpl(Slice,type)) { .ptr = array, .len = Array_len(array) }
 
-FI_ void slice_zero_(Slice s) { slice_assert(s); mem_zero(u4_(s.ptr), s.len); }
+FI_ void slice_zero_(Slice s) { slice_assert(s); mem_zero(s.ptr, s.len); }
 #define  slice_zero(s)        slice_zero_(slice_to_ut(s))
 
 FI_ void slice_copy_(Slice dest, Slice src) {
 	assert(S_slice(dest) >= S_slice(src));
 	slice_assert(dest);
 	slice_assert(src);
-	mem_copy(u4_(dest.ptr), u4_(src.ptr), S_slice(src));
+	mem_copy(dest.ptr, src.ptr, S_slice(src));
 }
 #define slice_copy(dest, src) do {  \
 	static_assert(T_same(dest, src)); \
@@ -95,6 +94,7 @@ FI_ Slice slice_bump(U4_R used, U4 start, U4 len, U4 amount) {
 	return slice_ut(ptr, amount);
 }
 
+typedef Slice_(B1);
 typedef Slice_(U1);
 typedef Slice_(U4);
 
@@ -117,7 +117,7 @@ I_  Slice farena_push(FArena_R arena, U4 amount, Opt_farena o) {
 	U4 to_commit = align_pow2(desired, o.alignment ?  o.alignment : MEM_ALIGNMENT_DEFAULT);
 	U4 ptr       = arena->start + arena->used;
 	mem_bump(arena->capacity, & arena->used, to_commit);
-	return (Slice){ (B1*)ptr, to_commit };
+	return (Slice){ (U1*)ptr, to_commit };
 }
 FI_ void farena_reset (FArena_R arena) { arena->used = 0; }
 FI_ void farena_rewind(FArena_R arena, U4 save_point) {
@@ -134,8 +134,7 @@ FI_ U4 farena_unused_start(FArena arena) { return arena.start + arena.used; }
 
 #pragma region BIOS Scratchpad
 /* BIOS scratchpad location. 1 KB at 0x1F800000.
- * TapeHostFrame occupies the final 44 bytes while tape code executes.
- * Atom scratch is bounded by the TapeHostFrame_Loc declaration in lottes_tape.h. */
+ * TapeHostFrame occupies the final 44 bytes while tape code executes. */
 enum {
 	Scratchpad_Loc = 0x1F800000,
 	Scratchpad_Len = 0x400,                             /* 1 KB */

code/duffle/mips.atom.c

@@ -3,7 +3,7 @@
 #		include "gen/offsets.h"
 #	include "bios.h"
 #	include "mips.h"
-#	include "lottes_tape.h"
+#	include "tape.h"
 #endif
 
 ATOM_FILE_DEBUGGER_LINE_MARKER(mips_atom_c);

code/duffle/mips.h

@@ -81,13 +81,8 @@ enum {
  *  (e.g. for asm clobber lists and register-variable declarations via `rgcc(R_X)`).
  *  The enum value is bound to the `#define` so the two forms cannot drift apart.
  * 
- *  Only registers that get stringified need a `_Code` form; the rest are plain enum values.
- *  If you need to add a new one, follow the pattern:
- *      #define R_T7_Code 15
- *      R_T7 = R_T7_Code,     // in the enum
- *
  *  User code should always reference the enum form (`R_T4`) at arithmetic sites and let
- *  `rlit(R_T4_Code)` / `rgcc(R_T4)` handle the stringify cases — never write the bare number `12`.
+ *  `rlit(R_T4_Code)` / `rgcc(R_T4)` handle the stringify cases
  * ============================================================================ */
 #define R_0_Code    0
 #define R_AT_Code   1
@@ -252,12 +247,12 @@ enum {
 enum { _BitOffsets = 0
 /* Bit Offsets for MIPS Instruction Fields */
 
-	, OPCODE_SHIFT = 26
-	, RS_SHIFT     = 21
-	, RT_SHIFT     = 16
-	, RD_SHIFT     = 11
-	, SHAMT_SHIFT  = 6  /* Shift Amount */
-	, FC_SHIFT     = 0
+	, OPCODE_POS = 26
+	, RS_POS     = 21
+	, RT_POS     = 16
+	, RD_POS     = 11
+	, SHAMT_POS  = 6  /* Shift Amount: Offset Position */
+	, FC_POS     = 0
 
 /* IMM_MASK is the 16-bit two's-complement truncation for the immediate field.
  * It is NOT a range guard — it is load-bearing for negative branch offsets
@@ -268,12 +263,12 @@ enum { _BitOffsets = 0
 	, IMM_MASK     = 0xFFFF
 };
 
-#define enc_op(op)       ((op)    << OPCODE_SHIFT)
-#define enc_rs(rs)       ((rs)    << RS_SHIFT)
-#define enc_rt(rt)       ((rt)    << RT_SHIFT)
-#define enc_rd(rd)       ((rd)    << RD_SHIFT)
-#define enc_shamt(shamt) ((shamt) << SHAMT_SHIFT)
-#define enc_fc(fc)       ((fc)    << FC_SHIFT)
+#define enc_op(op)       ((op)    << OPCODE_POS)
+#define enc_rs(rs)       ((rs)    << RS_POS)
+#define enc_rt(rt)       ((rt)    << RT_POS)
+#define enc_rd(rd)       ((rd)    << RD_POS)
+#define enc_shamt(shamt) ((shamt) << SHAMT_POS)
+#define enc_fc(fc)       ((fc)    << FC_POS)
 #define enc_imm(imm)     ((imm) & IMM_MASK)
 
 /* MIPS R-Type Instruction Format (Register-to-Register) */

code/duffle/pad.atom.c

@@ -3,7 +3,7 @@
 #		include "gen/offsets.h"
 #	include "mips.h"
 #	include "dsl.atom.h"
-#	include "lottes_tape.h"
+#	include "tape.h"
 #	include "pad.h"
 #endif
 

code/duffle/pad.c

@@ -6,16 +6,10 @@
 #	include "pad.h"
 #endif
 
-/* Uses ONE 8-byte frame allocated via the compiler's standard prologue.
+/* Uses an 8-byte frame allocated via the compiler's standard prologue.
  * 4 wasted-arg words for B(12h) InitPAD2 are at [SP+0..15] but are not explicitly allocated.
  * Compiler handles the MIPS O32 "wasted stack" convention for us by treating the B-call as a 4-arg call.
- *
- * The buffer pointers are passed as arguments so the compiler keeps them in callee-saved registers;
- * The B(12h) asm volatile block does NOT clobber those registers (it clobbers only the volatile GPRs + B-table arg registers explicitly).
- * The C-level writes after the call re-load the pointers from their callee-saved homes.
- *
- * The clobber list for both B-calls names the full BIOS destroy set documented in kernelbios.md:167-174 (R1..R15, R24..R25, R31, HI/LO).
- * The kernel-ABI "volatile GPRs" subset is clb_mem_drain; the rest of the destroy set is enumerated explicitly here. */
+ */
 NI_ void pad_bios_init_start(PadBiosRaw* raw0, PadBiosRaw* raw1)
 {
 	/* Pin raw0 + raw1 to $a0 + $a1 via rgcc; the B(12h) call uses these directly.
@@ -24,9 +18,6 @@ NI_ void pad_bios_init_start(PadBiosRaw* raw0, PadBiosRaw* raw1)
 	register PadBiosRaw* p1 rgcc(R_A1) = raw1;
 	(void)p0; (void)p1;
 
-	// TODO(Ed): Properly annotate the raw values in the inline asm instructions.
-	// Use enums.
-
 	/* B(12h) InitPAD2(raw0, 0x22, raw1, 0x22)
 	 *   $a0 = raw0 (rgcc-bound; survives the sequence below)
 	 *   $a1 = raw1 (preserved into $a2 before $a1 is overwritten)

code/duffle/pad.h

@@ -4,10 +4,7 @@
 #	include "math.h"
 #endif
 
-/* PSX button bit positions — 1:1 with PSX-SPX docs at docs/psx-spx/docs/controllersandmemorycards.md:405-421.
- * Wire is active-low (0 = pressed).
- * The decoder atom computes buttons = (~raw_buttons) & 0xFFFF; 
- * active-low-to-active-high inversion is applied bit-by-bit. */
+// PSX button bit positions: PSX-SPX docs/psx-spx/docs/controllersandmemorycards.md:405-421.
 typedef Enum_(U2, PadBtns) {
 	Bit_(Pad_Select,    0),
 	Bit_(Pad_L3,        1),
@@ -62,11 +59,7 @@ typedef Enum_(U4, PadStatus) {
 	PadStatus_Invalid,
 };
 
-/* Distinct from the game-facing PadStatus enum: PadRawStatus_Ok and PadRawStatus_Timeout are raw BIOS values;
- * PadStatus_* are game-facing post-decode states. PadUnknownId_Sentinel is written by the decoder 
- * when the controller id does not match any known controller type.
- * PadAxisCentered_Word: Four-byte 0x80 pattern used to clear / center 
- * four byte axes at PadState.left_x through PadState.right_y. */
+// Distinct from the game-facing PadStatus enum: PadRawStatus_Ok and PadRawStatus_Timeout are raw BIOS values
 typedef Enum_(U1, PadRawStatus) {
 	PadRawStatus_Ok      = 0x00,
 	PadRawStatus_Timeout = 0xFF,

code/duffle/psyq.h

@@ -104,7 +104,7 @@ void gte_matrix_set_translation(MT3_S2S4* mat) asm("SetTransMatrix");
 
 // Einheit, Metrication to unit vector. "Normalization", not Orthogonal "Normal, Normalis". Directionalization.
 // RGA(Lengyel): Normalize the bulk of a zero-weight direction. This is not finite-point unitization (which forces w=1).
-S4 normalize_v3s4(V3_S4* v0, V3_S4* v1) asm("VectorNormal");
+S4 psy_normalize_v3s4(V3_S4* v0, V3_S4* v1) asm("VectorNormal");
 
 // RGA(Lengyel): Apply the matrix expansion of a rigid transformation.
 // Motor antiproduct is equivalent for unitized points; LA form is what GTE consumes.

code/duffle/tape.h

@@ -13,56 +13,32 @@
 
 #pragma region Tape Drive
 /* -----------------------------------------------------------------------------------------------------------
- *  TAPE DRIVE ABI
+ *  THREADED ATOMS - TAPE EXECUTION & ABI
+ *  _________
+ * |   ___   |         
+ * |  o___o  |              ,-----<-----.
+ * |__/___\__|              V           ^
+ *          \_[Enter]_[A]->[A]->[A]->[A(B)]->[A]->[Exit]
  * -----------------------------------------------------------------------------------------------------------
- * Note(Ed): One of the main purposes of this codebase is to help me learn this, 
- * as such the information below may not* be entirely realized or finalized conceptually.
- * -----------------------------------------------------------------------------------------------------------
- * This ABI and its associated legos were directly inspired by researching the work of 
- * Timothy Lottes and Onat Türkçüoğlu; along with many others. It's the simplest bootstrap of a 
- * directly executed chain of assemby arrays (Atoms) that terminate with a yield sequence to the next atom.
- * These eventually lead to a terminal atom for the tape which is defined below as "tape_exit".
+ * This ABI and its associated legos were directly inspired by researching the work of Timothy Lottes and
+ * Onat Türkçüoğlu; Forth, threaded code system, and various other people or programming techniques.
+ * 
+ * The setup is simple: 
+ * A tape is a linear stream containing addresses of directly executable native-code fragments ("Atoms").
+ * Most atoms terminate in a small yield sequence which loads the next atom address from the tape.
+ * It's a runtime composed of directly executed native machine-code sequences (Atoms) that usually terminate 
+ * in a yield sequence to the next atom. These eventually lead to a terminal atom for the tape
+ * which is defined below as "tape_exit". Traditionally referred to as Direct Threaded Execution.
  * 
  * It behaves as one of the simplest runtime harnesses ontop of a host-enviornment's execution engine 
  * to author and compose programs with. From here various conventions can be further applied. 
- * To make things easier  to understand it may be better to focus on what this ABI does not have. 
- * It does not have have any branching within the tape but relative branches within atoms or between atoms.
- * Branching nearly is always downstream. Automatic stack usage is non-existent.
- * Push/Pop, FIFO, or Arena/Bump data structures are used by atoms explicitly.
- * In it's current form with the C11 macro DSL, the user also has fullfill manual register allocation per atom.
- * 
- * One of the remarkable things about utilizing this ABI is its essentially interopable with CPUs, GPUs, FPGA, 
- * or, basically anything from the 5th generation consoles and onward.
- * The ABI directly reflects how all computational hardware must be architected in order to execute 
- * digital logic effectively on current era tech.
- * On the PS1 we don't have access to a few features like multi-threading, speculative execution, or L3 cache;
- * but, we can set the foundation for legoing whats required for eventually expanding this ABI's paradigm 
- * and core atoms to take those newer hardware features into account. For example, you can easily expand 
- * this to support wave-based execution model on a PS2 or PS3. Not having a stack or 
- * automatic register allocation means the user cannot ignore excessive argument shuffle across workload or
- * waves and thier phases. Crossing ABI boundaries to other runtimes that do has obviouss penalties.
- * 
- * Learning data-oriented code becomes a natural progression. Your not fighting a stack-based procedural 
- * paradigm that wants to argument shuffle. There is no ambiguity due to the lack of constraints, for example,
- * on how the user may "call" a procedure in traditional random dispatch runtimes. The user does have to
- * hammer down "rules" or patterns for massaging the compiler to dissolve those call frames; just to get 
- * the asesmbly into its desired form. The form is obvious, and once the user gets to author these compoonents
- * it becomes a game of tetris.
- * 
- * Another feature is this ABI is very compatible with bootstrapping and developing simple toolchains built off
- * of bit-packed annotated command streams the user can directly author, maintatain, and immediately execute.
- * That being like a color forth, or maybe something more familar like an immediate mode library 
- * for various systems such as GUIs. This can make the tetris less of a chore with some helpful policy
- * generation for allocation of registers, helping to choose resuable components, designing DSL on the fly, etc.
- * -----------------------------------------------------------------------------------------------------------
- * TODO(Ed): We need pretty ascii diagrams and proper guides, articles, etc.
- * -----------------------------------------------------------------------------------------------------------
- * For now this ideation has just started functioning. I'm abusing C11 & a lua metaprogram to help establish 
- * a hybrid toolchain to ideate on a traditional text-based authoring UX for this paradigm.
- * If pcsx-redux provides viable hot-reload and persistent data storage beyond save-states
- * (just copying ram to filesystem), I can author a color forth to mess around with.
- * With either an editor in-emulator or on the actual machine itself. Assembly is tedius,
- * but I think this codebase most likely has a pretty ergonomic flavor worst case...
+ * To make things easier to understand it may be better to focus on what this ABI does not have. 
+ * The tape itself does not have have any branching behavior.
+ * Branches, loops, skips, or other control-flow policies must be implemented explicitly by atoms.
+ * Push/Pop, FIFO, or Arena/Bump data structures are utilized by atoms explicitly.
+ * There is no implicit call-stack, return stack, or per-atom stack-frame.
+ * The user must also explictly handle register allocation per atom (by default). 
+ * However they could procedurally automate it using metaprogramming functionality.
  * */
 /* Register Allocation Info */
 enum {
@@ -99,8 +75,8 @@ enum {
 	R_Atom7  = R_T7,
 	R_Atom8  = R_T8,
 	R_Atom9  = R_T9,
-	R_Atom10 = R_V0, // Tend to be used with gte DMAs
-	R_Atom11 = R_V1, // Tend to be used with gte DMAs
+	R_Atom10 = R_V0, // Tend to be used with gte moves
+	R_Atom11 = R_V1, // Tend to be used with gte moves
 	R_Atom12 = R_A0,
 	R_Atom13 = R_A1,
 	R_Atom14 = R_A2,
@@ -121,7 +97,7 @@ typedef U2 Reg; // Register parameter used with atom or atom component procedure
 typedef U4 const MipsCode; // Underlying type to mips asm words.
 typedef Slice_(MipsCode);
 
-typedef U4 const MipsAtom; // Underlying type to a mips atom defnition 
+typedef U4 const MipsAtom; // Underlying type to a mips atom definition 
 typedef Slice_(MipsAtom);
 
 // Sometimes a user will define a bundle of atoms that represent a procedure of work as:
@@ -163,6 +139,12 @@ typedef Slice_(MipsAtom);
 // Used for trivial mappings from one atom component proc to the command of a more baser (meant for type-mapping)
 #define MipsAtomComp_ProcMap_(ab, base_command) atom_dbg_skip MipsAtomComp_Proc_(ab, {base_command })
 
+// WIP: Atoms Assocated closely with each other to form a tape procedure. (Maybe also a phase in a procedure/pipeline?)
+
+#define AtomBundle_(name)              Struct_(tmpl(AtomBundle,name))
+#define AtomBundle_Len(name)           S_(tmpl(AtomBundle,name))/S_(MipsAtom*)
+#define AtomBundleEntry_(bundle,entry) tmpl(bundle,entry)
+
 /* Line-table anchor: gcc only adds a file to the .debug_line file table when the contains line-numbered content.
 	Files containing only atoms and atom components.
    Place `ATOM_FILE_LINE_MARKER();` once at file scope in any `.atom.c` that defines atoms.
@@ -170,7 +152,7 @@ typedef Slice_(MipsAtom);
 	 The constant is in `.rodata` so the linker may eliminate it. */
 #define ATOM_FILE_DEBUGGER_LINE_MARKER(file_name) internal U4 const tmpl(atom_file_debugger_line_marker,file_name) = 0
 
-typedef Slice_MipsAtom Tape;
+typedef Struct_(Tape) { union { MipsAtom* ptr; U4* inlaid_data; }; U4 len; };
 
 typedef Struct_(TapeHostFrame) {
 	U4 s0;
@@ -236,22 +218,27 @@ FI_ void tape_run(Tape tape) { C_(TapeEntryFn*, tape_enter)(tape.ptr); }
 // Procedural authoring of tapes:
 typedef Relative_(FArena) Struct_(TapeBuilder) { U4 ptr; U4 capacity; U4 used; };
 FI_ void        tb_init(TapeBuilder* tb, FArena* arena) { tb->ptr = arena->start; tb->used = 0; }
-FI_ TapeBuilder tb_make_old(             FArena* arena) { return (TapeBuilder){ arena->start, 0 }; }
 FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ u4_(mem.ptr), mem.len, 0 }; }  /* capacity in elements (matches used units) */
 
 FI_ void tb_emit(TapeBuilder* tb, MipsAtom* atom) { u4_r(tb->ptr)[tb->used] = u4_(atom); ++ tb->used; }
 FI_ void tb_data(TapeBuilder* tb, U4        data) { u4_r(tb->ptr)[tb->used] = u4_(data); ++ tb->used; }
 #define tb_emit_(atom)        tb_emit(& tb, atom)
-#define tb_data_(field, data) tb_data(& tb, u4_(data))
 
-FI_ void tb_emit_bundle(TapeBuilder_R tb, Slice_MipsAtom atoms) { mem_copy(u4_(tb->ptr), u4_(atoms.ptr), S_slice(atoms)); tb->used += atoms.len; }
+FI_ void tb_bind(TapeBuilder* tb, Slice data) { mem_copy(b1_r(tb->ptr + tb->used * S_(MipsCode)), data.ptr, data.len); tb->used += data.len / S_(MipsCode); }
+#define tb_bind_(tb,type,...) tb_bind(tb, (Slice){ (U1*)(& (type){__VA_ARGS__}), S_(type) }); static_assert(S_(type) % S_(MipsCode) == 0)
 
 FI_ Tape tb_end  (TapeBuilder* tb) { tb_emit(tb,tape_exit); return (Tape){ C_(U4*,tb->ptr), tb->used }; }
 FI_ Tape tb_slice(TapeBuilder  tb) {                        return (Tape){ C_(U4*,tb.ptr),  tb.used }; }
-#define tb_scope(tb)     for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,tape_exit))
+#define tb_scope(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_emit(tb,tape_exit))
 
 FI_ void tb_scope_run_end(TapeBuilder* tb) { tb_emit(tb,tape_exit); tape_run(tb_slice(tb[0])); }
 #define tb_scope_run(tb) for(U4 tbs_once=0;tbs_once==0;++tbs_once,tb_scope_run_end(tb))
+
+
+// NOTE(Ed): Wip still ideating convention. Possibly will never use a composite.
+#define tb_emit_wbind_(tb,atom,...)       tb_emit(tb,atom); tb_bind_(tb,tmpl(Binds,atom),__VA_ARGS__)
+#define tb_emit_wbind2_(tb,atom,type,...) tb_emit(tb,atom); tb_bind_(tb,type,__VA_ARGS__)
+
 #pragma endregion Tape Drive
 
 #pragma region Macro Mips Atom Components
@@ -261,6 +248,7 @@ FI_ void tb_scope_run_end(TapeBuilder* tb) { tb_emit(tb,tape_exit); tape_run(tb_
  * ---------------------------------------------------------------------------*/
 
 // The 'Yield' sequence for Tape Atoms (mac_yield). 
+// In Forth this is considered the "NEXT" mechanism.
 
 atom_dbg_skip MipsAtomComp_(ac_yield) {
 	load_word(R_AtomJmp, R_TapePtr, 0), LdSlot_
@@ -289,7 +277,7 @@ typedef Relative_(FArena) Struct_(AtomBuilder) { U4 start; U4 capacity; U4 used;
 FI_ void atombuilder_push(AtomBuilder_R ab, Slice_MipsCode code) {
 	assert(ab->capacity - ab->used - code.len);
 	U4 dest = ab->start + ab->used * S_(MipsCode); U4 size = S_slice(code);
-	mem_copy(dest, u4_(code.ptr), size); ab->used += size;
+	mem_copy(b1_r(dest), b1_r(code.ptr), size); ab->used += size;
 }
 #define atombuilder_push_mac(ab, mac) atombuilder_push(ab, slice_arg_from_array(Slice_MipsCode, mac))
 
@@ -313,7 +301,7 @@ FI_ AtomArena atomarena_make(Slice mem) { AtomArena a; atomarena_init(& a, mem);
 FI_ MipsAtom* atomarena_push(AtomArena_R aa, Slice_MipsCode code) {
 	assert(aa->capacity - aa->used - code.len);
 	U4 dest = atomarena_unused_start(aa[0]); U4 size = S_slice(code);
-	mem_copy(dest, u4_(code.ptr), size); aa->used += size;
+	mem_copy(b1_r(dest), b1_r(code.ptr), size); aa->used += size;
 	return C_(MipsAtom*, dest);
 }
 FI_ void atomarena_reset(AtomArena_R aa) { aa->used = 0; }
@@ -344,24 +332,14 @@ internal Reg const regfile_alloc_order[] = {
 	R_T8, R_T9,
 };
 
-typedef Struct_(RegFile) {
-	A2_U2 GPR;
-	A2_U2 GTE;
-};
+typedef Struct_(RegFile) { A2_U2 GPR; };
 #define regfile(pin_mask) {.GPR={u4_lo(pin_mask), u4_hi(pin_mask)} }
 FI_ void regfile_init(RegFile_R rf) {
-	/* pack the 32-bit ABI mask into the two U2s */
-	rf->GPR[0] = u4_lo(regfile_abi_mask);
-	rf->GPR[1] = u4_hi(regfile_abi_mask);
-	rf->GTE[0] = rf->GTE[1] = 0;
+	rf->GPR[0] = u4_lo(regfile_abi_mask); rf->GPR[1] = u4_hi(regfile_abi_mask);
 }
 FI_ RegFile regfile_make(void) { RegFile rf; regfile_init(& rf); return rf; }
 
-typedef Struct_(RegFile_RInfo) {
-	U2_R section;
-	U2   mask;
-	B2   occupied;
-};
+typedef Struct_(RegFile_RInfo) { U2_R section; U2 mask; B2 occupied; };
 FI_ RegFile_RInfo regfile_rinfo(A2_U2 file, Reg r_id) {
 	U2   s_id     = r_id >> 4;
 	U2_R section  = & file[s_id];
@@ -371,19 +349,11 @@ FI_ RegFile_RInfo regfile_rinfo(A2_U2 file, Reg r_id) {
 }
 FI_ Reg regfile__alloc_helper(A2_U2 file, Reg r_id) {
 	Reg result = 0; RegFile_RInfo info = regfile_rinfo(file, r_id);
-	if (info.occupied == false) {
-		info.section[0] |= info.mask;
-		result           = r_id;
-	}
+	if (info.occupied == false) { info.section[0] |= info.mask; result = r_id; }
 	return result; 
 }
-/* regfile_alloc picks the next free GPR from regfile_alloc_order.
- * The table is the first-fit allocation order: T0..T7, V0..V1, A0..A3,
- * S0..S7, T8..T9. The 24 entries leave room for the tape program to use
- * any of them while R0, R1, R26-R31 remain reserved. */
 I_ Reg regfile_alloc(RegFile_R rf) { 
-	Reg allocated = 0;
-	for index_iter(U4, r_id, R_V0, <, R_T9) {
+	Reg allocated = 0; for index_iter(U4, r_id, R_V0, <, R_T9) {
 		allocated = regfile__alloc_helper(rf->GPR, r_id);
 		Jmp_nZero_(allocated,resolved);
 	}
@@ -397,8 +367,7 @@ FI_ Reg regfile_pin(RegFile_R rf, Reg r_id) {
 	return r_id;
 }
 FI_ void regfile_pin_mask(RegFile_R rf, U4 mask) {
-	B4 occupied = u4_r(rf->GPR)[0] & mask;
-	assert(occupied == false);
+	B4 occupied = u4_r(rf->GPR)[0] & mask; assert(occupied == false);
 	u4_r(rf->GPR)[0] |= mask;
 }
 FI_ void regfile_free_mask(RegFile_R rf, U4 mask) {
@@ -406,21 +375,23 @@ FI_ void regfile_free_mask(RegFile_R rf, U4 mask) {
 	u4_r(rf->GPR)[0] &= ~mask;
 }
 FI_ void regfile_free_reg(RegFile_R rf, Reg r_id) {
-	/* never free the ABI set */
-	if (regfile_abi_mask & (1u << r_id)) return;
+	if (regfile_abi_mask & (1u << r_id)) return; // never free the ABI set
 	RegFile_RInfo info = regfile_rinfo(rf->GPR, r_id);
 	info.section[0] &= ~info.mask;
 }
-FI_ void regfile_reset(RegFile_R rf) {
-	rf->GPR[0] = u4_lo(regfile_abi_mask);
-	rf->GPR[1] = u4_hi(regfile_abi_mask);
-}
-FI_ void regfile_reset_to_mask(RegFile_R rf, U4 mask) {
-	rf->GPR[0] = u4_lo(mask);
-	rf->GPR[1] = u4_hi(mask);
-}
+FI_ void regfile_reset        (RegFile_R rf)          { rf->GPR[0] = u4_lo(regfile_abi_mask); rf->GPR[1] = u4_hi(regfile_abi_mask); }
+FI_ void regfile_reset_to_mask(RegFile_R rf, U4 mask) { rf->GPR[0] = u4_lo(mask);             rf->GPR[1] = u4_hi(mask); }
 #pragma endregion RegFileArena (Register File Allocator)
 
+#pragma region Mips Atom Components (Procedures)
+
+// For doing direct-chaining of "atoms or fragments".
+FI_ Slice_MipsCode ac_yield_to(AtomBuilder_R ab, Reg code_ptr) atom_dbg_skip MipsAtomComp_Proc_(ab, {
+	jump_reg(code_ptr), BdSlot_ nop,
+})
+
+#pragma endregion Mips Atom Components (Procedures)
+
 #pragma region Mips Atom Procs
 /* RegUse structs are a convention to organize register allocations for a mips atom procedure.
 	Unlike the usual enum-based declarations, they provide a namespaced scope and have view types via union declarations. */
@@ -441,7 +412,6 @@ FI_ void regfile_reset_to_mask(RegFile_R rf, U4 mask) {
 		add_si(r.t1.view_3, r.usual_modifiable, 10),
 		mac_yield(),
 	})
-
 #pragma endregion Mips Atom Procs
 
 #pragma region Baked Mips Atoms

code/hello_camera/gen/offsets.h

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

code/hello_camera/hello_camera.atom.c

@@ -3,7 +3,7 @@
 #		include "duffle/gen/macs.h"
 #		include "duffle/gen/offsets.h"
 #	include "duffle/dsl.atom.h"
-#	include "duffle/lottes_tape.h"
+#	include "duffle/tape.h"
 #	include "duffle/mips.h"
 #	include "duffle/gte.h"
 #	include "duffle/gp.h"
@@ -11,8 +11,8 @@
 #	include "duffle/word_count.metadata.h"
 #	include "duffle/psyq.h"
 #	include "duffle/math.atom.h"
-#	include "duffle/mips.atom.c"
 #	include "duffle/gte.atom.c"
+#	include "duffle/mips.atom.c"
 #	include "duffle/gp.atom.c"
 #	include "duffle/psyq.atom.c"
 #		include "gen/offsets.h"
@@ -21,7 +21,7 @@
 #	include "hello_camera.h"
 #endif
 
-ATOM_FILE_DEBUGGER_LINE_MARKER(hello_joypad_atom_c);
+ATOM_FILE_DEBUGGER_LINE_MARKER(hello_camera_atom_c);
 
 #pragma region MACs (Mips Atom components)
 
@@ -92,11 +92,6 @@ MipsAtomComp_Proc_(ab, {
 #pragma endregion MACs
 
 #pragma region Atom Procs
-// Modular Atoms
-
-#define AtomBundle_(name)              Struct_(tmpl(AtomBundle,name))
-#define AtomBundle_Len(name)           S_(tmpl(AtomBundle,name))/S_(MipsAtom*)
-#define AtomBundleEntry_(bundle,entry) tmpl(bundle,entry)
 
 #pragma region resolve_look_at
 /* ─── resolve_look_at bundle chain atoms ──────────────────────────── */
@@ -108,7 +103,7 @@ typedef AtomBundle_(resolve_look_at) { MipsAtom
 	*normalize_right_ux,
 	*cross_to_up,
 	*normalize_up_uy,
-	*pop_mv_trans;
+	*populate_mt3s4s2;
 };
 
 typedef Struct_(ResolveLookAtScratch) {
@@ -123,71 +118,56 @@ typedef Struct_(ResolveLookAtScratch) {
 	V3_S4 up_in;
 };
 
-/* Binds_ResolveLookAtSub — what the C side pushes onto the tape before input_and_sub.
- * The scratchpad base is no longer pushed because R_ScratchBase (= R_SP) is a tape carrier
- * preserved across atoms; the atom body reads 0x1F800000 directly from R_SP. */
-typedef Struct_(Binds_ResolveLookAt) {
-	MT3_S2S4* look_at;
-	P3_S4*    eye;
-	P3_S4*    target;
-	V3_S4*    up_in;
-};
 typedef Struct_(Binds_ResolveLookAtSub) {
 	P3_S4* target;
 	P3_S4* eye;
 	V3_S4* up_in;
 };
 typedef Struct_(RegUse_resolve_look_at_input_and_sub) {
-	Reg target; Reg eye; Reg up_in;
-	Reg t0; Reg t1; Reg t2; Reg t3; Reg t4;
+	Reg target_ptr;
+	Reg eye_ptr;
+	Reg up_in_ptr;
+	union { Reg_(V3_S4) r012, up_in,  eye; };
+	union { Reg_(V3_S4) r345, target, fwd; };
 };
 /* Atom 0 in the bundle: input_and_sub. Stages C-side inputs into the scratchpad and computes fwd = target - eye. */
 internal MipsAtom* AtomBundleEntry_(resolve_look_at,input_and_sub)(AtomArena_R aa, RegUse_resolve_look_at_input_and_sub r)
 atom_info(atom_bind(Binds_ResolveLookAtSub)) MipsAtom_Proc_(aa, {
-	load_word(r.target, R_TapePtr, O_(Binds_ResolveLookAtSub,target)),
-	load_word(r.eye,    R_TapePtr, O_(Binds_ResolveLookAtSub,eye)),
-	load_word(r.up_in,  R_TapePtr, O_(Binds_ResolveLookAtSub,up_in)),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_ResolveLookAtSub)),
+	load_word(r.target_ptr, R_TapePtr, O_(Binds_ResolveLookAtSub,target)),
+	load_word(r.eye_ptr,    R_TapePtr, O_(Binds_ResolveLookAtSub,eye)),
+	load_word(r.up_in_ptr,  R_TapePtr, O_(Binds_ResolveLookAtSub,up_in)),
+	LdSlot_ add_ui_self(    R_TapePtr, S_(Binds_ResolveLookAtSub)),
 
 	/* Stage up_in.x/y/z into the scratchpad. R_ScratchBase = R_SP = 0x1F800000. */
-	mac_load_word_v3( r.t0, r.t1, r.t2, r.up_in,   0), LdSlot_
-	mac_store_word_v3(r.t0, r.t1, r.t2, R_ScratchBase, O_(ResolveLookAtScratch,up_in)),
+	mac_load_v3s4( r.up_in, r.up_in_ptr, 0), LdSlot_
+	mac_store_v3s4(r.up_in, R_ScratchBase, O_(ResolveLookAtScratch,up_in)),
 
 	// Stage eye.x/y/z into the scratchpad (atom 6 reads these for the translation column).
-	mac_load_word_v3( r.t0, r.t1, r.t2, r.eye,      0), LdSlot_
-	mac_store_word_v3(r.t0, r.t1, r.t2, R_ScratchBase, O_(ResolveLookAtScratch,eye)),
+	mac_load_v3s4( r.eye, r.eye_ptr, 0), LdSlot_
+	mac_store_v3s4(r.eye, R_ScratchBase, O_(ResolveLookAtScratch,eye)),
 
 	/* Compute fwd = target - eye. */
-	// mac_load_p3s4(t3, R_AT, t4, r.eye,    0),
-	mac_load_word_v3(r.t3, R_AT, r.t4, r.target, 0), LdSlot_
-	mac_sub_s_v3_self(
-		r.t3, R_AT, r.t4,
-		r.t0, r.t1, r.t2),
-	mac_store_word_v3(r.t3, R_AT, r.t4, R_ScratchBase, O_(ResolveLookAtScratch,fwd)),
+	mac_load_v3s4(    r.target, r.target_ptr, 0), LdSlot_
+	mac_sub_v3s4_self(r.fwd, r.eye),
+	mac_store_v3s4(   r.fwd, R_ScratchBase, O_(ResolveLookAtScratch,fwd)),
 
 	mac_yield()
 })
 
-
-typedef Struct_(Binds_ResolveLookAtPopMvTrans) {
-	U4 look_at;  /* MT3_S2S4* — destination matrix address */
+typedef Struct_(Binds_ResolveLookAt_PopulateMT3S4S2) {
+	MT3_S2S4* look_at;  /* MT3_S2S4* — destination matrix address */
 };
-typedef Struct_(RegUse_resolve_look_at__pop_mv_trans) {
+typedef Struct_(RegUse_resolve_look_at_populate_mt3s4s2) {
 	Reg         look_at;
-	Reg_(V3_S4) row;             /* populate phase: load ux/uy/uz */
-	union { Reg ux, v_x; } t6;   /* populate addr (canonical) → matrix_vector v_x */
-	union { Reg uy, v_y; } t7;   /* populate uy → matrix_vector v_y */
-	union { Reg uz, v_z; } t8;   /* populate uz → matrix_vector v_z */
-	Reg         eye;             /* matrix_vector phase: load -eye */
+	Reg         eye;            /* matrix_vector phase: load -eye */
+	Reg_(V3_S4) row;            /* populate phase: load ux/uy/uz */
+	union { Reg r0, ux, vx; }; /* populate addr → matrix_vector v_x */
+	union { Reg r1, uy, vy; }; /* populate uy   → matrix_vector v_y */
+	union { Reg r2, uz, vz; }; /* populate uz   → matrix_vector v_z */
 };
-/* Atom 6 (fused): write look_at->m[][] from ux/uy/uz as packed S2 (populate),
+/* write look_at->m[][] from ux/uy/uz as packed S2 (populate),
  * ctc2 RT chain into C2[0..4] (matrix_vector), MVMVA RT*(-eye)>>12, store off
- * directly to look_at->t[] (trans_matrix). Replaces the previous 3 separate atoms
- * (populate + matrix_vector + trans_matrix).
- *
- * MT3_S2S4 { A3x3_S2 m; A3_S4 t; }
- *   m[][] is S2 packed (9 × 2 = 18 bytes at offset 0)
- *   t[0..2]   is S4       (3 × 4 = 12 bytes at offset 18)
+ * directly to look_at->t[] (trans_matrix).
  *
  * C11 ApplyMatrixLV semantics (gte.atom.c ac_apply_matrix_lv; libgte reference):
  *   1. ctc2 RT matrix (5 ctc2s to C2[0..4])
@@ -197,82 +177,51 @@ typedef Struct_(RegUse_resolve_look_at__pop_mv_trans) {
  *   4. mtc2 to IR1/2/3, nop2, MVMVA pass2 (sf=1, mx=0, v=3, cv=3)
  *   5. mfc2 MACs → off
  *   6. store off to look_at->t[] (skip scratch.eye intermediate)
- *
- * GPR codes (assigned by resolve_look_at_init):
- *   r_scratch : R_ResolveScratch (R_T4 carrier)
- *   r_look_at : ralloc() — also serves as the off-dst in the trans_matrix phase
- *   r_row     : V3_S4, reused for ux/uy/uz loads in populate phase
- *   r_eye     : ralloc() — &scratch.eye, used for -eye load in matrix_vector phase
- *   r_v_x/v_y/v_z : ralloc() — populate scratch addrs (ux/uy/uz), reused as
- *                    ctc2 transfer + MVMVA -eye temp in matrix_vector phase
- *   (v_x/v_y/v_z alias ux/uy/uz via the union; lifetime ends for ux/uy/uz after
- *    populate's mac_load_v3s4, so reusing for v.x/v.y/v.z is safe)
- * Pool cost: 1 carrier + 1 look_at + 3 row + 1 eye + 3 aliased = 9 GPRs
- *
- * Net word savings vs the previous 3-atom flow: ~15 words + 2 mac_yields + 1 tape pop.
- *   - 2 mac_yields (trans_matrix's + matrix_vector's) → fused into one yield
- *   - 1 redundant tb_data (look_at was pushed 2x; now once)
- *   - mac_trans_mt3s3s4 (6 words) → replaced by direct mac_store_v3s4
- *   - mac_store_v3s4 to scratch.eye (3 words intermediate) → eliminated
- *   - add_si for r_off_ptr (2 words) → eliminated
- *   - mac_store_v3s4 zero-store of t[] (3 words) → eliminated (matrix_vector writes
- *     off directly; no consumer needed the zero first)
- *   - 1 set_gte_mt3s2s4 ctc2 chain (13 baked words) → eliminated (matrix_vector
- *     has its own ctc2 RT chain; cube rendering atoms reload C2 state themselves)
  */
-internal MipsAtom* resolve_look_at__pop_mv_trans(AtomArena_R aa,
-	RegUse_resolve_look_at__pop_mv_trans r
-) MipsAtom_Proc_(aa, {
+internal MipsAtom* AtomBundleEntry_(resolve_look_at,populate_mt3s4s2)(AtomArena_R aa, RegUse_resolve_look_at_populate_mt3s4s2 r)
+atom_info(atom_bind(Binds_ResolveLookAt_PopulateMT3S4S2)) MipsAtom_Proc_(aa, {
 	/* --- Tape pop: look_at pointer --- */
-	load_word(r.look_at, R_TapePtr, O_(Binds_ResolveLookAtPopMvTrans,look_at)),
-	LdSlot_ add_ui_self(R_TapePtr, S_(Binds_ResolveLookAtPopMvTrans)),
+	load_word(r.look_at, R_TapePtr, O_(Binds_ResolveLookAt_PopulateMT3S4S2,look_at)),
+	LdSlot_ add_ui_self( R_TapePtr, S_(Binds_ResolveLookAt_PopulateMT3S4S2)),
 
-	/* --- Scratch addresses for ux/uy/uz/eye (populate phase; t6/t7/t8 alias ux/uy/uz).
-	 * R_ScratchBase (= R_SP) holds 0x1F800000; no per-atom bake is required because
-	 * R_SP is a tape carrier preserved across atoms. --- */
-	add_si(r.t6.ux, R_ScratchBase, O_(ResolveLookAtScratch, ux)),  LdSlot_
-	add_si(r.t7.uy, R_ScratchBase, O_(ResolveLookAtScratch, uy)),
-	add_si(r.t8.uz, R_ScratchBase, O_(ResolveLookAtScratch, uz)),
-	add_si(r.eye,   R_ScratchBase, O_(ResolveLookAtScratch, eye)),
+	add_si(r.ux,  R_ScratchBase, O_(ResolveLookAtScratch, ux)), LdSlot_
+	add_si(r.uy,  R_ScratchBase, O_(ResolveLookAtScratch, uy)),
+	add_si(r.uz,  R_ScratchBase, O_(ResolveLookAtScratch, uz)),
+	add_si(r.eye, R_ScratchBase, O_(ResolveLookAtScratch, eye)),
 
-	/* --- POPULATE phase: write look_at->m[][] from ux/uy/uz as packed S2 --- */
-	mac_load_v3s4(r.row, r.t6.ux, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[0])),
-	mac_load_v3s4(r.row, r.t7.uy, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[1])),
-	mac_load_v3s4(r.row, r.t8.uz, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[2])),
+	/* write look_at->m[][] from ux/uy/uz as packed S2 */
+	mac_load_v3s4(r.row, r.ux, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[0])),
+	mac_load_v3s4(r.row, r.uy, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[1])),
+	mac_load_v3s4(r.row, r.uz, 0), LdSlot_ mac_store_v3s2(r.row, r.look_at, O_(MT3_S2S4, m[2])),
 
-	/* --- MATRIX-VECTOR phase: ctc2 RT chain + MVMVA RT*(-eye)>>12 --- */
-	/* RT packing (per libgte ApplyMatrixLV convention; see gte.h:217-220 +
-	 * atom_6b_disasm_comparison.md:28-32):
-	 *   C2[0] = (RT12<<16)|RT11  ← ctc2 RT11 from m[0][0..1] packed word
-	 *   C2[1] = (RT21<<16)|RT13  ← ctc2 RT12 from m[0][2..3] packed word
-	 *   C2[2] = (RT23<<16)|RT22  ← ctc2 RT13 from m[1][1..2] packed word
-	 *   C2[3] = (RT32<<16)|RT31  ← ctc2 RT21 from m[2][0..1] packed word
-	 *   C2[4] = (RT33<<16)|junk  ← ctc2 RT22 from m[2][2] (half)
-	 * Each ctc2 writes a WHOLE 32-bit C2 slot; the "macro name" identifies
-	 * which C2 register, not which 16-bit half. */
-	load_word(  r.t6.v_x, r.look_at, O_(MT3_S2S4, m[0][0])), /* RT11|RT12 */ LdSlot_
-	load_word(  r.t7.v_y, r.look_at, O_(MT3_S2S4, m[0][2])), /* RT13|RT21 */ LdSlot_ gte_mv_to_ctrl_r(r.t6.v_x, gte_cr_RT11),
-	load_word(  r.t8.v_z, r.look_at, O_(MT3_S2S4, m[1][1])), /* RT22|RT23 */ LdSlot_ gte_mv_to_ctrl_r(r.t7.v_y, gte_cr_RT12),
-	load_word(  r.t6.v_x, r.look_at, O_(MT3_S2S4, m[2][0])), /* RT31|RT32 */ LdSlot_ gte_mv_to_ctrl_r(r.t8.v_z, gte_cr_RT13),
-	load_half_u(r.t7.v_y, r.look_at, O_(MT3_S2S4, m[2][2])), /* RT33 */      LdSlot_ gte_mv_to_ctrl_r(r.t6.v_x, gte_cr_RT21),
-	/* pos = -eye. The three loads also retire the last CTC2. */                  gte_mv_to_ctrl_r(r.t7.v_y, gte_cr_RT22),
-	GteDelay_ mac_load_word_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, r.eye, 0), LdSlot_ 
-	mac_sub_s_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, R_0, R_0, R_0, r.t6.v_x, r.t7.v_y, r.t8.v_z),
-	/* mtc2 pos (as S16) to IR1/2/3. The GTE takes low 16 bits. pos fits in S16. For negative pos, the 32-bit sign-extended value's low 16 bits = correct S16. */
-	gte_mv_to_data_r(r.t6.v_x, C2_IR1),
-	gte_mv_to_data_r(r.t7.v_y, C2_IR2),
-	gte_mv_to_data_r(r.t8.v_z, C2_IR3),
+	/* ctc2 RT chain + MVMVA RT * (-eye) >> 12 */
+	/*   C2[0] = (RT12<<16)|RT11  ← ctc2 RT11 from m[0][0..1]
+	 *   C2[1] = (RT21<<16)|RT13  ← ctc2 RT12 from m[0][2..3]
+	 *   C2[2] = (RT23<<16)|RT22  ← ctc2 RT13 from m[1][1..2]
+	 *   C2[3] = (RT32<<16)|RT31  ← ctc2 RT21 from m[2][0..1]
+	 *   C2[4] = (RT33<<16)|junk  ← ctc2 RT22 from m[2][2] (half) */
+	load_word(  r.vx, r.look_at, O_(MT3_S2S4, m[0][0])), /* RT11|RT12 */ LdSlot_
+	load_word(  r.vy, r.look_at, O_(MT3_S2S4, m[0][2])), /* RT13|RT21 */ LdSlot_ gte_mv_to_ctrl_r(r.vx, gte_cr_RT11),
+	load_word(  r.vz, r.look_at, O_(MT3_S2S4, m[1][1])), /* RT22|RT23 */ LdSlot_ gte_mv_to_ctrl_r(r.vy, gte_cr_RT12),
+	load_word(  r.vx, r.look_at, O_(MT3_S2S4, m[2][0])), /* RT31|RT32 */ LdSlot_ gte_mv_to_ctrl_r(r.vz, gte_cr_RT13),
+	load_half_u(r.vy, r.look_at, O_(MT3_S2S4, m[2][2])), /* RT33 */      LdSlot_ gte_mv_to_ctrl_r(r.vx, gte_cr_RT21),
+
+	GteDelay_ mac_load_word_v3(r.vx, r.vy, r.vz, r.eye, 0), LdSlot_ 
+	mac_sub_s_v3(r.vx, r.vy, r.vz, R_0, R_0, R_0, r.vx, r.vy, r.vz),
+
+	gte_mv_to_data_r(r.vx, C2_IR1),
+	gte_mv_to_data_r(r.vy, C2_IR2),
+	gte_mv_to_data_r(r.vz, C2_IR3),
 	GteDelay_ nop2,
 
-	/* MVMVA pass 2 — C11 ApplyMatrixLV command.
-	 * sf=1, mx=0 (RT), v=3 (IR), cv=3. Reads RT × IR >> 12. */
-	gte_cmdw_mvmva_c11_pass2,                                      GteDelay_ nop,
-	mac_gte_mv_from_data_r_mac123(r.t6.v_x, r.t7.v_y, r.t8.v_z),   GteDelay_ nop,
+	/* MVMVA pass 2 — C11 ApplyMatrixLV command. sf=1, mx=0 (RT), v=3 (IR), cv=3. Reads RT × IR >> 12. */
+	gte_cmdw_mvmva_c11_pass2,                        GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0),            // ac_yield: word 1
+	mac_gte_mv_from_data_r_mac123(r.vx, r.vy, r.vz), GteDelay_ add_ui_self(         R_TapePtr, S_(MipsCode)), // ac_yield: word 2
 
-	/* --- TRANS-MATRIX phase: store off directly to look_at->t[] (skip scratch.eye intermediate) --- */
-	mac_store_word_v3(r.t6.v_x, r.t7.v_y, r.t8.v_z, r.look_at, O_(MT3_S2S4, t)),
+	/* store off directly to look_at->t[] (skip scratch.eye intermediate) */
+	mac_store_word_v3(r.vx, r.vy, r.vz, r.look_at, O_(MT3_S2S4, t)),
 
-	mac_yield()
+	jump_reg(R_AtomJmp), BdSlot_ nop, // ac_yield: word 3-4
 })
 #pragma endregion resolve_look_at
 
@@ -288,8 +237,8 @@ enum {
 };
 //screen_env_init. Mirrors the libpsyx's SetDefDispEnv + SetDefDrawEnv + the manual enable_auto_clear / initial_bg_color writes.
 internal MipsAtom_(screen_env_init) atom_info(atom_phase(screen_init)
-,	atom_reads(R_T0, R_ScreenX, R_ScreenY, R_ScreenBuf)
-, atom_writes(R_T0, R_ScreenX, R_ScreenY)
+,	atom_reads(R_ScreenBuf)
+, atom_writes(R_ScreenBuf)
 ) {
 	/* display[0] = (0, 0, 320, 240); rest of struct zeroed. */
 	add_ui(R_ScreenX, R_0, ScreenRes_X), add_ui(R_ScreenY, R_0, ScreenRes_Y),
@@ -339,23 +288,6 @@ internal MipsAtom_(screen_env_init) atom_info(atom_phase(screen_init)
 	mac_yield(),
 };
 
-/* gp_screen_init's GPR setup. Tests the mixed user-pinning + auto-reg pattern:
- *   - R_IO_BaseAddr = R_T4 (user-pinned via atom_reg; pre-existing)
- *   - R_GP1_Offset  = R_T2 (user-pinned via atom_reg; NEW -- for GPIO_PORT1_OFFSET)
- *   - R_ScreenX     = R_T5 (user-pinned via atom_reg; used as a transfer and GTE setup reg)
- *   - R_GpTmp       = auto-allocated by the lua pass and used for several GPU transfers;
- *                    the C preprocessor resolves it to the chosen free pool GPR.
- *
- * For gp_screen_init, the auto-reg pool exclusions are:
- *   user_pinned (from the corpus register_alias_registry) : R_T0..R_T7 (all 8 user-pinned across hello_camera.atom.c)
- *   body-parsed physical registers                         : aliases resolve through the registry;
- *                                                           the body uses R_ScreenX, not raw R_T5
- *   source_pool after both subtractions                   : {R_V0, R_V1} only
- *   R_GpTmp gets R_V0 (the first-fit choice). Its repeated GPU-transfer use proves that the
- *   auto-reg allocation is active while the R_ScreenX references prove the pinned alias is used.
- *   R_TapePtr (R_T9), R_AtomJmp (R_T8), R_AT are excluded from the POOL by construction in
- *   passes/auto_reg.lua -- see the "obvious exclusions" comment block at the top of that file.
- */
 enum {
 	R_IO_BaseAddr = R_T4 atom_reg, /* Caller-pinned: IO_BASE_ADDR = 0x1F800000 */
 	R_GP1_Offset  = R_T2 atom_reg, /* Caller-pinned: GPIO_PORT1_OFFSET = 0x10 */
@@ -509,7 +441,7 @@ typedef Struct_(Binds_PadInputCam) {
 	Camera*   cam;
 };
 internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
-, atom_reads( R_Cam, R_CamPadState, R_TapePtr)
+, atom_reads( R_Cam, R_CamPadState)
 , atom_writes(R_Cam)
 ) {
 	/* Bind pop: state → R_CamPadState (R_T5), cam → R_Cam (R_T4), advance R_TapePtr by 8. */
@@ -522,7 +454,7 @@ internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
 	load_word(R_T1, R_Cam, O_(Camera,pos.x)),
 
 	// D-pad Left → cam.pos.x -= 50.  and_i fulfills BD-slot for load on R_Cam.
-	LdSlot_ and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(left_x, exit_left_x)), BdSlot_ mac_yield_load(), LdSlot_
+	LdSlot_ and_i(R_T3, R_T0, Pad_Left), branch_le_zero(R_T3, atom_offset(left_x, exit_left_x)), BdSlot_ nop,
 		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.x)), 
 	atom_label(exit_left_x)
 
@@ -544,16 +476,16 @@ internal MipsAtom_(pad_input_cam) atom_info(atom_bind(Binds_PadInputCam)
 
 	/* D-pad Cross → cam.pos.z -= 50. Load pos.z BEFORE the andi. */
 	load_word(R_T1, R_Cam, O_(Camera,pos.z)), LdSlot_
-	and_i(R_T3, R_T0, Pad_Cross), branch_le_zero(R_T3, atom_offset(cross_z, exit_cross_z)), BdSlot_ nop,
+	and_i(R_T3, R_T0, Pad_Cross), branch_le_zero(R_T3, atom_offset(cross_z, exit_cross_z)), BdSlot_ load_word(R_AtomJmp, R_TapePtr, 0), LdSlot_ // ac_yield: word 1
 		add_si(R_T1, R_T1, -50), store_word(R_T1, R_Cam, O_(Camera,pos.z)),
 	atom_label(exit_cross_z)
 
 	/* D-pad Circle → cam.pos.z += 50. Reuses R_T1 from Cross. */
-	and_i(R_T3, R_T0, Pad_Circle), branch_le_zero(R_T3, atom_offset(circle_z, exit_circle_z)), BdSlot_ nop,
+	and_i(R_T3, R_T0, Pad_Circle), branch_le_zero(R_T3, atom_offset(circle_z, exit_circle_z)), BdSlot_ add_ui_self(R_TapePtr, S_(MipsCode)), // ac_yield: word 2
 		add_si(R_T1, R_T1,  50), store_word(R_T1, R_Cam, O_(Camera,pos.z)),
 	atom_label(exit_circle_z)
 
-	mac_yield_tail(),
+	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
 };
 
 enum {
@@ -567,20 +499,17 @@ enum {
 #define R_OtBase_Code      R_T6_Code
 };
 typedef Struct_(Binds_CubeTri) {
-	U4     PrimCursor;
-	V4_S2* FaceCursor;
-	V3_S2* VertBase;
-	U4*    OtBase;
+	U1*    prim_cursor;
+	V4_S2* face_cursor;
+	V3_S2* vert_base;
+	U4*    ot_base;
 };
-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, R_TapePtr)
-){
+internal MipsAtom_(rbind_cube_g4_face) atom_info(atom_bind(Binds_CubeTri), atom_phase(cube_g4)){
 	/* Pop 4 arguments from the tape directly into the workspace registers */
-	load_word(R_PrimCursor, R_TapePtr, O_(Binds_CubeTri,PrimCursor)),
-	load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,FaceCursor)),
-	load_word(R_VertBase,   R_TapePtr, O_(Binds_CubeTri,VertBase)),
-	load_word(R_OtBase,     R_TapePtr, O_(Binds_CubeTri,OtBase)),
+	load_word(R_PrimCursor, R_TapePtr, O_(Binds_CubeTri,prim_cursor)),
+	load_word(R_FaceCursor, R_TapePtr, O_(Binds_CubeTri,face_cursor)),
+	load_word(R_VertBase,   R_TapePtr, O_(Binds_CubeTri,vert_base)),
+	load_word(R_OtBase,     R_TapePtr, O_(Binds_CubeTri,ot_base)),
 	LdSlot_ add_ui_self(    R_TapePtr, S_(Binds_CubeTri)),
 	mac_yield()
 };
@@ -596,11 +525,13 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 	load_half_u(R_T2, R_FaceCursor, 2 * S_(S2)),
 	// load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)),
 
-	LdSlot_ mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), GteDelay_ load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)), LdSlot_
-	GteDelay_ nop, gte_cmdw_rotate_translate_perspective_triple,
+	LdSlot_ mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), 
+		GteDelay_ load_half_u(R_T3, R_FaceCursor, 3 * S_(S2)), LdSlot_
+		GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0),          LdSlot_ //ac_yield: word 1,
+	gte_cmdw_rotate_translate_perspective_triple,
 	gte_cmdw_nclip,
 
-	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ nop,
+	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ add_ui_self(R_TapePtr, S_(MipsCode)), // ac_yield: word 2
 	branch_le_zero(R_T0, atom_offset(cull, cube_g4_face_exit)),
 		/* BD-slot: Write the prim tag (R_0=0; overwrites the legacy tag word in the prim_buffer).
 		 * If branch IS taken (face culled), the body is skipped and this 0-tag is stranded —
@@ -630,16 +561,16 @@ MipsAtom_(cube_g4_face) atom_info(atom_phase(cube_g4),
 // end: branch(cull)
 
 atom_label(cube_g4_face_exit)
-	add_ui_self(R_PrimCursor, S_(Poly_G4)),     /* 9 words = Poly_G4 */
-	add_ui_self(R_FaceCursor, S_(S2) * 4),      /* 4 × S2 = 8 bytes */
-	mac_yield()
+	add_ui_self(R_PrimCursor, S_(Poly_G4)), // 9 words = Poly_G4
+	add_ui_self(R_FaceCursor, S_(S2) * 4),  // 4 × S2 = 8 bytes
+	jump_reg(R_AtomJmp), BdSlot_ nop      // ac_yield: word 3-4
 };
 
 typedef Struct_(Binds_FloorTri) {
-	U4     PrimCursor;
-	V3_S2* FaceCursor;
-	V3_S2* VertBase;
-	U4*    OtBase;
+	U1*    prim_cursor;
+	V3_S2* face_cursor;
+	V3_S2* vert_base;
+	U4*    ot_base;
 };
 internal
 MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri), atom_phase(floor_f3)
@@ -647,10 +578,10 @@ MipsAtom_(rbind_floor_f3_face) atom_info(atom_bind(Binds_FloorTri), atom_phase(f
 	, atom_writes(R_PrimCursor, R_FaceCursor, R_VertBase, R_OtBase, R_TapePtr)
 ){
 	/* Pop 4 arguments from the tape directly into the workspace registers */
-	load_word(R_PrimCursor, R_TapePtr, O_(Binds_FloorTri,PrimCursor)),
-	load_word(R_FaceCursor, R_TapePtr, O_(Binds_FloorTri,FaceCursor)),
-	load_word(R_VertBase,   R_TapePtr, O_(Binds_FloorTri,VertBase)),
-	load_word(R_OtBase,     R_TapePtr, O_(Binds_FloorTri,OtBase)),
+	load_word(R_PrimCursor, R_TapePtr, O_(Binds_FloorTri,prim_cursor)),
+	load_word(R_FaceCursor, R_TapePtr, O_(Binds_FloorTri,face_cursor)),
+	load_word(R_VertBase,   R_TapePtr, O_(Binds_FloorTri,vert_base)),
+	load_word(R_OtBase,     R_TapePtr, O_(Binds_FloorTri,ot_base)),
 	LdSlot_ add_ui_self(    R_TapePtr, S_(Binds_FloorTri)),
 	mac_yield()
 };
@@ -662,13 +593,13 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 	, atom_writes(R_PrimCursor, R_FaceCursor)
 ) {
 	mac_load_tri_indices(R_FaceCursor, R_T0, R_T1, R_T2),
-	mac_gte_load_tri_verts(R_VertBase,   R_T0, R_T1, R_T2),
-	nop2, gte_cmdw_rotate_translate_perspective_triple, // 2 nops retire the final cpu -> gte writes before RTPT
+	mac_gte_load_tri_verts(R_VertBase, R_T0, R_T1, R_T2), GteDelay_ nop2,
+	gte_cmdw_rotate_translate_perspective_triple, // 2 nops retire the final cpu -> gte writes before RTPT
 	gte_cmdw_nclip,
 
 	/* Culling (Branch forward if Backface) */
-	gte_mv_from_data_r(R_T0, C2_MAC0),
-	nop, branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), nop, // required gte -> cpu load-delay slot.
+	gte_mv_from_data_r(R_T0, C2_MAC0), GteDelay_ load_word(R_AtomJmp, R_TapePtr, 0), // ac_yield: word 1
+	branch_le_zero(R_T0, atom_offset(culling, floor_f3_face_exit)), BdSlot_ add_ui_self(R_TapePtr, S_(MipsCode)),  // ac_yield: word 2
 		/* Format Primitive */
 		mac_gte_store_f3(R_PrimCursor),
 
@@ -678,7 +609,7 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 		/* Bounds Check OTZ < 2048 (Branch forward to skip insertion) */
 		add_ui(      R_AT, R_0,  OrderingTbl_Len),
 		set_lt_u(    R_AT, R_T1, R_AT),
-		branch_equal(R_AT, R_0,  atom_offset(bounds_chk, floor_f3_face_exit)), nop,
+		branch_equal(R_AT, R_0,  atom_offset(bounds_chk, floor_f3_face_exit)), BdSlot_ nop,
 			mac_format_f3_color(R_PrimCursor, 0xFF, 0xFF, 0xFF),  // RGB-form (R=FF, G=FF, B=FF = white)
 			mac_insert_ot_tag(R_OtBase, R_PrimCursor, S_(Poly_F3)),   /* Insert into Ordering Table Linked List */
 			add_ui_self(R_PrimCursor, S_(Poly_F3)), /* Advance Prim Cursor (5 words) */
@@ -689,13 +620,12 @@ MipsAtom_(floor_f3_face) atom_info(atom_phase(floor_f3)
 /* Advance Input Cursor & Yield (Both branch targets land here) */
 atom_label(floor_f3_face_exit)
 	add_ui_self(R_FaceCursor, S_(S2) * 4),  /* Advance Face Cursor (4 * S2 = 8 bytes) */
-	mac_yield()
+	jump_reg(R_AtomJmp), BdSlot_ nop // ac_yield: word 3-4
 };
 
-typedef Struct_(Binds_SyncPrimitiveArena) { U4 used; U4 cursor; };
+typedef Struct_(Binds_SyncPrimitiveArena) { U4* used; U1* cursor; };
 internal MipsAtom_(sync_primitive_arena) atom_info(atom_bind(Binds_SyncPrimitiveArena)
-	, atom_reads( R_TapePtr, R_PrimCursor)
-	, atom_writes(R_TapePtr)
+	, atom_reads(R_PrimCursor), atom_writes(R_AT)
 ){
 	load_word(R_AT, R_TapePtr, O_(Binds_SyncPrimitiveArena,used)),
 	load_word(R_T0, R_TapePtr, O_(Binds_SyncPrimitiveArena,cursor)), LdSlot_

code/hello_camera/hello_camera.c

@@ -24,7 +24,7 @@
 #include "duffle/pad.h"
 
 #include "duffle/dsl.atom.h"
-#include "duffle/lottes_tape.h"
+#include "duffle/tape.h"
 
 #include "duffle/bios.h"
 #include "duffle/psyq.h"
@@ -80,9 +80,6 @@ typedef Struct_(SMemory) {
 	PadBiosRaw pad_raw[2];
 	PadState   pad[2];
 
-	// TODO(Ed): We don't need this we can just cast at any point an address to a desired view of scratchpad, we have the address.
-	U4_V scratchpad; // d-cache
-
 	U1 ct_init_atom_mem[CT_InitAtomMem_Size];
 	MipsAtom* normalize_v3s4;
 	MipsAtom* gte_cross_v3s4;
@@ -96,11 +93,11 @@ extern SMemory smem;
 #define pad0_btn_(btn) btn & smem.pad[0].buttons
 #define pad1_btn_(btn) btn & smem.pad[1].buttons
 
-I_ B1* prim__alloc(U4 type_width, Str8 type_name) {
+I_ U1* prim__alloc(U4 type_width, Str8 type_name) {
 	gknown PrimitiveArena* pa  = & smem.primitives;
-	gknown B1*             buf = (B1*) r_(smem.primitives.buf)[smem.active_buf_id];
+	gknown U1*             buf = (U1*) r_(smem.primitives.buf)[smem.active_buf_id];
 	assert(pa->used + type_width < PrimitiveBuff_Len);
-	B1* next  = buf + pa->used;
+	U1* next  = buf + pa->used;
 	pa->used += type_width;
 	return next;
 }
@@ -114,10 +111,10 @@ I_ void resolve_look_at_c11(MT3_S2S4* look_at, P3_S4* eye, P3_S4* target, V3_S4*
 	V3_S4 pos, off;
 
 	forward = target[0]; sub_v3s4(& forward, eye[0]); // RGA(Lengyel): Affine point - point = zero-weight direction.
-	normalize_v3s4(& forward, & uz);                  // RGA(Lengyel): Normalize the direction bulk. Not finite-point unitization.
+	psy_normalize_v3s4(& forward, & uz);              // RGA(Lengyel): Normalize the direction bulk. Not finite-point unitization.
 
-	cross_v3s4(& uz,   up_in, & right); normalize_v3s4(& right, & ux); // RGA(Lengyel): Complement(Wedge(forward, up_in)) -> right axis.
-	cross_v3s4(& uz, & ux,    & up);    normalize_v3s4(& up,    & uy); // RGA(Lengyel): Complement(Wedge(forward, right)) -> up axis.
+	cross_v3s4(& uz,   up_in, & right); psy_normalize_v3s4(& right, & ux); // RGA(Lengyel): Complement(Wedge(forward, up_in)) -> right axis.
+	cross_v3s4(& uz, & ux,    & up);    psy_normalize_v3s4(& up,    & uy); // RGA(Lengyel): Complement(Wedge(forward, right)) -> up axis.
 
 	// RGA(Lengyel): matrix expansion of the world-to-camera rotation (basis rows).
 	look_at->m[0][0] = ux.x; look_at->m[0][1] = ux.y; look_at->m[0][2] = ux.z;
@@ -141,23 +138,23 @@ internal void compile_init_atoms(void) {
 
 	smem.gte_cross_v3s4 = gte_cross_v3s4(& ab,
 		RegUse_(gte_cross_v3s4) {
-			.a  = ralloc_v3(),
-			.b  = ralloc_v3(),
-			.x  = ralloc(),
-			.y  = ralloc(),
-			.z  = ralloc(),
+			.a     = ralloc_v3(),
+			.b     = ralloc_v3(),
+			.out   = ralloc(),
+			.src_a = ralloc(),
+			.src_b = ralloc(),
 		});
 	regfile_reset(& rf);
 
-	smem.normalize_v3s4 = build_normalize_v3s4(& ab,
-		RegUse_(build_normalize_v3s4) {
+	smem.normalize_v3s4 = normalize_v3s4(& ab,
+		RegUse_(normalize_v3s4) {
 			.res = ralloc_v3(),
-			.t0     = ralloc(),
-			.t1     = ralloc(),
-			.t2     = ralloc(),
-			.t3     = ralloc(),
-			.t4     = ralloc(),
-			.t5     = ralloc(),
+			.r0     = ralloc(),
+			.r1     = ralloc(),
+			.r2     = ralloc(),
+			.r3     = ralloc(),
+			.r4     = ralloc(),
+			.r5     = ralloc(),
 		});
 	regfile_reset(& rf);
 
@@ -167,26 +164,20 @@ internal void compile_init_atoms(void) {
 }
 
 internal void compile_resolve_look_at(void) {
-	AtomArena ab = atomarena_make(slice_ut_arr(smem.resolve_look_at_mem));
 	AtomBundle_resolve_look_at_R bundle = C_(void*, smem.resolve_look_at_bundle);
-
-	/* R_ScratchBase (= R_SP) is a tape carrier preserved across atoms; no carrier
-	 * pin is needed in the regfile. The standard 24-register pool is sufficient. */
-	RegFile rf = regfile(regfile_abi_mask);
+	AtomArena ab = atomarena_make(slice_ut_arr(smem.resolve_look_at_mem));
+	RegFile   rf = regfile(regfile_abi_mask);
 #define ralloc() regfile_alloc(& rf)
 #define ralloc_v3() { ralloc(), ralloc(), ralloc() }
-
 	bundle->input_and_sub = AtomBundleEntry_(resolve_look_at, input_and_sub)(& ab,
 		RegUse_(resolve_look_at_input_and_sub) {
-			.target  = ralloc(),
-			.eye     = ralloc(),
-			.up_in   = ralloc(),
-			.t0      = ralloc(),
-			.t1      = ralloc(),
-			.t2      = ralloc(),
-			.t3      = ralloc(),
-			.t4      = ralloc(),
-		});
+			.target_ptr = ralloc(),
+			.eye_ptr    = ralloc(),
+			.up_in_ptr  = ralloc(),
+			.up_in      = ralloc_v3(),
+			.r012       = ralloc_v3(),
+			.r345       = {ralloc(), R_AT, ralloc() },
+	});
 	regfile_reset(& rf);
 
 	bundle->normalize_fwd_uz   = smem.normalize_v3s4;
@@ -195,85 +186,70 @@ internal void compile_resolve_look_at(void) {
 	bundle->cross_to_up        = smem.gte_cross_v3s4;
 	bundle->normalize_up_uy    = smem.normalize_v3s4;
 
-	bundle->pop_mv_trans = resolve_look_at__pop_mv_trans(& ab,
-		RegUse_(resolve_look_at__pop_mv_trans){
+	bundle->populate_mt3s4s2 = AtomBundleEntry_(resolve_look_at,populate_mt3s4s2)(& ab,
+		RegUse_(resolve_look_at_populate_mt3s4s2){
 			.look_at = ralloc(),
 			.eye     = ralloc(),
 			.row     = ralloc_v3(),
-			.t6      = ralloc(),
-			.t7      = ralloc(),
-			.t8      = ralloc(),
+			.r0      = ralloc(),
+			.r1      = ralloc(),
+			.r2      = ralloc(),
 		});
 
-	/* Sanity check: arena didn't overflow. */
-	assert(ab.used <= ResolveLookAtArena_Size);
+	assert(ab.used <= ResolveLookAtArena_Size); // Sanity check: arena didn't overflow.
 #undef ralloc
 }
 
-/* Emit the resolve_look_at bundle into the tape. Called once per frame from update(). */
-I_ void resolve_look_at(TapeBuilder_R tb
-	,	MT3_S2S4* look_at
-	,	P3_S4*    eye
-	,	P3_S4*    target
-	,	V3_S4*    up_in
-){
+// Emit the resolve_look_at bundle into the tape. Called once per frame from update().
+I_ void resolve_look_at(TapeBuilder_R tb,	MT3_S2S4* look_at, P3_S4* eye, P3_S4* target,	V3_S4* up_in) {
 	/* Typed view of the scratchpad for field-address arithmetic. */
-	ResolveLookAtScratch* sp = C_scratch(ResolveLookAtScratch*);
+	ResolveLookAtScratch*        sp     = C_scratch(ResolveLookAtScratch*);
 	AtomBundle_resolve_look_at_R bundle = C_(void*, smem.resolve_look_at_bundle);
-
-	tb_emit(tb, bundle->input_and_sub); {
-		tb_data(tb, u4_(target));
-		tb_data(tb, u4_(eye));
-		tb_data(tb, u4_(up_in));
-	}
-	tb_emit(tb, bundle->normalize_fwd_uz); {
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, fwd) | (O_(ResolveLookAtScratch, uz) << 16)));
-	}
-	tb_emit(tb, bundle->cross_to_right); {
-		tb_data(tb, u4_(& sp->uz));
-		tb_data(tb, u4_(& sp->up_in));
-		tb_data(tb, u4_(& sp->right));
-	}
-	tb_emit(tb, bundle->normalize_right_ux); {
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, right) | (O_(ResolveLookAtScratch, ux) << 16)));
-	}
-	tb_emit(tb, bundle->cross_to_up); {
-		tb_data(tb, u4_(& sp->uz));
-		tb_data(tb, u4_(& sp->ux));
-		tb_data(tb, u4_(& sp->up));
-	}
-	tb_emit(tb, bundle->normalize_up_uy); {
-		tb_data(tb, u4_(O_(ResolveLookAtScratch, up) | (O_(ResolveLookAtScratch, uy) << 16)));
-	}
-	tb_emit(tb, bundle->pop_mv_trans); {
-		tb_data(tb, u4_(look_at));
-	}
+	tb_emit(tb, bundle->input_and_sub); tb_bind_(tb, Binds_ResolveLookAtSub, 
+		.target = target,
+		.eye    = eye,
+		.up_in  = up_in,
+	);
+	tb_emit(tb, bundle->normalize_fwd_uz); tb_bind_(tb, Binds_normalize_v3s4,
+		.src_offset = O_(ResolveLookAtScratch,fwd),
+		.dst_offset = O_(ResolveLookAtScratch,uz),
+	);
+	tb_emit(tb, bundle->cross_to_right); tb_bind_(tb, Binds_gte_cross_v3s4,
+		.src_a = & sp->uz,
+		.src_b = & sp->up_in,
+		.out   = & sp->right,
+	);
+	tb_emit(tb, bundle->normalize_right_ux); tb_bind_(tb, Binds_normalize_v3s4, 
+		.src_offset = O_(ResolveLookAtScratch,right),
+		.dst_offset = O_(ResolveLookAtScratch,ux),
+	);
+	tb_emit(tb, bundle->cross_to_up); tb_bind_(tb, Binds_gte_cross_v3s4, 
+		.src_a = & sp->uz,
+		.src_b = & sp->ux,
+		.out   = & sp->up,
+	);
+	tb_emit(tb, bundle->normalize_up_uy); tb_bind_(tb, Binds_normalize_v3s4,
+		.src_offset = O_(ResolveLookAtScratch,up),
+		.dst_offset = O_(ResolveLookAtScratch,uy),
+	);
+	tb_emit(tb, bundle->populate_mt3s4s2); tb_bind_(tb, Binds_ResolveLookAt_PopulateMT3S4S2, 
+		.look_at = look_at,
+	);
 }
+FI_ void camera_look_at(TapeBuilder_R tb, Camera* c, P3_S4* target, V3_S4* up_in) { resolve_look_at(tb, & c->look_at, & c->pos, target, up_in); }
 
-GCC_OPTIMIZATION_DISABLE
 void update(PrimitiveArena* pa, U4* ordering_buf) 
 {
 	TapeBuilder tb = tb_make(slice_ut_arr(smem.MemTape));
-
-	// Pad Input
-	{
+	/*Pad Input*/ {
 		tb.used = 0; tb_scope_run(& tb) {
 			// Grab latest state from bios.
 			tb_emit_(pad_bios_snapshot);
-				tb_data_(raw,   & smem.pad_raw[0]);
-				tb_data_(state, & smem.pad[0]);
-			// tb_emit_(pad_bios_snapshot);
-			// 	tb_data_(raw,   & smem.pad_raw[1]);
-			// 	tb_data_(state, & smem.pad[1]);
-
+				tb_data(& tb, u4_(& smem.pad_raw[0]));
+				tb_data(& tb, u4_(& smem.pad[0]));
 			tb_emit_(pad_input_cam);
-				tb_data_(state, & smem.pad[0]);
-				tb_data_(cam, & smem.cam);
-
-			// tb_emit_(pad_input_cube_rotation);
-			// 	tb_data_(state,     & smem.pad[0]);
-			// 	tb_data_(cube_rot,  & smem.cube.rot);
-			// 	tb_data_(floor_rot, & smem.floor.rot);
+				tb_data(& tb, u4_(& smem.pad[0]));
+				tb_data(& tb, u4_(& smem.cam));
 		}
 	}
 	
@@ -301,7 +277,7 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 	if (use_c11_path == false)
 	{
 		tb.used = 0; tb_scope_run(& tb) {
-			resolve_look_at(& tb, & smem.cam.look_at, & smem.cam.pos, & smem.cube.pos, & v3s4(0, -fp_one, 0));
+			camera_look_at(& tb, & smem.cam, & smem.cube.pos, & v3s4(0, -fp_one, 0));
 		}
 	}
 
@@ -311,33 +287,30 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		mt3s2s4_rotation   (& smem.cube.rot,    & smem.tform_world);
 		mt3s2s4_translation(& smem.tform_world, & smem.cube.pos);
 		mt3s2s4_scale      (& smem.tform_world, & smem.cube.scale);
-
 		// Combine world and look_at matrix.
 		gte_comp_coord_m3s2(& smem.cam.look_at, & smem.tform_world, & smem.tform_view);
 		gte_matrix_set_rotation   (& smem.tform_view);
 		gte_matrix_set_translation(& smem.tform_view);
 
-		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
-		U4 prim_cursor = prim_base + pa->used;
-
-		tb.used = 0; tb_scope(& tb) {
-			tb_emit(& tb, rbind_cube_g4_face);
-				tb_data(& tb, prim_cursor);
-				tb_data(& tb, u4_(smem.cube.faces));
-				tb_data(& tb, u4_(smem.cube.verts));
-				tb_data(& tb, u4_(ordering_buf));
-
+		// TODO(Ed): We should do a bounds check beforehand to confirm pa can hold all tris?
+		// The tape atoms in-flight should not need to care.
+		U1* prim_base   = u1_r(pa->buf[smem.active_buf_id]);
+		U1* prim_cursor = prim_base + pa->used;
+		tb.used = 0; tb_scope_run(& tb) {
+			tb_emit(& tb, rbind_cube_g4_face); tb_bind_(& tb, Binds_CubeTri, 
+				.prim_cursor = prim_cursor,
+				.face_cursor = smem.cube.faces,
+				.vert_base   = smem.cube.verts,
+				.ot_base     = ordering_buf,
+			);
 			for (U4 i = 0; i < Cube_num_faces; i++) {
-				// Two triangles per quad face: (x,y,z) and (x,z,w)
-				tb_emit(& tb, cube_g4_face);
+				tb_emit(& tb, cube_g4_face); // Two triangles per quad face: (x,y,z) and (x,z,w)
 			}
-
-			tb_emit(& tb, sync_primitive_arena);
-				tb_data(& tb, u4_(& pa->used));
-				tb_data(& tb, prim_base);
+			tb_emit(& tb, sync_primitive_arena); tb_bind_(& tb, Binds_SyncPrimitiveArena,
+				.used   = & pa->used,
+				.cursor = prim_base,
+			);
 		}
-		tape_run(tb_slice(tb));// Fire off the tape (bigger-clobber variant).
-
 		// smem.cube.rot.y += 30;
 	}
 	// Draw floor
@@ -346,45 +319,35 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		mt3s2s4_rotation   (& smem.floor.rot,   & smem.tform_world);
 		mt3s2s4_translation(& smem.tform_world, & smem.floor.pos);
 		mt3s2s4_scale      (& smem.tform_world, & smem.floor.scale);
-
 		// Combine world and look_at matrix.
 		gte_comp_coord_m3s2(& smem.cam.look_at, & smem.tform_world, & smem.tform_view);
-
 		gte_matrix_set_rotation   (& smem.tform_view);
 		gte_matrix_set_translation(& smem.tform_view);
 
-		U4 prim_base   = u4_(pa->buf[smem.active_buf_id]);
-		U4 prim_cursor = prim_base + pa->used;
-
 		// TODO(Ed): We should do a bounds check beforehand to confirm pa can hold all tris?
 		// The tape atoms in-flight should not need to care.
-
-		// Prepare the tape. (Push protocol to tape)
-		tb.used = 0; tb_scope(& tb) {
-			// tb_emit(& tb, set_gte_mt3s2s4);
-			// 	tb_data(& tb, u4_(& smem.tform_view));
-
-			tb_emit(& tb, rbind_floor_f3_face);
-			// TODO(Ed): Just use a single context struct ref?
-				tb_data(& tb, prim_cursor);
-				tb_data(& tb, u4_(smem.floor.faces));
-				tb_data(& tb, u4_(smem.floor.verts));
-				tb_data(& tb, u4_(ordering_buf));
+		U1_R prim_base   = u1_r(pa->buf[smem.active_buf_id]);
+		U1_R prim_cursor = prim_base + pa->used;
+		tb.used = 0; tb_scope_run(& tb) { // Prepare the tape. (Push protocol to tape)
+			tb_emit(& tb, rbind_floor_f3_face); tb_bind_(& tb, Binds_FloorTri,
+				.prim_cursor = prim_cursor,
+				.face_cursor = smem.floor.faces,
+				.vert_base   = smem.floor.verts,
+				.ot_base     = ordering_buf,
+			);
 			for (U4 i = 0; i < Floor_num_faces; i++) {
 				tb_emit(& tb, floor_f3_face);
 			}
 			// After floor_f3_face iterations complete, the primitive arena's used counter needs updating.
-			tb_emit(& tb, sync_primitive_arena);
-				tb_data(& tb, u4_(& pa->used));
-				tb_data(& tb, prim_base);
+			tb_emit(& tb, sync_primitive_arena); tb_bind_(& tb, Binds_SyncPrimitiveArena,
+				.used   = & pa->used,
+				.cursor = prim_base,
+			);
 		}
-		tape_run(tb_slice(tb));// Fire off the tape (bigger-clobber variant).
-
 		// C-side state (pa->used) has already been updated by the tape!
 		// smem.floor.rot.y += 5;
 	}
 }
-GCC_OPTIMIZATION_ENABLE
 
 void render(void) {
 }
@@ -401,12 +364,22 @@ void gp_display_frame(DoubleBuffer* screen_buf, S4* active_buf_id, U4* ordering_
 	active_buf_id[0] = ! active_buf_id[0]; // Swap current buffer
 }
 
-GCC_OPTIMIZATION_DISABLE
 int main(void)
 {
 	smem = (SMemory){0};
-	// TODO(Ed): remove this field we don't need it in smem.
-	smem.scratchpad = C_(U4_V, Scratchpad_Loc);
+
+	B4 basic_sample = false; if (basic_sample) {
+		// We will be defining the tape here along with its atom, then running the tape after.
+		TapeBuilder tb = tb_make(slice_ut_arr(smem.MemTape));
+		MipsCode add_one_to_R_T1[] = {
+			add_ui_self(R_T1, 1),
+			mac_yield(),
+		};
+		tb_emit(& tb, C_(MipsAtom*, add_one_to_R_T1));
+		Tape tape = tb_end(& tb);
+		tape_run(tape);
+	}
+
 	// smem.primitives.used = 0;
 	// smem.active_buf_id   = 0;
 	smem.cam.pos = v3s4(500, -1000, -1500);
@@ -451,4 +424,3 @@ int main(void)
 	};
 	return 0;
 }
-GCC_OPTIMIZATION_ENABLE

code/hello_camera/hello_camera.h

@@ -24,7 +24,7 @@ enum {
 typedef U4 OrderingTable_Buffer[OrderingTbl_Len];
 typedef Array_(OrderingTable_Buffer, 2);
 
-typedef B1 PrimitiveBuffer[PrimitiveBuff_Len];
+typedef U1 PrimitiveBuffer[PrimitiveBuff_Len];
 typedef Array_(PrimitiveBuffer, 2);
 typedef Struct_(PrimitiveArena) {
 	A2_PrimitiveBuffer buf;
@@ -54,14 +54,14 @@ I_ void ent_cube128_init(A8_V3_S2* verts, A6_V4_S2* faces) {
 		{ 2, 3, 6, 7 },
 		{ 3, 0, 7, 4 },
 	};
-	mem_copy(u4_(verts), u4_(& baked_verts), S_(A8_V3_S2) );
-	mem_copy(u4_(faces), u4_(& baked_faces), S_(A6_V4_S2) );
+	mem_copy(b1_r(verts), b1_r(& baked_verts), S_(A8_V3_S2) );
+	mem_copy(b1_r(faces), b1_r(& baked_faces), S_(A6_V4_S2) );
 	return;
 }
 typedef Struct_(Ent_Cube) {
 	V3_S4 accel;
 	V3_S4 vel;
-	V3_S4 pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	V3_S4 pos;
 	V3_S4 scale;
 	V3_S2 rot;
 	A8_V3_S2 verts;
@@ -83,12 +83,12 @@ I_ void ent_floor_init(A4_V3_S2* verts, A2_V3_S2* faces) {
 		{ 0, 1, 2 },
 		{ 1, 3, 2 },
 	};
-	mem_copy(u4_(verts), u4_(& baked_verts), S_(A4_V3_S2));
-	mem_copy(u4_(faces), u4_(& baked_faces), S_(A2_V3_S2));
+	mem_copy(b1_r(verts), b1_r(& baked_verts), S_(A4_V3_S2));
+	mem_copy(b1_r(faces), b1_r(& baked_faces), S_(A2_V3_S2));
 };
 typedef Struct_(Ent_Floor) {
 	V3_S4 accel;
-	V3_S4 pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	V3_S4 pos;
 	V3_S4 scale;
 	V3_S2 rot;
 	A4_V3_S2 verts;
@@ -96,7 +96,7 @@ typedef Struct_(Ent_Floor) {
 };
 
 typedef Struct_(Camera) {
-	P3_S4    pos; // RGA(Lengyel): affine point with implicit weight one. Storage alias of V3_S4.
+	P3_S4    pos;
 	V3_S2    rot;
 	MT3_S2S4 look_at;
 };

scripts/duffle.lua

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

scripts/duffle_isa.lua

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

scripts/duffle_paths.lua

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

scripts/elf32.lua

@@ -22,7 +22,94 @@
 -- spec: System V ABI gABI v1.2 §"ELF Header" (Table 1) + §"Section Header Table"
 -- spec: System V ABI gABI v1.2 §"Symbol Table" (Elf32_Sym layout)
 
-local M = {}
+--- @class Elf32Adapter
+--- @field read_u8_at  fun(off: integer): integer|nil
+--- @field read_u16_at fun(off: integer): integer|nil
+--- @field read_u32_at fun(off: integer): integer|nil
+--- @field read_size   fun(): integer
+
+--- @class Elf32Header
+--- @field e_entry     integer
+--- @field e_shoff     integer
+--- @field e_shentsize integer
+--- @field e_shnum     integer
+--- @field e_shstrndx  integer
+--- @field error       string|nil
+
+--- @class Elf32Section
+--- @field sh_name   integer
+--- @field sh_type   integer
+--- @field sh_flags  integer
+--- @field sh_addr   integer
+--- @field sh_offset integer
+--- @field sh_size   integer
+--- @field sh_link   integer
+--- @field name      string
+
+--- @class Elf32Sym
+--- @field value integer
+--- @field size  integer
+--- @field info  integer
+--- @field shndx integer
+
+--- @class Elf32HeaderLayout
+--- @field magic_offset       integer
+--- @field magic              string
+--- @field class_offset       integer
+--- @field endian_offset      integer
+--- @field header_bytes       integer
+--- @field e_entry_offset     integer
+--- @field e_shoff_offset     integer
+--- @field e_shentsize_offset integer
+--- @field e_shnum_offset     integer
+--- @field e_shstrndx_offset  integer
+
+--- @class Elf32SectionLayout
+--- @field sh_name_offset   integer
+--- @field sh_type_offset   integer
+--- @field sh_flags_offset  integer
+--- @field sh_addr_offset   integer
+--- @field sh_offset_offset integer
+--- @field sh_size_offset   integer
+--- @field sh_link_offset   integer
+--- @field sh_entsize_bytes integer
+
+--- @class Elf32SymLayout
+--- @field st_name         integer
+--- @field st_value        integer
+--- @field st_size         integer
+--- @field st_info         integer
+--- @field sym_entry_bytes integer
+
+--- @class Elf32Mod
+--- @field ELFCLASS32             integer
+--- @field ELFDATA2LSB            integer
+--- @field EM_MIPS                integer
+--- @field SHT_SYMTAB             integer
+--- @field SHT_STRTAB             integer
+--- @field SHT_NOBITS             integer
+--- @field SHF_WRITE              integer
+--- @field SHF_ALLOC              integer
+--- @field SHF_EXECINSTR          integer
+--- @field ELF32_HEADER           Elf32HeaderLayout
+--- @field ELF32_SECTION          Elf32SectionLayout
+--- @field ELF32_SYM              Elf32SymLayout
+--- @field dw_dwarf32_terminator  integer
+--- @field read_u32               fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field read_u16               fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field read_u8                fun(adapter: Elf32Adapter, off: integer): integer|nil
+--- @field size                   fun(adapter: Elf32Adapter): integer
+--- @field read_u32_le            fun(buf: string, off: integer): integer
+--- @field read_u16_le            fun(buf: string, off: integer): integer
+--- @field validate_adapter       fun(adapter: any): boolean, string|nil
+--- @field get_str                fun(strtab: string, off: integer): string|nil
+--- @field parse_elf32_headers    fun(adapter: Elf32Adapter): Elf32Header|nil, string|nil
+--- @field walk_sections          fun(adapter: Elf32Adapter, hdr: Elf32Header): Elf32Section[]|nil, string|nil
+--- @field read_section_bytes     fun(adapter: Elf32Adapter, section: Elf32Section): string|nil
+--- @field read_named_section     fun(adapter: Elf32Adapter, sections: Elf32Section[], name: string): string|nil, string|nil
+--- @field collect_symbols        fun(adapter: Elf32Adapter, sections: Elf32Section[]): table<string, Elf32Sym>|nil, string|nil
+
+local M = {} ---@type Elf32Mod
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Little-endian readers (bit-weighted accumulator, math.floor only)
@@ -39,7 +126,7 @@ local M = {}
 --- **Call form:** explicit-pass. The reader receives `adapter` as the first positional argument and the offset as the second; no `self` is passed.
 --- Test fixtures declare `function(offset) ... end` and the parsers call them via dot syntax `adapter.read_u8_at(off)`.
 --- The colon form `adapter:read_u8_at(off)` would prepend the adapter table as `offset` and break the contract.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param off     integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u32(adapter, off)
@@ -50,7 +137,7 @@ function M.read_u32(adapter, off)
 end
 
 --- Read a 2-byte little-endian unsigned integer from `adapter` at zero-based wire offset `off`.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param off integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u16(adapter, off)
@@ -59,7 +146,7 @@ function M.read_u16(adapter, off)
 end
 
 --- Read a 1-byte unsigned integer from `adapter` at zero-based wire offset `off`.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param off integer  -- zero-based wire offset
 --- @return integer|nil
 function M.read_u8(adapter, off)
@@ -67,7 +154,7 @@ function M.read_u8(adapter, off)
 end
 
 --- Total adapter byte length.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @return integer
 function M.size(adapter)
 	return adapter.read_size()
@@ -76,8 +163,11 @@ end
 --- Forwarders kept for backward compat with scripts/elf_dwarf.lua.
 --- The metaprogram side keeps `read_u32_le` / `read_u16_le`;
 --- both layers now use the same byte-level helpers under the hood.
+--- @param buf string
+--- @param off integer
+--- @return integer
 function M.read_u32_le(buf, off)
-	local byte_off = off + 1
+	local byte_off = off + 1 ---@type integer
 	return buf:byte(byte_off)
 		+ buf:byte(byte_off + 0x01) * 0x00000100
 		+ buf:byte(byte_off + 0x02) * 0x00010000
@@ -89,7 +179,7 @@ end
 --- @param off integer  -- zero-based wire offset
 --- @return integer
 function M.read_u16_le(buf, off)
-	local byte_off = off + 1
+	local byte_off = off + 1 ---@type integer
 	return buf:byte(byte_off) + buf:byte(byte_off + 0x01) * 0x00000100
 end
 
@@ -116,6 +206,7 @@ M.SHF_EXECINSTR = 0x4 -- spec: gABI v1.2 §"Section Attributes" — executable
 -- ELF32 header layout (System V ABI gABI v1.2 §"ELF Header" Table 1)
 -- ---------------------------------------------------------------------------
 -- All offsets are zero-based wire offsets. The header is 52 bytes total (header_bytes = 0x34 = 52).
+--- @type Elf32HeaderLayout
 M.ELF32_HEADER = {
 	magic_offset         = 0x00,  -- 4 bytes; expected "\127ELF"
 	magic                = "\127ELF",
@@ -134,6 +225,7 @@ M.ELF32_HEADER = {
 -- ---------------------------------------------------------------------------
 -- Each entry is 40 bytes (sh_entsize_bytes = 0x28 = 40);
 -- zero-based, field offsets relative to the start of the entry.
+--- @type Elf32SectionLayout
 M.ELF32_SECTION = {
 	sh_name_offset    = 0x00,  -- 4-byte LE; offset into .shstrtab
 	sh_type_offset    = 0x04,  -- 4-byte LE; section type (SHT_*)
@@ -150,6 +242,7 @@ M.ELF32_SECTION = {
 -- ---------------------------------------------------------------------------
 -- Each entry is 16 bytes (sym_entry_bytes = 0x10 = 16);
 -- zero-based, field offsets relative to the start of the entry.
+--- @type Elf32SymLayout
 M.ELF32_SYM = {
 	st_name          = 0x00,  -- 4-byte LE; offset into the linked string table
 	st_value         = 0x04,  -- 4-byte LE; symbol value (address / absolute)
@@ -186,11 +279,11 @@ end
 --- Extract a NUL-terminated C string from `strtab` at zero-based offset `off`.
 --- Returns nil if `off` is out of range or the string is not NUL-terminated.
 --- @param strtab string
---- @param off integer
+--- @param off    integer
 --- @return string|nil
 function M.get_str(strtab, off)
 	if off < 0 or off >= #strtab then return nil end
-	local  end_pos = strtab:find("\0", off + 1, true)
+	local  end_pos = strtab:find("\0", off + 1, true) ---@type integer|nil
 	if not end_pos then return nil end
 	return strtab:sub(off + 1, end_pos - 1)
 end
@@ -205,39 +298,39 @@ end
 --- On failure returns nil + a stable error code:
 ---   bad_magic, unsupported_elf_class, unsupported_elf_data, truncated_header
 --- The header's machine field is NOT validated here — callers (e.g. the helper's prime path) decide whether to require EM_MIPS before symbol reads.
---- @param adapter table
---- @return table|nil, string|nil
+--- @param adapter Elf32Adapter
+--- @return Elf32Header|nil, string|nil
 function M.parse_elf32_headers(adapter)
-	local  ok, err = M.validate_adapter(adapter)
+	local  ok, err = M.validate_adapter(adapter) ---@type boolean, string|nil
 	if not ok then return nil, err end
 
 	-- 4-byte magic: 0x7F 'E' 'L' 'F'.
 	-- The byte readers take the adapter explicitly.
 	-- The production `Support.File` adapter is wrapped by the caller to drop its implicit `self` so the parser shape is flat pass-style.
-	local b1 = M.read_u8(adapter, 0)
-	local b2 = M.read_u8(adapter, 1)
-	local b3 = M.read_u8(adapter, 2)
-	local b4 = M.read_u8(adapter, 3)
+	local b1 = M.read_u8(adapter, 0) ---@type integer|nil
+	local b2 = M.read_u8(adapter, 1) ---@type integer|nil
+	local b3 = M.read_u8(adapter, 2) ---@type integer|nil
+	local b4 = M.read_u8(adapter, 3) ---@type integer|nil
 	if not (b1 and b2 and b3 and b4)
 		or not (b1 == 0x7f and b2 == 0x45 and b3 == 0x4c and b4 == 0x46) then
 		return nil, "bad_magic"
 	end
 
-	local class = M.read_u8(adapter, M.ELF32_HEADER.class_offset)
+	local class = M.read_u8(adapter, M.ELF32_HEADER.class_offset) ---@type integer|nil
 	if    class ~= M.ELFCLASS32 then
 		return nil, "unsupported_elf_class"
 	end
 
-	local data = M.read_u8(adapter, M.ELF32_HEADER.endian_offset)
+	local data = M.read_u8(adapter, M.ELF32_HEADER.endian_offset) ---@type integer|nil
 	if    data ~= M.ELFDATA2LSB then
 		return nil, "unsupported_elf_data"
 	end
 
-	local e_entry     = M.read_u32(adapter, M.ELF32_HEADER.e_entry_offset)
-	local e_shoff     = M.read_u32(adapter, M.ELF32_HEADER.e_shoff_offset)
-	local e_shentsize = M.read_u16(adapter, M.ELF32_HEADER.e_shentsize_offset)
-	local e_shnum     = M.read_u16(adapter, M.ELF32_HEADER.e_shnum_offset)
-	local e_shstrndx  = M.read_u16(adapter, M.ELF32_HEADER.e_shstrndx_offset)
+	local e_entry     = M.read_u32(adapter, M.ELF32_HEADER.e_entry_offset)     ---@type integer|nil
+	local e_shoff     = M.read_u32(adapter, M.ELF32_HEADER.e_shoff_offset)     ---@type integer|nil
+	local e_shentsize = M.read_u16(adapter, M.ELF32_HEADER.e_shentsize_offset) ---@type integer|nil
+	local e_shnum     = M.read_u16(adapter, M.ELF32_HEADER.e_shnum_offset)     ---@type integer|nil
+	local e_shstrndx  = M.read_u16(adapter, M.ELF32_HEADER.e_shstrndx_offset)  ---@type integer|nil
 	if not (e_entry and e_shoff and e_shentsize and e_shnum and e_shstrndx) then
 		return nil, "truncated_header"
 	end
@@ -254,11 +347,11 @@ end
 
 --- Read one section-header entry from `adapter` at `sh_off`.
 --- Returns a table with the wire fields plus a (yet-unresolved) `name` field.
---- @param adapter table
+--- @param adapter Elf32Adapter
 --- @param sh_off  integer
---- @return table|nil, string|nil  -- entry, error
+--- @return Elf32Section|nil, string|nil
 local function read_section_entry(adapter, sh_off)
-	local entry = {
+	local entry = { ---@type Elf32Section
 		sh_name   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_name_offset),
 		sh_type   = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_type_offset),
 		sh_flags  = M.read_u32(adapter, sh_off + M.ELF32_SECTION.sh_flags_offset),
@@ -279,22 +372,22 @@ end
 --- (the section at logical index 0 is at array position 1, etc.).
 --- Each entry has the wire fields plus a resolved `name` derived from `.shstrtab`.
 --- Returns nil + a stable error code on failure: truncated_section_headers, missing_shstrtab, truncated_strtab
---- @param adapter table
---- @param hdr     table  -- the table returned by parse_elf32_headers
---- @return table|nil, string|nil
+--- @param adapter Elf32Adapter
+--- @param hdr     Elf32Header
+--- @return Elf32Section[]|nil, string|nil
 function M.walk_sections(adapter, hdr)
 	if not hdr or hdr.error then return nil, hdr and hdr.error or "truncated_section_headers" end
 
-	local file_size = M.size(adapter)
+	local file_size = M.size(adapter) ---@type integer
 	if hdr.e_shoff + hdr.e_shnum * hdr.e_shentsize > file_size then
 		return nil, "truncated_section_headers"
 	end
 
 	-- Read every section header first; we need .shstrtab to resolve names.
-	local sections = {}
-	for i = 0, hdr.e_shnum - 1 do
-		local sh_off = hdr.e_shoff + i * hdr.e_shentsize
-		local entry, err = read_section_entry(adapter, sh_off)
+	local sections = {} ---@type Elf32Section[]
+	for i = 0, hdr.e_shnum - 1 do ---@type integer
+		local sh_off = hdr.e_shoff + i * hdr.e_shentsize ---@type integer
+		local entry, err = read_section_entry(adapter, sh_off) ---@type Elf32Section|nil, string|nil
 		if not entry then return nil, err end
 		sections[i + 1] = entry
 	end
@@ -303,17 +396,17 @@ function M.walk_sections(adapter, hdr)
 		return nil, "missing_shstrtab"
 	end
 
-	local  shstrtab = sections[hdr.e_shstrndx + 1]
+	local  shstrtab = sections[hdr.e_shstrndx + 1] ---@type Elf32Section|nil
 	if not shstrtab or shstrtab.sh_type ~= M.SHT_STRTAB then
 		return nil, "missing_shstrtab"
 	end
 	if shstrtab.sh_offset + shstrtab.sh_size > file_size then
 		return nil, "truncated_section_headers"
 	end
-	local  shstrtab_bytes = M.read_section_bytes(adapter, shstrtab)
+	local  shstrtab_bytes = M.read_section_bytes(adapter, shstrtab) ---@type string|nil
 	if not shstrtab_bytes then return nil, "truncated_section_headers" end
 
-	for _, s in ipairs(sections) do
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		s.name = M.get_str(shstrtab_bytes, s.sh_name) or ""
 	end
 
@@ -322,15 +415,15 @@ end
 
 --- Read the bytes of one section. Returns a string, or nil if the adapter returns nil for any byte (out-of-bounds).
 --- The caller is responsible fors sizing the buffer (the section's sh_offset + sh_size must fit in adapter.size).
---- @param adapter table
---- @param section table  -- one entry from walk_sections
+--- @param adapter Elf32Adapter
+--- @param section Elf32Section
 --- @return string|nil
 function M.read_section_bytes(adapter, section)
-	local size = section.sh_size
+	local size = section.sh_size ---@type integer
 	if    size == 0 then return "" end
-	local out = {}
-	for i = 0, size - 1 do
-		local b = M.read_u8(adapter, section.sh_offset + i)
+	local out = {} ---@type string[]
+	for i = 0, size - 1 do ---@type integer
+		local b = M.read_u8(adapter, section.sh_offset + i) ---@type integer|nil
 		if    b == nil then return nil end
 		out[#out + 1] = string.char(b)
 	end
@@ -339,15 +432,15 @@ end
 
 --- Convenience: walk sections, then look up the named section, then read its bytes.
 --- Returns nil + a stable error code if the section is absent or out-of-bounds.
---- @param adapter  table
---- @param sections table  -- 1-based array from walk_sections
+--- @param adapter  Elf32Adapter
+--- @param sections Elf32Section[]
 --- @param name     string
 --- @return string|nil, string|nil
 function M.read_named_section(adapter, sections, name)
 	if not sections then return nil, "missing_section" end
-	for _, s in ipairs(sections) do
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		if   s.name == name then
-			local bytes = M.read_section_bytes(adapter, s)
+			local bytes = M.read_section_bytes(adapter, s) ---@type string|nil
 			if not bytes then return nil, "truncated_section_data" end
 			return bytes, nil
 		end
@@ -359,47 +452,47 @@ end
 --- Each stored entry is `{ value = st_value, size = st_size, info = st_info, shndx = st_shndx }`.
 --- Both STB_LOCAL and STB_GLOBAL symbols are included; the live ELF stores `smem` as a local symbol.
 --- Returns nil + a stable error code on failure: missing_symtab_strtab, truncated_section_headers
---- @param adapter  table
---- @param sections table
---- @return table|nil, string|nil
+--- @param adapter  Elf32Adapter
+--- @param sections Elf32Section[]
+--- @return table<string, Elf32Sym>|nil, string|nil
 function M.collect_symbols(adapter, sections)
 	if not sections then return nil, "missing_sections" end
-	local symbols = {}
-	local file_size = M.size(adapter)
-	for _, s in ipairs(sections) do
+	local symbols   = {}              ---@type table<string, Elf32Sym>  -- bag: symbol name -> Elf32Sym
+	local file_size = M.size(adapter) ---@type integer
+	for _, s in ipairs(sections) do ---@type integer, Elf32Section
 		if s.sh_type == M.SHT_SYMTAB then
-			local  strtab = sections[s.sh_link + 1]
+			local  strtab = sections[s.sh_link + 1] ---@type Elf32Section|nil
 			if not strtab or strtab.sh_type ~= M.SHT_STRTAB then
 				return nil, "missing_symtab_strtab"
 			end
 			if strtab.sh_offset + strtab.sh_size > file_size then
 				return nil, "truncated_section_headers"
 			end
-			local  strtab_bytes = M.read_section_bytes(adapter, strtab)
+			local  strtab_bytes = M.read_section_bytes(adapter, strtab) ---@type string|nil
 			if not strtab_bytes then return nil, "truncated_section_headers" end
 			if s.sh_offset + s.sh_size > file_size then
 				return nil, "truncated_section_headers"
 			end
-			local  symtab_bytes = M.read_section_bytes(adapter, s)
+			local  symtab_bytes = M.read_section_bytes(adapter, s) ---@type string|nil
 			if not symtab_bytes then return nil, "truncated_section_headers" end
-			local n = #symtab_bytes / M.ELF32_SYM.sym_entry_bytes
-			for j = 0, n - 1 do
-				local e = s.sh_offset + j * M.ELF32_SYM.sym_entry_bytes
-				local st_name  = M.read_u32(adapter, e + M.ELF32_SYM.st_name)
+			local n = #symtab_bytes / M.ELF32_SYM.sym_entry_bytes ---@type number
+			for j = 0, n - 1 do ---@type integer
+				local e        = s.sh_offset + j * M.ELF32_SYM.sym_entry_bytes ---@type integer
+				local st_name  = M.read_u32(adapter, e + M.ELF32_SYM.st_name)  ---@type integer|nil
 				if    st_name then
-					local st_value = M.read_u32(adapter, e + M.ELF32_SYM.st_value)
-					local st_size  = M.read_u32(adapter, e + M.ELF32_SYM.st_size)
-					local st_info  = M.read_u8(adapter, e + M.ELF32_SYM.st_info)
+					local st_value = M.read_u32(adapter, e + M.ELF32_SYM.st_value) ---@type integer|nil
+					local st_size  = M.read_u32(adapter, e + M.ELF32_SYM.st_size)  ---@type integer|nil
+					local st_info  = M.read_u8(adapter, e + M.ELF32_SYM.st_info)   ---@type integer|nil
 					-- st_shndx is at offset 14 (2 bytes) — derived from the layout
 					-- the metaprogram reads too. Inline the read to keep the
 					-- adapter as the only I/O surface.
-					local b1 = M.read_u8(adapter, e + 14)
-					local b2 = M.read_u8(adapter, e + 15)
+					local b1 = M.read_u8(adapter, e + 14) ---@type integer|nil
+					local b2 = M.read_u8(adapter, e + 15) ---@type integer|nil
 					if not (b1 and b2) then
 						return nil, "truncated_section_headers"
 					end
-					local st_shndx = b1 + b2 * 0x100
-					local name = M.get_str(strtab_bytes, st_name) or ""
+					local st_shndx = b1 + b2 * 0x100 ---@type integer
+					local name = M.get_str(strtab_bytes, st_name) or "" ---@type string
 					if    name ~= "" then
 						symbols[name] = {
 							value = st_value,

scripts/passes/annotation.lua

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

scripts/passes/atoms_source_map.lua

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

scripts/passes/auto_reg.lua

@@ -9,8 +9,7 @@
 --- These GPRs are unavailable to EVERY atom's source pool.
 --- Carriers are preserved across atoms by context discipline and must never be reallocated.
 --- Per-atom body parsing also catches alias references (R_<Alias>) and hardcoded R_Tn references,
---- so the user can write either `R_T4` or `R_ResolveScratch` in an atom body and the pass will
---- exclude R_T4 from that atom's pool.
+--- 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).
@@ -19,50 +18,56 @@
 --- Pool exhaustion: If a phase declares more `R_<Sym>` mappings than the 10-register pool can hold,
 --- emit `phase_register_pool_exhausted` as a build-stopping error.
 
+--- @alias GprIdent string
+
+--- @class GprAllocMap
+--- @field [string] GprIdent  -- bag: auto-reg symbol -> physical GPR
+
+--- @class AutoRegOutput
+--- @field auto_reg_h string
+
 --- @class AutoRegResult
---- @field outputs  table[]  -- {kind=, path=} entries
---- @field errors   table[]  -- {line=, msg=}  entries (build-stops)
---- @field warnings table[]  -- {line=, msg=}  entries (build-continues)
+--- @field outputs  AutoRegOutput[]
+--- @field errors   Finding[]
+--- @field warnings Finding[]
 
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+--- @class AutoRegPass
+--- @field run  fun(ctx: PassCtx): AutoRegResult
+--- @field POOL GprIdent[]
 
--- ════════════════════════════════════════════════════════════════════════════
--- THE GPR ALLOCATION POOL — what's allocatable, and (more importantly) WHY
--- ════════════════════════════════════════════════════════════════════════════
---
--- The auto-reg pass picks physical GPRs for `atom_auto_reg(...)` / `phase_auto_reg(...)` markers.
--- The 24-register pool covers R2-R25 (the user/atom allocatable surface):
---   R_T0..R_T7, R_V0..R_V1, R_A0..A3, R_S0..S7, R_T8..T9.
--- Excluded (and never added to the pool):
---   R_0          (code 0)  — hardwired zero. Cannot be written.
---   R_AT         (code 1)  — assembler temporary. Reserved by the MIPS O32 ABI.
---   R_A0..A3                — explicitly omitted above even though their integer codes
---                              map to POOL entries; the pool-construction loop below
---                              only references the POOL string literals, never the
---                              integer codes, so they are NOT auto-allocated by default.
---                              (A0-A3 become available when the user adds them to
---                              POOL or hardcodes an R_A0 reference in the atom body.)
---   R_K0/K1      (codes 26-27) — kernel / interrupt handler reserves. Never touched by user code.
---   R_GP/SP/FP/RA (codes 28-31) — R_SP/R_FP/R_RA are tape-runtime carriers between
---                              tape_enter and tape_exit; R_GP stays the host global pointer.
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
+local isa            = require("duffle_isa")                                      ---@type DuffleIsa
+
+--- ════════════════════════════════════════════════════════════════════════════
+--- THE GPR ALLOCATION POOL — what's allocatable, and (more importantly) WHY
+--- ════════════════════════════════════════════════════════════════════════════
 ---
-local POOL = {
-	"R_T0", "R_T1", "R_T2", "R_T3",
-	"R_T4", "R_T5", "R_T6", "R_T7",
-	"R_V0", "R_V1",
-	"R_A0", "R_A1", "R_A2", "R_A3",
-	"R_S0", "R_S1", "R_S2", "R_S3",
-	"R_S4", "R_S5", "R_S6", "R_S7",
-	"R_T8", "R_T9",
-}
+--- The auto-reg pass picks physical GPRs for `atom_auto_reg(...)` / `phase_auto_reg(...)` markers.
+--- The 24-register pool covers R2-R25 (the user/atom allocatable surface):
+---   R_T0..R_T7, R_V0..R_V1, R_A0..A3, R_S0..S7, R_T8..T9.
+--- Excluded (and never added to the pool):
+---   R_0          (code 0)   — Hardwired zero. Cannot be written.
+---   R_AT         (code 1)   — Assembler temporary. Reserved by the MIPS O32 ABI.
+---   R_A0..A3                — Explicitly omitted above even though their integer codes map to POOL entries;
+---                             the pool-construction loop below only references the POOL string literals, never the integer codes, so they are NOT auto-allocated by default.
+---                             (A0-A3 become available when the user adds them to POOL or hardcodes an R_A0 reference in the atom body.)
+---   R_K0/K1       (codes 26-27) — Kernel / interrupt handler reserves. Never touched by user code.
+---   R_GP/SP/FP/RA (codes 28-31) — R_SP/R_FP/R_RA are tape-runtime carriers between tape_enter and tape_exit; R_GP stays the host global pointer.
+---
+local POOL = {} ---@type GprIdent[]
+for _, row in ipairs(isa.GPR_ROLE) do ---@type integer, GprRole
+	if row.pool then
+		POOL[#POOL + 1] = row.name
+	end
+end
 
 -- Map from integer MIPS GPR code (the `code` field on AliasEntry) to the physical GPR ident in POOL.
 -- The standard MIPS O32 ABI register numbering matches mips.h's R_*_Code #defines (mips.h).
 -- Only the POOL entries matter for auto_reg — non-pool aliases
 -- (R_AT=1, R_A0..A3=4..7, R_T8=24, R_T9=25, R_K0/K1=26..27, R_GP/SP/FP/RA=28..31) 
 -- are deliberately omitted — see the comment block above for the WHY of each exclusion.
-local INT_CODE_TO_POOL_GPR = {
+local INT_CODE_TO_POOL_GPR = { ---@type table<integer, GprIdent>  -- bag: MIPS GPR code -> POOL ident
 	[2]  = "R_V0", [3]  = "R_V1",
 	[4]  = "R_A0", [5]  = "R_A1", [6]  = "R_A2", [7]  = "R_A3",
 	[8]  = "R_T0", [9]  = "R_T1", [10] = "R_T2", [11] = "R_T3",
@@ -73,25 +78,31 @@ local INT_CODE_TO_POOL_GPR = {
 }
 
 -- Stable sort for deterministic allocation order.
+--- @param tbl table<string, string>  -- bag: key set only; values unused
+--- @return string[]
 local function stable_sort_keys(tbl)
-	local keys = {}
-	for k in pairs(tbl) do keys[#keys + 1] = k end
+	local keys = {}                                ---@type string[]
+	for k in pairs(tbl) do keys[#keys + 1] = k end ---@type string
 	table.sort(keys)
 	return keys
 end
 
 -- Allocate one phase's auto-reg mappings.
 -- Returns (allocated_map, errors). On pool exhaustion, errors is populated and the function halts.
+--- @param phase_label string
+--- @param decls table<string, string>  -- bag: auto-reg symbol -> decl payload
+--- @return GprAllocMap
+--- @return Finding[]
 local function allocate_phase(phase_label, decls)
 	-- Deep-copy POOL into a fresh sequence table. The original `table.unpack and table.unpack(POOL) or { unpack(POOL) }`
 	-- idiom wraps the unpacked values in a single inner table under LuaJIT 5.1 (`table.unpack` is nil; the `or` returns one value),
 	-- which corrupts the pool into `{ {R_T0, R_T1, ...} }` — making `table.remove(pool, 1)` return the inner table on iteration.
-	local pool   = {}
-	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)
+	local pool   = {}                                ---@type GprIdent[]
+	for i = 1, #POOL do pool[i] = POOL[i] end        ---@type integer
+	local result = {}                                ---@type GprAllocMap
+	local errors = {}                                ---@type Finding[]
+	for _, sym in ipairs(stable_sort_keys(decls)) do ---@type integer, string
+		local next_gpr = table.remove(pool, 1) ---@type GprIdent|nil
 		if not next_gpr then
 			errors[#errors + 1] = {
 				line = 0,
@@ -115,13 +126,16 @@ end
 -- Each entry's `code` is the integer MIPS GPR number (0..31); INT_CODE_TO_POOL_GPR translates it back to the physical GPR ident.
 -- Aliases whose `code` points to a non-POOL GPR (e.g. R_S0, R_T8, R_K1) are ignored — 
 -- they don't affect the auto_reg pool, and they're already excluded from POOL above.
+--- @param corpus Corpus
+--- @return table<GprIdent, boolean>
+--- @return table<string, GprIdent>
 local function build_user_pins(corpus)
-	local user_pinned  = {}
-	local alias_to_gpr = {}
+	local user_pinned  = {} ---@type table<GprIdent, boolean>  -- bag: pinned physical GPR -> true
+	local alias_to_gpr = {} ---@type table<string, GprIdent>  -- bag: alias ident -> physical GPR
 	if not corpus.register_alias_registry then return user_pinned, alias_to_gpr end
-	for alias_name, alias_entry in pairs(corpus.register_alias_registry) do
+	for alias_name, alias_entry in pairs(corpus.register_alias_registry) do ---@type string, AliasEntry
 		if alias_entry.has_atom_reg and alias_entry.code then
-			local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code]
+			local gpr = INT_CODE_TO_POOL_GPR[alias_entry.code] ---@type GprIdent|nil
 			if gpr then
 				user_pinned[gpr]         = true
 				alias_to_gpr[alias_name] = gpr
@@ -131,30 +145,33 @@ local function build_user_pins(corpus)
 	return user_pinned, alias_to_gpr
 end
 
--- Find every physical GPR referenced in the atom body, via EITHER:
---   (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 }. Clash-detection and source-pool-exclusion logic
--- only needs the presence of each GPR (boolean test), but keeping count preserves the
--- original find_hardcoded_rn shape so callers can switch without churn.
--- The alias pattern is sorted lexicographically to keep the regex deterministic.
+--- 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 }.
+--- Clash-detection and source-pool-exclusion logic only needs the presence of each GPR (boolean test), 
+--- but keeping count preserves the original find_hardcoded_rn shape so callers can switch without churn.
+--- The alias pattern is sorted lexicographically to keep the regex deterministic.
+--- @param body_text string
+--- @param alias_to_gpr table<string, GprIdent>  -- bag: alias ident -> physical GPR
+--- @return table<GprIdent, integer>
 local function find_used_gprs(body_text, alias_to_gpr)
-	local found = {}
+	local found = {} ---@type table<GprIdent, integer>  -- bag: physical GPR -> hit count
 	-- (a) Hardcoded physical GPRs (R_T0..R_T7, R_V0..R_V1, R_A0..R_A3, R_S0..R_S7).
-	for gpr in body_text:gmatch("(R_T%d+|R_V%d+|R_A%d+|R_S%d+)") do
+	for gpr in body_text:gmatch("(R_T%d+|R_V%d+|R_A%d+|R_S%d+)") do ---@type GprIdent
 		found[gpr] = (found[gpr] or 0) + 1
 	end
 	-- (b) Alias references (R_<Alias>) resolved to physical GPRs via the registry.
 	--      Sorted by name so the regex is byte-stable across runs.
 	if alias_to_gpr and next(alias_to_gpr) then
-		local aliases = {}
-		for alias_name in pairs(alias_to_gpr) do
+		local aliases = {}                       ---@type string[]
+		for alias_name in pairs(alias_to_gpr) do ---@type string
 			aliases[#aliases + 1] = alias_name
 		end
 		table.sort(aliases)
-		local pattern = "(" .. table.concat(aliases, "|") .. ")"
-		for alias_name in body_text:gmatch(pattern) do
-			local gpr = alias_to_gpr[alias_name]
+		local pattern = "(" .. table.concat(aliases, "|") .. ")" ---@type string
+		for alias_name in body_text:gmatch(pattern) do           ---@type string
+			local gpr = alias_to_gpr[alias_name] ---@type GprIdent|nil
 			if gpr and not found[gpr] then
 				found[gpr] = 1
 			end
@@ -164,26 +181,31 @@ local function find_used_gprs(body_text, alias_to_gpr)
 end
 
 -- Emit one gen/auto_reg.h header per directory.
+--- @param out_dir string
+--- @param dir string
+--- @param sources SourceFile[]
+--- @param mappings GprAllocMap
+--- @return string|nil
 local function emit_auto_reg_h(out_dir, dir, sources, mappings)
 	if not mappings or next(mappings) == nil then return end
-	local out_path = out_dir .. "/" .. "auto_reg.h"
+	local out_path = out_dir .. "/" .. "auto_reg.h" ---@type string
 	duffle.ensure_dir(out_dir)
-	local lines = {
+	local lines = { ---@type string[]
 		"#ifdef INTELLISENSE_DIRECTIVES",
 		"#pragma once",
 		"#endif",
 		"// Auto-generated by ps1_meta.lua (passes/auto_reg.lua) — DO NOT EDIT",
 		"// Directory: " .. dir:gsub("/", "\\"),
 	}
-	for _, src in ipairs(sources) do
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
 		lines[#lines + 1] = "//   source: " .. src.path
 	end
 	lines[#lines + 1] = "// Per-phase register allocations resolved by the lua pass."
 	lines[#lines + 1] = "// R_<Sym>_Code = <chosen GPR's _Code constant> for every marker in this directory."
 	lines[#lines + 1] = ""
-	for _, sym in ipairs(stable_sort_keys(mappings)) do
-		local gpr         = mappings[sym]
-		local gpr_code    = gpr .. "_Code"
+	for _, sym in ipairs(stable_sort_keys(mappings)) do ---@type integer, string
+		local gpr         = mappings[sym]  ---@type GprIdent
+		local gpr_code    = gpr .. "_Code" ---@type string
 		lines[#lines + 1] = "#define " .. sym .. "_Code " .. gpr_code
 	end
 	lines[#lines + 1] = ""
@@ -196,16 +218,16 @@ end
 -- Pass entry
 -- ════════════════════════════════════════════════════════════════════════════
 
-local M = {}
+local M = {} ---@type AutoRegPass
 
 --- @param ctx PassCtx
 --- @return AutoRegResult
 function M.run(ctx)
-	local outputs  = {}
-	local errors   = {}
-	local warnings = {}
+	local outputs  = {} ---@type AutoRegOutput[]
+	local errors   = {} ---@type Finding[]
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("auto_reg.run requires ctx.shared.corpus", 0)
 	end
@@ -215,17 +237,17 @@ function M.run(ctx)
 	--  MUST NOT be allocated to any auto-reg marker — they're preserved across atoms by the wave-context discipline.
 	--  The corpus's register_alias_registry is the source of truth for these opt-in pins.
 	--  Body references to those aliases (via alias_to_gpr) are also excluded on a per-atom basis in step 2 below.
-	local user_pinned, alias_to_gpr = build_user_pins(corpus)
+	local user_pinned, alias_to_gpr = build_user_pins(corpus) ---@type table<GprIdent, boolean>, table<string, GprIdent>
 
 	-- 1. Allocate phase pools first (phase declarations take precedence over per-atom declarations).
-	local phase_allocations = {}
-	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
+	local phase_allocations = {}                                     ---@type table<string, GprAllocMap>  -- bag: phase_label -> alloc map
+	for phase_label, decls in pairs(corpus.phase_auto_regs or {}) do ---@type string, table<string, string>
+		local mapping, errs = allocate_phase(phase_label, decls) ---@type GprAllocMap, Finding[]
+		for sym, gpr in pairs(mapping) do                        ---@type string, GprIdent
 			phase_allocations[phase_label]      = phase_allocations[phase_label] or {}
 			phase_allocations[phase_label][sym] = gpr
 		end
-		for _, e in ipairs(errs) do
+		for _, e in ipairs(errs) do ---@type integer, Finding
 			errors[#errors + 1] = e
 		end
 	end
@@ -234,16 +256,16 @@ function M.run(ctx)
 	-- Otherwise, allocate a private pool for the atom.
 	-- The phase membership is in `corpus.atom_phases[phase_label].atoms` (an array of atom names declared via `atom_phase(<phase>)`
 	-- in the atom's `atom_info` line). Build a reverse map `atom_name -> phase_label` so the lookup is O(1) per atom scope.
-	local atom_name_to_phase = {}
-	for phase_label, entry in pairs(corpus.atom_phases or {}) do
-		for _, atom_name in ipairs(entry.atoms or {}) do
+	local atom_name_to_phase = {}                                ---@type table<AtomName, string>  -- bag: atom name -> phase label
+	for phase_label, entry in pairs(corpus.atom_phases or {}) do ---@type string, AtomPhaseGroup
+		for _, atom_name in ipairs(entry.atoms or {}) do ---@type integer, AtomName
 			atom_name_to_phase[atom_name] = phase_label
 		end
 	end
 
-	local atom_allocations = {}
-	for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do
-		local phase_label = atom_name_to_phase[atom_scope]
+	local atom_allocations = {}                                    ---@type table<AtomName, GprAllocMap>  -- bag: atom scope -> alloc map
+	for atom_scope, decls in pairs(corpus.atom_auto_regs or {}) do ---@type AtomName, table<string, string>
+		local phase_label = atom_name_to_phase[atom_scope] ---@type string|nil
 		-- Build the atom's source pool: start with the full POOL, subtract:
 		--   (a) every GPR already committed (phase allocations + prior atom allocations)
 		--   (b) every USER-PINNED GPR (wave-context carriers + file-scope pinned aliases)
@@ -253,27 +275,26 @@ function M.run(ctx)
 		-- the original `source_pool = phase_allocations[phase_label]` form used the phase
 		-- allocation MAP as a pool, but that map has no array part, so `table.remove(source_pool, 1)`
 		-- returned nil and every atom-with-phase marker errored with `phase_register_pool_exhausted`.
-		local used = {}
-		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
+		local used = {}                                                                            ---@type table<GprIdent, boolean>  -- bag: committed or body-referenced GPR -> true
+		for _, m in pairs(phase_allocations) do for _, gpr in pairs(m) do used[gpr] = true end end ---@type integer, GprAllocMap
+		for _, m in pairs(atom_allocations)  do for _, gpr in pairs(m) do used[gpr] = true end end ---@type integer, GprAllocMap
 		-- (c) Body references — scan the atom body for hardcoded + alias-resolved GPRs.
 		--     Folded into `used` so the source_pool exclusion is a single check.
-		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope]
+		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope] ---@type AtomEntry|nil
 		if atom and atom.body then
-			local body_used = find_used_gprs(atom.body, alias_to_gpr)
-			for gpr in pairs(body_used) do used[gpr] = true end
+			local body_used = find_used_gprs(atom.body, alias_to_gpr) ---@type table<GprIdent, integer>
+			for gpr in pairs(body_used) do used[gpr] = true end       ---@type GprIdent
 		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).
+		local source_pool = {}        ---@type GprIdent[]
+		for _, gpr in ipairs(POOL) do ---@type integer, GprIdent
+			-- 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)
+		local result = {}                                ---@type GprAllocMap
+		for _, sym in ipairs(stable_sort_keys(decls)) do ---@type integer, string
+			local next_gpr = table.remove(source_pool, 1) ---@type GprIdent|nil
 			if not next_gpr then
 				errors[#errors + 1] = {
 					line = 0,
@@ -295,11 +316,11 @@ function M.run(ctx)
 	-- This warning is kept as a defensive safety net for cases the body scanner might miss
 	-- (e.g. macros that expand to register references the scanner cannot resolve).
 	-- For each resolved (scope, sym) -> R_Tn mapping, scan the atom body source for used GPRs.
-	for atom_scope, decls in pairs(atom_allocations) do
-		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
+	for atom_scope, decls in pairs(atom_allocations) do ---@type AtomName, GprAllocMap
+		local atom = corpus.atoms_by_name and corpus.atoms_by_name[atom_scope] ---@type AtomEntry|nil
+		if    atom and atom.body then
+			local used_in_body = find_used_gprs(atom.body, alias_to_gpr) ---@type table<GprIdent, integer>
+			for sym, allocated_gpr in pairs(decls) do                    ---@type string, GprIdent
 				if used_in_body[allocated_gpr] and used_in_body[allocated_gpr] > 0 then
 					warnings[#warnings + 1] = {
 						line  = atom.line or 0,
@@ -314,30 +335,32 @@ function M.run(ctx)
 
 	-- 4. Emit per-directory gen/auto_reg.h.
 	-- For each source directory that has atom_auto_regs or phase_auto_regs entries, emit one header.
-	local sources_by_dir = corpus.sources_by_dir or {}
-	for dir, sources in pairs(sources_by_dir) do
-		local per_dir_mappings = {}
-		for _, src in ipairs(sources) do
+	local sources_by_dir = corpus.sources_by_dir or {} ---@type table<string, SourceFile[]>
+	for dir, sources in pairs(sources_by_dir) do       ---@type string, SourceFile[]
+		local per_dir_mappings = {}      ---@type GprAllocMap
+		for _, src in ipairs(sources) do ---@type integer, SourceFile
 			-- Collect every (sym -> gpr) entry that originated from a source in this directory.
 			-- `src.scan.atom_auto_regs` is keyed by ATOM SCOPE NAME; `pairs(t)` iterates KEYS so `scope_name` here is the scope ident (e.g. "cube_g4_face").
 			-- The previous `for _, scan_atom_auto` form silently assigned the VALUE (a `{sym = sym}` table) to the variable,
 			-- which made `atom_allocations[scan_atom_auto]` a table-indexed lookup that never resolved.
-			for scope_name in pairs(src.scan and src.scan.atom_auto_regs or {}) do
-				for sym, gpr in pairs(atom_allocations[scope_name] or {}) do
+			for scope_name in pairs(src.scan and src.scan.atom_auto_regs or {}) do ---@type string
+				for sym, gpr in pairs(atom_allocations[scope_name] or {}) do ---@type string, GprIdent
 					per_dir_mappings[sym] = gpr
 				end
 			end
-			for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do
-				for sym, gpr in pairs(phase_allocations[scope_name] or {}) do
+			for scope_name in pairs(src.scan and src.scan.phase_auto_regs or {}) do ---@type string
+				for sym, gpr in pairs(phase_allocations[scope_name] or {}) do ---@type string, GprIdent
 					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)
+		local out_dir  = dir .. "/gen"                                            ---@type string
+		local out_path = emit_auto_reg_h(out_dir, dir, sources, per_dir_mappings) ---@type string|nil
 		if out_path then outputs[#outputs + 1] = { auto_reg_h = out_path } end
 	end
 	return { outputs = outputs, errors = errors, warnings = warnings }
 end
 
+M.POOL = POOL
+
 return M

scripts/passes/components.lua

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

scripts/passes/emission_model.lua

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

scripts/passes/offsets.lua

@@ -9,13 +9,6 @@
 --- Per-directory aggregation: every source in the same directory contributes to the same `gen/offsets.h`.
 --- The directory itself is the namespace; the filename does not repeat the module name.
 ---
---- (Task 12.16 note: atom-namespaced enum names — e.g., `atom_offset__normalize_v3s4__srav_path__aligned_done` —
---- were considered to prevent cross-atom label collisions, but the C-side `atom_offset(F, T)` macro in
---- `code/duffle/dsl.atom.h` doesn't know the current atom_name at expansion time, so any namespacing
---- on the metaprogram side breaks the C build. Reverted. The C-side would need a per-atom
---- `CURRENT_ATOM` #define (set by `MipsAtom_`/`MipsAtom_Proc_` macros) plus an updated `atom_offset`
---- macro that uses it. That's a coordinated refactor — deferred to a future track.)
----
 --- The offset is `target_word - branch_word - 1` (the standard MIPS branch-immediate encoding: branch_offset = relative_pc_in_words - 1).
 
 -- ════════════════════════════════════════════════════════════════════════════
@@ -27,41 +20,25 @@
 -- Uses `debug.getinfo` to find this file's own directory, so it works both standalone and when require'd from the orchestrator.
 -- Bootstrap: load `duffle_paths.lua` via `debug.getinfo(1, "S").source` (works both standalone + when require'd).
 -- duffle_paths.lua sets package.path then returns `require("duffle")` at the bottom, so the dofile value IS the duffle module.
-local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./"
-local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")
+local _bootstrap_dir = debug.getinfo(1, "S").source:match("^@?(.*[/\\])") or "./" ---@type string
+local duffle         = dofile(_bootstrap_dir .. "../duffle_paths.lua")            ---@type DuffleExport
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Constants
 -- ════════════════════════════════════════════════════════════════════════════
 
 -- Offset macro/enum naming prefixes (the emitted header uses these).
-local OFFSET_MACRO_PREFIX = "_atom_offset_"
-local OFFSET_ENUM_PREFIX  = "atom_offset_"
+local OFFSET_MACRO_PREFIX = "_atom_offset_" ---@type string
+local OFFSET_ENUM_PREFIX  = "atom_offset_"  ---@type string
 
 -- Column width for the `#define _atom_offset_F_T = N` alignment.
-local OFFSET_MACRO_COL = 44
+local OFFSET_MACRO_COL = 44 ---@type integer
 
 -- ════════════════════════════════════════════════════════════════════════════
 -- Type declarations
 -- ════════════════════════════════════════════════════════════════════════════
 
---- @class SourceFile
---- @field path     string  -- Absolute path to the source file
---- @field text     string  -- Full source text
---- @field dir      string  -- Directory containing the source
---- @field basename string  -- Filename without extension
---- @field scan     table   -- Pre-scanned SourceScan payload (from duffle.scan_source)
-
---- @class PassCtx
---- @field shared             table -- Cross-pass shared state
---- @field shared.corpus      table -- Corpus projection
---- @field shared.word_counts table
---- @field out_root           string -- Output root (e.g. "build/gen")
-
---- @class PassResult
---- @field outputs  table[]  -- {kind=, path=} entries describing emit files
---- @field errors   table[]  -- {line=, msg=}  entries; build-stops
---- @field warnings table[]  -- {line=, msg=}  entries; build-succeeds
+-- SourceFile, PassCtx, PassResult: see ps1_meta.lua
 
 --- @class BranchOffset
 --- @field tag               string      -- Marker tag (e.g. "F" in `atom_offset(F, T)`)
@@ -76,6 +53,32 @@ local OFFSET_MACRO_COL = 44
 --- @field total_words integer        -- Total word count of the atom body
 --- @field offsets     BranchOffset[] -- Per-branch offset list
 
+--- @class OffsetBranch
+--- @field tag               string
+--- @field target            string
+--- @field branch_word       integer
+--- @field consuming_encoder string|nil
+--- @field consuming_arg_pos integer|nil
+--- @field line              integer|nil
+
+--- @class MarkerProjectState
+--- @field labels   table<string, integer>  -- bag: label name -> word index
+--- @field branches OffsetBranch[]
+
+--- @class OffsetConst
+--- @field macro_name string
+--- @field enum_name  string
+--- @field value      integer
+
+--- @class OffsetOutput
+--- @field offsets_h string
+
+--- @class OffsetsPass
+--- @field run fun(ctx: PassCtx): PassResult
+
+--- @class AtomEntry
+--- @field paths AtomPaths|nil
+
 -- ════════════════════════════════════════════════════════════════════════════
 -- Canonical marker projection
 -- ════════════════════════════════════════════════════════════════════════════
@@ -83,10 +86,16 @@ local OFFSET_MACRO_COL = 44
 -- MARKER_PROJECTORS is the marker-kind data table.
 -- The emission-model pass already records marker word positions + consuming-instruction context;
 -- this pass only projects those records into the label/branch lookup shape needed by offset computation.
-local MARKER_PROJECTORS = {
+local MARKER_PROJECTORS = { ---@type table<string, fun(state: MarkerProjectState, marker: EmissionMarker): nil>
+	--- @param state MarkerProjectState
+	--- @param marker EmissionMarker
+	--- @return nil
 	label = function(state, marker)
 		state.labels[marker.name] = marker.word_index
 	end,
+	--- @param state MarkerProjectState
+	--- @param marker EmissionMarker
+	--- @return nil
 	offset = function(state, marker)
 		state.branches[#state.branches + 1] = {
 			tag                = marker.name,
@@ -100,12 +109,13 @@ local MARKER_PROJECTORS = {
 
 --- Project canonical marker records into the two lookup tables used by the offset renderer.
 --- No source text, body text, or body token is inspected.
---- @param markers table[] -- atom.paths.markers
---- @return table<string, integer>, table[]
+--- @param markers EmissionMarker[]
+--- @return table<string, integer>
+--- @return OffsetBranch[]
 local function project_markers(markers)
-	local state = { labels = {}, branches = {} }
-	for _, marker in ipairs(markers or {}) do
-		local project = MARKER_PROJECTORS[marker.kind]
+	local state = { labels = {}, branches = {} } ---@type MarkerProjectState
+	for _, marker in ipairs(markers or {}) do    ---@type integer, EmissionMarker
+		local project = MARKER_PROJECTORS[marker.kind] ---@type (fun(state: MarkerProjectState, marker: EmissionMarker): nil)|nil
 		if    project then project(state, marker) end
 	end
 	return state.labels, state.branches
@@ -124,32 +134,35 @@ end
 ---     For cross-module `j`/`jal` (atom body in one module, target in another), the linker emits a `R_MIPS_26` relocation against the lower 26 bits; the upper 4 bits come from the PC of the delay slot following the `j`.
 ---     The metaprogram doesn't know either at compile time, so the emitted value is the relative word offset that the duffle `enc_i` macro places in the immediate field; the toolchain handles the rest.
 ---   `jump_reg` / `call_reg` / `jump_link` -> ERROR. Register-form jumps have no offset field; `atom_offset` is invalid.
----
---- Top-level `atom_offset(F, T)` markers (where the marker is the entire token — `consuming_encoder` == nil) default to `branch_*` behavior (relative offset).
---- This preserves backward compatibility for any top-level marker that may exist outside a control-transfer instruction.
+---   missing `consuming_encoder` -> ERROR. A lone top-level `atom_offset` is not a branch.
 --- @param labels   table<string, integer>
---- @param branches table[]
---- @param errors   table[]
+--- @param branches OffsetBranch[]
+--- @param errors   Finding[]
 --- @return BranchOffset[]
 local function compute_offsets(labels, branches, errors)
-	local results = {}
-	for _, br in ipairs(branches) do
-		local target = labels[br.target]
+	local results = {}               ---@type BranchOffset[]
+	for _, br in ipairs(branches) do ---@type integer, OffsetBranch
+		local target = labels[br.target] ---@type integer|nil
 		if not target then
 			errors[#errors + 1] = {
 				line = br.line or 0,
 				msg  = "Branch target '" .. br.target .. "' has no atom_label (at word " .. br.branch_word .. ")",
 			}
 		else
-			local consuming = br.consuming_encoder
-			if consuming == "jump_reg" or consuming == "call_reg" or consuming == "jump_link" then
+			local consuming = br.consuming_encoder ---@type string|nil
+			if consuming == nil or consuming == "" then
+				errors[#errors + 1] = {
+					line = br.line or 0,
+					msg  = "atom_offset requires a consuming encoder (branch_*, jump, call_addr); top-level atom_offset is invalid; at word " .. br.branch_word,
+				}
+			elseif consuming == "jump_reg" or consuming == "call_reg" or consuming == "jump_link" then
 				errors[#errors + 1] = {
 					line = br.line or 0,
 					msg  = "atom_offset cannot be used with " .. consuming
 						.. " (register-form jumps have no offset field); at word " .. br.branch_word,
 				}
 			else
-				-- All other consuming instructions (including `branch_*`, `jump`, `call_addr`, and nil for top-level markers) use the same relative offset value.
+				-- Consuming instructions with an offset field (`branch_*`, `jump`, `call_addr`) use the same relative offset value.
 				-- The MIPS encoding differs per opcode but the duffle `enc_i` macro handles the truncation to the immediate-field width.
 				results[#results + 1] = {
 					target             = br.target,
@@ -175,7 +188,7 @@ end
 
 --- (internal) Build a constant-table entry `{macro_name, enum_name, value}` from a BranchOffset.
 --- @param bo BranchOffset
---- @return table
+--- @return OffsetConst
 local function make_offset_const(bo)
 	return {
 		macro_name = OFFSET_MACRO_PREFIX .. bo.tag .. "_" .. bo.target,
@@ -187,20 +200,21 @@ end
 --- (internal) Emit one atom's offset constants + enum into the lines buffer.
 --- @param add  fun(s: string)
 --- @param atom AtomData
+--- @return nil
 local function emit_atom_offsets(add, atom)
 	if #atom.offsets == 0 then return end
 	add("// --- atom: " .. atom.name .. " (" .. atom.total_words .. " words) ---")
 	add("")
-	local consts = {}
-	for _, r in ipairs(atom.offsets) do
+	local consts = {}                   ---@type OffsetConst[]
+	for _, r in ipairs(atom.offsets) do ---@type integer, BranchOffset
 		consts[#consts + 1] = make_offset_const(r)
 	end
-	for _, c in ipairs(consts) do
+	for _, c in ipairs(consts) do ---@type integer, OffsetConst
 		add("#define " .. pad_right(c.macro_name, OFFSET_MACRO_COL) .. "  " .. c.value)
 	end
 	add("")
 	add("enum {")
-	for _, c in ipairs(consts) do
+	for _, c in ipairs(consts) do ---@type integer, OffsetConst
 		add("    " .. c.enum_name .. " = " .. c.macro_name .. ",")
 	end
 	add("};")
@@ -208,19 +222,21 @@ local function emit_atom_offsets(add, atom)
 end
 
 --- Generate the per-directory .offsets.h header.
---- @param dir          string     -- the absolute source directory
---- @param sources      table[]    -- sources contributing to this directory (for the header comment)
---- @param atoms_data   AtomData[]
+--- @param dir        string
+--- @param sources    SourceFile[]
+--- @param atoms_data AtomData[]
 --- @return string
 local function generate_header(dir, sources, atoms_data)
-	local dir_basename = duffle.basename_no_ext(dir)
+	local dir_basename = duffle.basename_no_ext(dir) ---@type string
 
-	local lines = {}
+	local lines = {} ---@type string[]
+	--- @param s string
+	--- @return nil
 	local function add(s) lines[#lines + 1] = s end
 
 	add("// Auto-generated by ps1_meta.lua (passes/offsets.lua) — DO NOT EDIT")
 	add("// Directory: " .. dir:gsub("/", "\\") .. "\\")
-	for _, src in ipairs(sources) do
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
 		add("//   source: " .. src.path:gsub("/", "\\"))
 	end
 	add("#pragma once")
@@ -228,7 +244,7 @@ local function generate_header(dir, sources, atoms_data)
 	add("#pragma region " .. dir_basename)
 	add("")
 	add("")
-	for _, atom in ipairs(atoms_data) do
+	for _, atom in ipairs(atoms_data) do ---@type integer, AtomData
 		emit_atom_offsets(add, atom)
 	end
 	add("#pragma endregion " .. dir_basename)
@@ -236,22 +252,24 @@ local function generate_header(dir, sources, atoms_data)
 	return table.concat(lines, "\n") .. "\n"
 end
 
-local M = {}
+local M = {} ---@type OffsetsPass
 
 --- (internal) Aggregate atoms from every source in one directory, render the per-directory `offsets.h`.
 --- Returns the offsets_h path if a header was written, or nil.
 --- @param ctx     PassCtx
---- @param dir     string       -- the absolute source directory
---- @param sources SourceFile[] -- sources in this directory
---- @param errors  table[]
---- @return string|nil  -- the offsets_h path
+--- @param dir     string
+--- @param sources SourceFile[]
+--- @param errors  Finding[]
+--- @return string|nil
 local function process_directory(ctx, dir, sources, errors)
-	local atoms_data = {}
+	local atoms_data = {} ---@type AtomData[]
 
+	--- @param atom AtomEntry
+	--- @return nil
 	local function append_atom(atom)
-		local  paths = atom and atom.paths
+		local  paths = atom and atom.paths ---@type AtomPaths|nil
 		if not paths then return end
-		local labels, branches = project_markers(paths.markers)
+		local labels, branches = project_markers(paths.markers) ---@type table<string, integer>, OffsetBranch[]
 		atoms_data[#atoms_data + 1] = {
 			name        = atom.raw_name or atom.name,
 			total_words = #(paths.word_events or {}),
@@ -259,14 +277,14 @@ local function process_directory(ctx, dir, sources, errors)
 		}
 	end
 
-	for _, src in ipairs(sources) do
-		local scan = src.scan or {}
-		for _, atom in ipairs(scan.atoms or {}) do append_atom(atom) end
-		for _, atom in ipairs(scan.raw_atoms or {}) do append_atom(atom) end
+	for _, src in ipairs(sources) do ---@type integer, SourceFile
+		local scan = src.scan or {}                                          ---@type SourceScan
+		for _, atom in ipairs(scan.atoms or {}) do append_atom(atom) end     ---@type integer, AtomEntry
+		for _, atom in ipairs(scan.raw_atoms or {}) do append_atom(atom) end ---@type integer, AtomEntry
 	end
 	if #atoms_data == 0 then return nil end
 
-	local out_path = dir .. "/gen/offsets.h"
+	local out_path = dir .. "/gen/offsets.h" ---@type string
 	duffle.ensure_dir(duffle.dirname(out_path))
 	duffle.write_file(out_path, generate_header(dir, sources, atoms_data))
 	return out_path
@@ -278,11 +296,11 @@ end
 --- @param ctx PassCtx
 --- @return PassResult
 function M.run(ctx)
-	local outputs  = {}
-	local errors   = {}
-	local warnings = {}
+	local outputs  = {} ---@type OffsetOutput[]
+	local errors   = {} ---@type Finding[]
+	local warnings = {} ---@type Finding[]
 
-	local corpus = ctx.shared and ctx.shared.corpus
+	local corpus = ctx.shared and ctx.shared.corpus ---@type Corpus|nil
 	if type(corpus) ~= "table" then
 		error("offsets.run requires ctx.shared.corpus", 0)
 	end
@@ -291,9 +309,9 @@ function M.run(ctx)
 	end
 
 	-- Per-directory aggregation: every source in the same directory contributes to one `gen/offsets.h`.
-	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order)
-	for dir, sources in pairs(sources_by_dir) do
-		local out_path = process_directory(ctx, dir, sources, errors)
+	local sources_by_dir = corpus.sources_by_dir or duffle.group_sources_by_dir(corpus.source_order) ---@type table<string, SourceFile[]>
+	for dir, sources in pairs(sources_by_dir) do                                                     ---@type string, SourceFile[]
+		local out_path = process_directory(ctx, dir, sources, errors) ---@type string|nil
 		if out_path then
 			outputs[#outputs + 1] = { offsets_h = out_path }
 		end

scripts/passes/word_count_eval.lua

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

scripts/ps1_meta.lua

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