qvm: server firing handler chains

docs/ASSET_PIPELINE_TODO.md

@@ -487,3 +487,6 @@ Research progress: RE-600 [report](research/QVM_GRENADE_SETUP.md); remaining nat
 
 
 Research progress: RE-601 [report](research/QVM_BASE_FIRE_GATE.md); remaining native/content/runtime/platform scope stays open.
+
+
+Research progress: RE-602 [report](research/QVM_SERVER_FIRE_CHAIN.md); remaining native/content/runtime/platform scope stays open.

docs/FINDINGS.md

@@ -845,3 +845,6 @@ Bounded qagame paths recover bomb-plant/inactivity correction requests, direct f
 
 
 **RE-601 — Base-dependent firing gate scan and distance contract:** 288903 requires mode8 and active!=1, scans type18 bases, then checks64-unit distance/ground and chooses nearest point with ties selecting the second; invalid base cardinalities are explicit stop boundaries. [Evidence](research/QVM_BASE_FIRE_GATE.md).
+
+
+**RE-602 — Published firing event to bounded server handler chains:** Actual31 publication now chains through server reset/basis/muzzle/dispatch into selected setup; event-loop continuation resumes only recovered returns and stays suspended at opaque shot/allocation/handler boundaries. [Evidence](research/QVM_SERVER_FIRE_CHAIN.md).

docs/PROVISIONAL_TODO.md

@@ -805,3 +805,8 @@ Research progress: RE-600 [report](research/QVM_GRENADE_SETUP.md); remaining nat
 
 
 Research progress: RE-601 [report](research/QVM_BASE_FIRE_GATE.md); remaining native/content/runtime/platform scope stays open.
+
+The [RE-593–602 server firing batch](research/QVM_SERVER_FIRE_BATCH.md) recovers event31 routing, server basis/muzzle/dispatch and selected temp-event/grenade/base setup. Its next ten tasks prioritize293732/295018, real entity allocation/query/linking and projectile/damage callbacks. Original reference, asset mapping and full Rust/Bevy/Solari macOS/Linux/native/rendering/network scope remain open.
+
+
+Research progress: RE-602 [report](research/QVM_SERVER_FIRE_CHAIN.md); remaining native/content/runtime/platform scope stays open.

docs/RESEARCH_LEDGER.md

@@ -695,3 +695,10 @@ Actual outer31 publication reaches server151634, which writes client4140=0 and43
 ## 2026-10-20 — RE-601 Base-dependent firing gate scan and distance contract (separate task commit)
 
 288903 requires mode8 and active!=1, scans type18 bases, then checks64-unit distance/ground and chooses nearest point with ties selecting the second; invalid base cardinalities are explicit stop boundaries. 36 probes independently check mode/active priority,0/1/2/3 bases, exact65655 float distances and short-circuit calls,64 equality, airborne rejection and tie selection. Full suite: 915 tests pass. Report regenerates byte-identically (169227 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+
+## 2026-10-20 — RE-602 Published firing event to bounded server handler chains (separate task commit)
+
+Actual31 publication now chains through server reset/basis/muzzle/dispatch into selected setup; event-loop continuation resumes only recovered returns and stays suspended at opaque shot/allocation/handler boundaries. 12 independent compositions verify all state/vector/record handoffs, queue re-entry and retained window, exact pending-call stacks and explicit engine-response contracts. Full suite: 919 tests pass. Report regenerates byte-identically (603514 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+RE-602 additional regression:19 related reports from RE-582–591 and RE-593–601 regenerate byte-identically. Storage/filter, documentation-link and whitespace checks pass; actual engine allocation/link/query effects and opaque firing/damage continuations remain open rather than supplied successful outcomes.

docs/REVERSE_ENGINEERING_TODO.md

@@ -816,7 +816,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-590 Complete bounded weapon body and actual main consumer suffix ([report](research/QVM_WEAPON_COMPLETE_BODY.md)).
 
 
-- [ ] RE-592 Recover event31 consumers and actual projectile/hitscan/damage effects; native vector snap and full53418/54475 step/scheduler composition; validate original legal-state traces, map numerical weapon/animation/audio IDs to assets, and continue Rust/Bevy/Solari macOS/Linux gameplay. See the [next ten tasks](research/QVM_FIRING_BATCH.md#boundaries-and-next-ten-tasks).
+- [ ] RE-592 Partially closed by RE-593–602: event31 routing, server firing basis/muzzle/dispatch and selected bounded setup are recovered. Actual projectile/hitscan/damage, allocator/query/linking, native snap, full step/scheduler, original legal-state reference and Rust/Bevy/Solari macOS/Linux gameplay remain open. See [server firing batch](research/QVM_SERVER_FIRE_BATCH.md).
 
 
 - [x] RE-591 Timer-coupled firing sequences and actual outer publication ([report](research/QVM_FIRE_SEQUENCES.md)).
@@ -847,3 +847,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-601 Base-dependent firing gate scan and distance contract ([report](research/QVM_BASE_FIRE_GATE.md)).
+
+
+- [ ] RE-603 Recover293732/295018 shot processing,277165/277125 allocator,276433 query/native linking, grenade223156 and remaining dispatcher/base/event consumers. Validate real collision/damage/lifetime and original traces, complete step/scheduler and native snap, map asset identities and implement Rust/Bevy/Solari macOS/Linux gameplay. See the [next ten tasks](research/QVM_SERVER_FIRE_BATCH.md#next-ten-concrete-tasks).
+
+
+- [x] RE-602 Published firing event to bounded server handler chains ([report](research/QVM_SERVER_FIRE_CHAIN.md)).

docs/research/QVM_FIRING_BATCH.md

@@ -55,3 +55,5 @@ No original executable/native library, collision/physics or renderer runs. Anima
 8. Compose outer54475 scheduling with the recovered step and event publication; check timestamp boundaries, substep aggregation and queue pressure.
 9. Capture original/reference execution and compare legal multi-step behavior, then continue broader native/DLL/network/rendering/content coverage.
 10. Start the Rust/Bevy/Solari executable slice with recorded fixture parity and measured macOS/Linux platform/rendering paths; this research does not count as a playable game.
+
+The subsequent [RE-593–602 server firing batch](QVM_SERVER_FIRE_BATCH.md) follows event31 into server preparation and selected bounded setup handlers. It retains explicit allocation/link/query and pending shot-processing boundaries rather than claiming native shot outcomes.

docs/research/QVM_SERVER_FIRE_BATCH.md

@@ -0,0 +1,49 @@
+# Server firing research batch: RE-593–602
+
+Ten separately committed tasks follow the [firing producer batch](QVM_FIRING_BATCH.md) into server-side event consumption, firing basis/muzzle preparation and selected handler setup. Recovered QVM effects are distinguished from supplied allocator/query replies, captured native requests and suspended opaque children.
+
+| Task | Recovered scope | Evidence |
+| --- | --- | --- |
+| RE-593 |151254 two-slot event window and recognized-consumer routing | [Event route](QVM_SERVER_EVENT_ROUTE.md) |
+| RE-594 | Actual31 publication→server prelude and pending289235 ABI | [Firing event](QVM_SERVER_FIRE_EVENT.md) |
+| RE-595 |289235 suppression/statistic and finite angle basis before muzzle | [Basis](QVM_SERVER_FIRE_BASIS.md) |
+| RE-596 | Complete288779/288871 muzzle helpers and actual firing caller | [Muzzle](QVM_SERVER_MUZZLE.md) |
+| RE-597 | Entity weapon dispatch table and pending handler sequences | [Dispatcher](QVM_SERVER_FIRE_DISPATCH.md) |
+| RE-598 |277695 tempEntity/278138 position setup with explicit engine boundaries | [Temporary event](QVM_TEMP_EVENT.md) |
+| RE-599 |285840 event57, quantized direction and actual36717 PRNG before295018 | [Shot setup](QVM_SERVER_SHOT_SETUP.md) |
+| RE-600 |285971 grenade descriptor, launch quantization and inherited velocity | [Grenade setup](QVM_GRENADE_SETUP.md) |
+| RE-601 |288903 mode/base/range/ground gates before allocation | [Base gate](QVM_BASE_FIRE_GATE.md) |
+| RE-602 | Published31→server→selected setup, with event-loop resume only on recovered returns | [Server chain](QVM_SERVER_FIRE_CHAIN.md) |
+
+## Findings for the Rust port
+
+- The server consumes only the latest two events from an ordinary signed sequence window. Event31 first writes client4140=0 and4328=1, then calls289235(entity); its prelude does not read the event parameter.
+- Client6164 suppresses the firing function before statistic or basis effects. Otherwise client4116 increments unless entity weaponID1, including IDs subsequently rejected by dispatch.
+- Forward/right/up are derived from client angles with native sin/cos requests. Finite ordinary-math float32 responses model those natives here; platform libm/reference bit parity is unverified.
+- The muzzle uses entity+24 plus viewheight and14×forward. It does not use entity+488 or PS origin, normalize the vector, trace or snap. The alternate helper omits14×forward.
+- Dispatch uses entity+192, independent of the selected packed slot. The initialized table has direct returns for12/18, an18-ID shared293732 handler and distinct handlers for the remaining groups. This is not proof that IDs12/18 never fire elsewhere.
+- tempEntity construction truncates coordinates before its actual position setter, issues a link request, then returns the allocation pointer. The selected285840 caller patches quantized direction, seed, shooter and weapon fields after that link request.
+- Actual36717 mutates a32-bit seed using xor shifts5/21/27 and returns low15 bits;285840 stores low8 before pending295018 shot processing.
+- The file-named grenade constructor biases forwardZ by.2, normalizes, scales by a mode speed, truncates, then adds owner velocity and matching-ground velocity. Its descriptor is constructed, not simulated through physics/explosion/damage.
+- The base-dependent handler requires mode8/active!=1 and two type18 bases. Both farther than64 or ground1023 reject; otherwise the nearer point is chosen, with ties selecting the second. Invalid cardinalities stop at the source assumptions/error boundary rather than inventing valid pointers.
+
+## Integration and limits
+
+RE-602 has twelve source-order chains. It resumes the actual event-loop continuation after suppressed firing, table returns, the bounded grenade constructor and recovered base-handler returns. It stays suspended at295018, base allocation277165 or other opaque handlers. Three publications demonstrate the two-event retained window and actual re-entry for returning paths. Full record, vector, queue and field handoffs have independent oracles.
+
+Allocation277165 and world-query276433 replies are explicitly supplied; native link−31 is captured without engine effects. These contracts permit finite QVM data-flow checks, not a claim that an entity was actually allocated, linked, collided or damaged. A complete bounded constructor return is not a successful gameplay action. Other native/game callbacks and legal input domains remain open.
+
+The879-test baseline gains40 independent checks. Reports regenerate deterministically and stay below the2MiB normal-Git cap. No original assets enter these commits; normal code/docs and filtered assets remain separated. No original executable/native library, full VM, native physics/rendering or macOS/Linux Rust runtime executes.
+
+## Next ten concrete tasks
+
+1. Partition shared handler293732 by call/return boundaries; decode its weapon-slot/configuration inputs and every unresolved child.
+2. Recover295018's direction/seed/spread setup and first trace requests, retaining exact finite arithmetic and table provenance.
+3. Follow reached trace/contact/material consumers into damage211239 only after their actual contracts are recovered; do not assume a hit from a supplied trace.
+4. Recover allocator277165 and record initializer277125, including free-slot reuse, timing, capacity and failure/error paths.
+5. Recover query276433 and native link−31 contracts so grenade/base construction can be tested against an actual entity list/world.
+6. Recover grenade callback223156, trajectory integration, contact/bounce, expiry and reached explosion/damage paths.
+7. Continue288903 after allocator289113 through its temp_bomb descriptor, linking, state and round callbacks, preserving the two-base assumptions.
+8. Recover remaining dispatcher handlers298842/293732/294171/286473/287330 and event consumers21/12/14/15/49/50/87, with explicit asset/animation/audio mappings.
+9. Complete native vector snap and movement/scheduler composition, then capture original reference execution and legal multi-step event/weapon outcomes.
+10. Continue the native/DLL/network/rendering/content inventory and first Rust/Bevy/Solari gameplay slice on macOS/Linux with measured parity. Bounded server data flow is not whole-game completion.

docs/research/QVM_SERVER_FIRE_CHAIN.md

@@ -0,0 +1,11 @@
+# Published firing event to bounded server handler chains
+
+RE-602. Reproduce with `python3 scripts/analyze_qvm_server_fire_chain.py`; check with `python3 scripts/test_qvm_server_fire_chain.py`. The [machine report](qvm-server-fire-chain.json) retains source identity and bounded fixtures.
+
+The staged source bridge publishes31 with actual29913, routes via151254, applies the two-field prelude, then evaluates289235 preparation and dispatch. Suppression and table-return paths reach the actual firing return. Selected285971 executes its bounded record constructor with explicit allocation/query responses;288903 resumes its caller only when its recovered gate actually returns. Actual event continuation151658 runs only after those source returns, retaining cursor/client locals across re-entry.
+
+285840 stops before295018; a valid base action stops before277165; other handlers remain opaque at their dispatch call sites. Their parents are not resumed and no successful shot/round outcome is supplied.12 scenarios include three-publication ring pressure, IDs1/4/7/12/16/18/22/27/28, suppression, mode/range rejection and pending allocation. Independent oracles reconstruct basis/muzzle, temp-event/PRNG record and grenade descriptor, alongside exact queue/statistic/reset handoffs.
+
+Source CALL/return boundary bridges are explicit, not a full VM implementation. Allocator/query replies and finite native trig/sqrt responses are supplied; native link requests are captured without engine effects. No original collision, damage, entity lifetime, whole tick or platform gameplay parity is claimed. See the [ten-task server batch](QVM_SERVER_FIRE_BATCH.md).
+
+No original executable/full QVM/native collision/physics/rendering executes. Native responses and legal input domains are supplied or unverified where stated; full runtime/macOS/Linux Rust/Bevy/Solari gameplay remains open.

docs/research/README.md

@@ -406,3 +406,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-601: Base-dependent firing gate scan and distance contract](QVM_BASE_FIRE_GATE.md). Reproduce with `python3 scripts/analyze_qvm_base_fire_gate.py`; check with `python3 scripts/test_qvm_base_fire_gate.py`.
+
+[RE-593–602 server firing batch and next ten tasks](QVM_SERVER_FIRE_BATCH.md): source-ordered event31 consumers, selected handler setup and explicit engine/opaque-call boundaries.
+
+
+[RE-602: Published firing event to bounded server handler chains](QVM_SERVER_FIRE_CHAIN.md). Reproduce with `python3 scripts/analyze_qvm_server_fire_chain.py`; check with `python3 scripts/test_qvm_server_fire_chain.py`.

scripts/analyze_qvm_server_fire_chain.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Published event31 through server preparation and explicitly bounded handlers."""
+from pathlib import Path
+from qvm_research_support import source,execute
+from analyze_deferred_auth import trace_slice
+from analyze_bsp_references import trace_fields
+from qvm_server_fire_support import seed,state,ENTITY,BASES
+from analyze_qvm_server_event_route import route,LOCAL as EVENT_LOCAL,TARGETS
+from analyze_qvm_server_fire_event import prelude
+from analyze_qvm_server_fire_dispatch import prepared
+from analyze_qvm_server_fire_basis import LOCAL as FIRE_LOCAL
+from analyze_qvm_server_shot_setup import shot_setup
+from analyze_qvm_grenade_setup import grenade
+from analyze_qvm_base_fire_gate import base_gate,setup
+from analyze_qvm_temp_event import record
+from analyze_qvm_fire_sequences import publish
+from analyze_qvm_acceleration import PS,FRAME,word
+from analyze_qvm import write_json
+
+class PendingChild(Exception):
+    def __init__(self,m,entry,report,pending):self.memory=m;self.entry=entry;self.report=report;self.pending=pending
+
+def server_path(ins,m):
+    m,p=prepared(ins,m);d=p['dispatch'];p['selected_child']=None;p['return_execution']=None;p['pending']=None;p['returned']=d is None or d['returned']
+    if d and not d['returned']:
+        entry=d['pending_call_sequence'][0]['target'];site=d['pending_call_sequence'][0]['instruction']
+        def child(i,m,a,c):
+            assert a[8]==ENTITY
+            if entry==285840:
+                m,r=shot_setup(i,m);raise PendingChild(m,entry,r,r['pending_call'])
+            if entry==285971:m,r=grenade(i,m);return m,c,0,r
+            m,r=base_gate(i,m)
+            if r['stop']!=289233:
+                pending={289111:{'instruction':289113,'target':277165},288942:{'instruction':288945,'target':2319}}.get(r['stop'],{'next_instruction':r['stop'],'reason':'base pointers not initialized by this source path'})
+                raise PendingChild(m,entry,r,pending)
+            return m,c,0,r
+        if entry in [285840,285971,288903]:
+            try:
+                m,c,r=execute(ins,d['execution']['stop'],289592,m,(0,0,0),FIRE_LOCAL,{entry:child});p['return_execution']=r;p['selected_child']={'entry':entry,'report':r['children'][0]['effect']};p['returned']=True
+            except PendingChild as e:m=e.memory;p['selected_child']={'entry':e.entry,'report':e.report};p['pending']={'server_call_instruction':site,'child_entry':entry,'nested_boundary':e.pending}
+        else:p['pending']={'server_call_instruction':site,'child_entry':entry,'reason':'unrecovered handler body'}
+    p['final']=state(m);return m,p
+
+def chain(ins,m,count=1,parameter=0):
+    initial=state(m);old=m[PS+108];publications=[]
+    for _ in range(count):
+        m.update({FRAME+48:0,FRAME+252:0,FRAME+256:0,FRAME+260:1,FRAME+264:parameter});m,r=publish(ins,m);publications.append({'calls':r['execution']['calls'],'queue':r['final']['queue']})
+    m,r=route(ins,m,old);routing=r;stop=r['execution']['stop'];attempts=[];completed=0
+    for _ in range(3):
+        if stop!=151634:break
+        cursor=m[EVENT_LOCAL+44];m,p=prelude(ins,m);m,s=server_path(ins,m);continuation=None
+        if s['returned']:
+            t=trace_slice(ins,151255,151952,m,{},resume_at=151658,stop_targets=TARGETS,local_base=EVENT_LOCAL,limit=4096);m=t['memory'];continuation={'stop':t['stop'],'calls':t['calls'],**trace_fields(t,False)};stop=continuation['stop'];completed+=1
+        attempts.append({'cursor':cursor,'prelude':p,'server':s,'event_continuation':continuation,'final':state(m)})
+        if not s['returned']:break
+    else:raise AssertionError('Two-slot event window exceeded')
+    return {'initial':initial,'publication_count':count,'parameter':parameter,'publications':publications,'route':routing,'attempts':attempts,'events_completed':completed,'complete':stop==151952,'server_parent_suspended':bool(attempts and not attempts[-1]['server']['returned']),'final':state(m),'constructed_record':record(m) if any(a['server']['selected_child'] and a['server']['selected_child']['entry'] in [285840,285971] for a in attempts) else None}
+
+def main():
+    q,raw,h,ins=source();rows=[]
+    cases=[('suppressed',22,3,{PS+6164:1}),('table-return12',12,3,{}),('table-return18',18,1,{}),('invalid-id',28,1,{}),('event57-pending-shot',4,1,{}),('grenade-record-return',7,1,{}),('base-allocation-pending',16,1,{}),('base-mode-return',16,1,{34090788:9}),('base-distance-return',16,1,{}),('id1-handler-pending',1,1,{}),('shared-handler-pending',22,1,{}),('handler27-pending',27,1,{})]
+    for name,ident,count,changes in cases:
+        m=seed(raw,h,ident);m.update({21044:0x12345678,PS+68:8,PS+44:99,PS+148:3});m.update(changes)
+        for o in range(0,880,4):m.setdefault(BASES+o,0)
+        for j,v in enumerate((30,60,15)):m[PS+152+4*j]=word(v)
+        if ident==16:
+            points=[(1000,0,0),(1000,1,0)] if name=='base-distance-return' else [(0,0,0),(1,0,0)];setup(m,[18,18],points)
+            for j in range(3):m[ENTITY+488+4*j]=word(0)
+        p=chain(ins,m,count,7);p['name']=name;rows.append(p)
+    write_json(Path('docs/research/qvm-server-fire-chain.json'),{'source':q['source'],'sha256':q['sha256'],'probes':rows,'limits':'Staged source event31→289235 basis/muzzle/dispatch→selected bounded setup. Parent event loop resumes only actual recovered QVM returns. Allocation/query replies supplied and native link effects captured;295018/other handlers remain suspended. No original physics/damage or full tick/gameplay/reference claim.'})
+if __name__=='__main__':main()

scripts/test_qvm_server_fire_chain.py

@@ -0,0 +1,57 @@
+import json,unittest,copy
+from pathlib import Path
+from test_qvm_server_fire_basis import vectors
+from test_qvm_server_muzzle import output
+from test_qvm_grenade_setup import projectile,normalized
+from test_qvm_base_fire_gate import expected as base_expected
+from test_qvm_temp_event import event_record
+from test_qvm_server_shot_setup import random_oracle
+from test_qvm_ground import word,n,f
+
+def shot_record(p):
+    r=event_record(p['execution']['children'][0]['effect']);_,random=random_oracle(p['initial_seed'])
+    for j,v in enumerate(p['initial']['forward']):r[str(104+4*j)]=word(float(int(f(n(v)*4096))))
+    r.update({'184':random&255,'140':p['initial']['entity_id'],'192':p['initial']['entity_weapon']});return r
+
+def server_state(test,p):
+    b=p['basis'];a=copy.deepcopy(b['initial'])
+    if not a['blocked6164']:
+        if a['entity_weapon']!=1:a['stat4116']=(a['stat4116']+1)&0xffffffff
+        a['forward'],a['right'],a['up']=vectors(a['angles'])
+    test.assertEqual(b['final'],a)
+    if p['muzzle_execution']:
+        child=p['muzzle_execution']['children'][0]['effect'];test.assertEqual(child['initial'],a);a['muzzle']=output(child);test.assertEqual(child['final'],a);test.assertEqual(p['dispatch']['initial'],a)
+    if p['selected_child']:
+        entry,r=p['selected_child']['entry'],p['selected_child']['report'];test.assertEqual(r['initial'],a)
+        if entry==285840:test.assertEqual(r['final_record'],shot_record(r))
+        elif entry==285971:test.assertEqual(r['final_record'],projectile(r));a['forward']=list(map(word,normalized(r)))
+        else:a,point,status,stop=base_expected(r);test.assertEqual((r['selected_point_after'],r['status'],r['stop']),(point,status,stop))
+        test.assertEqual(r['final'],a)
+    test.assertEqual(p['final'],a);return a
+class ServerFireChainTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/qvm-server-fire-chain.json').read_text());cls.rows={p['name']:p for p in cls.r['probes']}
+    def test_actual_event_preparation_and_selected_child_handoffs(self):
+        self.assertEqual(len(self.r['probes']),12)
+        for p in self.r['probes']:
+            a=copy.deepcopy(p['route']['final'])
+            for attempt in p['attempts']:
+                q=attempt['prelude'];self.assertEqual(q['initial'],a);a.update(field4140=0,field4328=1);self.assertEqual(q['final'],a);self.assertEqual(attempt['server']['basis']['initial'],a);a=server_state(self,attempt['server']);self.assertEqual(attempt['final'],a)
+            self.assertEqual(p['final'],a);self.assertEqual(a['queue'],p['publications'][-1]['queue'])
+    def test_only_recovered_returns_resume_event_loop(self):
+        complete={'suppressed','table-return12','table-return18','invalid-id','grenade-record-return','base-mode-return','base-distance-return'}
+        for p in self.r['probes']:
+            self.assertEqual(p['complete'],p['name'] in complete);self.assertEqual(p['server_parent_suspended'],p['name'] not in complete);self.assertEqual(p['events_completed'],sum(bool(a['server']['returned']) for a in p['attempts']))
+            for a in p['attempts']:self.assertEqual(a['event_continuation'] is not None,a['server']['returned'])
+    def test_nested_pending_boundaries_not_reported_as_shot_outcomes(self):
+        expected={'event57-pending-shot':(285840,295018),'base-allocation-pending':(288903,277165),'id1-handler-pending':(298842,None),'shared-handler-pending':(293732,None),'handler27-pending':(294171,None)}
+        for name,(entry,target) in expected.items():
+            p=self.rows[name];pending=p['attempts'][-1]['server']['pending'];self.assertEqual(pending['child_entry'],entry);self.assertEqual(p['events_completed'],0)
+            if target:self.assertEqual(pending['nested_boundary']['target'],target)
+    def test_queue_window_reentry_and_complete_record_evidence(self):
+        for name in ['suppressed','table-return12']:
+            p=self.rows[name];self.assertEqual(p['publication_count'],3);self.assertEqual([a['cursor'] for a in p['attempts']],[1,2]);self.assertEqual(p['events_completed'],2)
+        self.assertEqual(self.rows['table-return12']['final']['stat4116'],12);self.assertEqual(self.rows['suppressed']['final']['stat4116'],10);self.assertEqual(self.rows['id1-handler-pending']['final']['stat4116'],10)
+        for name in ['event57-pending-shot','grenade-record-return']:
+            p=self.rows[name];self.assertEqual(p['constructed_record'],p['attempts'][0]['server']['selected_child']['report']['final_record'])
+if __name__=='__main__':unittest.main()