Trace deferred authentication drops and bounded message copy semantics

docs/FINDINGS.md

@@ -190,3 +190,8 @@ Exact native fork/source revision, runtime resource lookup, legacy launch enviro
 **F-032 — Observed: bounded native byte regions reconciled.** The SDL text bytes outside debug-map function ranges are 70 NOP runs totaling 524 bytes. Windows client resource bytes partition into 353,268 payload bytes and 520 tree-structure bytes, with no unreferenced gaps. This resolves the previously unclassified bytes in these two regions, not whole-binary semantics. [COV-001/002](research/native/COVERAGE.md).
 
 **F-033 — Observed/inferred: authentication drop boundary and deferred QVM branch.** Linux ELF64 trap 603 receives index/broadcast text/disconnect reason; valid completion and invalid-index guards both return zero. The QVM caller validates slot and states 1/2; state 1 calls a helper with record buffers and limits 128/256, then sets a flag, while state 2 invokes the native service. Deferred-consumer behavior, state names, pointer errors and other platforms remain open. [AUTH-001/002](research/AUTH_DROP.md).
+
+
+**F-034 — Observed: bounded copy and error-service chain.** QVM helper 69338 calls trap 102 with capacity minus one and explicitly NUL-terminates the final destination byte. Null source/nonpositive capacity route through wrappers to game trap 1 and native Com_Error mode 1, not a print-only service. The native handler's full exit/escalation behavior remains open. [DEF-001](research/DEFERRED_AUTH.md).
+
+**F-035 — Observed: deferred-drop sentinel/timestamp and strict delay.** Eight direct constant-offset references show field 3588 changing from sentinel 1 to current time in the begin callback, then being consumed by the frame callback only for state 2, positive pending value and signed elapsed > 100. Synthetic instruction-slice tests verify 100/101 boundaries and wrap; actual runtime timing, aliases, state names and reentrancy remain open. [DEF-002/003](research/DEFERRED_AUTH.md).

docs/RESEARCH_LEDGER.md

@@ -83,3 +83,8 @@ Completed static milestones RE-214–216 with `analyze_native_metadata.py`: all
 ## 2026-10-11 — Byte reconciliation and authentication drop boundary
 
 Completed RE-218–220 with `analyze_native_coverage.py` and `analyze_auth_drop.py`: bounded byte partitions explain all SDL text gaps and resource-tree bytes; focused native/QVM evidence recovers broadcast/disconnect parameters, invalid-index zero returns and deferred versus immediate caller branches. F-032/033, COV-001/002 and AUTH-001/002 retain source hashes and limitations. Seven new tests verify interval accounting, malformed bounds, guard convergence, result-preserving epilogues, bounded literals and supplied fixtures. Static literal scanning excludes nonallocated ELF sections to avoid interpreting small numeric constants as offsets into compiler-comment sections. No original game code was executed.
+
+
+## 2026-10-11 — Deferred authentication drops
+
+Completed static milestones RE-222–224: copy-count/final-NUL behavior, invalid-input error-service chain, eight direct pending-field references and sentinel/timestamp transitions, strict signed elapsed > 100 consumer. `analyze_deferred_auth.py` emits source-hashed functions/native cases and bounded synthetic-memory traces; six tests check branch/copy boundaries and reject unsupported slices. Findings F-034/035 and DEF-001–003 distinguish these checks from runtime fixtures. An initial print-path interpretation of the diagnostic wrapper was corrected after tracing function 2319 through trap 1 to native Com_Error(1, ...). No game process or full QVM runtime was launched; tests only evaluate selected decoded instructions without entering callees.

docs/REVERSE_ENGINEERING_TODO.md

@@ -260,4 +260,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-218 Reconcile the 524 SDL text bytes outside paired debug-map functions and all Windows resource-region metadata/padding gaps; preserve evidence for every byte classification. **Evidence:** `analyze_native_coverage.py`, source-hashed segment partitions and COV-001/002; 70 SDL NOP runs account for all 524 bytes, Windows region accounts for 353,268 payload + 520 structure bytes with no gaps. Byte patterns do not establish runtime reachability.
 - [x] RE-219 Trace Linux ELF64 trap 603 argument meanings, both invalid-index continuations and common return epilogues. **Evidence:** `analyze_auth_drop.py`, `auth-drop.json`, AUTH-001; broadcast/disconnect formats and zero returns verified. Complete helper behavior/all-platform parity remain RE-206.
 - [x] RE-220 Recover the QVM trap-603 caller's slot/state guards, record stride and state-1 storage versus state-2 immediate service call. **Evidence:** AUTH-002 and full caller instructions; state names, copy-helper behavior and deferred consumer remain open.
-- [ ] RE-221 Trace the QVM record flag at offset 3588, helper 69338 and state transitions; specify deferred authentication drops, buffer limits, terminator behavior and reentrancy with runtime fixtures.
+- [ ] RE-221 Trace the QVM record flag at offset 3588, helper 69338 and state transitions; specify deferred authentication drops, buffer limits, terminator behavior and reentrancy with runtime fixtures. **Progress 2026-10-11:** Eight constant-offset references, copy/error helpers and state-dependent sentinel/timestamp consumption recovered. Strict signed elapsed > 100 gate has synthetic instruction-slice checks; runtime fixtures, aliases and reentrancy remain open ([DEF-001–003](research/DEFERRED_AUTH.md)).
+- [x] RE-222 Recover helper 69338 copy count, terminator write and invalid-input diagnostic chain through game trap 1/native Com_Error. **Evidence:** DEF-001, complete helper bodies and both ELF64 cases; capacity 1/2/128/256 and invalid-input slice tests pass.
+- [x] RE-223 Collect all explicit constant-3588 references and associate sentinel initialization, connection reset, begin-time replacement and frame-time reads with source-hashed function partitions. **Evidence:** DEF-002; eight references across four functions; alias/computed-offset coverage remains open.
+- [x] RE-224 Recover and verify the deferred drop consumer's strict > 100 signed 32-bit elapsed-time branch and argument forwarding. **Evidence:** DEF-003 and synthetic traces; delay boundaries, state gates, pending values and signed wrap tested without entering callees.
+- [ ] RE-225 Trace native Com_Error mode 1 through ordinary, repeated and recursive error paths on every platform; define formatting, shutdown, nonlocal exit and Rust error-boundary behavior.
+- [ ] RE-226 Establish game timestamp units and wrap/reset behavior; verify deferred-drop sentinel collisions, stored negative timestamps and connection resets with deterministic runtime traces.

docs/research/AUTH_DROP.md

@@ -28,3 +28,5 @@ For state 2, it passes `AccountKick: %i - %s\n`, the index and broadcast-message
 - Add deterministic reference fixtures for invalid/inactive slots, deferred state, immediate state, empty broadcast text, disconnect reasons and repeated drops. No runtime conformance is claimed by static recognizer tests.
 
 RE-219/220 record completed static milestones. RE-206 remains open for full error/helper behavior and all-platform parity.
+
+Follow-up: [DEF-001–003](DEFERRED_AUTH.md) resolves the copy helper, all eight direct pending-field references and the sentinel-to-timestamp consumer path. The strict elapsed > 100 branch has synthetic instruction-slice checks; runtime fixtures and reentrancy remain open.

docs/research/DEFERRED_AUTH.md

@@ -0,0 +1,42 @@
+# Deferred authentication drops and bounded message copying
+
+Static pass, 2026-10-11. Reproduce with `python3 scripts/analyze_deferred_auth.py`; validate with `python3 scripts/test_deferred_auth.py`. [Generated evidence](deferred-auth.json) retains source hashes, complete selected QVM functions, direct-call candidates, every observed constant-3588 reference, native service cases and synthetic instruction-slice traces.
+
+No original game process or complete QVM module was executed. The bounded test evaluator follows selected decoded instructions against synthetic memory, records calls without entering callees, and uses a placeholder return value. These checks establish local arithmetic/branch/argument behavior; they are not engine, networking or gameplay reference fixtures.
+
+## DEF-001: message-copy boundary
+
+Function entry **69338** contains the diagnostic literals `Q_strncpyz: NULL src` and `Q_strncpyz: destsize < 1`. For a non-null source and positive capacity, it calls game trap **102** with `(destination, source, capacity - 1)`, then writes a zero byte at `destination + capacity - 1`. Both Linux ELF64 native dispatch cases route trap 102 to `strncpy`; their address-keyed cases are preserved in the report.
+
+Capacity includes the terminator. A capacity of one requests a zero-length native copy and explicitly writes the sole destination byte to zero. Deferred broadcast/reason buffers pass capacities 128 and 256, producing maximum copy counts 127 and 255 and explicit terminal byte positions at those offsets. The native `strncpy` dependency still needs implementation/platform comparison for all padding, overlap and pointer-error behavior; slice tests record the call and do not perform a real native copy.
+
+For null source or capacity below one, the helper invokes function **5096**. That wrapper formats through helper 37914, then calls function **2319** with `%s`. Function 2319 formats again and invokes trap **1** (`CONST -2`), whose Linux ELF64 dispatcher converts the string pointer and calls **`Com_Error(1, format, string)`**. This is the engine error path. The full native `Com_Error` functions contain shutdown, system-error and nonlocal-jump paths; exact selection, repeated-error escalation and termination semantics remain open. Do not infer a normal return or model this as a print-only diagnostic.
+
+## DEF-002: field 3588 is sentinel plus timestamp
+
+Eight direct constant-offset references occur across four function partitions. Their complete contexts are recorded. This is coverage of explicit `CONST 3588` references, not proof that aliases or computed field addresses do not exist.
+
+| Function entry | Observed role | Field/buffer behavior |
+| --- | --- | --- |
+| 165818 | Authentication drop request | State 1 invokes the copy helper into record offsets 3204/3332 and stores field 3588 = 1. State 2 clears the field and invokes native trap 603 immediately. |
+| 173979 | Entry-command-2 connect callback candidate | Assigns state 1 at record offset 468. Under a nonzero incoming argument at local offset 1092, clears field 3588 and zeroes both 128/256-byte buffers using trap 100. Recovering the argument's authoritative name remains open. |
+| 174399 | Entry-command-3 begin callback candidate | Assigns state 2. When global 35017616 is positive, replaces field value exactly 1 with current global timestamp 34992532. Zero and other values are preserved by this branch. |
+| 15186 | Entry-command-8 frame callback candidate | Iterates client records, requires state 2 and field at least 1, then compares signed current-time-minus-field against 100. Eligible slots call 165818 with pointers to both stored message buffers. |
+
+The frame function first replaces global timestamp 34992532 with its incoming argument from local offset 92. This supplies the source of the deferred deadline comparison. Timestamp units have not been independently established in this pass.
+
+Field 3588 is not simply a Boolean flag. Value 1 initially acts as a sentinel and is later overwritten with a timestamp. At game time one, that stored timestamp also equals the sentinel, and zero/nonpositive timestamps interact with the pending-value gate. These edge cases need reference fixtures before choosing a Rust representation or normalizing behavior.
+
+## DEF-003: strictly greater than 100
+
+At instructions 15896–15905 the frame path subtracts the stored field from global time with 32-bit signed semantics and skips processing when the result is **less than or equal to 100**. The drop occurs only above 100, after the state/pending gates. At instruction 15920 it calls 165818 with `(slot, record + 3204, record + 3332)`; that function's state-2 path clears the field and invokes the native drop service.
+
+Synthetic slice checks verify elapsed 99 and 100 do not call the drop helper, while 101 does; inactive state, zero/negative pending values and negative elapsed time skip it. Subtraction wraps to 32 bits before the signed comparison. A crossing from positive stored time near `INT_MAX` to negative current time can therefore produce a positive elapsed result, but the separate pending-value gate rejects negative stored timestamps. This preserves observed arithmetic without promising desirable behavior after long uptime or clock changes.
+
+The begin callback also uses record field 3200 as a one-shot gate for helper 165352 when no pending drop is present and authentication is enabled. Its surrounding admission/authentication behavior remains unreviewed; do not generalize the drop timing slice to the entire callback.
+
+## Verification and remaining work
+
+Six tests cover strict delay boundaries, state/pending/wrap gates, sentinel replacement under the authentication-enabled gate, copy count/NUL positions, invalid-input diagnostic calls, native error targets, and fail-closed unknown reads/opcodes/control-flow bounds. The evaluator intentionally rejects full function prologues and arbitrary callees.
+
+RE-222–224 complete these static deliverables. RE-221 remains open for runtime fixtures, reentrancy, authoritative field/state naming, alias coverage and complete state-transition behavior. Follow the formatting helper and native error handler, test buffer contents and repeated drops in an isolated reference harness, and compare Windows/macOS service behavior before implementing compatibility policy in Rust.

docs/research/README.md

@@ -1,6 +1,6 @@
 # Binary reverse engineering: first static analysis pass
 
-Analysis date: **2026-10-11**. Reference: Urban Terror 4.3.4, with source hashes from [the installation snapshot](../inventory/snapshot.json) and [extraction manifests](../extraction/README.md). No original executable, library, QVM, or recovered native code was executed.
+Analysis date: **2026-10-11**. Reference: Urban Terror 4.3.4, with source hashes from [the installation snapshot](../inventory/snapshot.json) and [extraction manifests](../extraction/README.md). No original executable, library or recovered native code was launched. No complete QVM module was run; the deferred-auth follow-up evaluates selected decoded instructions with synthetic memory and records calls without entering callees.
 
 This pass decodes every supplied QVM and inventories/disassembles all eight native images. It recovers entry-command jump tables and selected native syscall tables, while retaining unknown calls, ambiguous strings and unreviewed function bodies. It does not establish gameplay parity or a complete engine ABI.
 
@@ -12,6 +12,8 @@ The [native metadata follow-up](native/METADATA.md) recovers SDL/client debug-ma
 
 [Byte reconciliation](native/COVERAGE.md) now explains the SDL text gaps and entire Windows resource region; [authentication drop analysis](AUTH_DROP.md) traces parameter meanings, invalid-index returns and QVM state branches.
 
+[Deferred authentication analysis](DEFERRED_AUTH.md) traces message-copy/error services and the sentinel/timestamp state branches, with bounded synthetic-memory instruction checks distinct from runtime conformance.
+
 ## Reproduce
 
 From the repository root, with the verified source installation and extracted assets present:
@@ -22,10 +24,11 @@ python3 scripts/test_binary_analysis.py
 python3 scripts/test_vm_extensions.py
 python3 scripts/test_native_metadata.py
 python3 scripts/test_native_followup.py
+python3 scripts/test_deferred_auth.py
 python3 scripts/storage_policy.py check --require-setup
 ```
 
-The pipeline runs `fetch_analysis_references.py`, `analyze_qvm.py`, `analyze_native.py`, `analyze_vm_abi.py`, `analyze_native_dispatch.py`, `analyze_vm_extensions.py`, `analyze_native_metadata.py`, `analyze_native_coverage.py`, and `analyze_auth_drop.py` in that order. Python 3.9+ and **LLVM objdump** with x86 ELF/COFF/Mach-O support are required. This pass used Apple LLVM 17.0.0 on macOS arm64; it disassembled x86 images without running them. Upstream references are downloaded only if absent, checked against the committed SHA-256 manifest, and cached under `.cache/research/upstream/`. A clone also needs `git lfs pull` to obtain the derived artifacts/extracted members.
+The pipeline runs `fetch_analysis_references.py`, `analyze_qvm.py`, `analyze_native.py`, `analyze_vm_abi.py`, `analyze_native_dispatch.py`, `analyze_vm_extensions.py`, `analyze_native_metadata.py`, `analyze_native_coverage.py`, `analyze_auth_drop.py`, and `analyze_deferred_auth.py` in that order. Python 3.9+ and **LLVM objdump** with x86 ELF/COFF/Mach-O support are required. This pass used Apple LLVM 17.0.0 on macOS arm64; it disassembled x86 images without running them. Upstream references are downloaded only if absent, checked against the committed SHA-256 manifest, and cached under `.cache/research/upstream/`. A clone also needs `git lfs pull` to obtain the derived artifacts/extracted members.
 
 Generated JSON/JSONL and compressed evidence are regenerated in place; keep prose notes in Markdown. Rerunning the four analysis stages reproduced every generated report and gzip artifact byte-for-byte on the same toolchain. gzip timestamps and stored filenames are fixed. Different objdump versions can produce different disassembly text, so tool version and uncompressed evidence hashes are recorded. Reports are UTF-8 normal Git text, with individual files below the storage policy's 2 MiB limit.
 

scripts/analyze_binaries.py

@@ -10,7 +10,8 @@ def main():
         raise SystemExit('Run from the repository root')
     for script in ('fetch_analysis_references.py', 'analyze_qvm.py', 'analyze_native.py',
                    'analyze_vm_abi.py', 'analyze_native_dispatch.py', 'analyze_vm_extensions.py',
-                   'analyze_native_metadata.py', 'analyze_native_coverage.py', 'analyze_auth_drop.py'):
+                   'analyze_native_metadata.py', 'analyze_native_coverage.py', 'analyze_auth_drop.py',
+                   'analyze_deferred_auth.py'):
         subprocess.run([sys.executable, str(Path('scripts')/script)], check=True)
 
 

scripts/analyze_deferred_auth.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Static references and bounded synthetic-memory traces for deferred auth drops."""
+import gzip
+import json
+from pathlib import Path
+from analyze_qvm import decode, write_json
+from analyze_vm_extensions import verified, native_functions
+from analyze_auth_drop import ascii_literal
+from analyze_native_dispatch import recover
+
+
+def signed32(value):
+    value &= 0xffffffff
+    return value-0x100000000 if value & 0x80000000 else value
+
+
+def trace_slice(instructions, start, stop, memory, locals_map, limit=256):
+    """Evaluate only a selected straight/bounded slice against synthetic memory.
+
+    Record calls rather than entering callees. Reject unknown reads/opcodes and
+    control flow outside the selected slice. This is not a QVM runtime.
+    """
+    stack, args, calls, trace, byte_writes = [], {}, [], [], []
+    memory = dict(memory)
+    local_base = 0x40000000
+    for offset, value in locals_map.items():
+        memory[local_base+offset] = value
+    pc = start
+    while pc != stop:
+        if not start <= pc < stop or len(trace) >= limit:
+            raise ValueError('slice control flow escaped bound')
+        ins = instructions[pc]
+        op, value = ins['opcode'], ins['operand']
+        trace.append(pc)
+        pc += 1
+        if op == 'CONST':
+            stack.append(value)
+        elif op == 'LOCAL':
+            stack.append(local_base+value)
+        elif op == 'LOAD4':
+            address = stack.pop()
+            if address not in memory:
+                raise ValueError('unknown synthetic memory read')
+            stack.append(memory[address])
+        elif op == 'STORE4':
+            value, address = stack.pop(), stack.pop()
+            memory[address] = signed32(value)
+        elif op == 'STORE1':
+            value, address = stack.pop(), stack.pop()
+            byte_writes.append({'address': address, 'value': value & 255})
+        elif op in ('ADD', 'SUB', 'MULI'):
+            right, left = stack.pop(), stack.pop()
+            stack.append(signed32(left+right if op == 'ADD' else left-right if op == 'SUB' else left*right))
+        elif op in ('EQ', 'NE', 'LTI', 'LEI', 'GTI', 'GEI'):
+            right, left = signed32(stack.pop()), signed32(stack.pop())
+            condition = {'EQ': left == right, 'NE': left != right, 'LTI': left < right,
+                         'LEI': left <= right, 'GTI': left > right, 'GEI': left >= right}[op]
+            if condition:
+                pc = value
+        elif op == 'ARG':
+            args[value] = stack.pop()
+        elif op == 'CALL':
+            calls.append({'instruction': ins['index'], 'target': stack.pop(), 'args': dict(args)})
+            args = {}
+            stack.append(0)  # synthetic placeholder, not a recovered callee result
+        elif op == 'POP':
+            stack.pop()
+        elif op == 'JUMP':
+            pc = stack.pop()
+        else:
+            raise ValueError(f'unsupported slice opcode {op}')
+    return {'trace': trace, 'calls': calls, 'memory': memory, 'byte_writes': byte_writes}
+
+
+def partition_function(instructions, entry, data, header):
+    if instructions[entry]['opcode'] != 'ENTER':
+        raise ValueError('expected function entry')
+    end = next(i for i in range(entry+1, len(instructions)) if instructions[i]['opcode'] == 'ENTER')
+    body = instructions[entry:end]
+    literals = []
+    for i in body:
+        if i['opcode'] == 'CONST' and instructions[i['index']+1]['opcode'] == 'ARG' and 0 <= i['operand'] < header['data_length']+header['literal_length']:
+            value = ascii_literal(data, header['data_offset']+i['operand'], header['data_offset']+header['data_length']+header['literal_length'])
+            if value:
+                literals.append({'instruction': i['index'], 'vm_address': i['operand'], 'text': value})
+    return {'entry': entry, 'linear_end_exclusive': end, 'instructions': body, 'literal_argument_candidates': literals}
+
+
+def main():
+    report = json.loads(Path('docs/research/qvm/qagame.json').read_text())
+    data = verified(Path(report['source']['member']['output']).read_bytes(), report['sha256'])
+    header, instructions = decode(data)
+    entries = [2319, 5096, 69338, 15186, 165818, 173979, 174399]
+    functions = {str(e): partition_function(instructions, e, data, header) for e in entries}
+    refs = []
+    for i in instructions:
+        if i['opcode'] == 'CONST' and i['operand'] == 3588:
+            entry = next(j for j in range(i['index'], -1, -1) if instructions[j]['opcode'] == 'ENTER')
+            refs.append({'instruction': i['index'], 'containing_entry': entry,
+                         'window': instructions[max(entry, i['index']-4):i['index']+9]})
+    callers = {str(e): [i['index'] for i in instructions if i['opcode'] == 'CALL' and i['index'] and
+                       instructions[i['index']-1]['opcode'] == 'CONST' and instructions[i['index']-1]['operand'] == e]
+               for e in entries}
+    synthetic = []
+    record = 0x10000
+    for state, pending, now in [(2, 1000, 1100), (2, 1000, 1101), (1, 1000, 1101),
+                                (2, 0, 1101), (2, 1, 102), (2, 0x7ffffff0, -0x7fffff80)]:
+        model = trace_slice(instructions, 15878, 15922,
+                            {record+468: state, record+3588: pending, 34992532: now}, {32: record, 28: 3})
+        synthetic.append({'state': state, 'pending': pending, 'now': now,
+                          'signed_elapsed': signed32(now-pending), 'trace': model['trace'], 'calls': model['calls']})
+    native = {}
+    for label in ('linux--Quake3-UrT-Ded.x86_64', 'linux--Quake3-UrT.x86_64'):
+        r = json.loads(Path(f'docs/research/native/{label}.json').read_text())
+        original = verified((Path('.cache/UrbanTerror43')/r['source']['path']).read_bytes(), r['source']['sha256'])
+        artifact = r['artifacts']['disassembly.txt']
+        text = verified(gzip.open(artifact['path'], 'rb').read(), artifact['uncompressed_sha256']).decode()
+        dispatch = recover(original, text, 'SV_GameSystemCalls')
+        native[label] = {'source': r['source'], 'disassembly_sha256': artifact['uncompressed_sha256'],
+                         'strncpy_case': next(c for c in dispatch['cases'] if 102 in c['numbers_sharing_target']),
+                         'error_case': next(c for c in dispatch['cases'] if 1 in c['numbers_sharing_target']),
+                         'error_function': native_functions(text)['Com_Error']}
+    write_json(Path('docs/research/deferred-auth.json'), {'source': report['source'], 'sha256': report['sha256'],
+               'functions': functions, 'direct_call_candidates': callers, 'field_constant_references': refs,
+               'synthetic_slice_traces': synthetic, 'native': native, 'limitations':
+               'Constant-offset references do not cover aliases or dynamically computed offsets. '
+               'Synthetic-memory traces evaluate selected QVM instructions without entering callees; '
+               'these are static boundary checks, not real gameplay/time/network fixtures or a full QVM runtime.'})
+    print('Recovered eight field references, copy/error helpers and deferred timing boundary traces')
+
+
+if __name__ == '__main__':
+    main()

scripts/test_deferred_auth.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Static instruction-slice boundary checks with synthetic memory, no callees."""
+import json
+from pathlib import Path
+import unittest
+from analyze_qvm import decode
+from analyze_deferred_auth import trace_slice, signed32
+
+
+class DeferredTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.report = json.loads(Path('docs/research/deferred-auth.json').read_text())
+        _, cls.instructions = decode(Path(cls.report['source']['member']['output']).read_bytes())
+        cls.record = 0x10000
+
+    def frame(self, state, pending, now):
+        return trace_slice(self.instructions, 15878, 15922,
+                           {self.record+468: state, self.record+3588: pending, 34992532: now},
+                           {32: self.record, 28: 3})
+
+    def test_strict_delay_boundary(self):
+        for elapsed, count in [(0, 0), (99, 0), (100, 0), (101, 1), (102, 1), (-1, 0)]:
+            with self.subTest(elapsed=elapsed):
+                calls = self.frame(2, 1000, 1000+elapsed)['calls']
+                self.assertEqual(len(calls), count)
+                if calls:
+                    self.assertEqual(calls[0]['target'], 165818)
+                    self.assertEqual(calls[0]['args'], {8: 3, 12: self.record+3204, 16: self.record+3332})
+
+    def test_state_pending_and_signed_wrap_gates(self):
+        self.assertEqual(self.frame(1, 1000, 2000)['calls'], [])
+        self.assertEqual(self.frame(2, 0, 2000)['calls'], [])
+        self.assertEqual(self.frame(2, -1, 2000)['calls'], [])
+        self.assertEqual(len(self.frame(2, 0x7ffffff0, -0x7fffff80)['calls']), 1)
+        self.assertEqual(signed32(0x80000000), -0x80000000)
+
+    def test_begin_replaces_only_sentinel_when_auth_enabled(self):
+        for enabled, pending, expected in [(1, 1, 1234), (1, 0, 0), (1, 100, 100), (0, 1, 1)]:
+            with self.subTest(enabled=enabled, pending=pending):
+                r = trace_slice(self.instructions, 174979, 175027,
+                                {35017616: enabled, self.record+3588: pending, 34992532: 1234,
+                                 self.record+3200: 0}, {24: self.record})
+                self.assertEqual(r['memory'][self.record+3588], expected)
+
+    def test_copy_request_and_terminator_boundaries(self):
+        for capacity in [1, 2, 128, 256]:
+            with self.subTest(capacity=capacity):
+                r = trace_slice(self.instructions, 69339, 69384, {}, {28: 0x20000, 32: 0x30000, 36: capacity})
+                self.assertEqual(r['calls'], [{'instruction': 69373, 'target': -103,
+                                               'args': {8: 0x20000, 12: 0x30000, 16: capacity-1}}])
+                self.assertEqual(r['byte_writes'], [{'address': 0x20000+capacity-1, 'value': 0}])
+
+    def test_bad_copy_inputs_reach_diagnostic_not_print_trap(self):
+        for source, capacity in [(0, 128), (0x30000, 0)]:
+            r = trace_slice(self.instructions, 69339, 69361, {}, {32: source, 36: capacity})
+            self.assertEqual(len(r['calls']), 1)
+            self.assertEqual(r['calls'][0]['target'], 5096)
+        for n in self.report['native'].values():
+            self.assertIn('Com_Error', n['error_case']['direct_call_or_jump_labels'])
+            self.assertIn('strncpy', [name.split('@')[0] for name in n['strncpy_case']['direct_call_or_jump_labels']])
+        body = self.report['functions']['2319']['instructions']
+        self.assertTrue(any(body[i-1]['operand'] == -2 and x['opcode'] == 'CALL' for i,x in enumerate(body) if i))
+
+    def test_unknown_reads_opcodes_and_escaped_branches_rejected(self):
+        with self.assertRaises(ValueError):
+            trace_slice(self.instructions, 15878, 15922, {}, {32: self.record})
+        with self.assertRaises(ValueError):
+            trace_slice(self.instructions, 69338, 69384, {}, {})
+        malformed = [{'index': 0, 'opcode': 'CONST', 'operand': 100}, {'index': 1, 'opcode': 'JUMP', 'operand': None}]
+        with self.assertRaises(ValueError):
+            trace_slice(malformed, 0, 2, {}, {})
+
+
+if __name__ == '__main__':
+    unittest.main()