Last adjustments for metaprogram, hitting a intermission checkpoint to do docs, writeups, and other research distillations.

code/duffle/gen/offsets.h

@@ -33,7 +33,7 @@ enum {
     atom_offset_example_atom_proc_skip = _atom_offset_example_atom_proc_skip,
 };
 
-// --- atom: build_normalize_v3s4 (62 words) ---
+// --- atom: normalize_v3s4 (62 words) ---
 
 #define _atom_offset_aligned_done_srav_path           3
 #define _atom_offset_srav_path_aligned_done           4

code/duffle/lottes_tape.h

@@ -99,8 +99,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,
@@ -248,17 +248,17 @@ FI_ TapeBuilder tb_make(Slice mem) { return (TapeBuilder){ u4_(mem.ptr), mem.len
 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_bind(TapeBuilder* tb, Slice data) { mem_copy(tb->ptr + tb->used * S_(MipsCode), u4_(data.ptr), data.len); tb->used += data.len / S_(MipsCode); }
 #define tb_bind_(tb,type,...) tb_bind(tb, (Slice){ (B1*)(& (type){__VA_ARGS__}), S_(type) }); static_assert(S_(type) % S_(MipsCode) == 0)
 
+// 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__)
 
 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))
@@ -387,10 +387,6 @@ FI_ Reg regfile__alloc_helper(A2_U2 file, Reg 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) {

code/hello_camera/hello_camera.c

@@ -113,8 +113,8 @@ I_ void resolve_look_at_c11(MT3_S2S4* look_at, P3_S4* eye, P3_S4* target, V3_S4*
 	forward = target[0]; sub_v3s4(& forward, eye[0]); // RGA(Lengyel): Affine point - point = zero-weight direction.
 	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;
@@ -238,7 +238,6 @@ I_ void resolve_look_at(TapeBuilder_R tb,	MT3_S2S4* look_at, P3_S4* eye, P3_S4*
 }
 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));
@@ -248,15 +247,15 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		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_data(& tb,   u4_(& smem.pad_raw[0]));
+				tb_data(& tb, u4_(& smem.pad[0]));
 			// tb_emit_(pad_bios_snapshot);
 			// 	tb_data_(raw,   & smem.pad_raw[1]);
 			// 	tb_data_(state, & smem.pad[1]);
 
 			tb_emit_(pad_input_cam);
-				tb_data_(state, & smem.pad[0]);
-				tb_data_(cam, & smem.cam);
+				tb_data(& tb, u4_(& smem.pad[0]));
+				tb_data(& tb, u4_(& smem.cam));
 
 			// tb_emit_(pad_input_cube_rotation);
 			// 	tb_data_(state,     & smem.pad[0]);
@@ -289,7 +288,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));
 		}
 	}
 
@@ -372,7 +371,6 @@ void update(PrimitiveArena* pa, U4* ordering_buf)
 		// smem.floor.rot.y += 5;
 	}
 }
-GCC_OPTIMIZATION_ENABLE
 
 void render(void) {
 }
@@ -389,7 +387,6 @@ 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};
@@ -437,4 +434,3 @@ int main(void)
 	};
 	return 0;
 }
-GCC_OPTIMIZATION_ENABLE

scripts/duffle_emit.lua

@@ -1041,6 +1041,16 @@ function M.find_atom_proc_decl_for(source, before_pos, mips_atom_ptr_len)
 		if source:sub(next_pos, next_pos) == "(" then
 			local inner, after_paren = M.read_parens(source, next_pos) ---@type string|nil, integer
 			if inner then
+				if ident == "AtomBundleEntry_" then
+					local tmpl = M.split_top_level_commas(inner) ---@type string[]
+					if   #tmpl ~= 2 then return nil end
+					local name        = M.trim(tmpl[1]) .. "_" .. M.trim(tmpl[2]) ---@type string
+					local formals_pos = M.skip_ws_and_cmt(source, after_paren)    ---@type integer
+					if source:sub(formals_pos, formals_pos) ~= "(" then return nil end
+					local  real_inner, after_real = M.read_parens(source, formals_pos) ---@type string|nil, integer
+					if not real_inner then return nil end
+					return name, real_inner, name, after_real
+				end
 				return ident, inner, ident, after_paren
 			end
 		end

scripts/passes/report.lua

@@ -544,6 +544,50 @@ local function render_section_binds(add, view)
 	if not wrote then add("_(none)_"); add("") end
 end
 
+--- @param add  fun(s: string): nil
+--- @param view ModuleView
+--- @return nil
+local function render_section_atom_bundles(add, view)
+	local bundles = (view.corpus and view.corpus.atom_bundles) or {} ---@type table<string, AtomBundle>
+	local names   = {}                                               ---@type string[]
+	for name, bundle in pairs(bundles) do ---@type string, AtomBundle
+		if path_in_module(bundle.path, view) then
+			names[#names + 1] = name
+		end
+	end
+	if #names == 0 then add("_(none)_"); add(""); return end
+	table.sort(names)
+	for _, name in ipairs(names) do ---@type integer, string
+		local bundle  = bundles[name]        ---@type AtomBundle
+		local entries = bundle.entries or {} ---@type table<string, string>
+		add(string.format("### %s", name))
+		for _, slot in ipairs(bundle.slots or {}) do ---@type integer, string
+			local ident = entries[slot] ---@type string|nil
+			if ident then
+				add(string.format("- `%s` `%s`", slot, ident))
+			else
+				add(string.format("- `%s`", slot))
+			end
+		end
+		add("")
+	end
+end
+
+--- @param add  fun(s: string): nil
+--- @param view ModuleView
+--- @return nil
+local function render_section_tape_emits(add, view)
+	local wrote = false ---@type boolean
+	for _, src in ipairs(view.sources or {}) do ---@type integer, SourceFile
+		for _, emit in ipairs((src.scan and src.scan.tape_emits) or {}) do ---@type integer, TapeEmit
+			wrote = true
+			add(string.format("- `%s` `%s`", emit.name or "?", emit.binds or "—"))
+		end
+	end
+	if not wrote then add("_(none)_"); add(""); return end
+	add("")
+end
+
 --- @param add fun(s: string): nil
 --- @param view ModuleView
 --- @return nil
@@ -895,6 +939,8 @@ local SECTION_RENDERERS = { ---@type SectionRenderer[]
 	{ header = "## Annotations",           render = render_section_annotations },
 	{ header = "## Component annotations", render = render_section_component_annotations },
 	{ header = "## Binds_* structs",       render = render_section_binds },
+	{ header = "## Atom bundles",          render = render_section_atom_bundles },
+	{ header = "## Tape emits",            render = render_section_tape_emits },
 	{ header = "## Phases / views / ctx",  render = render_section_phases },
 	{ header = "## Register aliases",      render = render_section_aliases },
 	{ header = "## Auto-reg",              render = render_section_autoreg },

scripts/passes/scan_source.lua

@@ -127,6 +127,13 @@ local parse_enum_int_literal ---@type fun(text: string, start: integer): (intege
 --- @field body   string
 --- @field bytes  integer|nil
 
+--- @class AtomBundle
+--- @field name    string
+--- @field slots   string[]   -- typedef order
+--- @field line    integer
+--- @field path    string
+--- @field entries table<string, string>|nil  -- slot → B_E when an AtomBundleEntry_ proc exists
+
 --- @class AliasEntry
 --- @field name          string
 --- @field code          integer
@@ -182,6 +189,14 @@ local parse_enum_int_literal ---@type fun(text: string, start: integer): (intege
 --- @class TapeChain
 --- @field [integer] string  -- ordered atom names in one tb_emit chain
 
+--- @class TapeEmit
+--- @field name       string
+--- @field binds      string|nil
+--- @field line       integer
+--- @field path       string
+--- @field slot       string|nil
+--- @field data_words integer|nil
+
 --- @class RegUseView
 --- @field names string[]
 --- @field lanes boolean
@@ -208,6 +223,8 @@ local parse_enum_int_literal ---@type fun(text: string, start: integer): (intege
 --- @field reg_use_schemas         table<string, RegUseSchema>
 --- @field reg_use_errors          RegUseError[]
 --- @field tape_chains             TapeChain[]
+--- @field tape_emits              TapeEmit[]
+--- @field atom_bundles            table<string, AtomBundle>
 --- @field _source_file            string|nil
 --- @field _code_macros            table<string, integer>|nil  -- bag
 --- @field _code_macro_bodies      table<string, string>|nil  -- bag
@@ -2439,11 +2456,76 @@ local function parse_typedef_array(source, pos, id2_end, line_of, out, after_typ
 	return semi and (semi + 1) or after_paren
 end
 
+--- Parse `MipsAtom *slot, …;` from an AtomBundle_ typedef body.
+--- Ignores the MipsAtom type token. Slot name is the ident after `*`.
+--- @param body string
+--- @return string[]
+local function parse_atom_bundle_slots(body)
+	local slots = {} ---@type string[]
+	local pos   = 1  ---@type integer
+	while pos <= #body do
+		pos = duffle.skip_ws_and_cmt(body, pos)
+		if pos > #body then break end
+		local b = body:byte(pos) ---@type integer
+		if b == BYTE_SEMI then
+			break
+		elseif b == BYTE_COMMA then
+			pos = pos + 1
+		elseif b == BYTE_STAR then
+			local after_star       = duffle.skip_ws_and_cmt(body, pos + 1) ---@type integer
+			local ident, ident_end = duffle.read_ident(body, after_star)   ---@type string|nil, integer
+			if ident then
+				slots[#slots + 1] = ident
+				pos = ident_end
+			else
+				pos = pos + 1
+			end
+		else
+			local ident, ident_end = duffle.read_ident(body, pos) ---@type string|nil, integer
+			if ident then
+				pos = ident_end
+			else
+				pos = pos + 1
+			end
+		end
+	end
+	return slots
+end
+
+-- Shape 5: `typedef AtomBundle_(<name>) { MipsAtom *slot, … };`
+--- @param source string
+--- @param pos integer
+--- @param id2_end integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+--- @param after_typedef integer
+--- @return integer
+local function parse_typedef_atom_bundle(source, pos, id2_end, line_of, out, after_typedef)
+	local inner, after_paren, open_paren = read_parens_after(source, id2_end, id2_end) ---@type string|nil, integer, integer
+	if not inner then return id2_end end
+	local name = duffle.trim(inner) ---@type string
+
+	local body, after_brace = find_body_braces(source, after_paren, open_paren + 1) ---@type string|nil, integer
+	if not body then return after_brace end
+	if name ~= "" and out.atom_bundles[name] == nil then
+		local bundle = { ---@type AtomBundle
+			name  = name,
+			slots = parse_atom_bundle_slots(body),
+			line  = line_of(pos),
+			path  = out._source_file or "",
+		}
+		out.atom_bundles[name] = bundle
+	end
+	attach_debug_skip_marker(out, "unrelated")
+	return after_brace
+end
+
 local TYPE_FORMS = { ---@type table<string, fun(source: string, pos: integer, id2_end: integer, line_of: fun(pos: integer): integer, out: SourceScan, after_typedef: integer): integer>
-	Struct_ = parse_typedef_struct,
-	Enum_   = parse_typedef_enum,
-	TSet_   = parse_typedef_tset,
-	Array_  = parse_typedef_array,
+	Struct_     = parse_typedef_struct,
+	Enum_       = parse_typedef_enum,
+	TSet_       = parse_typedef_tset,
+	Array_      = parse_typedef_array,
+	AtomBundle_ = parse_typedef_atom_bundle,
 }
 
 --- Parse: `typedef` declarations.
@@ -2827,6 +2909,23 @@ local function parse_addrs_assign(source, pos, ident_end, line_of, out)
 	return rhs
 end
 
+--- @param out   SourceScan
+--- @param name  string
+--- @param last  string
+--- @param line  integer
+--- @return nil
+local function push_tape_emit(out, name, last, line)
+	out.tape_emits = out.tape_emits or {}
+	out.tape_emits[#out.tape_emits + 1] = { ---@type TapeEmit
+		name       = name,
+		binds      = nil,
+		line       = line,
+		path       = out._source_file or "",
+		slot       = last:find("->", 1, true) and name or nil,
+		data_words = 0,
+	}
+end
+
 --- @param source string
 --- @param pos integer
 --- @param ident_end integer
@@ -2837,10 +2936,12 @@ local function parse_tb_emit_(source, pos, ident_end, line_of, out)
 	local after = duffle.skip_ws_and_cmt(source, ident_end) ---@type integer
 	if source:sub(after, after) ~= "(" then return ident_end end
 	local inner, after_p = duffle.read_parens(source, after)           ---@type string|nil, integer
-	local name           = duffle.trim(inner or ""):match("^([%w_]+)") ---@type string
+	local last           = duffle.trim(inner or "")                    ---@type string
+	local name           = last:match("^([%w_]+)")                     ---@type string
 	if name then
 		out._chain = out._chain or {}
 		out._chain[#out._chain + 1] = name
+		push_tape_emit(out, name, last, line_of(pos))
 	end
 	return after_p or (after + 1)
 end
@@ -2865,6 +2966,49 @@ local function parse_tb_emit(source, pos, ident_end, line_of, out)
 	if name then
 		out._chain = out._chain or {}
 		out._chain[#out._chain + 1] = name
+		push_tape_emit(out, name, last, line_of(pos))
+	end
+	return after_p or (after + 1)
+end
+
+--- @param source string
+--- @param pos integer
+--- @param ident_end integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+--- @return integer
+local function parse_tb_bind_(source, pos, ident_end, line_of, out)
+	local after = duffle.skip_ws_and_cmt(source, ident_end) ---@type integer
+	if source:sub(after, after) ~= "(" then return ident_end end
+	local inner, after_p = duffle.read_parens(source, after)          ---@type string|nil, integer
+	local args           = duffle.split_top_level_commas(inner or "") ---@type string[]
+	local typ            = duffle.trim(args[2] or "")                 ---@type string
+	if typ ~= "" then
+		local emits = out.tape_emits or {} ---@type TapeEmit[]
+		for i = #emits, 1, -1 do           ---@type integer
+			if emits[i].binds == nil then
+				emits[i].binds = typ
+				break
+			end
+		end
+	end
+	return after_p or (after + 1)
+end
+
+--- @param source string
+--- @param pos integer
+--- @param ident_end integer
+--- @param line_of fun(pos: integer): integer
+--- @param out SourceScan
+--- @return integer
+local function parse_tb_data(source, pos, ident_end, line_of, out)
+	local after = duffle.skip_ws_and_cmt(source, ident_end) ---@type integer
+	if source:sub(after, after) ~= "(" then return ident_end end
+	local _, after_p = duffle.read_parens(source, after) ---@type string|nil, integer
+	local emits = out.tape_emits or {} ---@type TapeEmit[]
+	local last  = emits[#emits]        ---@type TapeEmit|nil
+	if last then
+		last.data_words = (last.data_words or 0) + 1
 	end
 	return after_p or (after + 1)
 end
@@ -2872,6 +3016,8 @@ end
 local C_STMT_PARSERS = { ---@type table<string, fun(source: string, pos: integer, ident_end: integer, line_of: fun(pos: integer): integer, out: SourceScan): integer>
 	tb_emit_ = parse_tb_emit_,
 	tb_emit  = parse_tb_emit,
+	tb_bind_ = parse_tb_bind_,
+	tb_data  = parse_tb_data,
 	addrs    = parse_addrs_assign,
 }
 
@@ -2924,6 +3070,8 @@ local function scan_source(source, source_file, code_macros, code_macro_bodies)
 		atoms                = {},
 		raw_atoms            = {},
 		binds                = {},
+		atom_bundles         = {},
+		tape_emits           = {},
 		atom_infos           = {},
 		component_atom_infos = {},
 		macros               = {},
@@ -3238,6 +3386,8 @@ local function merge_corpus_registries(corpus)
 	corpus.reg_use_schemas         = corpus.reg_use_schemas         or {}
 	corpus.reg_use_errors          = corpus.reg_use_errors          or {}
 	corpus.tape_chains             = corpus.tape_chains             or {}
+	corpus.atom_bundles            = corpus.atom_bundles            or {}
+	corpus.tape_emits              = corpus.tape_emits              or {}
 
 	-- Replace the existing corpus collections with empty tables so a re-run on the same corpus produces identical state (deterministic merge).
 	-- This is safe because M.run is the only writer to these tables within a single orchestrator invocation.
@@ -3255,6 +3405,8 @@ local function merge_corpus_registries(corpus)
 		"reg_use_schemas",
 		"reg_use_errors",
 		"tape_chains",
+		"atom_bundles",
+		"tape_emits",
 	}) do
 		corpus[key] = {}
 	end
@@ -3362,6 +3514,55 @@ local function merge_corpus_registries(corpus)
 			for _, chain in ipairs(scan.tape_chains or {}) do ---@type integer, TapeChain
 				corpus.tape_chains[#corpus.tape_chains + 1] = chain
 			end
+			for _, emit in ipairs(scan.tape_emits or {}) do ---@type integer, TapeEmit
+				corpus.tape_emits[#corpus.tape_emits + 1] = emit
+			end
+
+			-- atom_bundles: keyed by typedef name. First-wins per name (like components).
+			for name, bundle in pairs(scan.atom_bundles or {}) do ---@type string, AtomBundle
+				if corpus.atom_bundles[name] == nil then
+					corpus.atom_bundles[name] = bundle
+				end
+			end
+		end
+	end
+
+	-- Join slot roles to AtomBundleEntry_ identities after catalogs and atoms exist.
+	-- Do not invent a catalog from an entry that has no typedef.
+	for _, bundle in pairs(corpus.atom_bundles) do ---@type string, AtomBundle
+		local entries = {} ---@type table<string, string>
+		for _, slot in ipairs(bundle.slots or {}) do ---@type integer, string
+			local atom_name = bundle.name .. "_" .. slot ---@type string
+			if corpus.atoms_by_name[atom_name] then
+				entries[slot] = atom_name
+			end
+		end
+		if next(entries) then
+			bundle.entries = entries
+		end
+	end
+
+	-- Resolve tb_emit names: atom first, else unique catalog slot → entries[slot].
+	-- Ambiguous slot or missing entry: leave the raw ident (no A/B later).
+	for _, emit in ipairs(corpus.tape_emits) do ---@type integer, TapeEmit
+		if corpus.atoms_by_name[emit.name] == nil then
+			local slot = emit.slot or emit.name ---@type string
+			local hit  = nil                    ---@type AtomBundle|nil
+			local n    = 0                      ---@type integer
+			for _, bundle in pairs(corpus.atom_bundles) do ---@type string, AtomBundle
+				for _, s in ipairs(bundle.slots or {}) do ---@type integer, string
+					if s == slot then
+						n = n + 1
+						hit = bundle
+						break
+					end
+				end
+			end
+			local ident = hit and hit.entries and hit.entries[slot] ---@type string|nil
+			if n == 1 and ident then
+				emit.name = ident
+				emit.slot = slot
+			end
 		end
 	end
 end

scripts/passes/static_analysis.lua

@@ -4016,6 +4016,66 @@ end
 -- Each check is one table row and one `check_*` function.
 -- This is the plex pattern: the iteration is in ONE place (validate), the variation is in DATA (this table).
 
+--- @param src      SourceFile
+--- @param pipe_ctx PassScratch
+--- @param findings Finding[]
+--- @return nil
+local function check_tb_bind_type_match(src, pipe_ctx, findings)
+	local atoms_by_name = pipe_ctx.atoms_by_name or {} ---@type table<string, AtomEntry>
+	local info_by       = {}                           ---@type table<string, AtomInfoEntry>
+	for _, info in ipairs(pipe_ctx.atom_infos_all or {}) do ---@type integer, AtomInfoEntry
+		info_by[info.atom_name] = info
+	end
+	for name, info in pairs(pipe_ctx.info_by_atom or {}) do ---@type string, AtomInfoEntry
+		info_by[name] = info
+	end
+	for _, emit in ipairs((src.scan and src.scan.tape_emits) or {}) do ---@type integer, TapeEmit
+		if atoms_by_name[emit.name] then
+			local atom_binds = info_by[emit.name] and info_by[emit.name].binds ---@type string|nil
+			if emit.binds and atom_binds and emit.binds ~= atom_binds then
+				findings[#findings + 1] = {
+					atom  = emit.name,
+					line  = emit.line or 0,
+					check = "tb_bind_type_match",
+					kind  = "error",
+					msg   = string.format("tb_emit '%s' binds %s but atom_bind is %s"
+						, emit.name, emit.binds, atom_binds),
+				}
+			end
+		end
+	end
+end
+
+--- @param src      SourceFile
+--- @param pipe_ctx PassScratch
+--- @param findings Finding[]
+--- @return nil
+local function check_tb_bind_required(src, pipe_ctx, findings)
+	local atoms_by_name = pipe_ctx.atoms_by_name or {} ---@type table<string, AtomEntry>
+	local info_by       = {}                           ---@type table<string, AtomInfoEntry>
+	for _, info in ipairs(pipe_ctx.atom_infos_all or {}) do ---@type integer, AtomInfoEntry
+		info_by[info.atom_name] = info
+	end
+	for name, info in pairs(pipe_ctx.info_by_atom or {}) do ---@type string, AtomInfoEntry
+		info_by[name] = info
+	end
+	for _, emit in ipairs((src.scan and src.scan.tape_emits) or {}) do ---@type integer, TapeEmit
+		if atoms_by_name[emit.name] then
+			local atom_binds = info_by[emit.name] and info_by[emit.name].binds ---@type string|nil
+			if atom_binds and emit.binds == nil and (emit.data_words or 0) == 0 then
+				findings[#findings + 1] = {
+					atom  = emit.name,
+					line  = emit.line or 0,
+					check = "tb_bind_required",
+					kind  = "error",
+					msg   = string.format("tb_emit '%s' has atom_bind(%s) but no tb_bind_ or tb_data"
+						, emit.name, atom_binds),
+				}
+			end
+		end
+	end
+end
+
 local CHECK_RULES = { ---@type CheckRule[]
 	{ name = "transfer_hazards",                per_atom   = check_transfer_hazards                },
 	{ name = "gte_input_latch",                 per_atom   = check_gte_input_latch                 },
@@ -4040,6 +4100,8 @@ local CHECK_RULES = { ---@type CheckRule[]
 	{ name = "binds_no_substruct_deref",        per_source = check_binds_no_substruct_deref        },
 	{ name = "component_self_consistency",      per_source = check_component_self_consistency      },
 	{ name = "atom_calls_inferred_traffic",     per_atom   = check_atom_calls_inferred_traffic     },
+	{ name = "tb_bind_type_match",              per_source = check_tb_bind_type_match              },
+	{ name = "tb_bind_required",                per_source = check_tb_bind_required                },
 }
 
 -- ════════════════════════════════════════════════════════════════════════════

scripts/ps1_meta.lua

@@ -77,6 +77,8 @@ local PASS_FLAG_DISPATCH_KEY   = "__pass__" ---@type string
 --- @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
@@ -373,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:
@@ -665,6 +666,8 @@ local function build_ctx(args)
 		atom_phases             = {},
 		word_counts             = {},
 		components              = {},
+		atom_bundles            = {},
+		tape_emits              = {},
 		collisions              = {},
 		resolver                = resolution.resolver,
 	}
@@ -816,8 +819,7 @@ local function main(argv)
 		local requested = args.requested_set           ---@type string[]
 		local closed    = topo_sort(PASSES, requested) ---@type string[]
 
-		local had_errors = dispatch_passes(ctx, closed) ---@type boolean
-		if had_errors then os.exit(EXIT_VALIDATION_ERRORS) end
+		dispatch_passes(ctx, closed)
 	end)
 
 	if not ok then