const auto deadline = std::chrono::steady_clock::now() + kBudget;

while (!pred()) {

if (std::chrono::steady_clock::now() >= deadline) return false;

std::this_thread::sleep_for(std::chrono::microseconds(200));

}

return true;

http::fields f;

f.append("Content-Type", "text/plain");

f.append("Content-Length", "5");

static_cast<void>(x.start_response(http::status::from_code(200), f));

const std::string body = "hello";

const std::byte* raw = reinterpret_cast<const std::byte*>(body.data());

co_await x.writer().write(std::span<const std::byte>(raw, body.size()));

co_await x.writer().finish();

const http::outcome admitted = x.admit_body(body_policy{});

if (!admitted.ok()) co_return;

const body_collect collected = co_await x.body().collect(1 << 20);

if (!collected.status.ok()) co_return;

http::fields f;

f.append("Content-Type", "text/plain");

f.append("Content-Length", std::to_string(collected.data.size()));

static_cast<void>(x.start_response(http::status::from_code(200), f));

const std::byte* raw =

reinterpret_cast<const std::byte*>(collected.data.data());

co_await x.writer().write(

std::span<const std::byte>(raw, collected.data.size()));

co_await x.writer().finish();

http::fields f;

f.append("Content-Length", "0");

static_cast<void>(x.respond(http::status::from_code(200), f));

co_return;

http::fields f;

f.append("Content-Length", "0");

static_cast<void>(x.respond(http::status::from_code(200), f));

co_return;

const resume_outcome gate = co_await late_gate.wait_for(kBudget);

if (gate != resume_outcome::resumed) co_return;

const http::outcome admitted = x.admit_body(body_policy{});

if (!admitted.ok()) co_return;

const body_collect collected = co_await x.body().collect(1 << 20);

if (!collected.status.ok()) co_return;

http::fields f;

f.append("Content-Type", "text/plain");

f.append("Content-Length", std::to_string(collected.data.size()));

static_cast<void>(x.start_response(http::status::from_code(200), f));

const std::byte* raw =

reinterpret_cast<const std::byte*>(collected.data.data());

co_await x.writer().write(

std::span<const std::byte>(raw, collected.data.size()));

co_await x.writer().finish();

http::fields f;

f.append("Content-Length", "0");

static_cast<void>(x.respond(http::status::from_code(403), f));

co_return;

const http::outcome admitted = x.admit_body(body_policy{});

if (!admitted.ok()) co_return;

http::fields f;

f.append("Content-Length", "0");

static_cast<void>(x.respond(http::status::from_code(200), f));

co_return;

resume_signal wait;

if (!x.suspend(wait).ok()) co_return;

suspend_entered.store(true);

const resume_outcome outcome = co_await wait.wait_for(kBudget);

suspend_outcome.store(static_cast<int>(outcome));

suspend_wait_done.fetch_add(1);

co_return; // a cancelled exchange must not respond

const http::outcome admitted = x.admit_body(body_policy{});

if (!admitted.ok()) co_return;

std::byte piece[8];

const body_read first = co_await x.body().read_some(piece);

if (!first.status.ok() || first.end_of_body) co_return;

resume_signal wait;

if (!x.suspend(wait).ok()) co_return;

suspend_entered.store(true);

const resume_outcome outcome = co_await wait.wait_for(kBudget);

suspend_outcome.store(static_cast<int>(outcome));

suspend_wait_done.fetch_add(1);

co_return;

gated_active.store(static_cast<int>(scenario_scope.active()));

gated_entered.store(true);

const resume_outcome gate = co_await gated_gate.wait_for(kBudget);

if (gate != resume_outcome::resumed) co_return;

http::fields f;

f.append("Content-Type", "text/plain");

f.append("Content-Length", "5");

static_cast<void>(x.start_response(http::status::from_code(200), f));

const std::string body = "gated";

const std::byte* raw = reinterpret_cast<const std::byte*>(body.data());

co_await x.writer().write(std::span<const std::byte>(raw, body.size()));

co_await x.writer().finish();

scenario(srv::budget_limits limits, srv::timeout_options timeouts_in)

: config_limits(limits), timeouts(timeouts_in),

root(srv::resource_budget::root(limits)) {

config.timeouts = timeouts;

static_cast<void>(srv::route_registry::create(root, registry));

static_cast<void>(registry.route(

http::method::known(http::method_id::get), "/hello",

hello_handler));

static_cast<void>(registry.route(

http::method::known(http::method_id::post), "/echo",

echo_handler));

static_cast<void>(registry.route(

http::method::known(http::method_id::get), "/gated",

gated_handler));

pair = io_loopback::pair::make();

if (pair.ok()) {

pollsys::set_nonblocking(pair.peer(), true);

}

}

explicit scenario(srv::budget_limits limits = srv::budget_limits())

: scenario(limits, srv::timeout_options()) { }

explicit scenario(srv::timeout_options timeouts_in)

: scenario(srv::budget_limits(), timeouts_in) { }

bool start_engine() {

if (!pair.ok()) return false;

backend.adopt_connection(kConnId, pair.detach_local());

engine = std::make_shared<connection_engine>(backend, pool, registry,

hooks, root, scenario_scope,

config, kConnId,

[this] {

stopped.store(true);

});

engine->start();

return true;

}

srv::budget_limits config_limits;

srv::timeout_options timeouts;

connection_engine_config config

= connection_engine_config::from_budget_limits(config_limits);

srv::resource_budget root;

srv::route_registry registry;

srv::hook_bus hooks; // TASK-118: no hooks by default (the zero-hook lane)

io_loopback::pair pair;

// Teardown is the reverse declaration order: the engine dies first,

// then the thread-backed backend (close + driver join), then the

// pool drains what the close enqueued (the documented order).

worker_pool pool{2};

io_poll_backend backend;

std::atomic<bool> stopped{false};

std::shared_ptr<connection_engine> engine;

// Stateful response reader: the parity parser buffers across

// segments and every completed response is queued, so several

// responses in one segment (an interim followed by the final head)

// are observed in order.

std::optional<observed_response> next_response(

pollsys::native_socket_t peer) {

const auto deadline = std::chrono::steady_clock::now() + kBudget;

while (std::chrono::steady_clock::now() < deadline

&& !wire_parser.failed()) {

if (!completed.empty()) {

observed_response done = completed.front();

completed.pop_front();

return done;

}

const pollsys::sys_result r =

pollsys::read_some(peer, wire_buf, sizeof wire_buf);

if (r.status == pollsys::sys_status::ok && r.transferred > 0) {

for (observed_response& done : wire_parser.feed(

as_view(wire_buf, r.transferred))) {

completed.push_back(done);

}

continue;

}

if (r.status != pollsys::sys_status::would_block) {

for (observed_response& done : wire_parser.finish()) {

completed.push_back(done);

}

continue;

}

std::this_thread::sleep_for(std::chrono::microseconds(200));

}

return std::nullopt;

}

response_frame_parser wire_parser;

std::deque<observed_response> completed;

std::byte wire_buf[1024];

std::byte buf[256];

const auto deadline = std::chrono::steady_clock::now() + kBudget;

while (std::chrono::steady_clock::now() < deadline) {

const pollsys::sys_result r =

pollsys::read_some(peer, buf, sizeof buf);

if (r.status == pollsys::sys_status::closed_reset) return true;

if (r.status == pollsys::sys_status::would_block) {

std::this_thread::sleep_for(std::chrono::microseconds(200));

continue;

}

return false;

}

return false;

std::chrono::milliseconds window) {

std::byte buf[64];

const auto deadline = std::chrono::steady_clock::now() + window;

for (;;) {

const pollsys::sys_result r =

pollsys::read_some(peer, buf, sizeof buf);

if (r.status == pollsys::sys_status::would_block) {

if (std::chrono::steady_clock::now() >= deadline) return true;

std::this_thread::sleep_for(std::chrono::milliseconds(5));

continue;

}

return false; // data arrived, or the peer closed

}

const auto deadline = std::chrono::steady_clock::now() + kBudget;

while (std::chrono::steady_clock::now() < deadline) {

const pollsys::sys_result r =

pollsys::read_some(peer, s.wire_buf, sizeof s.wire_buf);

if (r.status == pollsys::sys_status::ok && r.transferred > 0) {

for (observed_response& done : s.wire_parser.feed(

as_view(s.wire_buf, r.transferred))) {

s.completed.push_back(done);

}

continue;

}

if (r.status == pollsys::sys_status::closed_reset) {

for (observed_response& done : s.wire_parser.finish()) {

s.completed.push_back(done);

}

return;

}

if (r.status != pollsys::sys_status::would_block) return;

std::this_thread::sleep_for(std::chrono::microseconds(200));

}

if (s.stopped.load()) return;

s.engine->shutdown();

static_cast<void>(wait_until([&s] { return s.stopped.load(); }));