Enable durable cellular session actions
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 37s
Foundation / checks (ecs) (push) Successful in 1m53s
Foundation / checks (postgres) (push) Failing after 50s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (network) (push) Canceled after 2m38s
Foundation / checks (tsan) (push) Canceled after 22s
Foundation / checks (client) (push) Canceled after 3m18s

This commit is contained in:
dingo
2026-10-10 23:31:36 -04:00
parent 0ddba31d42
commit eeb663d696
7 changed files with 179 additions and 15 deletions
+9 -2
View File
@@ -255,8 +255,15 @@ scoped change before starting the next segment.
profile-4 adapter, pauses on ambiguous commits and resolves/retries the exact
prepared bytes. It exposes final action acknowledgements only after a confirmed
receipt. A real-PostgreSQL test exercises host publication followed by a new
host instance recovering the result. Session v7 admission, scheduler
ownership, process kill tests and CI execution remain open.
host instance recovering the result.
- 11.3d-7b: the QUIC client and region-session host can negotiate the reliable
v7 cellular action path. Admission requires both durable control and action
ledgers, and the server keeps v7 off the M10 probe/view datagrams. Actions
retain canonical biological input bytes through carry and can be retried after
reconnect; the session test covers durable duplicate-result recovery and
changed-input refusal. The caller still needs to own the live scheduler and
join admitted actions to the profile-4 host publication loop. Process kill
tests and CI execution remain open.
## Exit boundary
+17
View File
@@ -6300,3 +6300,20 @@ its action result, and recovery through a fresh host instance.
for the host and integration test. Full CMake build, PostgreSQL execution and
process fault tests remain pending CI; CMake's documented preset still fails its
cached MSVC C++23 feature check.
## 2026-10-10 — M11.3d-7b reliable cellular session actions (CI pending)
Added the v7 cellular action send API to the client session and opt-in server
admission. The server requires durable control and action ledgers, refuses v7
unless enabled, and keeps v7 away from the M10 view/intention datagrams. QUIC
session coverage checks admitted/carried canonical input, confirmed result,
exact retry after reconnect, and refusal when the same durable action ID is
reused with changed input. These changes do not yet connect session scheduling
to `CellularRegionHost` publication.
GCC 13.2 C++23 `-fsyntax-only` checks with warnings as errors pass for the
modified server/client sources and `tests/quic_sessions.cpp`, with and without
`NDEBUG`; `git diff --check` passes. `cmake --preset quic` cannot configure in
this checkout because its cached MSVC 19.44 compiler is reported as having no
known C++23 features. `clang-format` is unavailable on `PATH`. The QUIC test
binary, PostgreSQL suite, and CI have not run here.
+4
View File
@@ -59,6 +59,10 @@ class RegionSessionClient {
// retries and reconnects). False unless established and sent.
[[nodiscard]] bool send_action(std::uint64_t action_id, network::ActionKind kind,
std::uint64_t tick);
// Protocol v7 only. Reuse the exact same fields and action id after reconnect.
[[nodiscard]] bool send_cellular_action(
std::uint64_t action_id, std::uint64_t tick, std::int16_t move_x, std::int16_t move_y,
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target = {});
[[nodiscard]] bool query_action(std::uint64_t action_id);
// Primitive profile v5 only. The account and generation are always supplied by the
// authenticated session; callers choose only a stable request id.
+3
View File
@@ -102,6 +102,9 @@ struct RegionSessionsConfig {
query_primitive_life;
// M11.3 v6 cellular intentions. Opt-in until a cellular state owner consumes them.
bool accept_cellular_intentions{};
// M11.3 v7 durable cellular actions. Requires durable control and action ledgers;
// the caller must forward carried inputs to the profile-4 region host.
bool accept_cellular_actions{};
};
// The region host's authority, read once per poll.
struct HostFacts {
+16 -2
View File
@@ -151,7 +151,8 @@ std::expected<std::unique_ptr<RegionSessionClient>, network::quic::EndpointError
RegionSessionClient::connect(RegionSessionClientConfig config, Clock::time_point now) {
if (config.protocol_version != network::session_protocol_version &&
config.protocol_version != network::session_protocol_v5 &&
config.protocol_version != network::session_protocol_v6)
config.protocol_version != network::session_protocol_v6 &&
config.protocol_version != network::session_protocol_v7)
return std::unexpected(network::quic::EndpointError::configuration);
auto endpoint = network::quic::Endpoint::connect(config.transport);
if (!endpoint)
@@ -252,9 +253,22 @@ bool RegionSessionClient::send_action(std::uint64_t action_id, network::ActionKi
static_cast<std::uint16_t>(kind), tick});
}
bool RegionSessionClient::send_cellular_action(
std::uint64_t action_id, std::uint64_t tick, std::int16_t move_x, std::int16_t move_y,
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target) {
auto& m = *impl_;
return m.protocol_version == network::session_protocol_v7 &&
m.state == RegionSessionState::established && m.welcome && action_id != 0 && tick != 0 &&
m.send(network::CellularAction{m.welcome->session, m.welcome->epoch, action_id, tick,
move_x, move_y, intake_target.has_value(),
intake_target ? intake_target->first : 0,
intake_target ? intake_target->second : 0});
}
bool RegionSessionClient::query_action(std::uint64_t action_id) {
auto& m = *impl_;
return m.protocol_version == network::session_protocol_version &&
return (m.protocol_version == network::session_protocol_version ||
m.protocol_version == network::session_protocol_v7) &&
m.state == RegionSessionState::established && m.send(network::ActionQuery{action_id});
}
+33 -9
View File
@@ -323,9 +323,11 @@ struct RegionSessions::Impl {
intents.close(c.session);
return close(c, SessionCloseReason::capacity, now);
}
if (default_interest && c.protocol_version != network::session_protocol_v6)
if (default_interest && c.protocol_version != network::session_protocol_v6 &&
c.protocol_version != network::session_protocol_v7)
(void)replication.set_interest(c.session, *default_interest).has_value();
if (markers.area() && c.protocol_version != network::session_protocol_v6)
if (markers.area() && c.protocol_version != network::session_protocol_v6 &&
c.protocol_version != network::session_protocol_v7)
// Full or refused: the session simply has no marker.
(void)(c.probe ? markers.open_at(c.session, c.probe->x, c.probe->y)
: markers.open(c.session))
@@ -394,8 +396,10 @@ struct RegionSessions::Impl {
const auto decoded = network::decode_session(bytes, &wire_version);
if (c.state != State::established || !decoded || wire_version != c.protocol_version ||
(c.protocol_version != network::session_protocol_version &&
!(config.accept_cellular_intentions &&
c.protocol_version == network::session_protocol_v6)))
!((config.accept_cellular_intentions &&
c.protocol_version == network::session_protocol_v6) ||
(config.accept_cellular_actions &&
c.protocol_version == network::session_protocol_v7))))
return close(c, SessionCloseReason::protocol, now);
if (const auto* ack = std::get_if<network::SnapshotAck>(&*decoded))
return replication.acknowledge(c.session, *ack);
@@ -406,6 +410,8 @@ struct RegionSessions::Impl {
send_datagram(c, intents.intention(c.session, *m, admission()));
return;
}
if (c.protocol_version == network::session_protocol_v7)
return close(c, SessionCloseReason::protocol, now); // No M10 datagrams in v7.
const auto* m = std::get_if<network::SessionIntention>(&*decoded);
if (!m)
return close(c, SessionCloseReason::protocol, now);
@@ -525,6 +531,7 @@ struct RegionSessions::Impl {
if (receipt.status == network::AdmitStatus::duplicate)
if (const auto o = intents.query(c.session, {receipt.action_id}, admission());
o.result == network::ActionResult::committed_no_effect ||
o.result == network::ActionResult::committed ||
o.result == network::ActionResult::not_committed)
send(c, o);
}
@@ -554,10 +561,12 @@ struct RegionSessions::Impl {
c.protocol_version = wire_version;
const bool primitive_v5 = static_cast<bool>(config.create_primitive_life);
const bool cellular_v6 = config.accept_cellular_intentions;
const bool cellular_v7 = config.accept_cellular_actions;
if ((primitive_v5 && wire_version != network::session_protocol_v5) ||
(wire_version == network::session_protocol_v5 && !primitive_v5) ||
(wire_version == network::session_protocol_v6 && !cellular_v6) ||
wire_version > network::session_protocol_v6)
(wire_version == network::session_protocol_v7 && !cellular_v7) ||
wire_version > network::session_protocol_v7)
return close(c, SessionCloseReason::unsupported_version, now);
} else if (wire_version != c.protocol_version) {
return close(c, SessionCloseReason::unsupported_version, now);
@@ -571,13 +580,21 @@ struct RegionSessions::Impl {
return refresh(c, *m, now_seconds, now);
if (const auto* m = std::get_if<network::SessionAction>(&*decoded)) {
if (c.protocol_version == network::session_protocol_v5 ||
c.protocol_version == network::session_protocol_v6)
c.protocol_version == network::session_protocol_v6 ||
c.protocol_version == network::session_protocol_v7)
return close(c, SessionCloseReason::protocol, now);
// A durable uniqueness check waits for this poll's single `verify` (M10.9d).
if (const auto receipt = intents.admit(c.session, *m, admission()))
answer(c, *receipt);
return;
}
if (const auto* m = std::get_if<network::CellularAction>(&*decoded)) {
if (c.protocol_version != network::session_protocol_v7)
return close(c, SessionCloseReason::protocol, now);
if (const auto receipt = intents.admit(c.session, *m, admission()))
answer(c, *receipt);
return;
}
if (const auto* m = std::get_if<network::ActionQuery>(&*decoded)) {
if (c.protocol_version == network::session_protocol_v5 ||
c.protocol_version == network::session_protocol_v6)
@@ -586,7 +603,8 @@ struct RegionSessions::Impl {
}
if (const auto* m = std::get_if<network::SessionInterest>(&*decoded)) {
if (c.protocol_version == network::session_protocol_v5 ||
c.protocol_version == network::session_protocol_v6)
c.protocol_version == network::session_protocol_v6 ||
c.protocol_version == network::session_protocol_v7)
return close(c, SessionCloseReason::protocol, now);
(void)replication.set_interest(c.session, *m).has_value(); // Clamped by the server.
return;
@@ -630,6 +648,9 @@ RegionSessions::create(RegionSessionsConfig config) {
((config.create_primitive_life || config.query_primitive_life) &&
(!config.create_primitive_life || !config.query_primitive_life || !config.ledger)) ||
(config.accept_cellular_intentions && config.create_primitive_life) ||
(config.accept_cellular_actions &&
(!config.actions || !config.ledger || config.create_primitive_life ||
config.accept_cellular_intentions)) ||
config.transport.limits.max_connections < config.control.max_sessions ||
config.hello_deadline.count() <= 0 || config.close_flush.count() <= 0 ||
config.renew_interval.count() <= 0 || config.safety_margin.count() <= 0 ||
@@ -789,6 +810,7 @@ void RegionSessions::set_default_interest(network::SessionInterest interest) {
for (const auto& c : m.connections)
if (c.state == Impl::State::established &&
c.protocol_version != network::session_protocol_v6 &&
c.protocol_version != network::session_protocol_v7 &&
!m.replication.interest(c.session))
(void)m.replication.set_interest(c.session, interest).has_value();
}
@@ -812,7 +834,8 @@ void RegionSessions::replicate(
for (const auto& [session, chunks] : m.replication.tick(tick, with_markers, perceives, payload))
if (const auto* c = m.by_session(session);
c && c->state == Impl::State::established &&
c->protocol_version != network::session_protocol_v6)
c->protocol_version != network::session_protocol_v6 &&
c->protocol_version != network::session_protocol_v7)
for (const auto& chunk : chunks)
m.send_datagram(*c, chunk); // A refused chunk leaves the snapshot unacknowledged.
}
@@ -838,7 +861,8 @@ bool RegionSessions::set_motion_area(const network::motion::Area& area, std::int
m.spawn_y = std::clamp(spawn_y, area.min_y, area.max_y);
for (const auto& c : m.connections)
if (c.state == Impl::State::established &&
c.protocol_version != network::session_protocol_v6 && !m.markers.of(c.session))
c.protocol_version != network::session_protocol_v6 &&
c.protocol_version != network::session_protocol_v7 && !m.markers.of(c.session))
(void)m.markers.open(c.session).has_value();
return true;
}
+97 -2
View File
@@ -439,7 +439,16 @@ void cellular_v6_session(const Files& f) {
CHECK(!client->set_interest(SessionInterest{})); // No M10 probe view in cellular v6.
CHECK(client->view() == nullptr);
h.server->set_default_interest({0, 0, 0, 1});
h.source = [](const SessionInterest&) { return ReplicationSource{.identity = world_id}; };
h.source = [](const SessionInterest&) {
return ReplicationSource{.identity = world_id,
.field_revision = 0,
.organism_revision = 0,
.mask = 0,
.environment = {},
.organisms = {},
.markers = {},
.marker_area = {}};
};
h.pump();
CHECK(client->view() == nullptr); // Default M10 snapshots are withheld too.
CHECK(!client->send_intention(101, 0, 0));
@@ -470,6 +479,90 @@ void cellular_v6_session(const Files& f) {
CHECK(refused->close_reason() == SessionCloseReason::unsupported_version);
}
void cellular_v7_action_session(const Files& f) {
struct ActionLedgerFake final : ActionLedger {
AccountId owner{};
std::uint64_t id{};
std::optional<DurableActionRecord> record;
std::expected<std::optional<ActionOutcome>, ActionLedgerError>
find(const AccountId& account_id, std::uint64_t action_id) override {
if (record && owner == account_id && id == action_id)
return std::optional<ActionOutcome>{record->outcome};
return std::optional<ActionOutcome>{};
}
std::expected<std::optional<DurableActionRecord>, ActionLedgerError>
find_record(const AccountId& account_id, std::uint64_t action_id) override {
return owner == account_id && id == action_id ? record
: std::optional<DurableActionRecord>{};
}
} actions;
FakeLedger control;
Harness h{f, 4, 64, &control, [&](server::RegionSessionsConfig& c) {
c.actions = &actions;
c.accept_cellular_actions = true;
}};
const auto alice = account(0xA8);
auto client = h.connect(h.issuer.grant(alice, 1), session_protocol_v7);
CHECK(h.settled(*client) && client->state() == RegionSessionState::established);
CHECK(!client->send_action(88, ActionKind::probe, 101));
CHECK(client->send_cellular_action(88, 101, 0, 0));
std::vector<ActionReceipt> receipts;
CHECK(h.until([&] { return !(receipts = client->take_action_receipts()).empty(); }));
CHECK(receipts.front() == ActionReceipt{88, AdmitStatus::admitted, 100, 101});
const auto carried = h.server->carry(101);
CHECK(carried.size() == 1 && carried.front().account == alice &&
carried.front().action_id == 88 && carried.front().tick == 101 &&
carried.front().kind == ActionKind::cellular && carried.front().cellular_input ==
std::optional{encode_cellular_action_input({101, 0, 0, false, 0, 0})});
actions.owner = alice;
actions.id = 88;
actions.record = DurableActionRecord{
ActionOutcome{88, ActionResult::committed, 101, 1}, carried.front().cellular_input};
h.server->committed(carried, 1);
std::vector<ActionOutcome> outcomes;
CHECK(h.until([&] { return !(outcomes = client->take_action_outcomes()).empty(); }));
CHECK(outcomes.front() == ActionOutcome{88, ActionResult::committed, 101, 1});
// Exact retry returns the same final outcome. Reusing the key with changed bytes is refused.
CHECK(client->send_cellular_action(88, 101, 0, 0));
CHECK(h.until([&] { return !(receipts = client->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::duplicate);
CHECK(h.until([&] { return !(outcomes = client->take_action_outcomes()).empty(); }));
CHECK(outcomes.front() == ActionOutcome{88, ActionResult::committed, 101, 1});
CHECK(client->send_cellular_action(88, 101, 1, 0));
CHECK(h.until([&] { return !(receipts = client->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::invalid_action);
// A fresh session host resolves the same action from durable result and input bytes.
client->close();
CHECK(h.until([&] { return client->state() == RegionSessionState::closed; }));
Harness restarted{f, 4, 64, &control, [&](server::RegionSessionsConfig& c) {
c.actions = &actions;
c.accept_cellular_actions = true;
}};
auto reconnected = restarted.connect(restarted.issuer.grant(alice, 2),
session_protocol_v7);
CHECK(restarted.settled(*reconnected) &&
reconnected->state() == RegionSessionState::established);
CHECK(reconnected->send_cellular_action(88, 101, 0, 0));
CHECK(restarted.until(
[&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::duplicate);
CHECK(restarted.until(
[&] { return !(outcomes = reconnected->take_action_outcomes()).empty(); }));
CHECK(outcomes.front() == ActionOutcome{88, ActionResult::committed, 101, 1});
CHECK(reconnected->send_cellular_action(88, 101, 1, 0));
CHECK(restarted.until(
[&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::invalid_action);
Harness refused{f, 4, 64, &control};
auto unsupported = refused.connect(refused.issuer.grant(account(0xA9), 1),
session_protocol_v7);
CHECK(refused.settled(*unsupported) && unsupported->state() == RegionSessionState::closed &&
unsupported->close_reason() == SessionCloseReason::unsupported_version);
}
// M10.4: intentions, actions and their distinct answers against a simulated host.
void intentions_and_actions(const Files& f) {
Harness h{f};
@@ -507,7 +600,8 @@ void intentions_and_actions(const Files& f) {
CHECK(outcomes[0].result == ActionResult::pending);
CHECK(h.server->carry(102).empty());
const auto carried = h.server->carry(103);
CHECK(carried.size() == 1 && carried[0] == CarriedAction{alice, 7, 103, ActionKind::probe});
CHECK(carried.size() == 1 &&
carried[0] == CarriedAction{alice, 7, 103, ActionKind::probe, std::nullopt});
h.server->committed(carried, 4);
CHECK(h.until([&] { return !(outcomes = a->take_action_outcomes()).empty(); }));
CHECK(outcomes[0] == ActionOutcome{7, ActionResult::committed_no_effect, 103, 4});
@@ -1293,6 +1387,7 @@ int main() try {
login_rules(files);
primitive_v5_session(files);
cellular_v6_session(files);
cellular_v7_action_session(files);
limits(files);
durable_control(files);
intentions_and_actions(files);