Add M10.5a session protocol v2 and snapshot replication core
Foundation / checks (deploy) (push) Successful in 6s
Foundation / checks (ecs) (push) Successful in 1m58s
Foundation / checks (client) (push) Failing after 9m57s
Foundation / checks (network) (push) Successful in 11m17s
Foundation / checks (tsan) (push) Successful in 7m49s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 25m43s
Foundation / checks (postgres) (push) Canceled after 15m44s

Session protocol v2 adds Interest, SnapshotChunk and SnapshotAck (v1 is refused).
ReplicationServer filters by a server-capped client focus and a perception
predicate, sends per-tick entity deltas against the acknowledged baseline (kept
up to 40 ticks), nearest first within 16 KiB with a slower distant tier, as
self-contained datagram chunks. SnapshotAssembler applies complete snapshots to
one of two baselines and validates them as presentations. ADR-0093.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-06 10:22:11 -04:00
co-authored by Claude Opus 5.5
parent ca0939dda5
commit e640b6d3a3
17 changed files with 1342 additions and 9 deletions
+63
View File
@@ -16,6 +16,9 @@ constexpr std::size_t action_receipt_bytes = 8 + 1 + 8 + 8;
constexpr std::size_t action_outcome_bytes = 8 + 1 + 8 + 8;
constexpr std::size_t action_query_bytes = 8;
constexpr std::uint8_t max_admit_status = static_cast<std::uint8_t>(AdmitStatus::not_ready);
constexpr std::size_t interest_bytes = (3 * std::size_t{8}) + 2;
constexpr std::size_t snapshot_ack_bytes = 2 * std::size_t{8};
constexpr std::uint8_t max_snapshot_chunks = 16;
void put(std::vector<std::uint8_t>& out, std::uint64_t v, std::size_t count) {
for (std::size_t i = 0; i < count; ++i)
@@ -128,6 +131,32 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
put(out, m.action_id, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionInterest& m) const {
auto out = header(SessionMessageType::interest, interest_bytes);
for (const auto v : {m.x, m.y, m.z})
put(out, static_cast<std::uint64_t>(v), 8);
put(out, m.radius, 2);
return out;
}
std::vector<std::uint8_t> operator()(const SnapshotChunk& m) const {
auto out = header(SessionMessageType::snapshot_chunk,
snapshot_chunk_header_bytes + m.records.size());
for (const auto v :
{m.epoch, m.tick, m.baseline, m.field_revision, m.organism_revision})
put(out, v, 8);
put(out, m.mask, 4);
put(out, static_cast<std::uint64_t>(m.slice_z), 8);
out.push_back(m.index);
out.push_back(m.count);
out.insert(out.end(), m.records.begin(), m.records.end());
return out;
}
std::vector<std::uint8_t> operator()(const SnapshotAck& m) const {
auto out = header(SessionMessageType::snapshot_ack, snapshot_ack_bytes);
put(out, m.epoch, 8);
put(out, m.tick, 8);
return out;
}
};
return std::visit(Encoder{}, message);
}
@@ -243,6 +272,40 @@ decode_session(std::span<const std::uint8_t> bytes) {
return std::unexpected(SessionCodecError::wrong_length);
return ActionQuery{get(payload, 0, 8)};
}
case static_cast<std::uint8_t>(SessionMessageType::interest): {
if (!expect(interest_bytes))
return std::unexpected(SessionCodecError::wrong_length);
return SessionInterest{static_cast<std::int64_t>(get(payload, 0, 8)),
static_cast<std::int64_t>(get(payload, 8, 8)),
static_cast<std::int64_t>(get(payload, 16, 8)),
static_cast<std::uint16_t>(get(payload, 24, 2))};
}
case static_cast<std::uint8_t>(SessionMessageType::snapshot_chunk): {
// Variable length: a fixed header and up to one datagram of records.
if (payload.size() < snapshot_chunk_header_bytes ||
payload.size() > snapshot_chunk_header_bytes + max_snapshot_records_bytes)
return std::unexpected(SessionCodecError::wrong_length);
SnapshotChunk m;
m.epoch = get(payload, 0, 8);
m.tick = get(payload, 8, 8);
m.baseline = get(payload, 16, 8);
m.field_revision = get(payload, 24, 8);
m.organism_revision = get(payload, 32, 8);
m.mask = static_cast<std::uint32_t>(get(payload, 40, 4));
m.slice_z = static_cast<std::int64_t>(get(payload, 44, 8));
m.index = payload[52];
m.count = payload[53];
if (m.epoch == 0 || m.tick == 0 || m.baseline >= m.tick || m.count == 0 ||
m.count > max_snapshot_chunks || m.index >= m.count)
return std::unexpected(SessionCodecError::invalid_value);
m.records.assign(payload.begin() + snapshot_chunk_header_bytes, payload.end());
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::snapshot_ack): {
if (!expect(snapshot_ack_bytes))
return std::unexpected(SessionCodecError::wrong_length);
return SnapshotAck{get(payload, 0, 8), get(payload, 8, 8)};
}
default:
return std::unexpected(SessionCodecError::unknown_type);
}