fix: update E2E test helpers and fix fref allocation in allocate.py

- Add setup_tokens injection to run_program_direct E2E helper
- Fix fref assignment to interleave const and dest slots per node
- Fix const/dest slot counting to match actual node requirements
- Update frame layout computation to track all slots needed

asm/allocate.py

···
             # flit 1 (from EXTRACT_TAG) that determines the destination.
             # In the frame model, this maps to OutputStyle.CHANGE_TAG.
             has_ctx_override = any(e.ctx_override for e in out_edges)
-            output = OutputStyle.CHANGE_TAG if has_ctx_override else OutputStyle.INHERIT
+            if dest_count == 0:
+                output = OutputStyle.SINK
+            elif has_ctx_override:
+                output = OutputStyle.CHANGE_TAG
+            else:
+                output = OutputStyle.INHERIT
 
         mode = (output, has_const, dest_count)
         updated[name] = replace(node, mode=mode)
···
             )
             errors.append(warning)
 
-        # Collect constants (with deduplication by value)
-        const_values = {}
-        for node in nodes_in_act:
-            if node.const is not None and not isinstance(node.const, (str, type(None))):
-                const_values[node.const] = True
+        # Collect constants (one per const node; deduplicated by value later if needed)
+        const_count = sum(1 for n in nodes_in_act if n.const is not None and not isinstance(n.const, (str, type(None))))
 
-        # Collect destinations (with deduplication by identity)
-        dest_set = set()
-        for node in nodes_in_act:
-            out_edges = edges_by_source.get(node.name, [])
-            for edge in out_edges:
-                dest_set.add(edge.dest)
+        # Collect destination slots: each node needs dest_count slots for its destinations
+        # These are not deduplicated - each node gets its own slot(s)
+        dest_count = sum(n.mode[2] for n in nodes_in_act if n.mode is not None)
 
         # Count slots needed
         # Match slots reserved at 0 to matchable_offsets-1 (regardless of dyadic_count)
         match_slot_count = matchable_offsets
-        const_slot_count = len(const_values)
-        dest_slot_count = len(dest_set)
+        const_slot_count = const_count
+        dest_slot_count = dest_count
 
         # SM params and sinks (only count actual sink MemOps)
         sink_slot_count = len([n for n in nodes_in_act if isinstance(n.opcode, MemOp) and n.opcode in _SINK_MEMOPS])
···
             continue
 
         # Build frame layout
+        # NOTE: With interleaved const+dest allocation, const_slots and dest_slots are not
+        # contiguous separate regions. They're interleaved per node. The slot_map below is
+        # therefore approximate for documentation; the actual slot allocation comes from node frefs.
         match_slots = tuple(range(match_slot_count))
+
+        # All non-match slots are either const or dest type
+        # For documentation: mark const slots and dest slots
+        # This is approximate since they're interleaved
         const_start = match_slot_count
         const_slots = tuple(range(const_start, const_start + const_slot_count))
         dest_start = const_start + const_slot_count
···
 
         layout = act_id_to_layout[act_id]
 
-        # Assign fref to each node based on its mode
+        # Assign fref to each node in order
+        # const_nodes need: [const, dest1, dest2, ...] layout
+        # no-const,dest_nodes need: [dest1, dest2, ...] layout
+        # Allocation order: process nodes in sorted order, mixing const and dest allocations
+        # to ensure that const nodes get const_slot at fref with dests at fref+1 onward
         node_frefs = {}
-        next_slot = matchable_offsets  # Start after match region (uses parameter, not layout)
+
+        # Separate nodes by type
+        const_nodes = []
+        no_const_dest_nodes = []
+        sink_nodes = []
 
-        for node in nodes_in_act:
+        for node in sorted(nodes_in_act, key=lambda n: n.name):
             if node.seed or node.mode is None:
                 continue
+            output_style, has_const, dest_count = node.mode
+            if output_style == OutputStyle.SINK:
+                sink_nodes.append(node)
+            elif has_const:
+                const_nodes.append(node)
+            elif dest_count > 0:
+                no_const_dest_nodes.append(node)
 
-            # Calculate slot count for this node based on its mode
-            output_style, has_const, dest_count = node.mode
+        # Allocate const nodes first (they get const slot + dest slots)
+        slot_counter = matchable_offsets  # Start after match region
+        for node in const_nodes:
+            _, has_const, dest_count = node.mode
+            # Assign fref to const slot
+            node_frefs[node.name] = slot_counter
+            slot_counter += 1 + dest_count  # const + dests
 
-            # Determine slot count based on OutputStyle and parameters
-            if output_style == OutputStyle.SINK:
-                slot_count = 1  # Sink target slot
-            else:
-                # INHERIT or CHANGE_TAG: has_const slots + dest_count slots
-                slot_count = int(has_const) + dest_count
+        # Then allocate no-const,dest nodes
+        for node in no_const_dest_nodes:
+            _, has_const, dest_count = node.mode
+            # Assign fref to first dest slot
+            node_frefs[node.name] = slot_counter
+            slot_counter += dest_count
 
-            # Assign this node's fref
-            node_frefs[node.name] = next_slot
-            next_slot += slot_count
+        # Finally allocate sink nodes
+        for node in sink_nodes:
+            node_frefs[node.name] = slot_counter
+            slot_counter += 1
 
         act_id_to_node_frefs[act_id] = node_frefs
 

tests/test_e2e.py

···
     env = simpy.Environment()
     sys = build_topology(env, result.pe_configs, result.sm_configs)
 
-    # Inject seed tokens
+    # Inject setup tokens first (frame/IRAM initialization)
+    for setup in result.setup_tokens:
+        sys.inject(setup)
+
+    # Then inject seed tokens
     for seed in result.seed_tokens:
         sys.inject(seed)
 

tests/test_foundation_types.py

···
     def test_iramwrite_token_does_not_exist(self):
         """IRAMWriteToken is no longer available in tokens module."""
         with pytest.raises(ImportError):
-            from tokens import PELocalWriteToken  # type: ignore
+            from tokens import IRAMWriteToken  # type: ignore
 
 
 # ============================================================================

tests/test_integration.py

···
     """Test AC5.1: IRAM initialization"""
 
     def test_iram_contains_instructions_at_configured_offsets(self):
-        """IRAM contains ALUInst at offsets specified in PEConfig."""
+        """IRAM contains Instruction at offsets specified in PEConfig."""
         env = simpy.Environment()
 
         pe_iram = {
-            0: ALUInst(
-                op=ArithOp.ADD,
-                dest_l=None,
-                dest_r=None,
-                const=None,
+            0: Instruction(
+                opcode=ArithOp.ADD,
+                output=OutputStyle.INHERIT,
+                has_const=False,
+                dest_count=0,
+                wide=False,
+                fref=0,
             ),
-            5: ALUInst(
-                op=RoutingOp.CONST,
-                dest_l=None,
-                dest_r=None,
-                const=99,
+            5: Instruction(
+                opcode=RoutingOp.CONST,
+                output=OutputStyle.INHERIT,
+                has_const=True,
+                dest_count=0,
+                wide=False,
+                fref=0,
             ),
         }
 
···
 
         # Verify instructions are at expected offsets
         assert 0 in sys.pes[0].iram
-        assert sys.pes[0].iram[0].op == ArithOp.ADD
+        assert sys.pes[0].iram[0].opcode == ArithOp.ADD
         assert 5 in sys.pes[0].iram
-        assert sys.pes[0].iram[5].op == RoutingOp.CONST
-        assert sys.pes[0].iram[5].const == 99
+        assert sys.pes[0].iram[5].opcode == RoutingOp.CONST
 
     def test_iram_does_not_contain_uninitialized_offsets(self):
         """IRAM does not contain offsets not specified in config."""
         env = simpy.Environment()
 
         pe_iram = {
-            0: ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None),
-            5: ALUInst(op=RoutingOp.CONST, dest_l=None, dest_r=None, const=99),
+            0: Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=0, wide=False, fref=0),
+            5: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.INHERIT, has_const=True, dest_count=0, wide=False, fref=0),
         }
 
         sys = build_topology(
···
         token = MonadToken(
             target=0,
             offset=0,
-            ctx=0,
+            act_id=0,
             data=42,
             inline=False,
         )
···
             op=MemOp.READ,
             flags=None,
             data=None,
-            ret=CMToken(target=0, offset=0, ctx=0, data=0),
+            ret=CMToken(target=0, offset=0, act_id=0, data=0),
         )
 
         sys.inject(token)
···
             op=MemOp.READ,
             flags=None,
             data=None,
-            ret=CMToken(target=0, offset=0, ctx=0, data=0),
+            ret=CMToken(target=0, offset=0, act_id=0, data=0),
         )
         sys.inject(token1)
 
···
 
         assert len(sys.sms[1].input_store.items) == 1
         assert sys.sms[1].input_store.items[0].addr == 20
-
-
-class TestAC51GenCounterInitialization:
-    """Test AC5.1 extended: gen_counter initialization"""
-
-    def test_gen_counters_initialized_from_config(self):
-        """PEConfig with gen_counters list initializes PE's gen_counters."""
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [PEConfig(pe_id=0, iram={}, 0, 2, 3])],
-            [],
-        )
-
-        # Verify gen_counters match config
-        assert sys.pes[0].gen_counters == [1, 0, 2, 3]
-
-    def test_gen_counters_default_to_zero_when_none(self):
-        """PEConfig with gen_counters=None (default) initializes all to 0."""
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [PEConfig(pe_id=0, iram={})],
-            [],
-        )
-
-        # Verify all gen_counters are 0 (ctx_slots default is 16)
-        assert sys.pes[0].gen_counters == [0] * 16
-
-    def test_gen_counters_with_custom_ctx_slots(self):
-        """gen_counters list length matches ctx_slots."""
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [
-                PEConfig(
-                    pe_id=0, iram={}, frame_count=8, gen_counters=[1, 2, 3, 4, 5, 6, 7, 8]
-                )
-            ],
-            [],
-        )
-
-        # Verify gen_counters match provided list
-        assert sys.pes[0].gen_counters == [1, 2, 3, 4, 5, 6, 7, 8]
-        assert len(sys.pes[0].gen_counters) == 8
-
-
-class TestAC61E2EConstFedsAdd:
-    """Test AC6.1: CONST on PE0 feeds ADD on PE1"""
-
-    def test_const_feeds_add(self):
-        """CONST on PE0 emits tokens that arrive at PE1, trigger ADD, produce correct result."""
-        env = simpy.Environment()
-
-        # PE0 IRAM: offset 0 = CONST(7), offset 1 = CONST(3)
-        pe0_iram = {
-            0: ALUInst(
-                op=RoutingOp.CONST,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=None,
-                const=7,
-            ),
-            1: ALUInst(
-                op=RoutingOp.CONST,
-                dest_l=Addr(a=0, port=Port.R, pe=1),
-                dest_r=None,
-                const=3,
-            ),
-        }
-
-        # PE1 IRAM: offset 0 = ADD routing to PE2 (collector)
-        pe1_iram = {
-            0: ALUInst(
-                op=ArithOp.ADD,
-                dest_l=Addr(a=0, port=Port.L, pe=2),
-                dest_r=None,
-                const=None,
-            ),
-        }
-
-        # Build topology with 3 PEs (PE2 has no IRAM, acts as collector)
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram=pe0_iram),
-                PEConfig(pe_id=1, iram=pe1_iram),
-                PEConfig(pe_id=2, iram={}),
-            ],
-            [],
-        )
-
-        # Set up PE1's routing to direct output to a collector store (not PE2's input_store)
-        # This simulates a sink where results are collected without being consumed
-        collector_store = simpy.Store(env, capacity=100)
-        sys.pes[1].route_table[2] = collector_store
-
-        # Inject tokens via SimPy process
-        def injector():
-            yield sys.pes[0].input_store.put(
-                MonadToken(target=0, offset=0, act_id=0, data=0, inline=False)
-            )
-            yield sys.pes[0].input_store.put(
-                MonadToken(target=0, offset=1, act_id=0, data=0, inline=False)
-            )
-
-        env.process(injector())
-
-        # Run simulation until quiescence
-        env.run(until=1000)
-
-        # Verify collector receives exactly one token with data=10 (7+3)
-        assert len(collector_store.items) == 1
-        result_token = collector_store.items[0]
-        assert result_token.data == 10
-
-
-class TestAC62E2ESMRoundTrip:
-    """Test AC6.2: SM round-trip (PE writes, PE reads)"""
-
-    def test_sm_round_trip(self):
-        """PE writes to SM, another PE reads from SM, receives correct data."""
-        env = simpy.Environment()
-
-        # PE0 IRAM: offset 0 = SM WRITE, offset 1 = SM READ
-        pe0_iram = {
-            0: SMInst(op=MemOp.WRITE, sm_id=0, const=0),  # Write to cell 0
-            1: SMInst(
-                op=MemOp.READ,
-                sm_id=0,
-                const=0,  # Read from cell 0
-                ret=Addr(a=0, port=Port.L, pe=1),
-            ),
-        }
-
-        # PE1 IRAM: offset 0 = PASS (to pass through SM READ result)
-        pe1_iram = {
-            0: ALUInst(
-                op=RoutingOp.PASS,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=None,
-                const=None,
-            ),
-        }
-
-        # Build topology
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram=pe0_iram),
-                PEConfig(pe_id=1, iram=pe1_iram),
-            ],
-            [
-                # SM0: cell 0 starts EMPTY
-                SMConfig(sm_id=0, cell_count=512, initial_cells={}),
-            ],
-        )
-
-        # Set up collector for PE1's output
-        collector_store = simpy.Store(env, capacity=100)
-        sys.pes[1].route_table[1] = collector_store
-
-        # Inject tokens via SimPy process (FIFO order ensures WRITE before READ)
-        def injector():
-            yield sys.pes[0].input_store.put(
-                MonadToken(target=0, offset=0, act_id=0, data=42, inline=False)
-            )
-            yield sys.pes[0].input_store.put(
-                MonadToken(target=0, offset=1, act_id=0, data=0, inline=False)
-            )
-
-        env.process(injector())
-
-        # Run simulation
-        env.run(until=1000)
-
-        # Verify collector receives a token with data=42 (the value written and read back)
-        assert len(collector_store.items) >= 1
-        result_token = collector_store.items[0]
-        assert result_token.data == 42
-
-
-class TestAC63E2EDualFanout:
-    """Test AC6.3: DUAL mode fan-out to two consumers"""
-
-    def test_dual_fanout(self):
-        """DUAL mode emits same result to both PE1 and PE2."""
-        env = simpy.Environment()
-
-        # PE0 IRAM: offset 0 = PASS with dual destinations
-        pe0_iram = {
-            0: ALUInst(
-                op=RoutingOp.PASS,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=Addr(a=0, port=Port.L, pe=2),
-                const=None,
-            ),
-        }
-
-        # Build topology
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram=pe0_iram),
-                PEConfig(pe_id=1, iram={}),  # PE1: collector
-                PEConfig(pe_id=2, iram={}),  # PE2: collector
-            ],
-            [],
-        )
-
-        # Set up collectors for PE1 and PE2
-        collector_1 = simpy.Store(env, capacity=100)
-        collector_2 = simpy.Store(env, capacity=100)
-        sys.pes[0].route_table[1] = collector_1
-        sys.pes[0].route_table[2] = collector_2
-
-        # Inject token via SimPy process
-        def injector():
-            yield sys.pes[0].input_store.put(
-                MonadToken(target=0, offset=0, act_id=0, data=99, inline=False)
-            )
-
-        env.process(injector())
-
-        # Run simulation
-        env.run(until=1000)
-
-        # Verify each collector receives one token with data=99
-        assert len(collector_1.items) == 1
-        assert collector_1.items[0].data == 99
-
-        assert len(collector_2.items) == 1
-        assert collector_2.items[0].data == 99
-
-
-class TestAC64E2ESwitchRouting:
-    """Test AC6.4: SWITCH mode conditional routing"""
-
-    def test_switch_routing_condition_true(self):
-        """SWEQ with equal operands routes data to dest_l, trigger to dest_r."""
-        env = simpy.Environment()
-
-        # PE0 IRAM: offset 0 = SWEQ
-        pe0_iram = {
-            0: ALUInst(
-                op=RoutingOp.SWEQ,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=Addr(a=0, port=Port.L, pe=2),
-                const=None,
-            ),
-        }
-
-        # Build topology with gen_counters initialized for dyadic matching
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram=pe0_iram, 0, 0, 0]),
-                PEConfig(pe_id=1, iram={}),  # PE1: receives data token
-                PEConfig(pe_id=2, iram={}),  # PE2: receives inline trigger
-            ],
-            [],
-        )
-
-        # Set up collectors
-        collector_1 = simpy.Store(env, capacity=100)
-        collector_2 = simpy.Store(env, capacity=100)
-        sys.pes[0].route_table[1] = collector_1
-        sys.pes[0].route_table[2] = collector_2
-
-        # Inject two DyadTokens with same data (5, 5) via SimPy process
-        def injector():
-            yield sys.pes[0].input_store.put(
-                DyadToken(
-                    target=0,
-                    offset=0,
-                    ctx=0,
-                    data=5,
-                    port=Port.L,
-                    gen=0,
-                    wide=False,
-                )
-            )
-            yield sys.pes[0].input_store.put(
-                DyadToken(
-                    target=0,
-                    offset=0,
-                    ctx=0,
-                    data=5,
-                    port=Port.R,
-                    gen=0,
-                    wide=False,
-                )
-            )
-
-        env.process(injector())
-
-        # Run simulation
-        env.run(until=1000)
-
-        # When bool_out=True (equal): data → dest_l (collector_1), trigger → dest_r (collector_2)
-        assert len(collector_1.items) == 1
-        data_token = collector_1.items[0]
-        assert data_token.data == 5
-
-        assert len(collector_2.items) == 1
-        trigger_token = collector_2.items[0]
-        assert trigger_token.inline is True
-        assert trigger_token.data == 0
-
-    def test_switch_routing_condition_false(self):
-        """SWEQ with unequal operands routes data to dest_r, trigger to dest_l."""
-        env = simpy.Environment()
-
-        # PE0 IRAM: offset 0 = SWEQ
-        pe0_iram = {
-            0: ALUInst(
-                op=RoutingOp.SWEQ,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=Addr(a=0, port=Port.L, pe=2),
-                const=None,
-            ),
-        }
-
-        # Build topology
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram=pe0_iram, 0, 0, 0]),
-                PEConfig(pe_id=1, iram={}),  # PE1: receives inline trigger
-                PEConfig(pe_id=2, iram={}),  # PE2: receives data token
-            ],
-            [],
-        )
-
-        # Set up collectors
-        collector_1 = simpy.Store(env, capacity=100)
-        collector_2 = simpy.Store(env, capacity=100)
-        sys.pes[0].route_table[1] = collector_1
-        sys.pes[0].route_table[2] = collector_2
-
-        # Inject two DyadTokens with different data (5, 10) via SimPy process
-        def injector():
-            yield sys.pes[0].input_store.put(
-                DyadToken(
-                    target=0,
-                    offset=0,
-                    ctx=0,
-                    data=5,
-                    port=Port.L,
-                    gen=0,
-                    wide=False,
-                )
-            )
-            yield sys.pes[0].input_store.put(
-                DyadToken(
-                    target=0,
-                    offset=0,
-                    ctx=0,
-                    data=10,
-                    port=Port.R,
-                    gen=0,
-                    wide=False,
-                )
-            )
-
-        env.process(injector())
-
-        # Run simulation
-        env.run(until=1000)
-
-        # When bool_out=False (not equal): data → dest_r (collector_2), trigger → dest_l (collector_1)
-        assert len(collector_2.items) == 1
-        data_token = collector_2.items[0]
-        assert data_token.data == 5  # First operand goes to dest_r
-
-        assert len(collector_1.items) == 1
-        trigger_token = collector_1.items[0]
-        assert trigger_token.inline is True
-        assert trigger_token.data == 0
-
-
-# Task 4: T0 Store Sharing and System Wiring Tests
-
-class TestAC4_4T0StoreShared:
-    """AC4.4: T0 storage is shared — all SMs reference the same T0 store."""
-
-    def test_t0_store_shared_across_sms(self):
-        """All SMs share the same t0_store object."""
-        env = simpy.Environment()
-
-        # Build topology with 2 SMs
-        sys = build_topology(
-            env,
-            [],
-            [
-                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
-                SMConfig(sm_id=1, cell_count=512, tier_boundary=256),
-            ],
-        )
-
-        # Verify both SMs reference the same t0_store object
-        assert sys.sms[0].t0_store is sys.sms[1].t0_store
-
-    def test_t0_write_visible_across_sms(self):
-        """Data written to T0 by one SM is visible to another SM."""
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [],
-            [
-                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
-                SMConfig(sm_id=1, cell_count=512, tier_boundary=256),
-            ],
-        )
-
-        # Create collector for SM1 read result
-        collector = simpy.Store(env)
-        sys.sms[1].route_table[0] = collector  # SM1 can return to PE0 (dummy)
-
-        def test_sequence():
-            # SM0 writes to T0 address 256
-            write_token = SMToken(target=0, addr=256, op=MemOp.WRITE, flags=None, data=0xDEAD, ret=None)
-            yield sys.sms[0].input_store.put(write_token)
-
-            # SM1 reads from same T0 address
-            ret_route = CMToken(target=0, offset=0, ctx=0, data=0)
-            read_token = SMToken(target=1, addr=256, op=MemOp.READ, flags=None, data=None, ret=ret_route)
-            yield sys.sms[1].input_store.put(read_token)
-
-        env.process(test_sequence())
-        env.run(until=100)
-
-        # Verify SM1 read returned the value written by SM0
-        assert len(collector.items) == 1
-        assert collector.items[0].data == 0xDEAD
-
-
-class TestAC5_2ExecInjectsTokensProcessedNormally:
-    """AC5.2: EXEC injects tokens that are processed normally by target PEs/SMs."""
-
-    def test_exec_injects_token_to_pe(self):
-        """EXEC reads DyadToken from T0 and PE receives it normally via send()."""
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram={}),
-                PEConfig(pe_id=1, iram={}),
-            ],
-            [
-                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
-            ],
-        )
-
-        # Create DyadToken to be injected by EXEC
-        seed_token = DyadToken(
-            target=1,
-            offset=0,
-            ctx=0,
-            data=0x1234,
-            port=Port.L,
-            gen=0,
-            wide=False,
-        )
-
-        # Pre-populate T0 with the token
-        sys.sms[0].t0_store.append(seed_token)
-        sys.sms[0].system = sys  # Ensure system reference is set
-
-        def test_sequence():
-            # SM0 executes EXEC at T0 address 256 (t0_idx=0, which has seed_token)
-            exec_token = SMToken(target=0, addr=256, op=MemOp.EXEC, flags=None, data=None, ret=None)
-            yield sys.sms[0].input_store.put(exec_token)
-
-        env.process(test_sequence())
-        env.run(until=100)
-
-        # Verify token was injected via send() and received by PE1 in its matching_store
-        # The send() call triggers PE1's _run() loop to wake up and consume the token
-        assert sys.pes[1].matching_store[0][0].occupied is True
-        assert sys.pes[1].matching_store[0][0].data == 0x1234
-
-
-class TestAC5_3FullBootstrapSequence:
-    """AC5.3: EXEC can load a program (IRAM writes + seed tokens) from T0 that executes correctly."""
-
-    def test_exec_bootstrap_with_iram_write_and_seed_token(self):
-        """Full bootstrap sequence: T0 contains IRAMWriteToken and seed DyadToken, EXEC loads and runs them.
-
-        Tests the FULL SimPy execution chain:
-        - Populate T0 with IRAMWriteToken + seed DyadToken pair
-        - Send EXEC SMToken to SM
-        - Run env.run()
-        - Assert on pe.output_log containing the expected ALU result
-        """
-        env = simpy.Environment()
-
-        sys = build_topology(
-            env,
-            [
-                PEConfig(pe_id=0, iram={}),  # PE0 starts empty
-                PEConfig(pe_id=1, iram={}),  # PE1 is output receiver
-            ],
-            [
-                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
-            ],
-        )
-
-        # Create instruction to be loaded: CONST(0x5555) routing to PE1
-        const_inst = ALUInst(
-            op=RoutingOp.CONST,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=None,
-            const=0x5555,
-        )
-
-        # Create IRAMWriteToken to load instruction at offset 0
-        iram_write = IRAMWriteToken(
-            target=0,
-            offset=0,
-            ctx=0,
-            data=0,
-            instructions=(const_inst,),
-        )
-
-        # Create seed DyadToken to trigger the loaded instruction
-        seed_token = DyadToken(
-            target=0,
-            offset=0,
-            ctx=0,
-            data=0,
-            port=Port.L,
-            gen=0,
-            wide=False,
-        )
-
-        # Pre-populate T0 with bootstrap sequence
-        sys.sms[0].t0_store.append(iram_write)
-        sys.sms[0].t0_store.append(seed_token)
-        sys.sms[0].system = sys
-
-        def test_sequence():
-            # Trigger EXEC to bootstrap
-            exec_token = SMToken(target=0, addr=256, op=MemOp.EXEC, flags=None, data=None, ret=None)
-            yield sys.sms[0].input_store.put(exec_token)
-
-        env.process(test_sequence())
-        env.run(until=200)
-
-        # Verify FULL SimPy execution chain:
-        # 1. PE0 should have received and processed IRAMWriteToken
-        assert 0 in sys.pes[0].iram, "Instruction not loaded into IRAM by bootstrap"
-        assert sys.pes[0].iram[0].op == RoutingOp.CONST
-        assert sys.pes[0].iram[0].const == 0x5555
-
-        # 2. PE0 should have received and processed seed token, producing output
-        assert len(sys.pes[0].output_log) > 0, \
-            "PE0 did not produce output; seed token may not have triggered IRAM execution"
-
-        # 3. The output should be routed to PE1 with the CONST value
-        output_to_pe1 = [t for t in sys.pes[0].output_log if t.target == 1]
-        assert len(output_to_pe1) > 0, "PE0 did not route output to PE1"
-        assert output_to_pe1[0].data == 0x5555, f"Expected output data 0x5555, got {output_to_pe1[0].data}"