chore: sync dev into #386 validation branch - #393
Merged
Merged
Conversation
…its (#296) * refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * style: restore final newline in #296 deadline coverage * fix(server): preserve single request logging scope after restack * test(server): adapt request-scope harness to retained payload parameter * test(server): declare TimeBudget policy for compressed one-way deadline * test(server): disambiguate SharpLink one-way timeout attribute
* refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * style: restore final newline in #296 deadline coverage * fix(server): preserve single request logging scope after restack * test(server): adapt request-scope harness to retained payload parameter * test(server): declare TimeBudget policy for compressed one-way deadline * test(server): disambiguate SharpLink one-way timeout attribute * fix(server): avoid duplicate async request scope * chore: preserve InvocationDispatch newline * chore(ci): refresh exact-head validation after #296 merge
* refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * test(server): make worker saturation portable and cover remote cancel * style: restore final newline in #296 deadline coverage * fix(server): preserve single request logging scope after restack * test(server): adapt request-scope harness to retained payload parameter * test(server): declare TimeBudget policy for compressed one-way deadline * test(server): disambiguate SharpLink one-way timeout attribute * fix(server): avoid duplicate async request scope * chore: preserve InvocationDispatch newline * chore(ci): refresh exact-head validation
…#319) * refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * test(server): make worker saturation portable and cover remote cancel * style: restore final newline in #296 deadline coverage * fix(server): preserve single request logging scope after restack * test(server): adapt request-scope harness to retained payload parameter * test(server): declare TimeBudget policy for compressed one-way deadline * test(server): disambiguate SharpLink one-way timeout attribute * fix(server): avoid duplicate async request scope * chore: preserve InvocationDispatch newline * chore(ci): refresh exact-head validation --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
* refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * test(server): make worker saturation portable and cover remote cancel * fix(test): align admission context helper with current API * fix(test): align request-scope harness with admission generation dispatch * chore(test): restore request-scope test formatting * fix(test): restore async request-scope assertion --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
* refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * refactor: add admission program retire lifecycle * refactor: add stable admission state kernel * refactor: bind admission programs to kernel state * refactor: compose stable admission lifecycle owner * refactor: retire and retry admission publication capture * refactor: always materialize server admission state kernel * test: adapt admission request owner assertions to kernel * fix: close admission program registration shutdown race * test: cover admission kernel state reuse and reclamation * test: keep generation regression on server-scoped kernel * test: expose allocation-free admission capture probe * test: cover admission capture retire and stop races * fix: reclaim unreferenced admission state without unrelated traffic delay * test: import threading primitives for kernel matrix * test(server): make retained-budget generation assertion deterministic * fix(server): complete admission reclamation before drain * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * test(server): make worker saturation portable and cover remote cancel * fix(server): align kernel controller with current admission context * fix(server): preserve partition ownership across kernel restack --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
…330) * refactor(server): prototype two-phase call reservations * test(server): cover call reservation lifecycle * test(server): import threading primitives * fix(server): make call reservation ownership identity-safe * test(server): cover stale reservation aliases * fix(server): harden reservation contracts for review * test(server): cover activation disposal transition * perf(server): add phase0 decode execution evidence runner * perf(server): expose phase0 decode evidence command * ci(perf): run phase0 decode strategy matrix * docs(perf): document phase0 decode matrix methodology * fix(perf): import threading primitives for decode evidence * fix(perf): scope stackalloc analyzer exception to phase0 runner * chore(perf): document relative hosted-runner evidence * docs(perf): select adaptive decode execution model * perf(server): add bounded decode executor saturation evidence * perf(server): wire executor backpressure evidence runner * perf(server): exercise bounded executor backpressure * docs(server): narrow Phase 0 decode conclusions after review * fix(perf): reference runtime compression provider contract * fix(perf): add IO global using for evidence runners * test(perf): cover queued decode cancellation * docs(perf): narrow cooperative decode conclusion * fix(perf): cancel queued persistent decode before provider * fix(perf): isolate persistent queue cancellation from A baseline * test(bench): expose actual D cancellation seam * test(bench): probe queued cancellation through actual D * fix(bench): align D probe seam accessibility * docs(bench): require post-cancellation-safe-D evidence * docs(bench): refresh current-D performance evidence * test(perf): cover actual D blocked-writer cancellation * test(perf): expose blocked-writer cancellation probe * ci(perf): run actual D blocked-writer cancellation probe * refactor(server): add production call permit owner for #273 * test(server): cover production call permit lifecycle for #273 * test(server): align call permit fixture with transport interface * test(server): narrow call permit nullability in assertions * test(server): avoid duplicate session handshake in permit fixture * fix(server): serialize request permit release completion * test(server): cover concurrent permit disposal release race * test(server): keep concurrent dispose tasks non-null * test(server): use dedicated disposer tasks for permit race * refactor(runtime): add server decode resource budgets for #273 * refactor(server): add ResourceGovernor decode permits for #273 * refactor(server): attach decode resources to request permits for #273 * refactor(server): keep decode acquisition request-owned * test(server): cover ResourceGovernor permit ownership for #273 * test(server): make ResourceGovernor nullable flow explicit * refactor(server): make decode permit rollback leak-safe * refactor(server): preserve activation state semantics with decode permits * refactor(server): keep zero-byte decode reservations state-aware * refactor(server): add transferable retained-byte permits * refactor(server): transfer retained bytes into decode permits * refactor(runtime): expose decoded request owner size * feat(abstractions): classify decode resource exhaustion * refactor(server): gate compressed admission retention by budget * refactor(server): keep compressed requests cheap in reader loop * refactor(server): centralize compressed request resource gates * refactor(server): wire request permits before compressed decode * refactor(server): bind retained accounting to admission payload owner * refactor(server): wire one-way and queued request resource ownership * refactor(server): align queued retention with decode ownership * refactor(server): preserve queued retained ownership through inline decode * refactor(server): pass queued retained owner directly to dispatch * refactor(server): remove temporary dispatch overload * test(server): verify compressed decode follows call reservation * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * refactor: add admission program retire lifecycle * refactor: add stable admission state kernel * refactor: bind admission programs to kernel state * refactor: compose stable admission lifecycle owner * refactor: retire and retry admission publication capture * refactor: always materialize server admission state kernel * test: adapt admission request owner assertions to kernel * fix: close admission program registration shutdown race * test: cover admission kernel state reuse and reclamation * test: keep generation regression on server-scoped kernel * test: expose allocation-free admission capture probe * test: cover admission capture retire and stop races * fix: reclaim unreferenced admission state without unrelated traffic delay * test: import threading primitives for kernel matrix * test(server): make retained-budget generation assertion deterministic * fix(server): complete admission reclamation before drain * Add runtime admission control API * Centralize admission publication lifecycle * Test admission runtime control transactions * Test runtime admission request semantics * Document runtime admission enable disable * Fix runtime control test type declarations * Complete admission writer and overlap tests * Add deterministic admission writer race seam * Cover runtime disable stop race * Add deterministic admission construction fault seam * Cover candidate rollback and stop writer race * Cover runtime admission resource regressions * Clarify runtime admission stop boundary * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * test(server): make worker saturation portable and cover remote cancel * test(server): align runtime admission context helpers * style(test): restore final newlines in runtime admission tests --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
…s runtime updates (#332) * test(server): fix compression capacity acceptance formatting * fix(server): preserve service exception mapping after request permit wiring * test(server): pass retained owner slot to dispatch harness * test(server): cover request decode hard-budget rejection * test(server): restore drain-race harness rationale * fix(server): create pre-decode cancellation state independently of admission * fix(server): release failed decode ownership before response backpressure * fix(server): release decode ownership before error response backpressure * fix(server): align one-way decode deadline ownership * test(server): prove decode resources release before response backpressure * test(server): prove decode deadline cancellation is admission-independent * test(server): tighten decode backpressure ownership assertions * test(server): import cancellation primitives for decode backpressure probe * fix(server): transfer decoded-byte ownership with payload lifetime * fix(server): transfer decoded-byte permit to call state * fix(server): couple decoded-byte charge to payload owner * fix(server): transfer one-way decoded-byte ownership before teardown * fix(server): transfer decoded-byte ownership before rpc teardown * test(server): hold decoded charge across external call-state lease * test(server): avoid touching recycled call state after lease release * refactor(server): restack persistent decode executor foundation * refactor(server): route large compressed requests through persistent decode * test(server): expose deterministic persistent decode starts * test(server): expose persistent decode start diagnostics * test(server): cover persistent decode control-plane ownership * fix(server): close persistent decode publication on drain * test(server): cover persistent decode graceful drain failures * fix(test): expose persistent decode counter waiter * fix(server): admit persistent decode before resource ownership * fix(server): satisfy persistent decode nullability * test(server): cover persistent decode review invariants * fix(server): release decode concurrency at worker boundary * style: add final newline to persistent decode control-plane tests * style: add final newline to persistent decode review tests * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * refactor: add admission program retire lifecycle * refactor: add stable admission state kernel * refactor: bind admission programs to kernel state * refactor: compose stable admission lifecycle owner * refactor: retire and retry admission publication capture * refactor: always materialize server admission state kernel * test: adapt admission request owner assertions to kernel * fix: close admission program registration shutdown race * test: cover admission kernel state reuse and reclamation * test: keep generation regression on server-scoped kernel * test: expose allocation-free admission capture probe * test: cover admission capture retire and stop races * fix: reclaim unreferenced admission state without unrelated traffic delay * test: import threading primitives for kernel matrix * test(server): make retained-budget generation assertion deterministic * fix(server): complete admission reclamation before drain * Add runtime admission control API * Centralize admission publication lifecycle * Test admission runtime control transactions * Test runtime admission request semantics * Document runtime admission enable disable * Fix runtime control test type declarations * Complete admission writer and overlap tests * Add deterministic admission writer race seam * Cover runtime disable stop race * Add deterministic admission construction fault seam * Cover candidate rollback and stop writer race * Cover runtime admission resource regressions * Clarify runtime admission stop boundary * Implement stable resizable admission limiter state * Split admission concurrency and rate state identity * Reconcile dynamic admission rules by independent state * Add transactional dynamic admission update publication * Expose enabled admission update API * Fix admission rate limiter type inference * Preserve RateLimiter compatibility for admission slots * Keep admission slot surface compatible with RateLimiter * Track split concurrency state in reclamation regression * Add dynamic admission update state and race matrix * Fix dynamic admission rate test accessibility * Extend admission dynamic update benchmarks * Document runtime admission updates * Complete dynamic admission state matrix * Run issue 331 admission benchmark evidence * Cover update lifecycle and repeated resize matrix * Narrow issue 331 benchmark evidence * Cover retained rate leases for all algorithms * Cover ResourceGovernor semantics across admission update * Remove temporary issue 331 benchmark workflow * Reduce dynamic admission queue allocations * Re-run issue 331 benchmark evidence * Restore fast rejection path for dynamic concurrency * Remove temporary issue 331 benchmark workflow * Add issue 331 review fix runner * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * Trigger issue 331 review fix validation * Fix review repair trigger extraction * Diagnose issue 331 review fix regressions * Preserve pre-publication kernel compatibility in review fix * Run corrected issue 331 review fix validation * Add draft-safe issue 331 review repair runner * Make issue 331 repair run self-identifying * Run corrected issue 331 P1 repair * test(server): make worker saturation portable and cover remote cancel * Make concurrency permits observe atomic target commits * Make dynamic admission publication state coherent * Prevent mixed-policy concurrency acquisition * Preserve FIFO across atomic concurrency updates * Publish concurrency updates behind one reader-visible epoch * Add issue 331 P1 review regressions * Make queued concurrency grants epoch-safe * Wake resized concurrency waiters after atomic publication * Validate one concurrency epoch across each admission request * Tighten concurrency grant linearization * Cover cross-epoch requests and queued grant race * Remove temporary issue 331 repair workflow * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair workflow * Add final issue 331 benchmark evidence workflow * Add issue 331 performance fix validation * Remove failed issue 331 perf helper * Retry issue 331 performance fix with single-scope queue gate * Reduce dynamic admission epoch hot-path overhead * Refresh final issue 331 benchmark evidence * Add final issue 331 single-slot performance validation * Restore admission single-slot fast path * Refresh issue 331 benchmark after single-slot fast-path fix * Add issue 331 exhausted-reject performance validation * Fix issue 331 perf validation commands * Keep exhausted admission rejection on fast path * Refresh issue 331 final benchmark after reject fast-path fix * Add issue 331 reject read-order validation * Short-circuit exhausted admission rejection * Add issue 331 direct reject fast-path validation * Keep exhausted admission reject in override * Refresh issue 331 final benchmark after direct reject fast path * Add issue 331 nonvolatile reject probe validation * Use BCL-shaped exhausted admission probe * Refresh issue 331 benchmark after BCL-shaped reject probe * Remove issue 331 benchmark evidence workflow * Restore volatile reads on concurrency reject fast path * Publish concurrency reject fast-path state atomically * Fix admission limiter final newline * Add issue 331 P2 benchmark evidence workflow * Trigger issue 331 P2 benchmark evidence * Probe P2 volatile reject codegen shape * Compare P2 reject fix to reviewed V7 shape * Remove issue 331 P2 benchmark probe * Remove issue 331 benchmark evidence workflow * noop * chore(ci): stage #332 restack preflight * chore(ci): retry #332 restack preflight * noop * chore(ci): trigger exact-head #332 validation --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
) * fix(protocol): register persistent decode queue exhaustion * fix(server): use registered decode queue exhaustion reason * fix(server): linearize pre-activation cancellation * fix(server): reject cancellation before call activation * test(server): align graceful drain with running decode credits * test(server): cover persistent decode cancel before activation * test(server): isolate decode queue ordering from byte budget drain * feat(server): add fair persistent decode scheduler * feat(server): schedule persistent decode by connection * test(server): cover per-connection decode fairness * test(server): expose fair decode scheduler diagnostics * test(server): prove persistent decode fairness across connections * test: include generic collections in unit globals * test(server): preserve global decode pending bound across connections * fix(server): let fair decode workers exit after publication seals * test(server): make real connection fairness ordering deterministic * test(server): cover fair scheduler stop lifecycle across connections * test(server): make fair decode routing explicitly cancellable * test(server): make fair lifecycle requests explicitly cancellable * feat(protocol): add pre-admission stream budget exhaustion reason * feat(runtime): configure pre-admission stream byte budget * feat(server): govern pre-admission stream bytes * refactor(runtime): bind pre-admission buffers to byte leases * refactor(runtime): preserve stream-manager lease adapter * refactor(server): expose stable stream byte callbacks * feat(server): budget pre-admission streams in resource governor * feat(server): distinguish pre-admission stream exhaustion * feat(server): map stream budget exhaustion independently * test(server): cover stable pre-admission stream byte budget * test(server): prove global pre-admission stream budget on wire * test(server): cover stream budget release on force stop * fix(test): correct stream budget lifecycle helper * style(test): normalize stream budget assertion formatting * fix(server): adapt stream budget callbacks to runtime delegates * refactor(server): hand stream byte leases to runtime buffers * fix(server): use compatible stream budget callback boundary * test(server): avoid contextual field identifier in budget probe * ci: stage integration source for exact patching * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * refactor: add admission program retire lifecycle * refactor: add stable admission state kernel * refactor: bind admission programs to kernel state * refactor: compose stable admission lifecycle owner * refactor: retire and retry admission publication capture * refactor: always materialize server admission state kernel * test: adapt admission request owner assertions to kernel * fix: close admission program registration shutdown race * test: cover admission kernel state reuse and reclamation * test: keep generation regression on server-scoped kernel * test: expose allocation-free admission capture probe * test: cover admission capture retire and stop races * fix: reclaim unreferenced admission state without unrelated traffic delay * test: import threading primitives for kernel matrix * test(server): make retained-budget generation assertion deterministic * fix(server): complete admission reclamation before drain * Add runtime admission control API * Centralize admission publication lifecycle * Test admission runtime control transactions * Test runtime admission request semantics * Document runtime admission enable disable * Fix runtime control test type declarations * Complete admission writer and overlap tests * Add deterministic admission writer race seam * Cover runtime disable stop race * Add deterministic admission construction fault seam * Cover candidate rollback and stop writer race * Cover runtime admission resource regressions * Clarify runtime admission stop boundary * Implement stable resizable admission limiter state * Split admission concurrency and rate state identity * Reconcile dynamic admission rules by independent state * Add transactional dynamic admission update publication * Expose enabled admission update API * Fix admission rate limiter type inference * Preserve RateLimiter compatibility for admission slots * Keep admission slot surface compatible with RateLimiter * Track split concurrency state in reclamation regression * Add dynamic admission update state and race matrix * Fix dynamic admission rate test accessibility * Extend admission dynamic update benchmarks * Document runtime admission updates * Complete dynamic admission state matrix * Run issue 331 admission benchmark evidence * Cover update lifecycle and repeated resize matrix * Narrow issue 331 benchmark evidence * Cover retained rate leases for all algorithms * Cover ResourceGovernor semantics across admission update * Remove temporary issue 331 benchmark workflow * Reduce dynamic admission queue allocations * Re-run issue 331 benchmark evidence * Restore fast rejection path for dynamic concurrency * Remove temporary issue 331 benchmark workflow * Add issue 331 review fix runner * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * Trigger issue 331 review fix validation * Fix review repair trigger extraction * Diagnose issue 331 review fix regressions * Preserve pre-publication kernel compatibility in review fix * Run corrected issue 331 review fix validation * Add draft-safe issue 331 review repair runner * Make issue 331 repair run self-identifying * Run corrected issue 331 P1 repair * test(server): make worker saturation portable and cover remote cancel * Make concurrency permits observe atomic target commits * Make dynamic admission publication state coherent * Prevent mixed-policy concurrency acquisition * Preserve FIFO across atomic concurrency updates * Publish concurrency updates behind one reader-visible epoch * Add issue 331 P1 review regressions * Make queued concurrency grants epoch-safe * Wake resized concurrency waiters after atomic publication * Validate one concurrency epoch across each admission request * Tighten concurrency grant linearization * Cover cross-epoch requests and queued grant race * Remove temporary issue 331 repair workflow * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair workflow * Add final issue 331 benchmark evidence workflow * Add issue 331 performance fix validation * Remove failed issue 331 perf helper * Retry issue 331 performance fix with single-scope queue gate * Reduce dynamic admission epoch hot-path overhead * Refresh final issue 331 benchmark evidence * Add final issue 331 single-slot performance validation * Restore admission single-slot fast path * Refresh issue 331 benchmark after single-slot fast-path fix * Add issue 331 exhausted-reject performance validation * Fix issue 331 perf validation commands * Keep exhausted admission rejection on fast path * Refresh issue 331 final benchmark after reject fast-path fix * Add issue 331 reject read-order validation * Short-circuit exhausted admission rejection * Add issue 331 direct reject fast-path validation * Keep exhausted admission reject in override * Refresh issue 331 final benchmark after direct reject fast path * Add issue 331 nonvolatile reject probe validation * Use BCL-shaped exhausted admission probe * Refresh issue 331 benchmark after BCL-shaped reject probe * Remove issue 331 benchmark evidence workflow * Restore volatile reads on concurrency reject fast path * Publish concurrency reject fast-path state atomically * Fix admission limiter final newline * Add issue 331 P2 benchmark evidence workflow * Trigger issue 331 P2 benchmark evidence * Probe P2 volatile reject codegen shape * Compare P2 reject fix to reviewed V7 shape * Remove issue 331 P2 benchmark probe * Remove issue 331 benchmark evidence workflow * test(admission): add failing dynamic rate transition coverage * feat(admission): add transitionable rate state core * feat(admission): route rate limits through owned state * feat(admission): prepare transactional rate transitions * feat(admission): compile dynamic rate transitions into updates * feat(admission): publish exact rate lineage with updates * test(admission): update rate transition expectations * test(admission): cover conservative algorithm replacement barriers * test(admission): cover legacy waiter debt after rate replacement * test(admission): release retained source on expected failure * fix(admission): preserve conservative rate debt horizons * test(admission): expand deterministic rate update semantics * test(admission): cover rate lineage writer and lifecycle invariants * test(admission): add LINQ global using for dynamic rate lifecycle tests * bench(admission): cover dynamic rate transition steady state * docs(admission): document dynamic rate transition semantics * test(admission): cover carried rate debt and cadence boundaries * test(admission): keep carried-debt assertion capacity-aware * fix(admission): preserve carried rate debt and timing boundaries * bench(admission): add fresh rate RPC comparison baselines * ci: collect issue 333 rate performance evidence * ci: remove issue 333 performance evidence workflow * ci: isolate issue 333 integration timeout * ci: remove issue 333 integration isolation workflow * test(admission): reproduce rate lineage review blockers * fix(admission): preserve accumulated legacy rate debt * fix(admission): retain current rate lineage anchor * test(admission): cover coupled TokenBucket carry credit (#333) * fix(admission): couple TokenBucket carry replenishment (#333) * docs(admission): document coupled TokenBucket carry credit (#333) * ci: compare coupled TokenBucket hot path (#333) * ci: restore performance evidence workflow (#333) * test: localize LINQ import for dynamic rate lifecycle tests (#333) * test: restore shared global usings (#333) * chore(ci): stage #334 restack preflight * chore(ci): resolve #334 partition owner/time-provider restack * chore(ci): fix #334 restack workflow syntax * chore(ci): adapt #334 rate tests to six-field admission context * chore(ci): trigger exact-head #334 validation --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
… (#336) * ci: apply deterministic integration test migration * test(server): migrate stream budget overflow regression * ci: restore standard PR Quick workflow * refactor(runtime): accept pre-admission stream byte leases directly * refactor(server): hand governor stream permits to runtime * fix(server): map pre-admission stream exhaustion terminal reason * test(server): expose pre-activation race hook * fix(server): gate one-way activation on terminal state * test(server): cover stream budget termination mapping * fix(server): include stable stream reason in terminal diagnostic * test(server): cover stream budget pre-activation races * test(server): match stream exhaustion wire diagnostic * test(server): register deterministic activation race service * test(server): queue one-way calls in stream activation race * feat(server): add immutable admission program generations * refactor(server): publish initial admission program in composition * refactor(server): bind admission generation use to call lifetime * test(server): add deterministic admission publication hook * fix(server): acquire admission generation before publication hook * refactor(server): capture admission program once in request loop * refactor(server): dispatch one-way calls with captured admission generation * refactor(server): dispatch two-way calls with captured admission generation * refactor(server): retain build admission publication identity * refactor(server): preserve controller lifecycle compatibility * fix(server): qualify admission publication registry type * refactor(server): model disabled admission publication without request ownership * refactor(server): initialize and capture admission publication once * test(server): cover captured admission generations and release matrix * test(server): keep retained-budget reason local to integration probe * chore(ci): apply scoped issue 322 harness patch * chore(ci): trigger scoped issue 322 harness patch * chore(ci): make issue 322 harness patch deterministic * test(server): pass captured admission generation in dispatch harness * chore: trigger exact-head issue 322 validation * chore(ci): apply issue 322 zero-allocation ownership refinement * chore: trigger admission use ownership refinement * chore(ci): trigger issue 322 zero-allocation refinement * chore(ci): stage issue 322 zero-allocation patch script * chore(ci): arm issue 322 ownership patch helper * chore(ci): trigger issue 322 ownership patch helper * chore(ci): correct issue 322 zero-allocation patch script * chore(ci): harden issue 322 zero-allocation patch matching * perf(server): remove admission generation use allocation * refactor(server): make admission use release diagnostic race-safe * chore(ci): stage deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore(ci): trigger deterministic one-way generation test fix * test(server): synchronize one-way admission publication race * chore: trigger exact-head issue 322 validation * chore(ci): stage generation test barrier dedupe * test(server): dedupe admission publication barrier * chore(ci): trigger generation test barrier dedupe * chore(ci): remove temporary issue 322 test helper * refactor: add admission program retire lifecycle * refactor: add stable admission state kernel * refactor: bind admission programs to kernel state * refactor: compose stable admission lifecycle owner * refactor: retire and retry admission publication capture * refactor: always materialize server admission state kernel * test: adapt admission request owner assertions to kernel * fix: close admission program registration shutdown race * test: cover admission kernel state reuse and reclamation * test: keep generation regression on server-scoped kernel * test: expose allocation-free admission capture probe * test: cover admission capture retire and stop races * fix: reclaim unreferenced admission state without unrelated traffic delay * test: import threading primitives for kernel matrix * test(server): make retained-budget generation assertion deterministic * fix(server): complete admission reclamation before drain * Add runtime admission control API * Centralize admission publication lifecycle * Test admission runtime control transactions * Test runtime admission request semantics * Document runtime admission enable disable * Fix runtime control test type declarations * Complete admission writer and overlap tests * Add deterministic admission writer race seam * Cover runtime disable stop race * Add deterministic admission construction fault seam * Cover candidate rollback and stop writer race * Cover runtime admission resource regressions * Clarify runtime admission stop boundary * Implement stable resizable admission limiter state * Split admission concurrency and rate state identity * Reconcile dynamic admission rules by independent state * Add transactional dynamic admission update publication * Expose enabled admission update API * Fix admission rate limiter type inference * Preserve RateLimiter compatibility for admission slots * Keep admission slot surface compatible with RateLimiter * Track split concurrency state in reclamation regression * Add dynamic admission update state and race matrix * Fix dynamic admission rate test accessibility * Extend admission dynamic update benchmarks * Document runtime admission updates * Complete dynamic admission state matrix * Run issue 331 admission benchmark evidence * Cover update lifecycle and repeated resize matrix * Narrow issue 331 benchmark evidence * Cover retained rate leases for all algorithms * Cover ResourceGovernor semantics across admission update * Remove temporary issue 331 benchmark workflow * Reduce dynamic admission queue allocations * Re-run issue 331 benchmark evidence * Restore fast rejection path for dynamic concurrency * Remove temporary issue 331 benchmark workflow * Add issue 331 review fix runner * fix(server): coordinate decode scheduler wake ownership * test(server): cover stale ready wakes with four workers * test(server): cover compatibility dispose publication race * fix(test): make dispose race regression deterministic * test(server): cover four-worker connection close * Trigger issue 331 review fix validation * Fix review repair trigger extraction * Diagnose issue 331 review fix regressions * Preserve pre-publication kernel compatibility in review fix * Run corrected issue 331 review fix validation * Add draft-safe issue 331 review repair runner * Make issue 331 repair run self-identifying * Run corrected issue 331 P1 repair * test(server): make worker saturation portable and cover remote cancel * Make concurrency permits observe atomic target commits * Make dynamic admission publication state coherent * Prevent mixed-policy concurrency acquisition * Preserve FIFO across atomic concurrency updates * Publish concurrency updates behind one reader-visible epoch * Add issue 331 P1 review regressions * Make queued concurrency grants epoch-safe * Wake resized concurrency waiters after atomic publication * Validate one concurrency epoch across each admission request * Tighten concurrency grant linearization * Cover cross-epoch requests and queued grant race * Remove temporary issue 331 repair workflow * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair trigger * Remove temporary issue 331 repair workflow * Add final issue 331 benchmark evidence workflow * Add issue 331 performance fix validation * Remove failed issue 331 perf helper * Retry issue 331 performance fix with single-scope queue gate * Reduce dynamic admission epoch hot-path overhead * Refresh final issue 331 benchmark evidence * Add final issue 331 single-slot performance validation * Restore admission single-slot fast path * Refresh issue 331 benchmark after single-slot fast-path fix * Add issue 331 exhausted-reject performance validation * Fix issue 331 perf validation commands * Keep exhausted admission rejection on fast path * Refresh issue 331 final benchmark after reject fast-path fix * Add issue 331 reject read-order validation * Short-circuit exhausted admission rejection * Add issue 331 direct reject fast-path validation * Keep exhausted admission reject in override * Refresh issue 331 final benchmark after direct reject fast path * Add issue 331 nonvolatile reject probe validation * Use BCL-shaped exhausted admission probe * Refresh issue 331 benchmark after BCL-shaped reject probe * Remove issue 331 benchmark evidence workflow * Restore volatile reads on concurrency reject fast path * Publish concurrency reject fast-path state atomically * Fix admission limiter final newline * Add issue 331 P2 benchmark evidence workflow * Trigger issue 331 P2 benchmark evidence * Probe P2 volatile reject codegen shape * Compare P2 reject fix to reviewed V7 shape * Remove issue 331 P2 benchmark probe * Remove issue 331 benchmark evidence workflow * test(admission): add failing dynamic rate transition coverage * feat(admission): add transitionable rate state core * feat(admission): route rate limits through owned state * feat(admission): prepare transactional rate transitions * feat(admission): compile dynamic rate transitions into updates * feat(admission): publish exact rate lineage with updates * test(admission): update rate transition expectations * test(admission): cover conservative algorithm replacement barriers * test(admission): cover legacy waiter debt after rate replacement * test(admission): release retained source on expected failure * fix(admission): preserve conservative rate debt horizons * test(admission): expand deterministic rate update semantics * test(admission): cover rate lineage writer and lifecycle invariants * test(admission): add LINQ global using for dynamic rate lifecycle tests * bench(admission): cover dynamic rate transition steady state * docs(admission): document dynamic rate transition semantics * test(admission): cover carried rate debt and cadence boundaries * test(admission): keep carried-debt assertion capacity-aware * fix(admission): preserve carried rate debt and timing boundaries * bench(admission): add fresh rate RPC comparison baselines * ci: collect issue 333 rate performance evidence * ci: remove issue 333 performance evidence workflow * ci: isolate issue 333 integration timeout * ci: remove issue 333 integration isolation workflow * test(admission): reproduce rate lineage review blockers * fix(admission): preserve accumulated legacy rate debt * fix(admission): retain current rate lineage anchor * test(admission): cover coupled TokenBucket carry credit (#333) * fix(admission): couple TokenBucket carry replenishment (#333) * docs(admission): document coupled TokenBucket carry credit (#333) * ci: compare coupled TokenBucket hot path (#333) * ci: restore performance evidence workflow (#333) * test: localize LINQ import for dynamic rate lifecycle tests (#333) * test: restore shared global usings (#333) * chore: start #335 stacked slice * test(admission): lock partition update invariants * refactor(admission): separate partition namespace identity from policy * feat(admission): preserve partition entry state across updates * feat(admission): commit partition targets with publication * test(admission): update legacy assertions for partition migration * test(admission): align partition rate growth with delta quota semantics * test(admission): cover partition lifecycle and writer races * test(admission): fix partition advanced test imports * perf(admission): benchmark dynamic partition steady state * docs(admission): document partition runtime transitions * test(admission): cover partition rate handoff semantics * ci: apply issue 335 transactional self-review fix * ci: stage issue 335 transactional patch script * ci: run issue 335 transactional patch script * fix(admission): preallocate partition commit state * chore: remove issue 335 patch workflow * chore: remove issue 335 patch helper * test(admission): cover partition commit preparation failure * test(admission): make queue-delay update deterministic * chore: trigger exact-head validation * test(admission): cover captured partition generation across update * test(admission): fix captured generation regression fixture * test(admission): keep P9 fixture stable * chore(admission): stage P9 review fix preflight * fix(admission): bind captured partition policy generations * test(admission): harden captured partition generation coverage * perf(admission): trim partition generation hot path * chore(ci): validate final issue 335 head * perf(admission): reduce partition request overhead * chore: trigger exact-head validation * test: carry forward interceptor stabilization from #279 * chore(ci): stage #336 restack preflight * chore(ci): resolve #336 partition generation restack * chore(ci): harden #336 partition splice bounds * chore(ci): splice #336 partition tail deterministically * chore(ci): adapt #336 partition lease boundary * chore(ci): complete #336 restack compatibility * chore(ci): handle multiline #336 context helpers * chore: trigger exact-head #336 validation * chore(ci): repair #336 idle reconciliation * chore: trigger exact-head #336 idle reconciliation validation --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: SunSi12138 <54728594+SunSi12138@users.noreply.github.com>
Replacement landing for closed Dependabot PR #327.
* test: synchronize one-way time-budget emission boundary * test: make client-stream time-budget boundary deterministic
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Temporary sync PR used to merge the current dev head (including #392) into the #386 head lineage before updating the actual feature branch.